diff --git a/benchmarks/model_checking_opreuse/C++/CAN_BUS_tlc.cpp b/benchmarks/model_checking_opreuse/C++/CAN_BUS_tlc.cpp
index 2b84558ed2c79c7cf7246ec51abf1678a646139f..90f2443cb4c8d082782bf1aed818cd6106fa69b9 100644
--- a/benchmarks/model_checking_opreuse/C++/CAN_BUS_tlc.cpp
+++ b/benchmarks/model_checking_opreuse/C++/CAN_BUS_tlc.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -6101,12 +6100,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 CAN_BUS_tlc state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<CAN_BUS_tlc, CAN_BUS_tlc::Hash, CAN_BUS_tlc::HashEqual> nextStates = generateNextStates(state);
@@ -6127,12 +6130,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -6142,24 +6147,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -6248,262 +6256,168 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T1Evaluate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T1Calculate read__tr_T1Calculate_state = state._projected_state_for__tr_T1Calculate();
+                BSet<BInteger> _trid_2;
                 auto _trid_2_ptr = _OpCache_tr_T1Calculate.find(read__tr_T1Calculate_state);
                 if(_trid_2_ptr == _OpCache_tr_T1Calculate.end()) {
-                    BSet<BInteger> _trid_2 = state._tr_T1Calculate();
+                    _trid_2 = state._tr_T1Calculate();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T1Calculate_lock(_ProjectionRead__tr_T1Calculate_mutex);
                         _OpCache_tr_T1Calculate.insert({read__tr_T1Calculate_state, _trid_2});
                     }
-                    for(const BInteger& param : _trid_2) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T1Calculate readState = state._projected_state_for_T1Calculate();
+                } else {
+                    _trid_2 = _trid_2_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T1Calculate_ptr = _OpCache_T1Calculate.find(param);
-                        if(_OpCache_with_parameter_T1Calculate_ptr == _OpCache_T1Calculate.end()) {
-                            copiedState.T1Calculate(_tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate;
-                            _OpCache_with_parameter_T1Calculate.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex);
-                                _OpCache_T1Calculate.insert({param, _OpCache_with_parameter_T1Calculate});
-                            }
+                for(const BInteger& param : _trid_2) {
+                    BInteger _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate = _OpCache_with_parameter_T1Calculate_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T1Calculate.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T1Calculate.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T1Calculate(writeState);
-                            } else {
-                                copiedState.T1Calculate(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex);
-                                    _OpCache_with_parameter_T1Calculate.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T1Calculate readState = state._projected_state_for_T1Calculate();
+
+                    auto _OpCache_with_parameter_T1Calculate_ptr = _OpCache_T1Calculate.find(param);
+                    if(_OpCache_with_parameter_T1Calculate_ptr == _OpCache_T1Calculate.end()) {
+                        copiedState.T1Calculate(_tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate;
+                        _OpCache_with_parameter_T1Calculate.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex);
+                            _OpCache_T1Calculate.insert({param, _OpCache_with_parameter_T1Calculate});
                         }
 
-                        copiedState.stateAccessedVia = "T1Calculate";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BInteger> _trid_2 = _trid_2_ptr->second;
-                    for(const BInteger& param : _trid_2) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T1Calculate readState = state._projected_state_for_T1Calculate();
-
-                        auto _OpCache_with_parameter_T1Calculate_ptr = _OpCache_T1Calculate.find(param);
-                        if(_OpCache_with_parameter_T1Calculate_ptr == _OpCache_T1Calculate.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate = _OpCache_with_parameter_T1Calculate_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T1Calculate.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T1Calculate.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T1Calculate(writeState);
+                        } else {
                             copiedState.T1Calculate(_tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate;
-                            _OpCache_with_parameter_T1Calculate.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex);
-                                _OpCache_T1Calculate.insert({param, _OpCache_with_parameter_T1Calculate});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Calculate, CAN_BUS_tlc::_ProjectionWrite_T1Calculate, CAN_BUS_tlc::_ProjectionRead_T1Calculate::Hash, CAN_BUS_tlc::_ProjectionRead_T1Calculate::HashEqual> _OpCache_with_parameter_T1Calculate = _OpCache_with_parameter_T1Calculate_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T1Calculate.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T1Calculate.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T1Calculate(writeState);
-                            } else {
-                                copiedState.T1Calculate(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T1Calculate writeState = copiedState._update_for_T1Calculate();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T1Calculate_lock(_ProjectionRead_T1Calculate_mutex);
-                                    _OpCache_with_parameter_T1Calculate.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T1Calculate.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T1Calculate";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T1Calculate";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T1SendResult read__tr_T1SendResult_state = state._projected_state_for__tr_T1SendResult();
+                BSet<BTuple<BInteger, BInteger >> _trid_3;
                 auto _trid_3_ptr = _OpCache_tr_T1SendResult.find(read__tr_T1SendResult_state);
                 if(_trid_3_ptr == _OpCache_tr_T1SendResult.end()) {
-                    BSet<BTuple<BInteger, BInteger >> _trid_3 = state._tr_T1SendResult();
+                    _trid_3 = state._tr_T1SendResult();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T1SendResult_lock(_ProjectionRead__tr_T1SendResult_mutex);
                         _OpCache_tr_T1SendResult.insert({read__tr_T1SendResult_state, _trid_3});
                     }
-                    for(const BTuple<BInteger, BInteger >& param : _trid_3) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T1SendResult readState = state._projected_state_for_T1SendResult();
+                } else {
+                    _trid_3 = _trid_3_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T1SendResult_ptr = _OpCache_T1SendResult.find(param);
-                        if(_OpCache_with_parameter_T1SendResult_ptr == _OpCache_T1SendResult.end()) {
-                            copiedState.T1SendResult(_tmp_2, _tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult;
-                            _OpCache_with_parameter_T1SendResult.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex);
-                                _OpCache_T1SendResult.insert({param, _OpCache_with_parameter_T1SendResult});
-                            }
+                for(const BTuple<BInteger, BInteger >& param : _trid_3) {
+                    BInteger _tmp_1 = param.projection2();
+                    BInteger _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult = _OpCache_with_parameter_T1SendResult_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T1SendResult.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T1SendResult.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T1SendResult(writeState);
-                            } else {
-                                copiedState.T1SendResult(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex);
-                                    _OpCache_with_parameter_T1SendResult.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T1SendResult readState = state._projected_state_for_T1SendResult();
+
+                    auto _OpCache_with_parameter_T1SendResult_ptr = _OpCache_T1SendResult.find(param);
+                    if(_OpCache_with_parameter_T1SendResult_ptr == _OpCache_T1SendResult.end()) {
+                        copiedState.T1SendResult(_tmp_2, _tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult;
+                        _OpCache_with_parameter_T1SendResult.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex);
+                            _OpCache_T1SendResult.insert({param, _OpCache_with_parameter_T1SendResult});
                         }
 
-                        copiedState.stateAccessedVia = "T1SendResult";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BInteger, BInteger >> _trid_3 = _trid_3_ptr->second;
-                    for(const BTuple<BInteger, BInteger >& param : _trid_3) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T1SendResult readState = state._projected_state_for_T1SendResult();
-
-                        auto _OpCache_with_parameter_T1SendResult_ptr = _OpCache_T1SendResult.find(param);
-                        if(_OpCache_with_parameter_T1SendResult_ptr == _OpCache_T1SendResult.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult = _OpCache_with_parameter_T1SendResult_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T1SendResult.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T1SendResult.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T1SendResult(writeState);
+                        } else {
                             copiedState.T1SendResult(_tmp_2, _tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult;
-                            _OpCache_with_parameter_T1SendResult.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex);
-                                _OpCache_T1SendResult.insert({param, _OpCache_with_parameter_T1SendResult});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1SendResult, CAN_BUS_tlc::_ProjectionWrite_T1SendResult, CAN_BUS_tlc::_ProjectionRead_T1SendResult::Hash, CAN_BUS_tlc::_ProjectionRead_T1SendResult::HashEqual> _OpCache_with_parameter_T1SendResult = _OpCache_with_parameter_T1SendResult_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T1SendResult.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T1SendResult.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T1SendResult(writeState);
-                            } else {
-                                copiedState.T1SendResult(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T1SendResult writeState = copiedState._update_for_T1SendResult();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T1SendResult_lock(_ProjectionRead_T1SendResult_mutex);
-                                    _OpCache_with_parameter_T1SendResult.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T1SendResult.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T1SendResult";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T1SendResult";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T1Wait read__tr_T1Wait_state = state._projected_state_for__tr_T1Wait();
+                BSet<BInteger> _trid_4;
                 auto _trid_4_ptr = _OpCache_tr_T1Wait.find(read__tr_T1Wait_state);
                 if(_trid_4_ptr == _OpCache_tr_T1Wait.end()) {
-                    BSet<BInteger> _trid_4 = state._tr_T1Wait();
+                    _trid_4 = state._tr_T1Wait();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T1Wait_lock(_ProjectionRead__tr_T1Wait_mutex);
                         _OpCache_tr_T1Wait.insert({read__tr_T1Wait_state, _trid_4});
                     }
-                    for(const BInteger& param : _trid_4) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T1Wait readState = state._projected_state_for_T1Wait();
+                } else {
+                    _trid_4 = _trid_4_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T1Wait_ptr = _OpCache_T1Wait.find(param);
-                        if(_OpCache_with_parameter_T1Wait_ptr == _OpCache_T1Wait.end()) {
-                            copiedState.T1Wait(_tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait;
-                            _OpCache_with_parameter_T1Wait.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex);
-                                _OpCache_T1Wait.insert({param, _OpCache_with_parameter_T1Wait});
-                            }
+                for(const BInteger& param : _trid_4) {
+                    BInteger _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait = _OpCache_with_parameter_T1Wait_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T1Wait.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T1Wait.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T1Wait(writeState);
-                            } else {
-                                copiedState.T1Wait(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex);
-                                    _OpCache_with_parameter_T1Wait.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T1Wait readState = state._projected_state_for_T1Wait();
+
+                    auto _OpCache_with_parameter_T1Wait_ptr = _OpCache_T1Wait.find(param);
+                    if(_OpCache_with_parameter_T1Wait_ptr == _OpCache_T1Wait.end()) {
+                        copiedState.T1Wait(_tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait;
+                        _OpCache_with_parameter_T1Wait.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex);
+                            _OpCache_T1Wait.insert({param, _OpCache_with_parameter_T1Wait});
                         }
 
-                        copiedState.stateAccessedVia = "T1Wait";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BInteger> _trid_4 = _trid_4_ptr->second;
-                    for(const BInteger& param : _trid_4) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T1Wait readState = state._projected_state_for_T1Wait();
-
-                        auto _OpCache_with_parameter_T1Wait_ptr = _OpCache_T1Wait.find(param);
-                        if(_OpCache_with_parameter_T1Wait_ptr == _OpCache_T1Wait.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait = _OpCache_with_parameter_T1Wait_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T1Wait.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T1Wait.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T1Wait(writeState);
+                        } else {
                             copiedState.T1Wait(_tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait;
-                            _OpCache_with_parameter_T1Wait.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex);
-                                _OpCache_T1Wait.insert({param, _OpCache_with_parameter_T1Wait});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T1Wait, CAN_BUS_tlc::_ProjectionWrite_T1Wait, CAN_BUS_tlc::_ProjectionRead_T1Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T1Wait::HashEqual> _OpCache_with_parameter_T1Wait = _OpCache_with_parameter_T1Wait_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T1Wait.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T1Wait.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T1Wait(writeState);
-                            } else {
-                                copiedState.T1Wait(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T1Wait writeState = copiedState._update_for_T1Wait();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T1Wait_lock(_ProjectionRead_T1Wait_mutex);
-                                    _OpCache_with_parameter_T1Wait.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T1Wait.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T1Wait";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T1Wait";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -6552,92 +6466,62 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T2Evaluate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T2ReadBus read__tr_T2ReadBus_state = state._projected_state_for__tr_T2ReadBus();
+                BSet<BTuple<BInteger, BInteger >> _trid_6;
                 auto _trid_6_ptr = _OpCache_tr_T2ReadBus.find(read__tr_T2ReadBus_state);
                 if(_trid_6_ptr == _OpCache_tr_T2ReadBus.end()) {
-                    BSet<BTuple<BInteger, BInteger >> _trid_6 = state._tr_T2ReadBus();
+                    _trid_6 = state._tr_T2ReadBus();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T2ReadBus_lock(_ProjectionRead__tr_T2ReadBus_mutex);
                         _OpCache_tr_T2ReadBus.insert({read__tr_T2ReadBus_state, _trid_6});
                     }
-                    for(const BTuple<BInteger, BInteger >& param : _trid_6) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T2ReadBus readState = state._projected_state_for_T2ReadBus();
+                } else {
+                    _trid_6 = _trid_6_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T2ReadBus_ptr = _OpCache_T2ReadBus.find(param);
-                        if(_OpCache_with_parameter_T2ReadBus_ptr == _OpCache_T2ReadBus.end()) {
-                            copiedState.T2ReadBus(_tmp_2, _tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus;
-                            _OpCache_with_parameter_T2ReadBus.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex);
-                                _OpCache_T2ReadBus.insert({param, _OpCache_with_parameter_T2ReadBus});
-                            }
+                for(const BTuple<BInteger, BInteger >& param : _trid_6) {
+                    BInteger _tmp_1 = param.projection2();
+                    BInteger _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus = _OpCache_with_parameter_T2ReadBus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T2ReadBus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T2ReadBus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T2ReadBus(writeState);
-                            } else {
-                                copiedState.T2ReadBus(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex);
-                                    _OpCache_with_parameter_T2ReadBus.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T2ReadBus readState = state._projected_state_for_T2ReadBus();
+
+                    auto _OpCache_with_parameter_T2ReadBus_ptr = _OpCache_T2ReadBus.find(param);
+                    if(_OpCache_with_parameter_T2ReadBus_ptr == _OpCache_T2ReadBus.end()) {
+                        copiedState.T2ReadBus(_tmp_2, _tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus;
+                        _OpCache_with_parameter_T2ReadBus.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex);
+                            _OpCache_T2ReadBus.insert({param, _OpCache_with_parameter_T2ReadBus});
                         }
 
-                        copiedState.stateAccessedVia = "T2ReadBus";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BInteger, BInteger >> _trid_6 = _trid_6_ptr->second;
-                    for(const BTuple<BInteger, BInteger >& param : _trid_6) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T2ReadBus readState = state._projected_state_for_T2ReadBus();
-
-                        auto _OpCache_with_parameter_T2ReadBus_ptr = _OpCache_T2ReadBus.find(param);
-                        if(_OpCache_with_parameter_T2ReadBus_ptr == _OpCache_T2ReadBus.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus = _OpCache_with_parameter_T2ReadBus_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T2ReadBus.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T2ReadBus.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T2ReadBus(writeState);
+                        } else {
                             copiedState.T2ReadBus(_tmp_2, _tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus;
-                            _OpCache_with_parameter_T2ReadBus.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex);
-                                _OpCache_T2ReadBus.insert({param, _OpCache_with_parameter_T2ReadBus});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReadBus, CAN_BUS_tlc::_ProjectionWrite_T2ReadBus, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReadBus::HashEqual> _OpCache_with_parameter_T2ReadBus = _OpCache_with_parameter_T2ReadBus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T2ReadBus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T2ReadBus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T2ReadBus(writeState);
-                            } else {
-                                copiedState.T2ReadBus(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T2ReadBus writeState = copiedState._update_for_T2ReadBus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T2ReadBus_lock(_ProjectionRead_T2ReadBus_mutex);
-                                    _OpCache_with_parameter_T2ReadBus.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T2ReadBus.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T2ReadBus";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T2ReadBus";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -6686,7 +6570,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T2Reset";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T2Complete read__tr_T2Complete_state = state._projected_state_for__tr_T2Complete();
                 bool _trid_8;
@@ -6733,90 +6620,61 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T2Complete";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T2ReleaseBus read__tr_T2ReleaseBus_state = state._projected_state_for__tr_T2ReleaseBus();
+                BSet<BInteger> _trid_9;
                 auto _trid_9_ptr = _OpCache_tr_T2ReleaseBus.find(read__tr_T2ReleaseBus_state);
                 if(_trid_9_ptr == _OpCache_tr_T2ReleaseBus.end()) {
-                    BSet<BInteger> _trid_9 = state._tr_T2ReleaseBus();
+                    _trid_9 = state._tr_T2ReleaseBus();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T2ReleaseBus_lock(_ProjectionRead__tr_T2ReleaseBus_mutex);
                         _OpCache_tr_T2ReleaseBus.insert({read__tr_T2ReleaseBus_state, _trid_9});
                     }
-                    for(const BInteger& param : _trid_9) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus readState = state._projected_state_for_T2ReleaseBus();
+                } else {
+                    _trid_9 = _trid_9_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T2ReleaseBus_ptr = _OpCache_T2ReleaseBus.find(param);
-                        if(_OpCache_with_parameter_T2ReleaseBus_ptr == _OpCache_T2ReleaseBus.end()) {
-                            copiedState.T2ReleaseBus(_tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus;
-                            _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex);
-                                _OpCache_T2ReleaseBus.insert({param, _OpCache_with_parameter_T2ReleaseBus});
-                            }
+                for(const BInteger& param : _trid_9) {
+                    BInteger _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus = _OpCache_with_parameter_T2ReleaseBus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T2ReleaseBus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T2ReleaseBus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T2ReleaseBus(writeState);
-                            } else {
-                                copiedState.T2ReleaseBus(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex);
-                                    _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus readState = state._projected_state_for_T2ReleaseBus();
+
+                    auto _OpCache_with_parameter_T2ReleaseBus_ptr = _OpCache_T2ReleaseBus.find(param);
+                    if(_OpCache_with_parameter_T2ReleaseBus_ptr == _OpCache_T2ReleaseBus.end()) {
+                        copiedState.T2ReleaseBus(_tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus;
+                        _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex);
+                            _OpCache_T2ReleaseBus.insert({param, _OpCache_with_parameter_T2ReleaseBus});
                         }
 
-                        copiedState.stateAccessedVia = "T2ReleaseBus";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BInteger> _trid_9 = _trid_9_ptr->second;
-                    for(const BInteger& param : _trid_9) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus readState = state._projected_state_for_T2ReleaseBus();
-
-                        auto _OpCache_with_parameter_T2ReleaseBus_ptr = _OpCache_T2ReleaseBus.find(param);
-                        if(_OpCache_with_parameter_T2ReleaseBus_ptr == _OpCache_T2ReleaseBus.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus = _OpCache_with_parameter_T2ReleaseBus_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T2ReleaseBus.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T2ReleaseBus.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T2ReleaseBus(writeState);
+                        } else {
                             copiedState.T2ReleaseBus(_tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus;
-                            _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex);
-                                _OpCache_T2ReleaseBus.insert({param, _OpCache_with_parameter_T2ReleaseBus});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2ReleaseBus::HashEqual> _OpCache_with_parameter_T2ReleaseBus = _OpCache_with_parameter_T2ReleaseBus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T2ReleaseBus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T2ReleaseBus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T2ReleaseBus(writeState);
-                            } else {
-                                copiedState.T2ReleaseBus(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T2ReleaseBus writeState = copiedState._update_for_T2ReleaseBus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T2ReleaseBus_lock(_ProjectionRead_T2ReleaseBus_mutex);
-                                    _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T2ReleaseBus.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T2ReleaseBus";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T2ReleaseBus";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -6865,177 +6723,115 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T2Calculate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T2WriteBus read__tr_T2WriteBus_state = state._projected_state_for__tr_T2WriteBus();
+                BSet<BTuple<BInteger, BInteger >> _trid_11;
                 auto _trid_11_ptr = _OpCache_tr_T2WriteBus.find(read__tr_T2WriteBus_state);
                 if(_trid_11_ptr == _OpCache_tr_T2WriteBus.end()) {
-                    BSet<BTuple<BInteger, BInteger >> _trid_11 = state._tr_T2WriteBus();
+                    _trid_11 = state._tr_T2WriteBus();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T2WriteBus_lock(_ProjectionRead__tr_T2WriteBus_mutex);
                         _OpCache_tr_T2WriteBus.insert({read__tr_T2WriteBus_state, _trid_11});
                     }
-                    for(const BTuple<BInteger, BInteger >& param : _trid_11) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T2WriteBus readState = state._projected_state_for_T2WriteBus();
+                } else {
+                    _trid_11 = _trid_11_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T2WriteBus_ptr = _OpCache_T2WriteBus.find(param);
-                        if(_OpCache_with_parameter_T2WriteBus_ptr == _OpCache_T2WriteBus.end()) {
-                            copiedState.T2WriteBus(_tmp_2, _tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus;
-                            _OpCache_with_parameter_T2WriteBus.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex);
-                                _OpCache_T2WriteBus.insert({param, _OpCache_with_parameter_T2WriteBus});
-                            }
+                for(const BTuple<BInteger, BInteger >& param : _trid_11) {
+                    BInteger _tmp_1 = param.projection2();
+                    BInteger _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus = _OpCache_with_parameter_T2WriteBus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T2WriteBus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T2WriteBus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T2WriteBus(writeState);
-                            } else {
-                                copiedState.T2WriteBus(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex);
-                                    _OpCache_with_parameter_T2WriteBus.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T2WriteBus readState = state._projected_state_for_T2WriteBus();
+
+                    auto _OpCache_with_parameter_T2WriteBus_ptr = _OpCache_T2WriteBus.find(param);
+                    if(_OpCache_with_parameter_T2WriteBus_ptr == _OpCache_T2WriteBus.end()) {
+                        copiedState.T2WriteBus(_tmp_2, _tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus;
+                        _OpCache_with_parameter_T2WriteBus.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex);
+                            _OpCache_T2WriteBus.insert({param, _OpCache_with_parameter_T2WriteBus});
                         }
 
-                        copiedState.stateAccessedVia = "T2WriteBus";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BInteger, BInteger >> _trid_11 = _trid_11_ptr->second;
-                    for(const BTuple<BInteger, BInteger >& param : _trid_11) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T2WriteBus readState = state._projected_state_for_T2WriteBus();
-
-                        auto _OpCache_with_parameter_T2WriteBus_ptr = _OpCache_T2WriteBus.find(param);
-                        if(_OpCache_with_parameter_T2WriteBus_ptr == _OpCache_T2WriteBus.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus = _OpCache_with_parameter_T2WriteBus_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T2WriteBus.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T2WriteBus.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T2WriteBus(writeState);
+                        } else {
                             copiedState.T2WriteBus(_tmp_2, _tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus;
-                            _OpCache_with_parameter_T2WriteBus.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex);
-                                _OpCache_T2WriteBus.insert({param, _OpCache_with_parameter_T2WriteBus});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2WriteBus, CAN_BUS_tlc::_ProjectionWrite_T2WriteBus, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::Hash, CAN_BUS_tlc::_ProjectionRead_T2WriteBus::HashEqual> _OpCache_with_parameter_T2WriteBus = _OpCache_with_parameter_T2WriteBus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T2WriteBus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T2WriteBus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T2WriteBus(writeState);
-                            } else {
-                                copiedState.T2WriteBus(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T2WriteBus writeState = copiedState._update_for_T2WriteBus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T2WriteBus_lock(_ProjectionRead_T2WriteBus_mutex);
-                                    _OpCache_with_parameter_T2WriteBus.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T2WriteBus.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T2WriteBus";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T2WriteBus";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T2Wait read__tr_T2Wait_state = state._projected_state_for__tr_T2Wait();
+                BSet<BInteger> _trid_12;
                 auto _trid_12_ptr = _OpCache_tr_T2Wait.find(read__tr_T2Wait_state);
                 if(_trid_12_ptr == _OpCache_tr_T2Wait.end()) {
-                    BSet<BInteger> _trid_12 = state._tr_T2Wait();
+                    _trid_12 = state._tr_T2Wait();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T2Wait_lock(_ProjectionRead__tr_T2Wait_mutex);
                         _OpCache_tr_T2Wait.insert({read__tr_T2Wait_state, _trid_12});
                     }
-                    for(const BInteger& param : _trid_12) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T2Wait readState = state._projected_state_for_T2Wait();
+                } else {
+                    _trid_12 = _trid_12_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T2Wait_ptr = _OpCache_T2Wait.find(param);
-                        if(_OpCache_with_parameter_T2Wait_ptr == _OpCache_T2Wait.end()) {
-                            copiedState.T2Wait(_tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait;
-                            _OpCache_with_parameter_T2Wait.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex);
-                                _OpCache_T2Wait.insert({param, _OpCache_with_parameter_T2Wait});
-                            }
+                for(const BInteger& param : _trid_12) {
+                    BInteger _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait = _OpCache_with_parameter_T2Wait_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T2Wait.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T2Wait.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T2Wait(writeState);
-                            } else {
-                                copiedState.T2Wait(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex);
-                                    _OpCache_with_parameter_T2Wait.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T2Wait readState = state._projected_state_for_T2Wait();
+
+                    auto _OpCache_with_parameter_T2Wait_ptr = _OpCache_T2Wait.find(param);
+                    if(_OpCache_with_parameter_T2Wait_ptr == _OpCache_T2Wait.end()) {
+                        copiedState.T2Wait(_tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait;
+                        _OpCache_with_parameter_T2Wait.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex);
+                            _OpCache_T2Wait.insert({param, _OpCache_with_parameter_T2Wait});
                         }
 
-                        copiedState.stateAccessedVia = "T2Wait";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BInteger> _trid_12 = _trid_12_ptr->second;
-                    for(const BInteger& param : _trid_12) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T2Wait readState = state._projected_state_for_T2Wait();
-
-                        auto _OpCache_with_parameter_T2Wait_ptr = _OpCache_T2Wait.find(param);
-                        if(_OpCache_with_parameter_T2Wait_ptr == _OpCache_T2Wait.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait = _OpCache_with_parameter_T2Wait_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T2Wait.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T2Wait.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T2Wait(writeState);
+                        } else {
                             copiedState.T2Wait(_tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait;
-                            _OpCache_with_parameter_T2Wait.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex);
-                                _OpCache_T2Wait.insert({param, _OpCache_with_parameter_T2Wait});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T2Wait, CAN_BUS_tlc::_ProjectionWrite_T2Wait, CAN_BUS_tlc::_ProjectionRead_T2Wait::Hash, CAN_BUS_tlc::_ProjectionRead_T2Wait::HashEqual> _OpCache_with_parameter_T2Wait = _OpCache_with_parameter_T2Wait_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T2Wait.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T2Wait.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T2Wait(writeState);
-                            } else {
-                                copiedState.T2Wait(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T2Wait writeState = copiedState._update_for_T2Wait();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T2Wait_lock(_ProjectionRead_T2Wait_mutex);
-                                    _OpCache_with_parameter_T2Wait.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T2Wait.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T2Wait";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T2Wait";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -7084,7 +6880,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T3Initiate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T3Evaluate read__tr_T3Evaluate_state = state._projected_state_for__tr_T3Evaluate();
                 bool _trid_14;
@@ -7131,179 +6930,116 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T3Evaluate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T3writebus read__tr_T3writebus_state = state._projected_state_for__tr_T3writebus();
+                BSet<BTuple<BInteger, BInteger >> _trid_15;
                 auto _trid_15_ptr = _OpCache_tr_T3writebus.find(read__tr_T3writebus_state);
                 if(_trid_15_ptr == _OpCache_tr_T3writebus.end()) {
-                    BSet<BTuple<BInteger, BInteger >> _trid_15 = state._tr_T3writebus();
+                    _trid_15 = state._tr_T3writebus();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T3writebus_lock(_ProjectionRead__tr_T3writebus_mutex);
                         _OpCache_tr_T3writebus.insert({read__tr_T3writebus_state, _trid_15});
                     }
-                    for(const BTuple<BInteger, BInteger >& param : _trid_15) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T3writebus readState = state._projected_state_for_T3writebus();
+                } else {
+                    _trid_15 = _trid_15_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T3writebus_ptr = _OpCache_T3writebus.find(param);
-                        if(_OpCache_with_parameter_T3writebus_ptr == _OpCache_T3writebus.end()) {
-                            copiedState.T3writebus(_tmp_2, _tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus;
-                            _OpCache_with_parameter_T3writebus.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex);
-                                _OpCache_T3writebus.insert({param, _OpCache_with_parameter_T3writebus});
-                            }
+                for(const BTuple<BInteger, BInteger >& param : _trid_15) {
+                    BInteger _tmp_1 = param.projection2();
+                    BInteger _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus = _OpCache_with_parameter_T3writebus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T3writebus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T3writebus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T3writebus(writeState);
-                            } else {
-                                copiedState.T3writebus(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex);
-                                    _OpCache_with_parameter_T3writebus.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T3writebus readState = state._projected_state_for_T3writebus();
+
+                    auto _OpCache_with_parameter_T3writebus_ptr = _OpCache_T3writebus.find(param);
+                    if(_OpCache_with_parameter_T3writebus_ptr == _OpCache_T3writebus.end()) {
+                        copiedState.T3writebus(_tmp_2, _tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus;
+                        _OpCache_with_parameter_T3writebus.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex);
+                            _OpCache_T3writebus.insert({param, _OpCache_with_parameter_T3writebus});
                         }
 
-                        copiedState.stateAccessedVia = "T3writebus";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BInteger, BInteger >> _trid_15 = _trid_15_ptr->second;
-                    for(const BTuple<BInteger, BInteger >& param : _trid_15) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T3writebus readState = state._projected_state_for_T3writebus();
-
-                        auto _OpCache_with_parameter_T3writebus_ptr = _OpCache_T3writebus.find(param);
-                        if(_OpCache_with_parameter_T3writebus_ptr == _OpCache_T3writebus.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus = _OpCache_with_parameter_T3writebus_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T3writebus.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T3writebus.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T3writebus(writeState);
+                        } else {
                             copiedState.T3writebus(_tmp_2, _tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus;
-                            _OpCache_with_parameter_T3writebus.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex);
-                                _OpCache_T3writebus.insert({param, _OpCache_with_parameter_T3writebus});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3writebus, CAN_BUS_tlc::_ProjectionWrite_T3writebus, CAN_BUS_tlc::_ProjectionRead_T3writebus::Hash, CAN_BUS_tlc::_ProjectionRead_T3writebus::HashEqual> _OpCache_with_parameter_T3writebus = _OpCache_with_parameter_T3writebus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T3writebus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T3writebus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T3writebus(writeState);
-                            } else {
-                                copiedState.T3writebus(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T3writebus writeState = copiedState._update_for_T3writebus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T3writebus_lock(_ProjectionRead_T3writebus_mutex);
-                                    _OpCache_with_parameter_T3writebus.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T3writebus.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T3writebus";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T3writebus";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T3Read read__tr_T3Read_state = state._projected_state_for__tr_T3Read();
+                BSet<BTuple<BInteger, BInteger >> _trid_16;
                 auto _trid_16_ptr = _OpCache_tr_T3Read.find(read__tr_T3Read_state);
                 if(_trid_16_ptr == _OpCache_tr_T3Read.end()) {
-                    BSet<BTuple<BInteger, BInteger >> _trid_16 = state._tr_T3Read();
+                    _trid_16 = state._tr_T3Read();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T3Read_lock(_ProjectionRead__tr_T3Read_mutex);
                         _OpCache_tr_T3Read.insert({read__tr_T3Read_state, _trid_16});
                     }
-                    for(const BTuple<BInteger, BInteger >& param : _trid_16) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T3Read readState = state._projected_state_for_T3Read();
+                } else {
+                    _trid_16 = _trid_16_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T3Read_ptr = _OpCache_T3Read.find(param);
-                        if(_OpCache_with_parameter_T3Read_ptr == _OpCache_T3Read.end()) {
-                            copiedState.T3Read(_tmp_2, _tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read;
-                            _OpCache_with_parameter_T3Read.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex);
-                                _OpCache_T3Read.insert({param, _OpCache_with_parameter_T3Read});
-                            }
+                for(const BTuple<BInteger, BInteger >& param : _trid_16) {
+                    BInteger _tmp_1 = param.projection2();
+                    BInteger _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read = _OpCache_with_parameter_T3Read_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T3Read.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T3Read.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T3Read(writeState);
-                            } else {
-                                copiedState.T3Read(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex);
-                                    _OpCache_with_parameter_T3Read.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T3Read readState = state._projected_state_for_T3Read();
+
+                    auto _OpCache_with_parameter_T3Read_ptr = _OpCache_T3Read.find(param);
+                    if(_OpCache_with_parameter_T3Read_ptr == _OpCache_T3Read.end()) {
+                        copiedState.T3Read(_tmp_2, _tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read;
+                        _OpCache_with_parameter_T3Read.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex);
+                            _OpCache_T3Read.insert({param, _OpCache_with_parameter_T3Read});
                         }
 
-                        copiedState.stateAccessedVia = "T3Read";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BInteger, BInteger >> _trid_16 = _trid_16_ptr->second;
-                    for(const BTuple<BInteger, BInteger >& param : _trid_16) {
-                        BInteger _tmp_1 = param.projection2();
-                        BInteger _tmp_2 = param.projection1();
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T3Read readState = state._projected_state_for_T3Read();
-
-                        auto _OpCache_with_parameter_T3Read_ptr = _OpCache_T3Read.find(param);
-                        if(_OpCache_with_parameter_T3Read_ptr == _OpCache_T3Read.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read = _OpCache_with_parameter_T3Read_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T3Read.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T3Read.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T3Read(writeState);
+                        } else {
                             copiedState.T3Read(_tmp_2, _tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read;
-                            _OpCache_with_parameter_T3Read.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex);
-                                _OpCache_T3Read.insert({param, _OpCache_with_parameter_T3Read});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3Read, CAN_BUS_tlc::_ProjectionWrite_T3Read, CAN_BUS_tlc::_ProjectionRead_T3Read::Hash, CAN_BUS_tlc::_ProjectionRead_T3Read::HashEqual> _OpCache_with_parameter_T3Read = _OpCache_with_parameter_T3Read_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T3Read.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T3Read.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T3Read(writeState);
-                            } else {
-                                copiedState.T3Read(_tmp_2, _tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T3Read writeState = copiedState._update_for_T3Read();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T3Read_lock(_ProjectionRead_T3Read_mutex);
-                                    _OpCache_with_parameter_T3Read.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T3Read.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T3Read";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T3Read";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -7352,90 +7088,61 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T3Poll";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T3ReleaseBus read__tr_T3ReleaseBus_state = state._projected_state_for__tr_T3ReleaseBus();
+                BSet<BInteger> _trid_18;
                 auto _trid_18_ptr = _OpCache_tr_T3ReleaseBus.find(read__tr_T3ReleaseBus_state);
                 if(_trid_18_ptr == _OpCache_tr_T3ReleaseBus.end()) {
-                    BSet<BInteger> _trid_18 = state._tr_T3ReleaseBus();
+                    _trid_18 = state._tr_T3ReleaseBus();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_T3ReleaseBus_lock(_ProjectionRead__tr_T3ReleaseBus_mutex);
                         _OpCache_tr_T3ReleaseBus.insert({read__tr_T3ReleaseBus_state, _trid_18});
                     }
-                    for(const BInteger& param : _trid_18) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus readState = state._projected_state_for_T3ReleaseBus();
+                } else {
+                    _trid_18 = _trid_18_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_T3ReleaseBus_ptr = _OpCache_T3ReleaseBus.find(param);
-                        if(_OpCache_with_parameter_T3ReleaseBus_ptr == _OpCache_T3ReleaseBus.end()) {
-                            copiedState.T3ReleaseBus(_tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus;
-                            _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex);
-                                _OpCache_T3ReleaseBus.insert({param, _OpCache_with_parameter_T3ReleaseBus});
-                            }
+                for(const BInteger& param : _trid_18) {
+                    BInteger _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus = _OpCache_with_parameter_T3ReleaseBus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T3ReleaseBus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T3ReleaseBus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T3ReleaseBus(writeState);
-                            } else {
-                                copiedState.T3ReleaseBus(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex);
-                                    _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus readState = state._projected_state_for_T3ReleaseBus();
+
+                    auto _OpCache_with_parameter_T3ReleaseBus_ptr = _OpCache_T3ReleaseBus.find(param);
+                    if(_OpCache_with_parameter_T3ReleaseBus_ptr == _OpCache_T3ReleaseBus.end()) {
+                        copiedState.T3ReleaseBus(_tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus;
+                        _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex);
+                            _OpCache_T3ReleaseBus.insert({param, _OpCache_with_parameter_T3ReleaseBus});
                         }
 
-                        copiedState.stateAccessedVia = "T3ReleaseBus";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BInteger> _trid_18 = _trid_18_ptr->second;
-                    for(const BInteger& param : _trid_18) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus readState = state._projected_state_for_T3ReleaseBus();
-
-                        auto _OpCache_with_parameter_T3ReleaseBus_ptr = _OpCache_T3ReleaseBus.find(param);
-                        if(_OpCache_with_parameter_T3ReleaseBus_ptr == _OpCache_T3ReleaseBus.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus = _OpCache_with_parameter_T3ReleaseBus_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_T3ReleaseBus.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_T3ReleaseBus.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_T3ReleaseBus(writeState);
+                        } else {
                             copiedState.T3ReleaseBus(_tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus;
-                            _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex);
-                                _OpCache_T3ReleaseBus.insert({param, _OpCache_with_parameter_T3ReleaseBus});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus, CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::Hash, CAN_BUS_tlc::_ProjectionRead_T3ReleaseBus::HashEqual> _OpCache_with_parameter_T3ReleaseBus = _OpCache_with_parameter_T3ReleaseBus_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_T3ReleaseBus.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_T3ReleaseBus.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_T3ReleaseBus(writeState);
-                            } else {
-                                copiedState.T3ReleaseBus(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_T3ReleaseBus writeState = copiedState._update_for_T3ReleaseBus();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_T3ReleaseBus_lock(_ProjectionRead_T3ReleaseBus_mutex);
-                                    _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_T3ReleaseBus.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "T3ReleaseBus";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "T3ReleaseBus";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -7484,7 +7191,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T3Wait";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_T3ReEnableWait read__tr_T3ReEnableWait_state = state._projected_state_for__tr_T3ReEnableWait();
                 bool _trid_20;
@@ -7531,90 +7241,61 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "T3ReEnableWait";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 CAN_BUS_tlc::_ProjectionRead__tr_Update read__tr_Update_state = state._projected_state_for__tr_Update();
+                BSet<BInteger> _trid_21;
                 auto _trid_21_ptr = _OpCache_tr_Update.find(read__tr_Update_state);
                 if(_trid_21_ptr == _OpCache_tr_Update.end()) {
-                    BSet<BInteger> _trid_21 = state._tr_Update();
+                    _trid_21 = state._tr_Update();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Update_lock(_ProjectionRead__tr_Update_mutex);
                         _OpCache_tr_Update.insert({read__tr_Update_state, _trid_21});
                     }
-                    for(const BInteger& param : _trid_21) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_Update readState = state._projected_state_for_Update();
+                } else {
+                    _trid_21 = _trid_21_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Update_ptr = _OpCache_Update.find(param);
-                        if(_OpCache_with_parameter_Update_ptr == _OpCache_Update.end()) {
-                            copiedState.Update(_tmp_1);
-                            CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update;
-                            _OpCache_with_parameter_Update.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex);
-                                _OpCache_Update.insert({param, _OpCache_with_parameter_Update});
-                            }
+                for(const BInteger& param : _trid_21) {
+                    BInteger _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update = _OpCache_with_parameter_Update_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Update.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Update.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_Update writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Update(writeState);
-                            } else {
-                                copiedState.Update(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex);
-                                    _OpCache_with_parameter_Update.insert({readState, writeState});
-                                }
-                            }
+                    CAN_BUS_tlc copiedState = state._copy();
+                    CAN_BUS_tlc::_ProjectionRead_Update readState = state._projected_state_for_Update();
+
+                    auto _OpCache_with_parameter_Update_ptr = _OpCache_Update.find(param);
+                    if(_OpCache_with_parameter_Update_ptr == _OpCache_Update.end()) {
+                        copiedState.Update(_tmp_1);
+                        CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update();
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update;
+                        _OpCache_with_parameter_Update.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex);
+                            _OpCache_Update.insert({param, _OpCache_with_parameter_Update});
                         }
 
-                        copiedState.stateAccessedVia = "Update";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BInteger> _trid_21 = _trid_21_ptr->second;
-                    for(const BInteger& param : _trid_21) {
-                        BInteger _tmp_1 = param;
-
-                        CAN_BUS_tlc copiedState = state._copy();
-                        CAN_BUS_tlc::_ProjectionRead_Update readState = state._projected_state_for_Update();
-
-                        auto _OpCache_with_parameter_Update_ptr = _OpCache_Update.find(param);
-                        if(_OpCache_with_parameter_Update_ptr == _OpCache_Update.end()) {
+                    } else {
+                        std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update = _OpCache_with_parameter_Update_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Update.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Update.end()) {
+                            CAN_BUS_tlc::_ProjectionWrite_Update writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Update(writeState);
+                        } else {
                             copiedState.Update(_tmp_1);
                             CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update();
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update;
-                            _OpCache_with_parameter_Update.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex);
-                                _OpCache_Update.insert({param, _OpCache_with_parameter_Update});
-                            }
-
-                        } else {
-                            std::unordered_map<CAN_BUS_tlc::_ProjectionRead_Update, CAN_BUS_tlc::_ProjectionWrite_Update, CAN_BUS_tlc::_ProjectionRead_Update::Hash, CAN_BUS_tlc::_ProjectionRead_Update::HashEqual> _OpCache_with_parameter_Update = _OpCache_with_parameter_Update_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Update.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Update.end()) {
-                                CAN_BUS_tlc::_ProjectionWrite_Update writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Update(writeState);
-                            } else {
-                                copiedState.Update(_tmp_1);
-                                CAN_BUS_tlc::_ProjectionWrite_Update writeState = copiedState._update_for_Update();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Update_lock(_ProjectionRead_Update_mutex);
-                                    _OpCache_with_parameter_Update.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Update.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Update";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Update";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -7625,7 +7306,10 @@ class ModelChecker {
                     copiedState.T1Evaluate();
                     copiedState.stateAccessedVia = "T1Evaluate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BInteger> _trid_2 = state._tr_T1Calculate();
                 for(const BInteger& param : _trid_2) {
@@ -7635,7 +7319,10 @@ class ModelChecker {
                     copiedState.T1Calculate(_tmp_1);
                     copiedState.stateAccessedVia = "T1Calculate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BInteger, BInteger >> _trid_3 = state._tr_T1SendResult();
                 for(const BTuple<BInteger, BInteger >& param : _trid_3) {
@@ -7646,7 +7333,10 @@ class ModelChecker {
                     copiedState.T1SendResult(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "T1SendResult";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BInteger> _trid_4 = state._tr_T1Wait();
                 for(const BInteger& param : _trid_4) {
@@ -7656,14 +7346,20 @@ class ModelChecker {
                     copiedState.T1Wait(_tmp_1);
                     copiedState.stateAccessedVia = "T1Wait";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T2Evaluate()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T2Evaluate();
                     copiedState.stateAccessedVia = "T2Evaluate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BInteger, BInteger >> _trid_6 = state._tr_T2ReadBus();
                 for(const BTuple<BInteger, BInteger >& param : _trid_6) {
@@ -7674,21 +7370,30 @@ class ModelChecker {
                     copiedState.T2ReadBus(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "T2ReadBus";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T2Reset()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T2Reset();
                     copiedState.stateAccessedVia = "T2Reset";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T2Complete()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T2Complete();
                     copiedState.stateAccessedVia = "T2Complete";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BInteger> _trid_9 = state._tr_T2ReleaseBus();
                 for(const BInteger& param : _trid_9) {
@@ -7698,14 +7403,20 @@ class ModelChecker {
                     copiedState.T2ReleaseBus(_tmp_1);
                     copiedState.stateAccessedVia = "T2ReleaseBus";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T2Calculate()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T2Calculate();
                     copiedState.stateAccessedVia = "T2Calculate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BInteger, BInteger >> _trid_11 = state._tr_T2WriteBus();
                 for(const BTuple<BInteger, BInteger >& param : _trid_11) {
@@ -7716,7 +7427,10 @@ class ModelChecker {
                     copiedState.T2WriteBus(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "T2WriteBus";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BInteger> _trid_12 = state._tr_T2Wait();
                 for(const BInteger& param : _trid_12) {
@@ -7726,21 +7440,30 @@ class ModelChecker {
                     copiedState.T2Wait(_tmp_1);
                     copiedState.stateAccessedVia = "T2Wait";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T3Initiate()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T3Initiate();
                     copiedState.stateAccessedVia = "T3Initiate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T3Evaluate()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T3Evaluate();
                     copiedState.stateAccessedVia = "T3Evaluate";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BInteger, BInteger >> _trid_15 = state._tr_T3writebus();
                 for(const BTuple<BInteger, BInteger >& param : _trid_15) {
@@ -7751,7 +7474,10 @@ class ModelChecker {
                     copiedState.T3writebus(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "T3writebus";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BInteger, BInteger >> _trid_16 = state._tr_T3Read();
                 for(const BTuple<BInteger, BInteger >& param : _trid_16) {
@@ -7762,14 +7488,20 @@ class ModelChecker {
                     copiedState.T3Read(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "T3Read";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T3Poll()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T3Poll();
                     copiedState.stateAccessedVia = "T3Poll";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BInteger> _trid_18 = state._tr_T3ReleaseBus();
                 for(const BInteger& param : _trid_18) {
@@ -7779,21 +7511,30 @@ class ModelChecker {
                     copiedState.T3ReleaseBus(_tmp_1);
                     copiedState.stateAccessedVia = "T3ReleaseBus";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T3Wait()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T3Wait();
                     copiedState.stateAccessedVia = "T3Wait";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_T3ReEnableWait()) {
                     CAN_BUS_tlc copiedState = state._copy();
                     copiedState.T3ReEnableWait();
                     copiedState.stateAccessedVia = "T3ReEnableWait";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BInteger> _trid_21 = state._tr_Update();
                 for(const BInteger& param : _trid_21) {
@@ -7803,7 +7544,10 @@ class ModelChecker {
                     copiedState.Update(_tmp_1);
                     copiedState.stateAccessedVia = "Update";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/Cruise_finite1_deterministic_MC.cpp b/benchmarks/model_checking_opreuse/C++/Cruise_finite1_deterministic_MC.cpp
index 17be0a899ec94f516575c8a213d4486448a1c5ff..997336871a764b7413557ee1acf710dd86899da2 100644
--- a/benchmarks/model_checking_opreuse/C++/Cruise_finite1_deterministic_MC.cpp
+++ b/benchmarks/model_checking_opreuse/C++/Cruise_finite1_deterministic_MC.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -8610,12 +8609,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 Cruise_finite1_deterministic_MC state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<Cruise_finite1_deterministic_MC, Cruise_finite1_deterministic_MC::Hash, Cruise_finite1_deterministic_MC::HashEqual> nextStates = generateNextStates(state);
@@ -8636,12 +8639,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -8651,24 +8656,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -8757,7 +8765,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "CruiseBecomesNotAllowed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_CruiseBecomesAllowed read__tr_CruiseBecomesAllowed_state = state._projected_state_for__tr_CruiseBecomesAllowed();
                 bool _trid_2;
@@ -8804,179 +8815,116 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "CruiseBecomesAllowed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_SetCruiseSpeed read__tr_SetCruiseSpeed_state = state._projected_state_for__tr_SetCruiseSpeed();
+                BSet<BTuple<BBoolean, BBoolean >> _trid_3;
                 auto _trid_3_ptr = _OpCache_tr_SetCruiseSpeed.find(read__tr_SetCruiseSpeed_state);
                 if(_trid_3_ptr == _OpCache_tr_SetCruiseSpeed.end()) {
-                    BSet<BTuple<BBoolean, BBoolean >> _trid_3 = state._tr_SetCruiseSpeed();
+                    _trid_3 = state._tr_SetCruiseSpeed();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_SetCruiseSpeed_lock(_ProjectionRead__tr_SetCruiseSpeed_mutex);
                         _OpCache_tr_SetCruiseSpeed.insert({read__tr_SetCruiseSpeed_state, _trid_3});
                     }
-                    for(const BTuple<BBoolean, BBoolean >& param : _trid_3) {
-                        BBoolean _tmp_1 = param.projection2();
-                        BBoolean _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed readState = state._projected_state_for_SetCruiseSpeed();
+                } else {
+                    _trid_3 = _trid_3_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_SetCruiseSpeed_ptr = _OpCache_SetCruiseSpeed.find(param);
-                        if(_OpCache_with_parameter_SetCruiseSpeed_ptr == _OpCache_SetCruiseSpeed.end()) {
-                            copiedState.SetCruiseSpeed(_tmp_2, _tmp_1);
-                            Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed;
-                            _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex);
-                                _OpCache_SetCruiseSpeed.insert({param, _OpCache_with_parameter_SetCruiseSpeed});
-                            }
+                for(const BTuple<BBoolean, BBoolean >& param : _trid_3) {
+                    BBoolean _tmp_1 = param.projection2();
+                    BBoolean _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed = _OpCache_with_parameter_SetCruiseSpeed_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_SetCruiseSpeed.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_SetCruiseSpeed.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_SetCruiseSpeed(writeState);
-                            } else {
-                                copiedState.SetCruiseSpeed(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex);
-                                    _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState});
-                                }
-                            }
+                    Cruise_finite1_deterministic_MC copiedState = state._copy();
+                    Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed readState = state._projected_state_for_SetCruiseSpeed();
+
+                    auto _OpCache_with_parameter_SetCruiseSpeed_ptr = _OpCache_SetCruiseSpeed.find(param);
+                    if(_OpCache_with_parameter_SetCruiseSpeed_ptr == _OpCache_SetCruiseSpeed.end()) {
+                        copiedState.SetCruiseSpeed(_tmp_2, _tmp_1);
+                        Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed();
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed;
+                        _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex);
+                            _OpCache_SetCruiseSpeed.insert({param, _OpCache_with_parameter_SetCruiseSpeed});
                         }
 
-                        copiedState.stateAccessedVia = "SetCruiseSpeed";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BBoolean, BBoolean >> _trid_3 = _trid_3_ptr->second;
-                    for(const BTuple<BBoolean, BBoolean >& param : _trid_3) {
-                        BBoolean _tmp_1 = param.projection2();
-                        BBoolean _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed readState = state._projected_state_for_SetCruiseSpeed();
-
-                        auto _OpCache_with_parameter_SetCruiseSpeed_ptr = _OpCache_SetCruiseSpeed.find(param);
-                        if(_OpCache_with_parameter_SetCruiseSpeed_ptr == _OpCache_SetCruiseSpeed.end()) {
+                    } else {
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed = _OpCache_with_parameter_SetCruiseSpeed_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_SetCruiseSpeed.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_SetCruiseSpeed.end()) {
+                            Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_SetCruiseSpeed(writeState);
+                        } else {
                             copiedState.SetCruiseSpeed(_tmp_2, _tmp_1);
                             Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed;
-                            _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex);
-                                _OpCache_SetCruiseSpeed.insert({param, _OpCache_with_parameter_SetCruiseSpeed});
-                            }
-
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_SetCruiseSpeed::HashEqual> _OpCache_with_parameter_SetCruiseSpeed = _OpCache_with_parameter_SetCruiseSpeed_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_SetCruiseSpeed.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_SetCruiseSpeed.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_SetCruiseSpeed(writeState);
-                            } else {
-                                copiedState.SetCruiseSpeed(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_SetCruiseSpeed writeState = copiedState._update_for_SetCruiseSpeed();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_SetCruiseSpeed_lock(_ProjectionRead_SetCruiseSpeed_mutex);
-                                    _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_SetCruiseSpeed.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "SetCruiseSpeed";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "SetCruiseSpeed";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_CCInitialisationFinished read__tr_CCInitialisationFinished_state = state._projected_state_for__tr_CCInitialisationFinished();
+                BSet<BTuple<BBoolean, BBoolean >> _trid_4;
                 auto _trid_4_ptr = _OpCache_tr_CCInitialisationFinished.find(read__tr_CCInitialisationFinished_state);
                 if(_trid_4_ptr == _OpCache_tr_CCInitialisationFinished.end()) {
-                    BSet<BTuple<BBoolean, BBoolean >> _trid_4 = state._tr_CCInitialisationFinished();
+                    _trid_4 = state._tr_CCInitialisationFinished();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_CCInitialisationFinished_lock(_ProjectionRead__tr_CCInitialisationFinished_mutex);
                         _OpCache_tr_CCInitialisationFinished.insert({read__tr_CCInitialisationFinished_state, _trid_4});
                     }
-                    for(const BTuple<BBoolean, BBoolean >& param : _trid_4) {
-                        BBoolean _tmp_1 = param.projection2();
-                        BBoolean _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished readState = state._projected_state_for_CCInitialisationFinished();
+                } else {
+                    _trid_4 = _trid_4_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_CCInitialisationFinished_ptr = _OpCache_CCInitialisationFinished.find(param);
-                        if(_OpCache_with_parameter_CCInitialisationFinished_ptr == _OpCache_CCInitialisationFinished.end()) {
-                            copiedState.CCInitialisationFinished(_tmp_2, _tmp_1);
-                            Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished;
-                            _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex);
-                                _OpCache_CCInitialisationFinished.insert({param, _OpCache_with_parameter_CCInitialisationFinished});
-                            }
+                for(const BTuple<BBoolean, BBoolean >& param : _trid_4) {
+                    BBoolean _tmp_1 = param.projection2();
+                    BBoolean _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished = _OpCache_with_parameter_CCInitialisationFinished_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_CCInitialisationFinished.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_CCInitialisationFinished.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_CCInitialisationFinished(writeState);
-                            } else {
-                                copiedState.CCInitialisationFinished(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex);
-                                    _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState});
-                                }
-                            }
+                    Cruise_finite1_deterministic_MC copiedState = state._copy();
+                    Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished readState = state._projected_state_for_CCInitialisationFinished();
+
+                    auto _OpCache_with_parameter_CCInitialisationFinished_ptr = _OpCache_CCInitialisationFinished.find(param);
+                    if(_OpCache_with_parameter_CCInitialisationFinished_ptr == _OpCache_CCInitialisationFinished.end()) {
+                        copiedState.CCInitialisationFinished(_tmp_2, _tmp_1);
+                        Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished();
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished;
+                        _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex);
+                            _OpCache_CCInitialisationFinished.insert({param, _OpCache_with_parameter_CCInitialisationFinished});
                         }
 
-                        copiedState.stateAccessedVia = "CCInitialisationFinished";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BBoolean, BBoolean >> _trid_4 = _trid_4_ptr->second;
-                    for(const BTuple<BBoolean, BBoolean >& param : _trid_4) {
-                        BBoolean _tmp_1 = param.projection2();
-                        BBoolean _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished readState = state._projected_state_for_CCInitialisationFinished();
-
-                        auto _OpCache_with_parameter_CCInitialisationFinished_ptr = _OpCache_CCInitialisationFinished.find(param);
-                        if(_OpCache_with_parameter_CCInitialisationFinished_ptr == _OpCache_CCInitialisationFinished.end()) {
+                    } else {
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished = _OpCache_with_parameter_CCInitialisationFinished_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_CCInitialisationFinished.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_CCInitialisationFinished.end()) {
+                            Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_CCInitialisationFinished(writeState);
+                        } else {
                             copiedState.CCInitialisationFinished(_tmp_2, _tmp_1);
                             Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished;
-                            _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex);
-                                _OpCache_CCInitialisationFinished.insert({param, _OpCache_with_parameter_CCInitialisationFinished});
-                            }
-
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CCInitialisationFinished::HashEqual> _OpCache_with_parameter_CCInitialisationFinished = _OpCache_with_parameter_CCInitialisationFinished_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_CCInitialisationFinished.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_CCInitialisationFinished.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_CCInitialisationFinished(writeState);
-                            } else {
-                                copiedState.CCInitialisationFinished(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_CCInitialisationFinished writeState = copiedState._update_for_CCInitialisationFinished();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_CCInitialisationFinished_lock(_ProjectionRead_CCInitialisationFinished_mutex);
-                                    _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_CCInitialisationFinished.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "CCInitialisationFinished";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "CCInitialisationFinished";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -9025,92 +8973,62 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "CCInitialisationDelayFinished";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_CruiseSpeedChangeFinished read__tr_CruiseSpeedChangeFinished_state = state._projected_state_for__tr_CruiseSpeedChangeFinished();
+                BSet<BTuple<BBoolean, BBoolean >> _trid_6;
                 auto _trid_6_ptr = _OpCache_tr_CruiseSpeedChangeFinished.find(read__tr_CruiseSpeedChangeFinished_state);
                 if(_trid_6_ptr == _OpCache_tr_CruiseSpeedChangeFinished.end()) {
-                    BSet<BTuple<BBoolean, BBoolean >> _trid_6 = state._tr_CruiseSpeedChangeFinished();
+                    _trid_6 = state._tr_CruiseSpeedChangeFinished();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_CruiseSpeedChangeFinished_lock(_ProjectionRead__tr_CruiseSpeedChangeFinished_mutex);
                         _OpCache_tr_CruiseSpeedChangeFinished.insert({read__tr_CruiseSpeedChangeFinished_state, _trid_6});
                     }
-                    for(const BTuple<BBoolean, BBoolean >& param : _trid_6) {
-                        BBoolean _tmp_1 = param.projection2();
-                        BBoolean _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished readState = state._projected_state_for_CruiseSpeedChangeFinished();
+                } else {
+                    _trid_6 = _trid_6_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr = _OpCache_CruiseSpeedChangeFinished.find(param);
-                        if(_OpCache_with_parameter_CruiseSpeedChangeFinished_ptr == _OpCache_CruiseSpeedChangeFinished.end()) {
-                            copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1);
-                            Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished;
-                            _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex);
-                                _OpCache_CruiseSpeedChangeFinished.insert({param, _OpCache_with_parameter_CruiseSpeedChangeFinished});
-                            }
+                for(const BTuple<BBoolean, BBoolean >& param : _trid_6) {
+                    BBoolean _tmp_1 = param.projection2();
+                    BBoolean _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished = _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_CruiseSpeedChangeFinished.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_CruiseSpeedChangeFinished.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_CruiseSpeedChangeFinished(writeState);
-                            } else {
-                                copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex);
-                                    _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState});
-                                }
-                            }
+                    Cruise_finite1_deterministic_MC copiedState = state._copy();
+                    Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished readState = state._projected_state_for_CruiseSpeedChangeFinished();
+
+                    auto _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr = _OpCache_CruiseSpeedChangeFinished.find(param);
+                    if(_OpCache_with_parameter_CruiseSpeedChangeFinished_ptr == _OpCache_CruiseSpeedChangeFinished.end()) {
+                        copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1);
+                        Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished();
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished;
+                        _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex);
+                            _OpCache_CruiseSpeedChangeFinished.insert({param, _OpCache_with_parameter_CruiseSpeedChangeFinished});
                         }
 
-                        copiedState.stateAccessedVia = "CruiseSpeedChangeFinished";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BBoolean, BBoolean >> _trid_6 = _trid_6_ptr->second;
-                    for(const BTuple<BBoolean, BBoolean >& param : _trid_6) {
-                        BBoolean _tmp_1 = param.projection2();
-                        BBoolean _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished readState = state._projected_state_for_CruiseSpeedChangeFinished();
-
-                        auto _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr = _OpCache_CruiseSpeedChangeFinished.find(param);
-                        if(_OpCache_with_parameter_CruiseSpeedChangeFinished_ptr == _OpCache_CruiseSpeedChangeFinished.end()) {
+                    } else {
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished = _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_CruiseSpeedChangeFinished.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_CruiseSpeedChangeFinished.end()) {
+                            Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_CruiseSpeedChangeFinished(writeState);
+                        } else {
                             copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1);
                             Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished;
-                            _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex);
-                                _OpCache_CruiseSpeedChangeFinished.insert({param, _OpCache_with_parameter_CruiseSpeedChangeFinished});
-                            }
-
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_CruiseSpeedChangeFinished::HashEqual> _OpCache_with_parameter_CruiseSpeedChangeFinished = _OpCache_with_parameter_CruiseSpeedChangeFinished_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_CruiseSpeedChangeFinished.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_CruiseSpeedChangeFinished.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_CruiseSpeedChangeFinished(writeState);
-                            } else {
-                                copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_CruiseSpeedChangeFinished writeState = copiedState._update_for_CruiseSpeedChangeFinished();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_CruiseSpeedChangeFinished_lock(_ProjectionRead_CruiseSpeedChangeFinished_mutex);
-                                    _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_CruiseSpeedChangeFinished.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "CruiseSpeedChangeFinished";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "CruiseSpeedChangeFinished";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -9159,7 +9077,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "CruiseSpeedChangeDelayFinished";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_CruiseOff read__tr_CruiseOff_state = state._projected_state_for__tr_CruiseOff();
                 bool _trid_8;
@@ -9206,7 +9127,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "CruiseOff";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ExternalForcesBecomesExtreme read__tr_ExternalForcesBecomesExtreme_state = state._projected_state_for__tr_ExternalForcesBecomesExtreme();
                 bool _trid_9;
@@ -9253,7 +9177,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ExternalForcesBecomesExtreme";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ExternalForcesBecomesNormal read__tr_ExternalForcesBecomesNormal_state = state._projected_state_for__tr_ExternalForcesBecomesNormal();
                 bool _trid_10;
@@ -9300,7 +9227,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ExternalForcesBecomesNormal";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleLeavesCruiseSpeed read__tr_VehicleLeavesCruiseSpeed_state = state._projected_state_for__tr_VehicleLeavesCruiseSpeed();
                 bool _trid_11;
@@ -9347,7 +9277,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "VehicleLeavesCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleReachesCruiseSpeed read__tr_VehicleReachesCruiseSpeed_state = state._projected_state_for__tr_VehicleReachesCruiseSpeed();
                 bool _trid_12;
@@ -9394,7 +9327,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "VehicleReachesCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleExceedsMaxCruiseSpeed read__tr_VehicleExceedsMaxCruiseSpeed_state = state._projected_state_for__tr_VehicleExceedsMaxCruiseSpeed();
                 bool _trid_13;
@@ -9441,7 +9377,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "VehicleExceedsMaxCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleFallsBelowMaxCruiseSpeed read__tr_VehicleFallsBelowMaxCruiseSpeed_state = state._projected_state_for__tr_VehicleFallsBelowMaxCruiseSpeed();
                 bool _trid_14;
@@ -9488,7 +9427,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "VehicleFallsBelowMaxCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleDistanceBecomesVeryClose read__tr_ObstacleDistanceBecomesVeryClose_state = state._projected_state_for__tr_ObstacleDistanceBecomesVeryClose();
                 bool _trid_15;
@@ -9535,7 +9477,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleDistanceBecomesVeryClose";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleDistanceBecomesClose read__tr_ObstacleDistanceBecomesClose_state = state._projected_state_for__tr_ObstacleDistanceBecomesClose();
                 bool _trid_16;
@@ -9582,7 +9527,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleDistanceBecomesClose";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleDistanceBecomesBig read__tr_ObstacleDistanceBecomesBig_state = state._projected_state_for__tr_ObstacleDistanceBecomesBig();
                 bool _trid_17;
@@ -9629,7 +9577,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleDistanceBecomesBig";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleStartsTravelFaster read__tr_ObstacleStartsTravelFaster_state = state._projected_state_for__tr_ObstacleStartsTravelFaster();
                 bool _trid_18;
@@ -9676,7 +9627,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleStartsTravelFaster";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleStopsTravelFaster read__tr_ObstacleStopsTravelFaster_state = state._projected_state_for__tr_ObstacleStopsTravelFaster();
                 bool _trid_19;
@@ -9723,7 +9677,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleStopsTravelFaster";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleStartsTravelSlower read__tr_ObstacleStartsTravelSlower_state = state._projected_state_for__tr_ObstacleStartsTravelSlower();
                 bool _trid_20;
@@ -9770,7 +9727,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleStartsTravelSlower";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleStopsTravelSlower read__tr_ObstacleStopsTravelSlower_state = state._projected_state_for__tr_ObstacleStopsTravelSlower();
                 bool _trid_21;
@@ -9817,177 +9777,115 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleStopsTravelSlower";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleAppearsWhenCruiseActive read__tr_ObstacleAppearsWhenCruiseActive_state = state._projected_state_for__tr_ObstacleAppearsWhenCruiseActive();
+                BSet<BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >> _trid_22;
                 auto _trid_22_ptr = _OpCache_tr_ObstacleAppearsWhenCruiseActive.find(read__tr_ObstacleAppearsWhenCruiseActive_state);
                 if(_trid_22_ptr == _OpCache_tr_ObstacleAppearsWhenCruiseActive.end()) {
-                    BSet<BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >> _trid_22 = state._tr_ObstacleAppearsWhenCruiseActive();
+                    _trid_22 = state._tr_ObstacleAppearsWhenCruiseActive();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead__tr_ObstacleAppearsWhenCruiseActive_mutex);
                         _OpCache_tr_ObstacleAppearsWhenCruiseActive.insert({read__tr_ObstacleAppearsWhenCruiseActive_state, _trid_22});
                     }
-                    for(const BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >& param : _trid_22) {
-                        Cruise_finite1_deterministic_MC::ODset _tmp_1 = param.projection2();
-                        Cruise_finite1_deterministic_MC::RSset _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive readState = state._projected_state_for_ObstacleAppearsWhenCruiseActive();
+                } else {
+                    _trid_22 = _trid_22_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr = _OpCache_ObstacleAppearsWhenCruiseActive.find(param);
-                        if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr == _OpCache_ObstacleAppearsWhenCruiseActive.end()) {
-                            copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1);
-                            Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive;
-                            _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex);
-                                _OpCache_ObstacleAppearsWhenCruiseActive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive});
-                            }
+                for(const BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >& param : _trid_22) {
+                    Cruise_finite1_deterministic_MC::ODset _tmp_1 = param.projection2();
+                    Cruise_finite1_deterministic_MC::RSset _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_ObstacleAppearsWhenCruiseActive(writeState);
-                            } else {
-                                copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex);
-                                    _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState});
-                                }
-                            }
+                    Cruise_finite1_deterministic_MC copiedState = state._copy();
+                    Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive readState = state._projected_state_for_ObstacleAppearsWhenCruiseActive();
+
+                    auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr = _OpCache_ObstacleAppearsWhenCruiseActive.find(param);
+                    if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr == _OpCache_ObstacleAppearsWhenCruiseActive.end()) {
+                        copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1);
+                        Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive();
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive;
+                        _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex);
+                            _OpCache_ObstacleAppearsWhenCruiseActive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive});
                         }
 
-                        copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseActive";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >> _trid_22 = _trid_22_ptr->second;
-                    for(const BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >& param : _trid_22) {
-                        Cruise_finite1_deterministic_MC::ODset _tmp_1 = param.projection2();
-                        Cruise_finite1_deterministic_MC::RSset _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive readState = state._projected_state_for_ObstacleAppearsWhenCruiseActive();
-
-                        auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr = _OpCache_ObstacleAppearsWhenCruiseActive.find(param);
-                        if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr == _OpCache_ObstacleAppearsWhenCruiseActive.end()) {
+                    } else {
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.end()) {
+                            Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_ObstacleAppearsWhenCruiseActive(writeState);
+                        } else {
                             copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1);
                             Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive;
-                            _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex);
-                                _OpCache_ObstacleAppearsWhenCruiseActive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive});
-                            }
-
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseActive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_ObstacleAppearsWhenCruiseActive(writeState);
-                            } else {
-                                copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseActive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseActive();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseActive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseActive_mutex);
-                                    _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_ObstacleAppearsWhenCruiseActive.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseActive";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseActive";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_ObstacleAppearsWhenCruiseInactive read__tr_ObstacleAppearsWhenCruiseInactive_state = state._projected_state_for__tr_ObstacleAppearsWhenCruiseInactive();
+                BSet<Cruise_finite1_deterministic_MC::RSset> _trid_23;
                 auto _trid_23_ptr = _OpCache_tr_ObstacleAppearsWhenCruiseInactive.find(read__tr_ObstacleAppearsWhenCruiseInactive_state);
                 if(_trid_23_ptr == _OpCache_tr_ObstacleAppearsWhenCruiseInactive.end()) {
-                    BSet<Cruise_finite1_deterministic_MC::RSset> _trid_23 = state._tr_ObstacleAppearsWhenCruiseInactive();
+                    _trid_23 = state._tr_ObstacleAppearsWhenCruiseInactive();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead__tr_ObstacleAppearsWhenCruiseInactive_mutex);
                         _OpCache_tr_ObstacleAppearsWhenCruiseInactive.insert({read__tr_ObstacleAppearsWhenCruiseInactive_state, _trid_23});
                     }
-                    for(const Cruise_finite1_deterministic_MC::RSset& param : _trid_23) {
-                        Cruise_finite1_deterministic_MC::RSset _tmp_1 = param;
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive readState = state._projected_state_for_ObstacleAppearsWhenCruiseInactive();
+                } else {
+                    _trid_23 = _trid_23_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr = _OpCache_ObstacleAppearsWhenCruiseInactive.find(param);
-                        if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr == _OpCache_ObstacleAppearsWhenCruiseInactive.end()) {
-                            copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1);
-                            Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive;
-                            _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex);
-                                _OpCache_ObstacleAppearsWhenCruiseInactive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive});
-                            }
+                for(const Cruise_finite1_deterministic_MC::RSset& param : _trid_23) {
+                    Cruise_finite1_deterministic_MC::RSset _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_ObstacleAppearsWhenCruiseInactive(writeState);
-                            } else {
-                                copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex);
-                                    _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState});
-                                }
-                            }
+                    Cruise_finite1_deterministic_MC copiedState = state._copy();
+                    Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive readState = state._projected_state_for_ObstacleAppearsWhenCruiseInactive();
+
+                    auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr = _OpCache_ObstacleAppearsWhenCruiseInactive.find(param);
+                    if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr == _OpCache_ObstacleAppearsWhenCruiseInactive.end()) {
+                        copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1);
+                        Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive();
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive;
+                        _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex);
+                            _OpCache_ObstacleAppearsWhenCruiseInactive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive});
                         }
 
-                        copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseInactive";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Cruise_finite1_deterministic_MC::RSset> _trid_23 = _trid_23_ptr->second;
-                    for(const Cruise_finite1_deterministic_MC::RSset& param : _trid_23) {
-                        Cruise_finite1_deterministic_MC::RSset _tmp_1 = param;
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive readState = state._projected_state_for_ObstacleAppearsWhenCruiseInactive();
-
-                        auto _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr = _OpCache_ObstacleAppearsWhenCruiseInactive.find(param);
-                        if(_OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr == _OpCache_ObstacleAppearsWhenCruiseInactive.end()) {
+                    } else {
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.end()) {
+                            Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_ObstacleAppearsWhenCruiseInactive(writeState);
+                        } else {
                             copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1);
                             Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive;
-                            _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex);
-                                _OpCache_ObstacleAppearsWhenCruiseInactive.insert({param, _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive});
-                            }
-
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_ObstacleAppearsWhenCruiseInactive::HashEqual> _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_ObstacleAppearsWhenCruiseInactive(writeState);
-                            } else {
-                                copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_ObstacleAppearsWhenCruiseInactive writeState = copiedState._update_for_ObstacleAppearsWhenCruiseInactive();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_ObstacleAppearsWhenCruiseInactive_lock(_ProjectionRead_ObstacleAppearsWhenCruiseInactive_mutex);
-                                    _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_ObstacleAppearsWhenCruiseInactive.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseInactive";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseInactive";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -10036,92 +9934,62 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleDisappears";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Cruise_finite1_deterministic_MC::_ProjectionRead__tr_VehicleManageObstacle read__tr_VehicleManageObstacle_state = state._projected_state_for__tr_VehicleManageObstacle();
+                BSet<BTuple<BBoolean, BBoolean >> _trid_25;
                 auto _trid_25_ptr = _OpCache_tr_VehicleManageObstacle.find(read__tr_VehicleManageObstacle_state);
                 if(_trid_25_ptr == _OpCache_tr_VehicleManageObstacle.end()) {
-                    BSet<BTuple<BBoolean, BBoolean >> _trid_25 = state._tr_VehicleManageObstacle();
+                    _trid_25 = state._tr_VehicleManageObstacle();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_VehicleManageObstacle_lock(_ProjectionRead__tr_VehicleManageObstacle_mutex);
                         _OpCache_tr_VehicleManageObstacle.insert({read__tr_VehicleManageObstacle_state, _trid_25});
                     }
-                    for(const BTuple<BBoolean, BBoolean >& param : _trid_25) {
-                        BBoolean _tmp_1 = param.projection2();
-                        BBoolean _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle readState = state._projected_state_for_VehicleManageObstacle();
+                } else {
+                    _trid_25 = _trid_25_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_VehicleManageObstacle_ptr = _OpCache_VehicleManageObstacle.find(param);
-                        if(_OpCache_with_parameter_VehicleManageObstacle_ptr == _OpCache_VehicleManageObstacle.end()) {
-                            copiedState.VehicleManageObstacle(_tmp_2, _tmp_1);
-                            Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle;
-                            _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex);
-                                _OpCache_VehicleManageObstacle.insert({param, _OpCache_with_parameter_VehicleManageObstacle});
-                            }
+                for(const BTuple<BBoolean, BBoolean >& param : _trid_25) {
+                    BBoolean _tmp_1 = param.projection2();
+                    BBoolean _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle = _OpCache_with_parameter_VehicleManageObstacle_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_VehicleManageObstacle.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_VehicleManageObstacle.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_VehicleManageObstacle(writeState);
-                            } else {
-                                copiedState.VehicleManageObstacle(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex);
-                                    _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState});
-                                }
-                            }
+                    Cruise_finite1_deterministic_MC copiedState = state._copy();
+                    Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle readState = state._projected_state_for_VehicleManageObstacle();
+
+                    auto _OpCache_with_parameter_VehicleManageObstacle_ptr = _OpCache_VehicleManageObstacle.find(param);
+                    if(_OpCache_with_parameter_VehicleManageObstacle_ptr == _OpCache_VehicleManageObstacle.end()) {
+                        copiedState.VehicleManageObstacle(_tmp_2, _tmp_1);
+                        Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle();
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle;
+                        _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex);
+                            _OpCache_VehicleManageObstacle.insert({param, _OpCache_with_parameter_VehicleManageObstacle});
                         }
 
-                        copiedState.stateAccessedVia = "VehicleManageObstacle";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BBoolean, BBoolean >> _trid_25 = _trid_25_ptr->second;
-                    for(const BTuple<BBoolean, BBoolean >& param : _trid_25) {
-                        BBoolean _tmp_1 = param.projection2();
-                        BBoolean _tmp_2 = param.projection1();
-
-                        Cruise_finite1_deterministic_MC copiedState = state._copy();
-                        Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle readState = state._projected_state_for_VehicleManageObstacle();
-
-                        auto _OpCache_with_parameter_VehicleManageObstacle_ptr = _OpCache_VehicleManageObstacle.find(param);
-                        if(_OpCache_with_parameter_VehicleManageObstacle_ptr == _OpCache_VehicleManageObstacle.end()) {
+                    } else {
+                        std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle = _OpCache_with_parameter_VehicleManageObstacle_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_VehicleManageObstacle.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_VehicleManageObstacle.end()) {
+                            Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_VehicleManageObstacle(writeState);
+                        } else {
                             copiedState.VehicleManageObstacle(_tmp_2, _tmp_1);
                             Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle();
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle;
-                            _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex);
-                                _OpCache_VehicleManageObstacle.insert({param, _OpCache_with_parameter_VehicleManageObstacle});
-                            }
-
-                        } else {
-                            std::unordered_map<Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::Hash, Cruise_finite1_deterministic_MC::_ProjectionRead_VehicleManageObstacle::HashEqual> _OpCache_with_parameter_VehicleManageObstacle = _OpCache_with_parameter_VehicleManageObstacle_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_VehicleManageObstacle.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_VehicleManageObstacle.end()) {
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_VehicleManageObstacle(writeState);
-                            } else {
-                                copiedState.VehicleManageObstacle(_tmp_2, _tmp_1);
-                                Cruise_finite1_deterministic_MC::_ProjectionWrite_VehicleManageObstacle writeState = copiedState._update_for_VehicleManageObstacle();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_VehicleManageObstacle_lock(_ProjectionRead_VehicleManageObstacle_mutex);
-                                    _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_VehicleManageObstacle.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "VehicleManageObstacle";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "VehicleManageObstacle";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -10170,7 +10038,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "ObstacleBecomesOld";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             } else {
@@ -10179,14 +10050,20 @@ class ModelChecker {
                     copiedState.CruiseBecomesNotAllowed();
                     copiedState.stateAccessedVia = "CruiseBecomesNotAllowed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_CruiseBecomesAllowed()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.CruiseBecomesAllowed();
                     copiedState.stateAccessedVia = "CruiseBecomesAllowed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BBoolean, BBoolean >> _trid_3 = state._tr_SetCruiseSpeed();
                 for(const BTuple<BBoolean, BBoolean >& param : _trid_3) {
@@ -10197,7 +10074,10 @@ class ModelChecker {
                     copiedState.SetCruiseSpeed(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "SetCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BBoolean, BBoolean >> _trid_4 = state._tr_CCInitialisationFinished();
                 for(const BTuple<BBoolean, BBoolean >& param : _trid_4) {
@@ -10208,14 +10088,20 @@ class ModelChecker {
                     copiedState.CCInitialisationFinished(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "CCInitialisationFinished";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_CCInitialisationDelayFinished()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.CCInitialisationDelayFinished();
                     copiedState.stateAccessedVia = "CCInitialisationDelayFinished";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BBoolean, BBoolean >> _trid_6 = state._tr_CruiseSpeedChangeFinished();
                 for(const BTuple<BBoolean, BBoolean >& param : _trid_6) {
@@ -10226,112 +10112,160 @@ class ModelChecker {
                     copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "CruiseSpeedChangeFinished";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_CruiseSpeedChangeDelayFinished()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.CruiseSpeedChangeDelayFinished();
                     copiedState.stateAccessedVia = "CruiseSpeedChangeDelayFinished";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_CruiseOff()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.CruiseOff();
                     copiedState.stateAccessedVia = "CruiseOff";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ExternalForcesBecomesExtreme()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ExternalForcesBecomesExtreme();
                     copiedState.stateAccessedVia = "ExternalForcesBecomesExtreme";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ExternalForcesBecomesNormal()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ExternalForcesBecomesNormal();
                     copiedState.stateAccessedVia = "ExternalForcesBecomesNormal";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_VehicleLeavesCruiseSpeed()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.VehicleLeavesCruiseSpeed();
                     copiedState.stateAccessedVia = "VehicleLeavesCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_VehicleReachesCruiseSpeed()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.VehicleReachesCruiseSpeed();
                     copiedState.stateAccessedVia = "VehicleReachesCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_VehicleExceedsMaxCruiseSpeed()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.VehicleExceedsMaxCruiseSpeed();
                     copiedState.stateAccessedVia = "VehicleExceedsMaxCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_VehicleFallsBelowMaxCruiseSpeed()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.VehicleFallsBelowMaxCruiseSpeed();
                     copiedState.stateAccessedVia = "VehicleFallsBelowMaxCruiseSpeed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleDistanceBecomesVeryClose()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleDistanceBecomesVeryClose();
                     copiedState.stateAccessedVia = "ObstacleDistanceBecomesVeryClose";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleDistanceBecomesClose()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleDistanceBecomesClose();
                     copiedState.stateAccessedVia = "ObstacleDistanceBecomesClose";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleDistanceBecomesBig()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleDistanceBecomesBig();
                     copiedState.stateAccessedVia = "ObstacleDistanceBecomesBig";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleStartsTravelFaster()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleStartsTravelFaster();
                     copiedState.stateAccessedVia = "ObstacleStartsTravelFaster";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleStopsTravelFaster()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleStopsTravelFaster();
                     copiedState.stateAccessedVia = "ObstacleStopsTravelFaster";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleStartsTravelSlower()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleStartsTravelSlower();
                     copiedState.stateAccessedVia = "ObstacleStartsTravelSlower";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleStopsTravelSlower()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleStopsTravelSlower();
                     copiedState.stateAccessedVia = "ObstacleStopsTravelSlower";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >> _trid_22 = state._tr_ObstacleAppearsWhenCruiseActive();
                 for(const BTuple<Cruise_finite1_deterministic_MC::RSset, Cruise_finite1_deterministic_MC::ODset >& param : _trid_22) {
@@ -10342,7 +10276,10 @@ class ModelChecker {
                     copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseActive";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<Cruise_finite1_deterministic_MC::RSset> _trid_23 = state._tr_ObstacleAppearsWhenCruiseInactive();
                 for(const Cruise_finite1_deterministic_MC::RSset& param : _trid_23) {
@@ -10352,14 +10289,20 @@ class ModelChecker {
                     copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1);
                     copiedState.stateAccessedVia = "ObstacleAppearsWhenCruiseInactive";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleDisappears()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleDisappears();
                     copiedState.stateAccessedVia = "ObstacleDisappears";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BBoolean, BBoolean >> _trid_25 = state._tr_VehicleManageObstacle();
                 for(const BTuple<BBoolean, BBoolean >& param : _trid_25) {
@@ -10370,14 +10313,20 @@ class ModelChecker {
                     copiedState.VehicleManageObstacle(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "VehicleManageObstacle";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_ObstacleBecomesOld()) {
                     Cruise_finite1_deterministic_MC copiedState = state._copy();
                     copiedState.ObstacleBecomesOld();
                     copiedState.stateAccessedVia = "ObstacleBecomesOld";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/LandingGear_R6.cpp b/benchmarks/model_checking_opreuse/C++/LandingGear_R6.cpp
index b0cdc8b8700cec6d91da4ece888a3b7ce2e8f71d..73b243d7790a45f5a5b2547850640665b69f9c5d 100644
--- a/benchmarks/model_checking_opreuse/C++/LandingGear_R6.cpp
+++ b/benchmarks/model_checking_opreuse/C++/LandingGear_R6.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -10473,12 +10472,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 LandingGear_R6 state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<LandingGear_R6, LandingGear_R6::Hash, LandingGear_R6::HashEqual> nextStates = generateNextStates(state);
@@ -10499,12 +10502,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -10514,24 +10519,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -10620,7 +10628,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "begin_flying";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_land_plane read__tr_land_plane_state = state._projected_state_for__tr_land_plane();
                 bool _trid_2;
@@ -10667,7 +10678,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "land_plane";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_open_valve_door_open read__tr_open_valve_door_open_state = state._projected_state_for__tr_open_valve_door_open();
                 bool _trid_3;
@@ -10714,7 +10728,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "open_valve_door_open";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_close_valve_door_open read__tr_close_valve_door_open_state = state._projected_state_for__tr_close_valve_door_open();
                 bool _trid_4;
@@ -10761,7 +10778,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "close_valve_door_open";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_open_valve_door_close read__tr_open_valve_door_close_state = state._projected_state_for__tr_open_valve_door_close();
                 bool _trid_5;
@@ -10808,7 +10828,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "open_valve_door_close";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_close_valve_door_close read__tr_close_valve_door_close_state = state._projected_state_for__tr_close_valve_door_close();
                 bool _trid_6;
@@ -10855,7 +10878,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "close_valve_door_close";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_open_valve_retract_gear read__tr_open_valve_retract_gear_state = state._projected_state_for__tr_open_valve_retract_gear();
                 bool _trid_7;
@@ -10902,7 +10928,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "open_valve_retract_gear";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_close_valve_retract_gear read__tr_close_valve_retract_gear_state = state._projected_state_for__tr_close_valve_retract_gear();
                 bool _trid_8;
@@ -10949,7 +10978,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "close_valve_retract_gear";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_open_valve_extend_gear read__tr_open_valve_extend_gear_state = state._projected_state_for__tr_open_valve_extend_gear();
                 bool _trid_9;
@@ -10996,7 +11028,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "open_valve_extend_gear";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_close_valve_extend_gear read__tr_close_valve_extend_gear_state = state._projected_state_for__tr_close_valve_extend_gear();
                 bool _trid_10;
@@ -11043,7 +11078,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "close_valve_extend_gear";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stimulate_open_door_valve read__tr_con_stimulate_open_door_valve_state = state._projected_state_for__tr_con_stimulate_open_door_valve();
                 bool _trid_11;
@@ -11090,7 +11128,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stimulate_open_door_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_open_door_valve read__tr_con_stop_stimulate_open_door_valve_state = state._projected_state_for__tr_con_stop_stimulate_open_door_valve();
                 bool _trid_12;
@@ -11137,7 +11178,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stop_stimulate_open_door_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stimulate_close_door_valve read__tr_con_stimulate_close_door_valve_state = state._projected_state_for__tr_con_stimulate_close_door_valve();
                 bool _trid_13;
@@ -11184,7 +11228,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stimulate_close_door_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_close_door_valve read__tr_con_stop_stimulate_close_door_valve_state = state._projected_state_for__tr_con_stop_stimulate_close_door_valve();
                 bool _trid_14;
@@ -11231,7 +11278,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stop_stimulate_close_door_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stimulate_retract_gear_valve read__tr_con_stimulate_retract_gear_valve_state = state._projected_state_for__tr_con_stimulate_retract_gear_valve();
                 bool _trid_15;
@@ -11278,7 +11328,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stimulate_retract_gear_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_retract_gear_valve read__tr_con_stop_stimulate_retract_gear_valve_state = state._projected_state_for__tr_con_stop_stimulate_retract_gear_valve();
                 bool _trid_16;
@@ -11325,7 +11378,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stop_stimulate_retract_gear_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stimulate_extend_gear_valve read__tr_con_stimulate_extend_gear_valve_state = state._projected_state_for__tr_con_stimulate_extend_gear_valve();
                 bool _trid_17;
@@ -11372,7 +11428,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stimulate_extend_gear_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_extend_gear_valve read__tr_con_stop_stimulate_extend_gear_valve_state = state._projected_state_for__tr_con_stop_stimulate_extend_gear_valve();
                 bool _trid_18;
@@ -11419,1025 +11478,644 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stop_stimulate_extend_gear_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_start_retracting_first read__tr_env_start_retracting_first_state = state._projected_state_for__tr_env_start_retracting_first();
+                BSet<LandingGear_R6::POSITION> _trid_19;
                 auto _trid_19_ptr = _OpCache_tr_env_start_retracting_first.find(read__tr_env_start_retracting_first_state);
                 if(_trid_19_ptr == _OpCache_tr_env_start_retracting_first.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_19 = state._tr_env_start_retracting_first();
+                    _trid_19 = state._tr_env_start_retracting_first();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_retracting_first_lock(_ProjectionRead__tr_env_start_retracting_first_mutex);
                         _OpCache_tr_env_start_retracting_first.insert({read__tr_env_start_retracting_first_state, _trid_19});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_19) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_start_retracting_first readState = state._projected_state_for_env_start_retracting_first();
+                } else {
+                    _trid_19 = _trid_19_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_start_retracting_first_ptr = _OpCache_env_start_retracting_first.find(param);
-                        if(_OpCache_with_parameter_env_start_retracting_first_ptr == _OpCache_env_start_retracting_first.end()) {
-                            copiedState.env_start_retracting_first(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first;
-                            _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex);
-                                _OpCache_env_start_retracting_first.insert({param, _OpCache_with_parameter_env_start_retracting_first});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_19) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first = _OpCache_with_parameter_env_start_retracting_first_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_start_retracting_first.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_start_retracting_first.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_start_retracting_first(writeState);
-                            } else {
-                                copiedState.env_start_retracting_first(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex);
-                                    _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_start_retracting_first readState = state._projected_state_for_env_start_retracting_first();
+
+                    auto _OpCache_with_parameter_env_start_retracting_first_ptr = _OpCache_env_start_retracting_first.find(param);
+                    if(_OpCache_with_parameter_env_start_retracting_first_ptr == _OpCache_env_start_retracting_first.end()) {
+                        copiedState.env_start_retracting_first(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first;
+                        _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex);
+                            _OpCache_env_start_retracting_first.insert({param, _OpCache_with_parameter_env_start_retracting_first});
                         }
 
-                        copiedState.stateAccessedVia = "env_start_retracting_first";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_19 = _trid_19_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_19) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_start_retracting_first readState = state._projected_state_for_env_start_retracting_first();
-
-                        auto _OpCache_with_parameter_env_start_retracting_first_ptr = _OpCache_env_start_retracting_first.find(param);
-                        if(_OpCache_with_parameter_env_start_retracting_first_ptr == _OpCache_env_start_retracting_first.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first = _OpCache_with_parameter_env_start_retracting_first_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_start_retracting_first.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_start_retracting_first.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_start_retracting_first(writeState);
+                        } else {
                             copiedState.env_start_retracting_first(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first;
-                            _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex);
-                                _OpCache_env_start_retracting_first.insert({param, _OpCache_with_parameter_env_start_retracting_first});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_retracting_first, LandingGear_R6::_ProjectionWrite_env_start_retracting_first, LandingGear_R6::_ProjectionRead_env_start_retracting_first::Hash, LandingGear_R6::_ProjectionRead_env_start_retracting_first::HashEqual> _OpCache_with_parameter_env_start_retracting_first = _OpCache_with_parameter_env_start_retracting_first_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_start_retracting_first.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_start_retracting_first.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_start_retracting_first(writeState);
-                            } else {
-                                copiedState.env_start_retracting_first(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_start_retracting_first writeState = copiedState._update_for_env_start_retracting_first();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_start_retracting_first_lock(_ProjectionRead_env_start_retracting_first_mutex);
-                                    _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_start_retracting_first.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_start_retracting_first";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_start_retracting_first";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_retract_gear_skip read__tr_env_retract_gear_skip_state = state._projected_state_for__tr_env_retract_gear_skip();
+                BSet<LandingGear_R6::POSITION> _trid_20;
                 auto _trid_20_ptr = _OpCache_tr_env_retract_gear_skip.find(read__tr_env_retract_gear_skip_state);
                 if(_trid_20_ptr == _OpCache_tr_env_retract_gear_skip.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_20 = state._tr_env_retract_gear_skip();
+                    _trid_20 = state._tr_env_retract_gear_skip();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_retract_gear_skip_lock(_ProjectionRead__tr_env_retract_gear_skip_mutex);
                         _OpCache_tr_env_retract_gear_skip.insert({read__tr_env_retract_gear_skip_state, _trid_20});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_20) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_retract_gear_skip readState = state._projected_state_for_env_retract_gear_skip();
+                } else {
+                    _trid_20 = _trid_20_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_retract_gear_skip_ptr = _OpCache_env_retract_gear_skip.find(param);
-                        if(_OpCache_with_parameter_env_retract_gear_skip_ptr == _OpCache_env_retract_gear_skip.end()) {
-                            copiedState.env_retract_gear_skip(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip;
-                            _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex);
-                                _OpCache_env_retract_gear_skip.insert({param, _OpCache_with_parameter_env_retract_gear_skip});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_20) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip = _OpCache_with_parameter_env_retract_gear_skip_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_skip.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_skip.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_retract_gear_skip(writeState);
-                            } else {
-                                copiedState.env_retract_gear_skip(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex);
-                                    _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_retract_gear_skip readState = state._projected_state_for_env_retract_gear_skip();
+
+                    auto _OpCache_with_parameter_env_retract_gear_skip_ptr = _OpCache_env_retract_gear_skip.find(param);
+                    if(_OpCache_with_parameter_env_retract_gear_skip_ptr == _OpCache_env_retract_gear_skip.end()) {
+                        copiedState.env_retract_gear_skip(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip;
+                        _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex);
+                            _OpCache_env_retract_gear_skip.insert({param, _OpCache_with_parameter_env_retract_gear_skip});
                         }
 
-                        copiedState.stateAccessedVia = "env_retract_gear_skip";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_20 = _trid_20_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_20) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_retract_gear_skip readState = state._projected_state_for_env_retract_gear_skip();
-
-                        auto _OpCache_with_parameter_env_retract_gear_skip_ptr = _OpCache_env_retract_gear_skip.find(param);
-                        if(_OpCache_with_parameter_env_retract_gear_skip_ptr == _OpCache_env_retract_gear_skip.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip = _OpCache_with_parameter_env_retract_gear_skip_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_skip.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_skip.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_retract_gear_skip(writeState);
+                        } else {
                             copiedState.env_retract_gear_skip(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip;
-                            _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex);
-                                _OpCache_env_retract_gear_skip.insert({param, _OpCache_with_parameter_env_retract_gear_skip});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_skip, LandingGear_R6::_ProjectionWrite_env_retract_gear_skip, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_skip::HashEqual> _OpCache_with_parameter_env_retract_gear_skip = _OpCache_with_parameter_env_retract_gear_skip_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_skip.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_skip.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_retract_gear_skip(writeState);
-                            } else {
-                                copiedState.env_retract_gear_skip(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_retract_gear_skip writeState = copiedState._update_for_env_retract_gear_skip();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_skip_lock(_ProjectionRead_env_retract_gear_skip_mutex);
-                                    _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_retract_gear_skip.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_retract_gear_skip";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_retract_gear_skip";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_retract_gear_last read__tr_env_retract_gear_last_state = state._projected_state_for__tr_env_retract_gear_last();
+                BSet<LandingGear_R6::POSITION> _trid_21;
                 auto _trid_21_ptr = _OpCache_tr_env_retract_gear_last.find(read__tr_env_retract_gear_last_state);
                 if(_trid_21_ptr == _OpCache_tr_env_retract_gear_last.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_21 = state._tr_env_retract_gear_last();
+                    _trid_21 = state._tr_env_retract_gear_last();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_retract_gear_last_lock(_ProjectionRead__tr_env_retract_gear_last_mutex);
                         _OpCache_tr_env_retract_gear_last.insert({read__tr_env_retract_gear_last_state, _trid_21});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_21) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_retract_gear_last readState = state._projected_state_for_env_retract_gear_last();
+                } else {
+                    _trid_21 = _trid_21_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_retract_gear_last_ptr = _OpCache_env_retract_gear_last.find(param);
-                        if(_OpCache_with_parameter_env_retract_gear_last_ptr == _OpCache_env_retract_gear_last.end()) {
-                            copiedState.env_retract_gear_last(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last;
-                            _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex);
-                                _OpCache_env_retract_gear_last.insert({param, _OpCache_with_parameter_env_retract_gear_last});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_21) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last = _OpCache_with_parameter_env_retract_gear_last_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_last.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_last.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_retract_gear_last(writeState);
-                            } else {
-                                copiedState.env_retract_gear_last(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex);
-                                    _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_retract_gear_last readState = state._projected_state_for_env_retract_gear_last();
+
+                    auto _OpCache_with_parameter_env_retract_gear_last_ptr = _OpCache_env_retract_gear_last.find(param);
+                    if(_OpCache_with_parameter_env_retract_gear_last_ptr == _OpCache_env_retract_gear_last.end()) {
+                        copiedState.env_retract_gear_last(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last;
+                        _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex);
+                            _OpCache_env_retract_gear_last.insert({param, _OpCache_with_parameter_env_retract_gear_last});
                         }
 
-                        copiedState.stateAccessedVia = "env_retract_gear_last";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_21 = _trid_21_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_21) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_retract_gear_last readState = state._projected_state_for_env_retract_gear_last();
-
-                        auto _OpCache_with_parameter_env_retract_gear_last_ptr = _OpCache_env_retract_gear_last.find(param);
-                        if(_OpCache_with_parameter_env_retract_gear_last_ptr == _OpCache_env_retract_gear_last.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last = _OpCache_with_parameter_env_retract_gear_last_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_last.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_last.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_retract_gear_last(writeState);
+                        } else {
                             copiedState.env_retract_gear_last(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last;
-                            _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex);
-                                _OpCache_env_retract_gear_last.insert({param, _OpCache_with_parameter_env_retract_gear_last});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_retract_gear_last, LandingGear_R6::_ProjectionWrite_env_retract_gear_last, LandingGear_R6::_ProjectionRead_env_retract_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_retract_gear_last::HashEqual> _OpCache_with_parameter_env_retract_gear_last = _OpCache_with_parameter_env_retract_gear_last_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_retract_gear_last.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_retract_gear_last.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_retract_gear_last(writeState);
-                            } else {
-                                copiedState.env_retract_gear_last(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_retract_gear_last writeState = copiedState._update_for_env_retract_gear_last();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_retract_gear_last_lock(_ProjectionRead_env_retract_gear_last_mutex);
-                                    _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_retract_gear_last.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_retract_gear_last";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_retract_gear_last";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_start_extending read__tr_env_start_extending_state = state._projected_state_for__tr_env_start_extending();
+                BSet<LandingGear_R6::POSITION> _trid_22;
                 auto _trid_22_ptr = _OpCache_tr_env_start_extending.find(read__tr_env_start_extending_state);
                 if(_trid_22_ptr == _OpCache_tr_env_start_extending.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_22 = state._tr_env_start_extending();
+                    _trid_22 = state._tr_env_start_extending();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_extending_lock(_ProjectionRead__tr_env_start_extending_mutex);
                         _OpCache_tr_env_start_extending.insert({read__tr_env_start_extending_state, _trid_22});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_22) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_start_extending readState = state._projected_state_for_env_start_extending();
+                } else {
+                    _trid_22 = _trid_22_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_start_extending_ptr = _OpCache_env_start_extending.find(param);
-                        if(_OpCache_with_parameter_env_start_extending_ptr == _OpCache_env_start_extending.end()) {
-                            copiedState.env_start_extending(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending;
-                            _OpCache_with_parameter_env_start_extending.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex);
-                                _OpCache_env_start_extending.insert({param, _OpCache_with_parameter_env_start_extending});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_22) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending = _OpCache_with_parameter_env_start_extending_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_start_extending.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_start_extending.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_start_extending writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_start_extending(writeState);
-                            } else {
-                                copiedState.env_start_extending(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex);
-                                    _OpCache_with_parameter_env_start_extending.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_start_extending readState = state._projected_state_for_env_start_extending();
+
+                    auto _OpCache_with_parameter_env_start_extending_ptr = _OpCache_env_start_extending.find(param);
+                    if(_OpCache_with_parameter_env_start_extending_ptr == _OpCache_env_start_extending.end()) {
+                        copiedState.env_start_extending(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending;
+                        _OpCache_with_parameter_env_start_extending.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex);
+                            _OpCache_env_start_extending.insert({param, _OpCache_with_parameter_env_start_extending});
                         }
 
-                        copiedState.stateAccessedVia = "env_start_extending";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_22 = _trid_22_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_22) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_start_extending readState = state._projected_state_for_env_start_extending();
-
-                        auto _OpCache_with_parameter_env_start_extending_ptr = _OpCache_env_start_extending.find(param);
-                        if(_OpCache_with_parameter_env_start_extending_ptr == _OpCache_env_start_extending.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending = _OpCache_with_parameter_env_start_extending_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_start_extending.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_start_extending.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_start_extending writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_start_extending(writeState);
+                        } else {
                             copiedState.env_start_extending(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending;
-                            _OpCache_with_parameter_env_start_extending.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex);
-                                _OpCache_env_start_extending.insert({param, _OpCache_with_parameter_env_start_extending});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_extending, LandingGear_R6::_ProjectionWrite_env_start_extending, LandingGear_R6::_ProjectionRead_env_start_extending::Hash, LandingGear_R6::_ProjectionRead_env_start_extending::HashEqual> _OpCache_with_parameter_env_start_extending = _OpCache_with_parameter_env_start_extending_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_start_extending.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_start_extending.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_start_extending writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_start_extending(writeState);
-                            } else {
-                                copiedState.env_start_extending(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_start_extending writeState = copiedState._update_for_env_start_extending();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_start_extending_lock(_ProjectionRead_env_start_extending_mutex);
-                                    _OpCache_with_parameter_env_start_extending.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_start_extending.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_start_extending";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_start_extending";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_extend_gear_last read__tr_env_extend_gear_last_state = state._projected_state_for__tr_env_extend_gear_last();
+                BSet<LandingGear_R6::POSITION> _trid_23;
                 auto _trid_23_ptr = _OpCache_tr_env_extend_gear_last.find(read__tr_env_extend_gear_last_state);
                 if(_trid_23_ptr == _OpCache_tr_env_extend_gear_last.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_23 = state._tr_env_extend_gear_last();
+                    _trid_23 = state._tr_env_extend_gear_last();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_extend_gear_last_lock(_ProjectionRead__tr_env_extend_gear_last_mutex);
                         _OpCache_tr_env_extend_gear_last.insert({read__tr_env_extend_gear_last_state, _trid_23});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_23) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_extend_gear_last readState = state._projected_state_for_env_extend_gear_last();
+                } else {
+                    _trid_23 = _trid_23_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_extend_gear_last_ptr = _OpCache_env_extend_gear_last.find(param);
-                        if(_OpCache_with_parameter_env_extend_gear_last_ptr == _OpCache_env_extend_gear_last.end()) {
-                            copiedState.env_extend_gear_last(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last;
-                            _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex);
-                                _OpCache_env_extend_gear_last.insert({param, _OpCache_with_parameter_env_extend_gear_last});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_23) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last = _OpCache_with_parameter_env_extend_gear_last_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_last.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_last.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_extend_gear_last(writeState);
-                            } else {
-                                copiedState.env_extend_gear_last(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex);
-                                    _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_extend_gear_last readState = state._projected_state_for_env_extend_gear_last();
+
+                    auto _OpCache_with_parameter_env_extend_gear_last_ptr = _OpCache_env_extend_gear_last.find(param);
+                    if(_OpCache_with_parameter_env_extend_gear_last_ptr == _OpCache_env_extend_gear_last.end()) {
+                        copiedState.env_extend_gear_last(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last;
+                        _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex);
+                            _OpCache_env_extend_gear_last.insert({param, _OpCache_with_parameter_env_extend_gear_last});
                         }
 
-                        copiedState.stateAccessedVia = "env_extend_gear_last";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_23 = _trid_23_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_23) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_extend_gear_last readState = state._projected_state_for_env_extend_gear_last();
-
-                        auto _OpCache_with_parameter_env_extend_gear_last_ptr = _OpCache_env_extend_gear_last.find(param);
-                        if(_OpCache_with_parameter_env_extend_gear_last_ptr == _OpCache_env_extend_gear_last.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last = _OpCache_with_parameter_env_extend_gear_last_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_last.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_last.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_extend_gear_last(writeState);
+                        } else {
                             copiedState.env_extend_gear_last(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last;
-                            _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex);
-                                _OpCache_env_extend_gear_last.insert({param, _OpCache_with_parameter_env_extend_gear_last});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_last, LandingGear_R6::_ProjectionWrite_env_extend_gear_last, LandingGear_R6::_ProjectionRead_env_extend_gear_last::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_last::HashEqual> _OpCache_with_parameter_env_extend_gear_last = _OpCache_with_parameter_env_extend_gear_last_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_last.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_last.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_extend_gear_last(writeState);
-                            } else {
-                                copiedState.env_extend_gear_last(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_extend_gear_last writeState = copiedState._update_for_env_extend_gear_last();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_last_lock(_ProjectionRead_env_extend_gear_last_mutex);
-                                    _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_extend_gear_last.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_extend_gear_last";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_extend_gear_last";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_extend_gear_skip read__tr_env_extend_gear_skip_state = state._projected_state_for__tr_env_extend_gear_skip();
+                BSet<LandingGear_R6::POSITION> _trid_24;
                 auto _trid_24_ptr = _OpCache_tr_env_extend_gear_skip.find(read__tr_env_extend_gear_skip_state);
                 if(_trid_24_ptr == _OpCache_tr_env_extend_gear_skip.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_24 = state._tr_env_extend_gear_skip();
+                    _trid_24 = state._tr_env_extend_gear_skip();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_extend_gear_skip_lock(_ProjectionRead__tr_env_extend_gear_skip_mutex);
                         _OpCache_tr_env_extend_gear_skip.insert({read__tr_env_extend_gear_skip_state, _trid_24});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_24) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
+                } else {
+                    _trid_24 = _trid_24_ptr->second;
+                }
+
+                for(const LandingGear_R6::POSITION& param : _trid_24) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_extend_gear_skip readState = state._projected_state_for_env_extend_gear_skip();
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_extend_gear_skip readState = state._projected_state_for_env_extend_gear_skip();
+
+                    auto _OpCache_with_parameter_env_extend_gear_skip_ptr = _OpCache_env_extend_gear_skip.find(param);
+                    if(_OpCache_with_parameter_env_extend_gear_skip_ptr == _OpCache_env_extend_gear_skip.end()) {
+                        copiedState.env_extend_gear_skip(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip;
+                        _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex);
+                            _OpCache_env_extend_gear_skip.insert({param, _OpCache_with_parameter_env_extend_gear_skip});
+                        }
 
-                        auto _OpCache_with_parameter_env_extend_gear_skip_ptr = _OpCache_env_extend_gear_skip.find(param);
-                        if(_OpCache_with_parameter_env_extend_gear_skip_ptr == _OpCache_env_extend_gear_skip.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip = _OpCache_with_parameter_env_extend_gear_skip_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_skip.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_skip.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_extend_gear_skip(writeState);
+                        } else {
                             copiedState.env_extend_gear_skip(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip;
-                            _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex);
-                                _OpCache_env_extend_gear_skip.insert({param, _OpCache_with_parameter_env_extend_gear_skip});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip = _OpCache_with_parameter_env_extend_gear_skip_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_skip.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_skip.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_extend_gear_skip(writeState);
-                            } else {
-                                copiedState.env_extend_gear_skip(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex);
-                                    _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_extend_gear_skip";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_extend_gear_skip";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
+                }
+                LandingGear_R6::_ProjectionRead__tr_env_start_open_door read__tr_env_start_open_door_state = state._projected_state_for__tr_env_start_open_door();
+                BSet<LandingGear_R6::POSITION> _trid_25;
+                auto _trid_25_ptr = _OpCache_tr_env_start_open_door.find(read__tr_env_start_open_door_state);
+                if(_trid_25_ptr == _OpCache_tr_env_start_open_door.end()) {
+                    _trid_25 = state._tr_env_start_open_door();
+                    {
+                        std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_open_door_lock(_ProjectionRead__tr_env_start_open_door_mutex);
+                        _OpCache_tr_env_start_open_door.insert({read__tr_env_start_open_door_state, _trid_25});
+                    }
                 } else {
-                    BSet<LandingGear_R6::POSITION> _trid_24 = _trid_24_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_24) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_extend_gear_skip readState = state._projected_state_for_env_extend_gear_skip();
-
-                        auto _OpCache_with_parameter_env_extend_gear_skip_ptr = _OpCache_env_extend_gear_skip.find(param);
-                        if(_OpCache_with_parameter_env_extend_gear_skip_ptr == _OpCache_env_extend_gear_skip.end()) {
-                            copiedState.env_extend_gear_skip(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip;
-                            _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex);
-                                _OpCache_env_extend_gear_skip.insert({param, _OpCache_with_parameter_env_extend_gear_skip});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_extend_gear_skip, LandingGear_R6::_ProjectionWrite_env_extend_gear_skip, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::Hash, LandingGear_R6::_ProjectionRead_env_extend_gear_skip::HashEqual> _OpCache_with_parameter_env_extend_gear_skip = _OpCache_with_parameter_env_extend_gear_skip_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_extend_gear_skip.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_extend_gear_skip.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_extend_gear_skip(writeState);
-                            } else {
-                                copiedState.env_extend_gear_skip(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_extend_gear_skip writeState = copiedState._update_for_env_extend_gear_skip();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_extend_gear_skip_lock(_ProjectionRead_env_extend_gear_skip_mutex);
-                                    _OpCache_with_parameter_env_extend_gear_skip.insert({readState, writeState});
-                                }
-                            }
-                        }
-
-                        copiedState.stateAccessedVia = "env_extend_gear_skip";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
+                    _trid_25 = _trid_25_ptr->second;
                 }
-                LandingGear_R6::_ProjectionRead__tr_env_start_open_door read__tr_env_start_open_door_state = state._projected_state_for__tr_env_start_open_door();
-                auto _trid_25_ptr = _OpCache_tr_env_start_open_door.find(read__tr_env_start_open_door_state);
-                if(_trid_25_ptr == _OpCache_tr_env_start_open_door.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_25 = state._tr_env_start_open_door();
-                    {
-                        std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_open_door_lock(_ProjectionRead__tr_env_start_open_door_mutex);
-                        _OpCache_tr_env_start_open_door.insert({read__tr_env_start_open_door_state, _trid_25});
-                    }
-                    for(const LandingGear_R6::POSITION& param : _trid_25) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
 
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_start_open_door readState = state._projected_state_for_env_start_open_door();
-
-                        auto _OpCache_with_parameter_env_start_open_door_ptr = _OpCache_env_start_open_door.find(param);
-                        if(_OpCache_with_parameter_env_start_open_door_ptr == _OpCache_env_start_open_door.end()) {
-                            copiedState.env_start_open_door(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door;
-                            _OpCache_with_parameter_env_start_open_door.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex);
-                                _OpCache_env_start_open_door.insert({param, _OpCache_with_parameter_env_start_open_door});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_25) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door = _OpCache_with_parameter_env_start_open_door_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_start_open_door.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_start_open_door.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_start_open_door(writeState);
-                            } else {
-                                copiedState.env_start_open_door(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex);
-                                    _OpCache_with_parameter_env_start_open_door.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_start_open_door readState = state._projected_state_for_env_start_open_door();
+
+                    auto _OpCache_with_parameter_env_start_open_door_ptr = _OpCache_env_start_open_door.find(param);
+                    if(_OpCache_with_parameter_env_start_open_door_ptr == _OpCache_env_start_open_door.end()) {
+                        copiedState.env_start_open_door(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door;
+                        _OpCache_with_parameter_env_start_open_door.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex);
+                            _OpCache_env_start_open_door.insert({param, _OpCache_with_parameter_env_start_open_door});
                         }
 
-                        copiedState.stateAccessedVia = "env_start_open_door";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_25 = _trid_25_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_25) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_start_open_door readState = state._projected_state_for_env_start_open_door();
-
-                        auto _OpCache_with_parameter_env_start_open_door_ptr = _OpCache_env_start_open_door.find(param);
-                        if(_OpCache_with_parameter_env_start_open_door_ptr == _OpCache_env_start_open_door.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door = _OpCache_with_parameter_env_start_open_door_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_start_open_door.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_start_open_door.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_start_open_door(writeState);
+                        } else {
                             copiedState.env_start_open_door(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door;
-                            _OpCache_with_parameter_env_start_open_door.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex);
-                                _OpCache_env_start_open_door.insert({param, _OpCache_with_parameter_env_start_open_door});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_open_door, LandingGear_R6::_ProjectionWrite_env_start_open_door, LandingGear_R6::_ProjectionRead_env_start_open_door::Hash, LandingGear_R6::_ProjectionRead_env_start_open_door::HashEqual> _OpCache_with_parameter_env_start_open_door = _OpCache_with_parameter_env_start_open_door_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_start_open_door.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_start_open_door.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_start_open_door(writeState);
-                            } else {
-                                copiedState.env_start_open_door(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_start_open_door writeState = copiedState._update_for_env_start_open_door();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_start_open_door_lock(_ProjectionRead_env_start_open_door_mutex);
-                                    _OpCache_with_parameter_env_start_open_door.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_start_open_door.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_start_open_door";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_start_open_door";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_open_door_last read__tr_env_open_door_last_state = state._projected_state_for__tr_env_open_door_last();
+                BSet<LandingGear_R6::POSITION> _trid_26;
                 auto _trid_26_ptr = _OpCache_tr_env_open_door_last.find(read__tr_env_open_door_last_state);
                 if(_trid_26_ptr == _OpCache_tr_env_open_door_last.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_26 = state._tr_env_open_door_last();
+                    _trid_26 = state._tr_env_open_door_last();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_open_door_last_lock(_ProjectionRead__tr_env_open_door_last_mutex);
                         _OpCache_tr_env_open_door_last.insert({read__tr_env_open_door_last_state, _trid_26});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_26) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_open_door_last readState = state._projected_state_for_env_open_door_last();
+                } else {
+                    _trid_26 = _trid_26_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_open_door_last_ptr = _OpCache_env_open_door_last.find(param);
-                        if(_OpCache_with_parameter_env_open_door_last_ptr == _OpCache_env_open_door_last.end()) {
-                            copiedState.env_open_door_last(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last;
-                            _OpCache_with_parameter_env_open_door_last.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex);
-                                _OpCache_env_open_door_last.insert({param, _OpCache_with_parameter_env_open_door_last});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_26) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last = _OpCache_with_parameter_env_open_door_last_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_open_door_last.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_open_door_last.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_open_door_last(writeState);
-                            } else {
-                                copiedState.env_open_door_last(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex);
-                                    _OpCache_with_parameter_env_open_door_last.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_open_door_last readState = state._projected_state_for_env_open_door_last();
+
+                    auto _OpCache_with_parameter_env_open_door_last_ptr = _OpCache_env_open_door_last.find(param);
+                    if(_OpCache_with_parameter_env_open_door_last_ptr == _OpCache_env_open_door_last.end()) {
+                        copiedState.env_open_door_last(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last;
+                        _OpCache_with_parameter_env_open_door_last.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex);
+                            _OpCache_env_open_door_last.insert({param, _OpCache_with_parameter_env_open_door_last});
                         }
 
-                        copiedState.stateAccessedVia = "env_open_door_last";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_26 = _trid_26_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_26) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_open_door_last readState = state._projected_state_for_env_open_door_last();
-
-                        auto _OpCache_with_parameter_env_open_door_last_ptr = _OpCache_env_open_door_last.find(param);
-                        if(_OpCache_with_parameter_env_open_door_last_ptr == _OpCache_env_open_door_last.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last = _OpCache_with_parameter_env_open_door_last_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_open_door_last.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_open_door_last.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_open_door_last(writeState);
+                        } else {
                             copiedState.env_open_door_last(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last;
-                            _OpCache_with_parameter_env_open_door_last.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex);
-                                _OpCache_env_open_door_last.insert({param, _OpCache_with_parameter_env_open_door_last});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_last, LandingGear_R6::_ProjectionWrite_env_open_door_last, LandingGear_R6::_ProjectionRead_env_open_door_last::Hash, LandingGear_R6::_ProjectionRead_env_open_door_last::HashEqual> _OpCache_with_parameter_env_open_door_last = _OpCache_with_parameter_env_open_door_last_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_open_door_last.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_open_door_last.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_open_door_last(writeState);
-                            } else {
-                                copiedState.env_open_door_last(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_open_door_last writeState = copiedState._update_for_env_open_door_last();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_open_door_last_lock(_ProjectionRead_env_open_door_last_mutex);
-                                    _OpCache_with_parameter_env_open_door_last.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_open_door_last.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_open_door_last";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_open_door_last";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_open_door_skip read__tr_env_open_door_skip_state = state._projected_state_for__tr_env_open_door_skip();
+                BSet<LandingGear_R6::POSITION> _trid_27;
                 auto _trid_27_ptr = _OpCache_tr_env_open_door_skip.find(read__tr_env_open_door_skip_state);
                 if(_trid_27_ptr == _OpCache_tr_env_open_door_skip.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_27 = state._tr_env_open_door_skip();
+                    _trid_27 = state._tr_env_open_door_skip();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_open_door_skip_lock(_ProjectionRead__tr_env_open_door_skip_mutex);
                         _OpCache_tr_env_open_door_skip.insert({read__tr_env_open_door_skip_state, _trid_27});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_27) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_open_door_skip readState = state._projected_state_for_env_open_door_skip();
+                } else {
+                    _trid_27 = _trid_27_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_open_door_skip_ptr = _OpCache_env_open_door_skip.find(param);
-                        if(_OpCache_with_parameter_env_open_door_skip_ptr == _OpCache_env_open_door_skip.end()) {
-                            copiedState.env_open_door_skip(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip;
-                            _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex);
-                                _OpCache_env_open_door_skip.insert({param, _OpCache_with_parameter_env_open_door_skip});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_27) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip = _OpCache_with_parameter_env_open_door_skip_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_open_door_skip.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_open_door_skip.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_open_door_skip(writeState);
-                            } else {
-                                copiedState.env_open_door_skip(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex);
-                                    _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_open_door_skip readState = state._projected_state_for_env_open_door_skip();
+
+                    auto _OpCache_with_parameter_env_open_door_skip_ptr = _OpCache_env_open_door_skip.find(param);
+                    if(_OpCache_with_parameter_env_open_door_skip_ptr == _OpCache_env_open_door_skip.end()) {
+                        copiedState.env_open_door_skip(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip;
+                        _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex);
+                            _OpCache_env_open_door_skip.insert({param, _OpCache_with_parameter_env_open_door_skip});
                         }
 
-                        copiedState.stateAccessedVia = "env_open_door_skip";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_27 = _trid_27_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_27) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_open_door_skip readState = state._projected_state_for_env_open_door_skip();
-
-                        auto _OpCache_with_parameter_env_open_door_skip_ptr = _OpCache_env_open_door_skip.find(param);
-                        if(_OpCache_with_parameter_env_open_door_skip_ptr == _OpCache_env_open_door_skip.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip = _OpCache_with_parameter_env_open_door_skip_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_open_door_skip.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_open_door_skip.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_open_door_skip(writeState);
+                        } else {
                             copiedState.env_open_door_skip(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip;
-                            _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex);
-                                _OpCache_env_open_door_skip.insert({param, _OpCache_with_parameter_env_open_door_skip});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_open_door_skip, LandingGear_R6::_ProjectionWrite_env_open_door_skip, LandingGear_R6::_ProjectionRead_env_open_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_open_door_skip::HashEqual> _OpCache_with_parameter_env_open_door_skip = _OpCache_with_parameter_env_open_door_skip_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_open_door_skip.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_open_door_skip.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_open_door_skip(writeState);
-                            } else {
-                                copiedState.env_open_door_skip(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_open_door_skip writeState = copiedState._update_for_env_open_door_skip();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_open_door_skip_lock(_ProjectionRead_env_open_door_skip_mutex);
-                                    _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_open_door_skip.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_open_door_skip";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_open_door_skip";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_start_close_door read__tr_env_start_close_door_state = state._projected_state_for__tr_env_start_close_door();
+                BSet<LandingGear_R6::POSITION> _trid_28;
                 auto _trid_28_ptr = _OpCache_tr_env_start_close_door.find(read__tr_env_start_close_door_state);
                 if(_trid_28_ptr == _OpCache_tr_env_start_close_door.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_28 = state._tr_env_start_close_door();
+                    _trid_28 = state._tr_env_start_close_door();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_start_close_door_lock(_ProjectionRead__tr_env_start_close_door_mutex);
                         _OpCache_tr_env_start_close_door.insert({read__tr_env_start_close_door_state, _trid_28});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_28) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_start_close_door readState = state._projected_state_for_env_start_close_door();
+                } else {
+                    _trid_28 = _trid_28_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_start_close_door_ptr = _OpCache_env_start_close_door.find(param);
-                        if(_OpCache_with_parameter_env_start_close_door_ptr == _OpCache_env_start_close_door.end()) {
-                            copiedState.env_start_close_door(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door;
-                            _OpCache_with_parameter_env_start_close_door.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex);
-                                _OpCache_env_start_close_door.insert({param, _OpCache_with_parameter_env_start_close_door});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_28) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door = _OpCache_with_parameter_env_start_close_door_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_start_close_door.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_start_close_door.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_start_close_door(writeState);
-                            } else {
-                                copiedState.env_start_close_door(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex);
-                                    _OpCache_with_parameter_env_start_close_door.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_start_close_door readState = state._projected_state_for_env_start_close_door();
+
+                    auto _OpCache_with_parameter_env_start_close_door_ptr = _OpCache_env_start_close_door.find(param);
+                    if(_OpCache_with_parameter_env_start_close_door_ptr == _OpCache_env_start_close_door.end()) {
+                        copiedState.env_start_close_door(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door;
+                        _OpCache_with_parameter_env_start_close_door.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex);
+                            _OpCache_env_start_close_door.insert({param, _OpCache_with_parameter_env_start_close_door});
                         }
 
-                        copiedState.stateAccessedVia = "env_start_close_door";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_28 = _trid_28_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_28) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_start_close_door readState = state._projected_state_for_env_start_close_door();
-
-                        auto _OpCache_with_parameter_env_start_close_door_ptr = _OpCache_env_start_close_door.find(param);
-                        if(_OpCache_with_parameter_env_start_close_door_ptr == _OpCache_env_start_close_door.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door = _OpCache_with_parameter_env_start_close_door_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_start_close_door.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_start_close_door.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_start_close_door(writeState);
+                        } else {
                             copiedState.env_start_close_door(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door;
-                            _OpCache_with_parameter_env_start_close_door.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex);
-                                _OpCache_env_start_close_door.insert({param, _OpCache_with_parameter_env_start_close_door});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_start_close_door, LandingGear_R6::_ProjectionWrite_env_start_close_door, LandingGear_R6::_ProjectionRead_env_start_close_door::Hash, LandingGear_R6::_ProjectionRead_env_start_close_door::HashEqual> _OpCache_with_parameter_env_start_close_door = _OpCache_with_parameter_env_start_close_door_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_start_close_door.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_start_close_door.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_start_close_door(writeState);
-                            } else {
-                                copiedState.env_start_close_door(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_start_close_door writeState = copiedState._update_for_env_start_close_door();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_start_close_door_lock(_ProjectionRead_env_start_close_door_mutex);
-                                    _OpCache_with_parameter_env_start_close_door.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_start_close_door.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_start_close_door";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_start_close_door";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_close_door read__tr_env_close_door_state = state._projected_state_for__tr_env_close_door();
+                BSet<LandingGear_R6::POSITION> _trid_29;
                 auto _trid_29_ptr = _OpCache_tr_env_close_door.find(read__tr_env_close_door_state);
                 if(_trid_29_ptr == _OpCache_tr_env_close_door.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_29 = state._tr_env_close_door();
+                    _trid_29 = state._tr_env_close_door();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_close_door_lock(_ProjectionRead__tr_env_close_door_mutex);
                         _OpCache_tr_env_close_door.insert({read__tr_env_close_door_state, _trid_29});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_29) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_close_door readState = state._projected_state_for_env_close_door();
+                } else {
+                    _trid_29 = _trid_29_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_close_door_ptr = _OpCache_env_close_door.find(param);
-                        if(_OpCache_with_parameter_env_close_door_ptr == _OpCache_env_close_door.end()) {
-                            copiedState.env_close_door(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door;
-                            _OpCache_with_parameter_env_close_door.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex);
-                                _OpCache_env_close_door.insert({param, _OpCache_with_parameter_env_close_door});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_29) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door = _OpCache_with_parameter_env_close_door_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_close_door.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_close_door.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_close_door writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_close_door(writeState);
-                            } else {
-                                copiedState.env_close_door(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex);
-                                    _OpCache_with_parameter_env_close_door.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_close_door readState = state._projected_state_for_env_close_door();
+
+                    auto _OpCache_with_parameter_env_close_door_ptr = _OpCache_env_close_door.find(param);
+                    if(_OpCache_with_parameter_env_close_door_ptr == _OpCache_env_close_door.end()) {
+                        copiedState.env_close_door(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door;
+                        _OpCache_with_parameter_env_close_door.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex);
+                            _OpCache_env_close_door.insert({param, _OpCache_with_parameter_env_close_door});
                         }
 
-                        copiedState.stateAccessedVia = "env_close_door";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_29 = _trid_29_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_29) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_close_door readState = state._projected_state_for_env_close_door();
-
-                        auto _OpCache_with_parameter_env_close_door_ptr = _OpCache_env_close_door.find(param);
-                        if(_OpCache_with_parameter_env_close_door_ptr == _OpCache_env_close_door.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door = _OpCache_with_parameter_env_close_door_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_close_door.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_close_door.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_close_door writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_close_door(writeState);
+                        } else {
                             copiedState.env_close_door(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door;
-                            _OpCache_with_parameter_env_close_door.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex);
-                                _OpCache_env_close_door.insert({param, _OpCache_with_parameter_env_close_door});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door, LandingGear_R6::_ProjectionWrite_env_close_door, LandingGear_R6::_ProjectionRead_env_close_door::Hash, LandingGear_R6::_ProjectionRead_env_close_door::HashEqual> _OpCache_with_parameter_env_close_door = _OpCache_with_parameter_env_close_door_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_close_door.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_close_door.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_close_door writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_close_door(writeState);
-                            } else {
-                                copiedState.env_close_door(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_close_door writeState = copiedState._update_for_env_close_door();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_close_door_lock(_ProjectionRead_env_close_door_mutex);
-                                    _OpCache_with_parameter_env_close_door.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_close_door.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_close_door";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_close_door";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_close_door_skip read__tr_env_close_door_skip_state = state._projected_state_for__tr_env_close_door_skip();
+                BSet<LandingGear_R6::POSITION> _trid_30;
                 auto _trid_30_ptr = _OpCache_tr_env_close_door_skip.find(read__tr_env_close_door_skip_state);
                 if(_trid_30_ptr == _OpCache_tr_env_close_door_skip.end()) {
-                    BSet<LandingGear_R6::POSITION> _trid_30 = state._tr_env_close_door_skip();
+                    _trid_30 = state._tr_env_close_door_skip();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_close_door_skip_lock(_ProjectionRead__tr_env_close_door_skip_mutex);
                         _OpCache_tr_env_close_door_skip.insert({read__tr_env_close_door_skip_state, _trid_30});
                     }
-                    for(const LandingGear_R6::POSITION& param : _trid_30) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_close_door_skip readState = state._projected_state_for_env_close_door_skip();
+                } else {
+                    _trid_30 = _trid_30_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_close_door_skip_ptr = _OpCache_env_close_door_skip.find(param);
-                        if(_OpCache_with_parameter_env_close_door_skip_ptr == _OpCache_env_close_door_skip.end()) {
-                            copiedState.env_close_door_skip(_tmp_1);
-                            LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip;
-                            _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex);
-                                _OpCache_env_close_door_skip.insert({param, _OpCache_with_parameter_env_close_door_skip});
-                            }
+                for(const LandingGear_R6::POSITION& param : _trid_30) {
+                    LandingGear_R6::POSITION _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip = _OpCache_with_parameter_env_close_door_skip_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_close_door_skip.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_close_door_skip.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_close_door_skip(writeState);
-                            } else {
-                                copiedState.env_close_door_skip(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex);
-                                    _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState});
-                                }
-                            }
+                    LandingGear_R6 copiedState = state._copy();
+                    LandingGear_R6::_ProjectionRead_env_close_door_skip readState = state._projected_state_for_env_close_door_skip();
+
+                    auto _OpCache_with_parameter_env_close_door_skip_ptr = _OpCache_env_close_door_skip.find(param);
+                    if(_OpCache_with_parameter_env_close_door_skip_ptr == _OpCache_env_close_door_skip.end()) {
+                        copiedState.env_close_door_skip(_tmp_1);
+                        LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip();
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip;
+                        _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex);
+                            _OpCache_env_close_door_skip.insert({param, _OpCache_with_parameter_env_close_door_skip});
                         }
 
-                        copiedState.stateAccessedVia = "env_close_door_skip";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<LandingGear_R6::POSITION> _trid_30 = _trid_30_ptr->second;
-                    for(const LandingGear_R6::POSITION& param : _trid_30) {
-                        LandingGear_R6::POSITION _tmp_1 = param;
-
-                        LandingGear_R6 copiedState = state._copy();
-                        LandingGear_R6::_ProjectionRead_env_close_door_skip readState = state._projected_state_for_env_close_door_skip();
-
-                        auto _OpCache_with_parameter_env_close_door_skip_ptr = _OpCache_env_close_door_skip.find(param);
-                        if(_OpCache_with_parameter_env_close_door_skip_ptr == _OpCache_env_close_door_skip.end()) {
+                    } else {
+                        std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip = _OpCache_with_parameter_env_close_door_skip_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_close_door_skip.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_close_door_skip.end()) {
+                            LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_close_door_skip(writeState);
+                        } else {
                             copiedState.env_close_door_skip(_tmp_1);
                             LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip();
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip;
-                            _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex);
-                                _OpCache_env_close_door_skip.insert({param, _OpCache_with_parameter_env_close_door_skip});
-                            }
-
-                        } else {
-                            std::unordered_map<LandingGear_R6::_ProjectionRead_env_close_door_skip, LandingGear_R6::_ProjectionWrite_env_close_door_skip, LandingGear_R6::_ProjectionRead_env_close_door_skip::Hash, LandingGear_R6::_ProjectionRead_env_close_door_skip::HashEqual> _OpCache_with_parameter_env_close_door_skip = _OpCache_with_parameter_env_close_door_skip_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_close_door_skip.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_close_door_skip.end()) {
-                                LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_close_door_skip(writeState);
-                            } else {
-                                copiedState.env_close_door_skip(_tmp_1);
-                                LandingGear_R6::_ProjectionWrite_env_close_door_skip writeState = copiedState._update_for_env_close_door_skip();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_close_door_skip_lock(_ProjectionRead_env_close_door_skip_mutex);
-                                    _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_close_door_skip.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_close_door_skip";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_close_door_skip";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -12486,7 +12164,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "toggle_handle_up";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_toggle_handle_down read__tr_toggle_handle_down_state = state._projected_state_for__tr_toggle_handle_down();
                 bool _trid_32;
@@ -12533,7 +12214,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "toggle_handle_down";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stimulate_general_valve read__tr_con_stimulate_general_valve_state = state._projected_state_for__tr_con_stimulate_general_valve();
                 bool _trid_33;
@@ -12580,7 +12264,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stimulate_general_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_con_stop_stimulate_general_valve read__tr_con_stop_stimulate_general_valve_state = state._projected_state_for__tr_con_stop_stimulate_general_valve();
                 bool _trid_34;
@@ -12627,7 +12314,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "con_stop_stimulate_general_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_evn_open_general_valve read__tr_evn_open_general_valve_state = state._projected_state_for__tr_evn_open_general_valve();
                 bool _trid_35;
@@ -12674,7 +12364,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "evn_open_general_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_evn_close_general_valve read__tr_evn_close_general_valve_state = state._projected_state_for__tr_evn_close_general_valve();
                 bool _trid_36;
@@ -12721,7 +12414,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "evn_close_general_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_close_analogical_switch read__tr_env_close_analogical_switch_state = state._projected_state_for__tr_env_close_analogical_switch();
                 bool _trid_37;
@@ -12768,7 +12464,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "env_close_analogical_switch";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 LandingGear_R6::_ProjectionRead__tr_env_open_analogical_switch read__tr_env_open_analogical_switch_state = state._projected_state_for__tr_env_open_analogical_switch();
                 bool _trid_38;
@@ -12815,7 +12514,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "env_open_analogical_switch";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             } else {
@@ -12824,126 +12526,180 @@ class ModelChecker {
                     copiedState.begin_flying();
                     copiedState.stateAccessedVia = "begin_flying";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_land_plane()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.land_plane();
                     copiedState.stateAccessedVia = "land_plane";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_open_valve_door_open()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.open_valve_door_open();
                     copiedState.stateAccessedVia = "open_valve_door_open";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_close_valve_door_open()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.close_valve_door_open();
                     copiedState.stateAccessedVia = "close_valve_door_open";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_open_valve_door_close()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.open_valve_door_close();
                     copiedState.stateAccessedVia = "open_valve_door_close";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_close_valve_door_close()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.close_valve_door_close();
                     copiedState.stateAccessedVia = "close_valve_door_close";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_open_valve_retract_gear()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.open_valve_retract_gear();
                     copiedState.stateAccessedVia = "open_valve_retract_gear";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_close_valve_retract_gear()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.close_valve_retract_gear();
                     copiedState.stateAccessedVia = "close_valve_retract_gear";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_open_valve_extend_gear()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.open_valve_extend_gear();
                     copiedState.stateAccessedVia = "open_valve_extend_gear";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_close_valve_extend_gear()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.close_valve_extend_gear();
                     copiedState.stateAccessedVia = "close_valve_extend_gear";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stimulate_open_door_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stimulate_open_door_valve();
                     copiedState.stateAccessedVia = "con_stimulate_open_door_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stop_stimulate_open_door_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stop_stimulate_open_door_valve();
                     copiedState.stateAccessedVia = "con_stop_stimulate_open_door_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stimulate_close_door_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stimulate_close_door_valve();
                     copiedState.stateAccessedVia = "con_stimulate_close_door_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stop_stimulate_close_door_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stop_stimulate_close_door_valve();
                     copiedState.stateAccessedVia = "con_stop_stimulate_close_door_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stimulate_retract_gear_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stimulate_retract_gear_valve();
                     copiedState.stateAccessedVia = "con_stimulate_retract_gear_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stop_stimulate_retract_gear_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stop_stimulate_retract_gear_valve();
                     copiedState.stateAccessedVia = "con_stop_stimulate_retract_gear_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stimulate_extend_gear_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stimulate_extend_gear_valve();
                     copiedState.stateAccessedVia = "con_stimulate_extend_gear_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stop_stimulate_extend_gear_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stop_stimulate_extend_gear_valve();
                     copiedState.stateAccessedVia = "con_stop_stimulate_extend_gear_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_19 = state._tr_env_start_retracting_first();
                 for(const LandingGear_R6::POSITION& param : _trid_19) {
@@ -12953,7 +12709,10 @@ class ModelChecker {
                     copiedState.env_start_retracting_first(_tmp_1);
                     copiedState.stateAccessedVia = "env_start_retracting_first";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_20 = state._tr_env_retract_gear_skip();
                 for(const LandingGear_R6::POSITION& param : _trid_20) {
@@ -12963,7 +12722,10 @@ class ModelChecker {
                     copiedState.env_retract_gear_skip(_tmp_1);
                     copiedState.stateAccessedVia = "env_retract_gear_skip";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_21 = state._tr_env_retract_gear_last();
                 for(const LandingGear_R6::POSITION& param : _trid_21) {
@@ -12973,7 +12735,10 @@ class ModelChecker {
                     copiedState.env_retract_gear_last(_tmp_1);
                     copiedState.stateAccessedVia = "env_retract_gear_last";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_22 = state._tr_env_start_extending();
                 for(const LandingGear_R6::POSITION& param : _trid_22) {
@@ -12983,7 +12748,10 @@ class ModelChecker {
                     copiedState.env_start_extending(_tmp_1);
                     copiedState.stateAccessedVia = "env_start_extending";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_23 = state._tr_env_extend_gear_last();
                 for(const LandingGear_R6::POSITION& param : _trid_23) {
@@ -12993,7 +12761,10 @@ class ModelChecker {
                     copiedState.env_extend_gear_last(_tmp_1);
                     copiedState.stateAccessedVia = "env_extend_gear_last";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_24 = state._tr_env_extend_gear_skip();
                 for(const LandingGear_R6::POSITION& param : _trid_24) {
@@ -13003,7 +12774,10 @@ class ModelChecker {
                     copiedState.env_extend_gear_skip(_tmp_1);
                     copiedState.stateAccessedVia = "env_extend_gear_skip";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_25 = state._tr_env_start_open_door();
                 for(const LandingGear_R6::POSITION& param : _trid_25) {
@@ -13013,7 +12787,10 @@ class ModelChecker {
                     copiedState.env_start_open_door(_tmp_1);
                     copiedState.stateAccessedVia = "env_start_open_door";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_26 = state._tr_env_open_door_last();
                 for(const LandingGear_R6::POSITION& param : _trid_26) {
@@ -13023,7 +12800,10 @@ class ModelChecker {
                     copiedState.env_open_door_last(_tmp_1);
                     copiedState.stateAccessedVia = "env_open_door_last";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_27 = state._tr_env_open_door_skip();
                 for(const LandingGear_R6::POSITION& param : _trid_27) {
@@ -13033,7 +12813,10 @@ class ModelChecker {
                     copiedState.env_open_door_skip(_tmp_1);
                     copiedState.stateAccessedVia = "env_open_door_skip";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_28 = state._tr_env_start_close_door();
                 for(const LandingGear_R6::POSITION& param : _trid_28) {
@@ -13043,7 +12826,10 @@ class ModelChecker {
                     copiedState.env_start_close_door(_tmp_1);
                     copiedState.stateAccessedVia = "env_start_close_door";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_29 = state._tr_env_close_door();
                 for(const LandingGear_R6::POSITION& param : _trid_29) {
@@ -13053,7 +12839,10 @@ class ModelChecker {
                     copiedState.env_close_door(_tmp_1);
                     copiedState.stateAccessedVia = "env_close_door";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<LandingGear_R6::POSITION> _trid_30 = state._tr_env_close_door_skip();
                 for(const LandingGear_R6::POSITION& param : _trid_30) {
@@ -13063,63 +12852,90 @@ class ModelChecker {
                     copiedState.env_close_door_skip(_tmp_1);
                     copiedState.stateAccessedVia = "env_close_door_skip";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_toggle_handle_up()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.toggle_handle_up();
                     copiedState.stateAccessedVia = "toggle_handle_up";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_toggle_handle_down()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.toggle_handle_down();
                     copiedState.stateAccessedVia = "toggle_handle_down";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stimulate_general_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stimulate_general_valve();
                     copiedState.stateAccessedVia = "con_stimulate_general_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_con_stop_stimulate_general_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.con_stop_stimulate_general_valve();
                     copiedState.stateAccessedVia = "con_stop_stimulate_general_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_evn_open_general_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.evn_open_general_valve();
                     copiedState.stateAccessedVia = "evn_open_general_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_evn_close_general_valve()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.evn_close_general_valve();
                     copiedState.stateAccessedVia = "evn_close_general_valve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_env_close_analogical_switch()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.env_close_analogical_switch();
                     copiedState.stateAccessedVia = "env_close_analogical_switch";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_env_open_analogical_switch()) {
                     LandingGear_R6 copiedState = state._copy();
                     copiedState.env_open_analogical_switch();
                     copiedState.stateAccessedVia = "env_open_analogical_switch";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/Lift_MC_Large.cpp b/benchmarks/model_checking_opreuse/C++/Lift_MC_Large.cpp
index 65e280dbc615204af6ab20dd50c8faa946d01db1..4f184f8960bbf5c353a7844491fb462b63bb812f 100644
--- a/benchmarks/model_checking_opreuse/C++/Lift_MC_Large.cpp
+++ b/benchmarks/model_checking_opreuse/C++/Lift_MC_Large.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -680,12 +679,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 Lift_MC_Large state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<Lift_MC_Large, Lift_MC_Large::Hash, Lift_MC_Large::HashEqual> nextStates = generateNextStates(state);
@@ -706,12 +709,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -721,24 +726,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -827,7 +835,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "inc";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 Lift_MC_Large::_ProjectionRead__tr_dec read__tr_dec_state = state._projected_state_for__tr_dec();
                 bool _trid_2;
@@ -874,7 +885,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "dec";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             } else {
@@ -883,14 +897,20 @@ class ModelChecker {
                     copiedState.inc();
                     copiedState.stateAccessedVia = "inc";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_dec()) {
                     Lift_MC_Large copiedState = state._copy();
                     copiedState.dec();
                     copiedState.stateAccessedVia = "dec";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/QueensWithEvents_4.cpp b/benchmarks/model_checking_opreuse/C++/QueensWithEvents_4.cpp
index 24e0fd57581f27fcb0ae0a808e1e790e5e5de4dc..1104e37cfad9efc171b1c56a1284ef9a33dc107a 100644
--- a/benchmarks/model_checking_opreuse/C++/QueensWithEvents_4.cpp
+++ b/benchmarks/model_checking_opreuse/C++/QueensWithEvents_4.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -510,12 +509,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 QueensWithEvents_4 state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<QueensWithEvents_4, QueensWithEvents_4::Hash, QueensWithEvents_4::HashEqual> nextStates = generateNextStates(state);
@@ -536,12 +539,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -551,24 +556,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -613,87 +621,55 @@ class ModelChecker {
             std::unordered_set<QueensWithEvents_4, QueensWithEvents_4::Hash, QueensWithEvents_4::HashEqual> result = std::unordered_set<QueensWithEvents_4, QueensWithEvents_4::Hash, QueensWithEvents_4::HashEqual>();
             if(isCaching) {
                 QueensWithEvents_4::_ProjectionRead__tr_Solve read__tr_Solve_state = state._projected_state_for__tr_Solve();
+                BSet<BRelation<BInteger, BInteger >> _trid_1;
                 auto _trid_1_ptr = _OpCache_tr_Solve.find(read__tr_Solve_state);
                 if(_trid_1_ptr == _OpCache_tr_Solve.end()) {
-                    BSet<BRelation<BInteger, BInteger >> _trid_1 = state._tr_Solve();
+                    _trid_1 = state._tr_Solve();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Solve_lock(_ProjectionRead__tr_Solve_mutex);
                         _OpCache_tr_Solve.insert({read__tr_Solve_state, _trid_1});
                     }
-                    for(const BRelation<BInteger, BInteger >& param : _trid_1) {
-                        BRelation<BInteger, BInteger > _tmp_1 = param;
-
-                        QueensWithEvents_4 copiedState = state._copy();
-                        QueensWithEvents_4::_ProjectionRead_Solve readState = state._projected_state_for_Solve();
+                } else {
+                    _trid_1 = _trid_1_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Solve_ptr = _OpCache_Solve.find(param);
-                        if(_OpCache_with_parameter_Solve_ptr == _OpCache_Solve.end()) {
-                            copiedState.Solve(_tmp_1);
-                            QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve();
-                            std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve;
-                            _OpCache_with_parameter_Solve.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex);
-                                _OpCache_Solve.insert({param, _OpCache_with_parameter_Solve});
-                            }
+                for(const BRelation<BInteger, BInteger >& param : _trid_1) {
+                    BRelation<BInteger, BInteger > _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve = _OpCache_with_parameter_Solve_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Solve.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Solve.end()) {
-                                QueensWithEvents_4::_ProjectionWrite_Solve writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Solve(writeState);
-                            } else {
-                                copiedState.Solve(_tmp_1);
-                                QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex);
-                                    _OpCache_with_parameter_Solve.insert({readState, writeState});
-                                }
-                            }
+                    QueensWithEvents_4 copiedState = state._copy();
+                    QueensWithEvents_4::_ProjectionRead_Solve readState = state._projected_state_for_Solve();
+
+                    auto _OpCache_with_parameter_Solve_ptr = _OpCache_Solve.find(param);
+                    if(_OpCache_with_parameter_Solve_ptr == _OpCache_Solve.end()) {
+                        copiedState.Solve(_tmp_1);
+                        QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve();
+                        std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve;
+                        _OpCache_with_parameter_Solve.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex);
+                            _OpCache_Solve.insert({param, _OpCache_with_parameter_Solve});
                         }
 
-                        copiedState.stateAccessedVia = "Solve";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BRelation<BInteger, BInteger >> _trid_1 = _trid_1_ptr->second;
-                    for(const BRelation<BInteger, BInteger >& param : _trid_1) {
-                        BRelation<BInteger, BInteger > _tmp_1 = param;
-
-                        QueensWithEvents_4 copiedState = state._copy();
-                        QueensWithEvents_4::_ProjectionRead_Solve readState = state._projected_state_for_Solve();
-
-                        auto _OpCache_with_parameter_Solve_ptr = _OpCache_Solve.find(param);
-                        if(_OpCache_with_parameter_Solve_ptr == _OpCache_Solve.end()) {
+                    } else {
+                        std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve = _OpCache_with_parameter_Solve_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Solve.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Solve.end()) {
+                            QueensWithEvents_4::_ProjectionWrite_Solve writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Solve(writeState);
+                        } else {
                             copiedState.Solve(_tmp_1);
                             QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve();
-                            std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve;
-                            _OpCache_with_parameter_Solve.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex);
-                                _OpCache_Solve.insert({param, _OpCache_with_parameter_Solve});
-                            }
-
-                        } else {
-                            std::unordered_map<QueensWithEvents_4::_ProjectionRead_Solve, QueensWithEvents_4::_ProjectionWrite_Solve, QueensWithEvents_4::_ProjectionRead_Solve::Hash, QueensWithEvents_4::_ProjectionRead_Solve::HashEqual> _OpCache_with_parameter_Solve = _OpCache_with_parameter_Solve_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Solve.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Solve.end()) {
-                                QueensWithEvents_4::_ProjectionWrite_Solve writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Solve(writeState);
-                            } else {
-                                copiedState.Solve(_tmp_1);
-                                QueensWithEvents_4::_ProjectionWrite_Solve writeState = copiedState._update_for_Solve();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Solve_lock(_ProjectionRead_Solve_mutex);
-                                    _OpCache_with_parameter_Solve.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Solve.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Solve";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Solve";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -707,7 +683,10 @@ class ModelChecker {
                     copiedState.Solve(_tmp_1);
                     copiedState.stateAccessedVia = "Solve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/Train_1_beebook_deterministic_MC_POR_v3.cpp b/benchmarks/model_checking_opreuse/C++/Train_1_beebook_deterministic_MC_POR_v3.cpp
index b7a2153c4f5b4f4e8dac30522994b044215cf896..0b5c4bc56063a61f009fe792636de63f89e6a263 100644
--- a/benchmarks/model_checking_opreuse/C++/Train_1_beebook_deterministic_MC_POR_v3.cpp
+++ b/benchmarks/model_checking_opreuse/C++/Train_1_beebook_deterministic_MC_POR_v3.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -3402,12 +3401,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 Train_1_beebook_deterministic_MC_POR_v3 state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<Train_1_beebook_deterministic_MC_POR_v3, Train_1_beebook_deterministic_MC_POR_v3::Hash, Train_1_beebook_deterministic_MC_POR_v3::HashEqual> nextStates = generateNextStates(state);
@@ -3428,12 +3431,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -3443,24 +3448,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -3505,682 +3513,426 @@ class ModelChecker {
             std::unordered_set<Train_1_beebook_deterministic_MC_POR_v3, Train_1_beebook_deterministic_MC_POR_v3::Hash, Train_1_beebook_deterministic_MC_POR_v3::HashEqual> result = std::unordered_set<Train_1_beebook_deterministic_MC_POR_v3, Train_1_beebook_deterministic_MC_POR_v3::Hash, Train_1_beebook_deterministic_MC_POR_v3::HashEqual>();
             if(isCaching) {
                 Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_route_reservation read__tr_route_reservation_state = state._projected_state_for__tr_route_reservation();
+                BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_1;
                 auto _trid_1_ptr = _OpCache_tr_route_reservation.find(read__tr_route_reservation_state);
                 if(_trid_1_ptr == _OpCache_tr_route_reservation.end()) {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_1 = state._tr_route_reservation();
+                    _trid_1 = state._tr_route_reservation();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_route_reservation_lock(_ProjectionRead__tr_route_reservation_mutex);
                         _OpCache_tr_route_reservation.insert({read__tr_route_reservation_state, _trid_1});
                     }
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_1) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation readState = state._projected_state_for_route_reservation();
+                } else {
+                    _trid_1 = _trid_1_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_route_reservation_ptr = _OpCache_route_reservation.find(param);
-                        if(_OpCache_with_parameter_route_reservation_ptr == _OpCache_route_reservation.end()) {
-                            copiedState.route_reservation(_tmp_1);
-                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation;
-                            _OpCache_with_parameter_route_reservation.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex);
-                                _OpCache_route_reservation.insert({param, _OpCache_with_parameter_route_reservation});
-                            }
+                for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_1) {
+                    Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation = _OpCache_with_parameter_route_reservation_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_route_reservation.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_route_reservation.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_route_reservation(writeState);
-                            } else {
-                                copiedState.route_reservation(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex);
-                                    _OpCache_with_parameter_route_reservation.insert({readState, writeState});
-                                }
-                            }
+                    Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
+                    Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation readState = state._projected_state_for_route_reservation();
+
+                    auto _OpCache_with_parameter_route_reservation_ptr = _OpCache_route_reservation.find(param);
+                    if(_OpCache_with_parameter_route_reservation_ptr == _OpCache_route_reservation.end()) {
+                        copiedState.route_reservation(_tmp_1);
+                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation();
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation;
+                        _OpCache_with_parameter_route_reservation.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex);
+                            _OpCache_route_reservation.insert({param, _OpCache_with_parameter_route_reservation});
                         }
 
-                        copiedState.stateAccessedVia = "route_reservation";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_1 = _trid_1_ptr->second;
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_1) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation readState = state._projected_state_for_route_reservation();
-
-                        auto _OpCache_with_parameter_route_reservation_ptr = _OpCache_route_reservation.find(param);
-                        if(_OpCache_with_parameter_route_reservation_ptr == _OpCache_route_reservation.end()) {
+                    } else {
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation = _OpCache_with_parameter_route_reservation_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_route_reservation.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_route_reservation.end()) {
+                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_route_reservation(writeState);
+                        } else {
                             copiedState.route_reservation(_tmp_1);
                             Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation;
-                            _OpCache_with_parameter_route_reservation.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex);
-                                _OpCache_route_reservation.insert({param, _OpCache_with_parameter_route_reservation});
-                            }
-
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_reservation::HashEqual> _OpCache_with_parameter_route_reservation = _OpCache_with_parameter_route_reservation_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_route_reservation.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_route_reservation.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_route_reservation(writeState);
-                            } else {
-                                copiedState.route_reservation(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_reservation writeState = copiedState._update_for_route_reservation();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_route_reservation_lock(_ProjectionRead_route_reservation_mutex);
-                                    _OpCache_with_parameter_route_reservation.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_route_reservation.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "route_reservation";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "route_reservation";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_route_freeing read__tr_route_freeing_state = state._projected_state_for__tr_route_freeing();
+                BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_2;
                 auto _trid_2_ptr = _OpCache_tr_route_freeing.find(read__tr_route_freeing_state);
                 if(_trid_2_ptr == _OpCache_tr_route_freeing.end()) {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_2 = state._tr_route_freeing();
+                    _trid_2 = state._tr_route_freeing();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_route_freeing_lock(_ProjectionRead__tr_route_freeing_mutex);
                         _OpCache_tr_route_freeing.insert({read__tr_route_freeing_state, _trid_2});
                     }
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_2) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing readState = state._projected_state_for_route_freeing();
+                } else {
+                    _trid_2 = _trid_2_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_route_freeing_ptr = _OpCache_route_freeing.find(param);
-                        if(_OpCache_with_parameter_route_freeing_ptr == _OpCache_route_freeing.end()) {
-                            copiedState.route_freeing(_tmp_1);
-                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing;
-                            _OpCache_with_parameter_route_freeing.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex);
-                                _OpCache_route_freeing.insert({param, _OpCache_with_parameter_route_freeing});
-                            }
+                for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_2) {
+                    Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing = _OpCache_with_parameter_route_freeing_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_route_freeing.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_route_freeing.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_route_freeing(writeState);
-                            } else {
-                                copiedState.route_freeing(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex);
-                                    _OpCache_with_parameter_route_freeing.insert({readState, writeState});
-                                }
-                            }
+                    Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
+                    Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing readState = state._projected_state_for_route_freeing();
+
+                    auto _OpCache_with_parameter_route_freeing_ptr = _OpCache_route_freeing.find(param);
+                    if(_OpCache_with_parameter_route_freeing_ptr == _OpCache_route_freeing.end()) {
+                        copiedState.route_freeing(_tmp_1);
+                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing();
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing;
+                        _OpCache_with_parameter_route_freeing.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex);
+                            _OpCache_route_freeing.insert({param, _OpCache_with_parameter_route_freeing});
                         }
 
-                        copiedState.stateAccessedVia = "route_freeing";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_2 = _trid_2_ptr->second;
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_2) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing readState = state._projected_state_for_route_freeing();
-
-                        auto _OpCache_with_parameter_route_freeing_ptr = _OpCache_route_freeing.find(param);
-                        if(_OpCache_with_parameter_route_freeing_ptr == _OpCache_route_freeing.end()) {
+                    } else {
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing = _OpCache_with_parameter_route_freeing_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_route_freeing.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_route_freeing.end()) {
+                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_route_freeing(writeState);
+                        } else {
                             copiedState.route_freeing(_tmp_1);
                             Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing;
-                            _OpCache_with_parameter_route_freeing.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex);
-                                _OpCache_route_freeing.insert({param, _OpCache_with_parameter_route_freeing});
-                            }
-
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_freeing::HashEqual> _OpCache_with_parameter_route_freeing = _OpCache_with_parameter_route_freeing_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_route_freeing.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_route_freeing.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_route_freeing(writeState);
-                            } else {
-                                copiedState.route_freeing(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_freeing writeState = copiedState._update_for_route_freeing();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_route_freeing_lock(_ProjectionRead_route_freeing_mutex);
-                                    _OpCache_with_parameter_route_freeing.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_route_freeing.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "route_freeing";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "route_freeing";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_FRONT_MOVE_1 read__tr_FRONT_MOVE_1_state = state._projected_state_for__tr_FRONT_MOVE_1();
+                BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_3;
                 auto _trid_3_ptr = _OpCache_tr_FRONT_MOVE_1.find(read__tr_FRONT_MOVE_1_state);
                 if(_trid_3_ptr == _OpCache_tr_FRONT_MOVE_1.end()) {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_3 = state._tr_FRONT_MOVE_1();
+                    _trid_3 = state._tr_FRONT_MOVE_1();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_FRONT_MOVE_1_lock(_ProjectionRead__tr_FRONT_MOVE_1_mutex);
                         _OpCache_tr_FRONT_MOVE_1.insert({read__tr_FRONT_MOVE_1_state, _trid_3});
                     }
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_3) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1 readState = state._projected_state_for_FRONT_MOVE_1();
+                } else {
+                    _trid_3 = _trid_3_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_FRONT_MOVE_1_ptr = _OpCache_FRONT_MOVE_1.find(param);
-                        if(_OpCache_with_parameter_FRONT_MOVE_1_ptr == _OpCache_FRONT_MOVE_1.end()) {
-                            copiedState.FRONT_MOVE_1(_tmp_1);
-                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1;
-                            _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex);
-                                _OpCache_FRONT_MOVE_1.insert({param, _OpCache_with_parameter_FRONT_MOVE_1});
-                            }
+                for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_3) {
+                    Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1 = _OpCache_with_parameter_FRONT_MOVE_1_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_1.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_1.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_FRONT_MOVE_1(writeState);
-                            } else {
-                                copiedState.FRONT_MOVE_1(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex);
-                                    _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState});
-                                }
-                            }
+                    Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
+                    Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1 readState = state._projected_state_for_FRONT_MOVE_1();
+
+                    auto _OpCache_with_parameter_FRONT_MOVE_1_ptr = _OpCache_FRONT_MOVE_1.find(param);
+                    if(_OpCache_with_parameter_FRONT_MOVE_1_ptr == _OpCache_FRONT_MOVE_1.end()) {
+                        copiedState.FRONT_MOVE_1(_tmp_1);
+                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1();
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1;
+                        _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex);
+                            _OpCache_FRONT_MOVE_1.insert({param, _OpCache_with_parameter_FRONT_MOVE_1});
                         }
 
-                        copiedState.stateAccessedVia = "FRONT_MOVE_1";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_3 = _trid_3_ptr->second;
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_3) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1 readState = state._projected_state_for_FRONT_MOVE_1();
-
-                        auto _OpCache_with_parameter_FRONT_MOVE_1_ptr = _OpCache_FRONT_MOVE_1.find(param);
-                        if(_OpCache_with_parameter_FRONT_MOVE_1_ptr == _OpCache_FRONT_MOVE_1.end()) {
+                    } else {
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1 = _OpCache_with_parameter_FRONT_MOVE_1_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_1.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_1.end()) {
+                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_FRONT_MOVE_1(writeState);
+                        } else {
                             copiedState.FRONT_MOVE_1(_tmp_1);
                             Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1;
-                            _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex);
-                                _OpCache_FRONT_MOVE_1.insert({param, _OpCache_with_parameter_FRONT_MOVE_1});
-                            }
-
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_1::HashEqual> _OpCache_with_parameter_FRONT_MOVE_1 = _OpCache_with_parameter_FRONT_MOVE_1_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_1.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_1.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_FRONT_MOVE_1(writeState);
-                            } else {
-                                copiedState.FRONT_MOVE_1(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_1 writeState = copiedState._update_for_FRONT_MOVE_1();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_1_lock(_ProjectionRead_FRONT_MOVE_1_mutex);
-                                    _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_FRONT_MOVE_1.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "FRONT_MOVE_1";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "FRONT_MOVE_1";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_FRONT_MOVE_2 read__tr_FRONT_MOVE_2_state = state._projected_state_for__tr_FRONT_MOVE_2();
+                BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_4;
                 auto _trid_4_ptr = _OpCache_tr_FRONT_MOVE_2.find(read__tr_FRONT_MOVE_2_state);
                 if(_trid_4_ptr == _OpCache_tr_FRONT_MOVE_2.end()) {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_4 = state._tr_FRONT_MOVE_2();
+                    _trid_4 = state._tr_FRONT_MOVE_2();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_FRONT_MOVE_2_lock(_ProjectionRead__tr_FRONT_MOVE_2_mutex);
                         _OpCache_tr_FRONT_MOVE_2.insert({read__tr_FRONT_MOVE_2_state, _trid_4});
                     }
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_4) {
-                        Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2 readState = state._projected_state_for_FRONT_MOVE_2();
+                } else {
+                    _trid_4 = _trid_4_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_FRONT_MOVE_2_ptr = _OpCache_FRONT_MOVE_2.find(param);
-                        if(_OpCache_with_parameter_FRONT_MOVE_2_ptr == _OpCache_FRONT_MOVE_2.end()) {
-                            copiedState.FRONT_MOVE_2(_tmp_1);
-                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2;
-                            _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex);
-                                _OpCache_FRONT_MOVE_2.insert({param, _OpCache_with_parameter_FRONT_MOVE_2});
-                            }
+                for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_4) {
+                    Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2 = _OpCache_with_parameter_FRONT_MOVE_2_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_2.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_2.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_FRONT_MOVE_2(writeState);
-                            } else {
-                                copiedState.FRONT_MOVE_2(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex);
-                                    _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState});
-                                }
-                            }
+                    Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
+                    Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2 readState = state._projected_state_for_FRONT_MOVE_2();
+
+                    auto _OpCache_with_parameter_FRONT_MOVE_2_ptr = _OpCache_FRONT_MOVE_2.find(param);
+                    if(_OpCache_with_parameter_FRONT_MOVE_2_ptr == _OpCache_FRONT_MOVE_2.end()) {
+                        copiedState.FRONT_MOVE_2(_tmp_1);
+                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2();
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2;
+                        _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex);
+                            _OpCache_FRONT_MOVE_2.insert({param, _OpCache_with_parameter_FRONT_MOVE_2});
                         }
 
-                        copiedState.stateAccessedVia = "FRONT_MOVE_2";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_4 = _trid_4_ptr->second;
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_4) {
-                        Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2 readState = state._projected_state_for_FRONT_MOVE_2();
-
-                        auto _OpCache_with_parameter_FRONT_MOVE_2_ptr = _OpCache_FRONT_MOVE_2.find(param);
-                        if(_OpCache_with_parameter_FRONT_MOVE_2_ptr == _OpCache_FRONT_MOVE_2.end()) {
+                    } else {
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2 = _OpCache_with_parameter_FRONT_MOVE_2_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_2.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_2.end()) {
+                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_FRONT_MOVE_2(writeState);
+                        } else {
                             copiedState.FRONT_MOVE_2(_tmp_1);
                             Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2;
-                            _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex);
-                                _OpCache_FRONT_MOVE_2.insert({param, _OpCache_with_parameter_FRONT_MOVE_2});
-                            }
-
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_FRONT_MOVE_2::HashEqual> _OpCache_with_parameter_FRONT_MOVE_2 = _OpCache_with_parameter_FRONT_MOVE_2_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_FRONT_MOVE_2.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_FRONT_MOVE_2.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_FRONT_MOVE_2(writeState);
-                            } else {
-                                copiedState.FRONT_MOVE_2(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_FRONT_MOVE_2 writeState = copiedState._update_for_FRONT_MOVE_2();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_FRONT_MOVE_2_lock(_ProjectionRead_FRONT_MOVE_2_mutex);
-                                    _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_FRONT_MOVE_2.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "FRONT_MOVE_2";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "FRONT_MOVE_2";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_BACK_MOVE_1 read__tr_BACK_MOVE_1_state = state._projected_state_for__tr_BACK_MOVE_1();
+                BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_5;
                 auto _trid_5_ptr = _OpCache_tr_BACK_MOVE_1.find(read__tr_BACK_MOVE_1_state);
                 if(_trid_5_ptr == _OpCache_tr_BACK_MOVE_1.end()) {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_5 = state._tr_BACK_MOVE_1();
+                    _trid_5 = state._tr_BACK_MOVE_1();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_BACK_MOVE_1_lock(_ProjectionRead__tr_BACK_MOVE_1_mutex);
                         _OpCache_tr_BACK_MOVE_1.insert({read__tr_BACK_MOVE_1_state, _trid_5});
                     }
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_5) {
-                        Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1 readState = state._projected_state_for_BACK_MOVE_1();
+                } else {
+                    _trid_5 = _trid_5_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_BACK_MOVE_1_ptr = _OpCache_BACK_MOVE_1.find(param);
-                        if(_OpCache_with_parameter_BACK_MOVE_1_ptr == _OpCache_BACK_MOVE_1.end()) {
-                            copiedState.BACK_MOVE_1(_tmp_1);
-                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1;
-                            _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex);
-                                _OpCache_BACK_MOVE_1.insert({param, _OpCache_with_parameter_BACK_MOVE_1});
-                            }
+                for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_5) {
+                    Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1 = _OpCache_with_parameter_BACK_MOVE_1_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_1.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_1.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_BACK_MOVE_1(writeState);
-                            } else {
-                                copiedState.BACK_MOVE_1(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex);
-                                    _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState});
-                                }
-                            }
+                    Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
+                    Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1 readState = state._projected_state_for_BACK_MOVE_1();
+
+                    auto _OpCache_with_parameter_BACK_MOVE_1_ptr = _OpCache_BACK_MOVE_1.find(param);
+                    if(_OpCache_with_parameter_BACK_MOVE_1_ptr == _OpCache_BACK_MOVE_1.end()) {
+                        copiedState.BACK_MOVE_1(_tmp_1);
+                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1();
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1;
+                        _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex);
+                            _OpCache_BACK_MOVE_1.insert({param, _OpCache_with_parameter_BACK_MOVE_1});
                         }
 
-                        copiedState.stateAccessedVia = "BACK_MOVE_1";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_5 = _trid_5_ptr->second;
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_5) {
-                        Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1 readState = state._projected_state_for_BACK_MOVE_1();
-
-                        auto _OpCache_with_parameter_BACK_MOVE_1_ptr = _OpCache_BACK_MOVE_1.find(param);
-                        if(_OpCache_with_parameter_BACK_MOVE_1_ptr == _OpCache_BACK_MOVE_1.end()) {
+                    } else {
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1 = _OpCache_with_parameter_BACK_MOVE_1_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_1.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_1.end()) {
+                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_BACK_MOVE_1(writeState);
+                        } else {
                             copiedState.BACK_MOVE_1(_tmp_1);
                             Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1;
-                            _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex);
-                                _OpCache_BACK_MOVE_1.insert({param, _OpCache_with_parameter_BACK_MOVE_1});
-                            }
-
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_1::HashEqual> _OpCache_with_parameter_BACK_MOVE_1 = _OpCache_with_parameter_BACK_MOVE_1_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_1.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_1.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_BACK_MOVE_1(writeState);
-                            } else {
-                                copiedState.BACK_MOVE_1(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_1 writeState = copiedState._update_for_BACK_MOVE_1();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_1_lock(_ProjectionRead_BACK_MOVE_1_mutex);
-                                    _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_BACK_MOVE_1.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "BACK_MOVE_1";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "BACK_MOVE_1";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_BACK_MOVE_2 read__tr_BACK_MOVE_2_state = state._projected_state_for__tr_BACK_MOVE_2();
+                BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_6;
                 auto _trid_6_ptr = _OpCache_tr_BACK_MOVE_2.find(read__tr_BACK_MOVE_2_state);
                 if(_trid_6_ptr == _OpCache_tr_BACK_MOVE_2.end()) {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_6 = state._tr_BACK_MOVE_2();
+                    _trid_6 = state._tr_BACK_MOVE_2();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_BACK_MOVE_2_lock(_ProjectionRead__tr_BACK_MOVE_2_mutex);
                         _OpCache_tr_BACK_MOVE_2.insert({read__tr_BACK_MOVE_2_state, _trid_6});
                     }
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_6) {
-                        Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2 readState = state._projected_state_for_BACK_MOVE_2();
+                } else {
+                    _trid_6 = _trid_6_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_BACK_MOVE_2_ptr = _OpCache_BACK_MOVE_2.find(param);
-                        if(_OpCache_with_parameter_BACK_MOVE_2_ptr == _OpCache_BACK_MOVE_2.end()) {
-                            copiedState.BACK_MOVE_2(_tmp_1);
-                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2;
-                            _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex);
-                                _OpCache_BACK_MOVE_2.insert({param, _OpCache_with_parameter_BACK_MOVE_2});
-                            }
+                for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_6) {
+                    Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2 = _OpCache_with_parameter_BACK_MOVE_2_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_2.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_2.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_BACK_MOVE_2(writeState);
-                            } else {
-                                copiedState.BACK_MOVE_2(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex);
-                                    _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState});
-                                }
-                            }
+                    Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
+                    Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2 readState = state._projected_state_for_BACK_MOVE_2();
+
+                    auto _OpCache_with_parameter_BACK_MOVE_2_ptr = _OpCache_BACK_MOVE_2.find(param);
+                    if(_OpCache_with_parameter_BACK_MOVE_2_ptr == _OpCache_BACK_MOVE_2.end()) {
+                        copiedState.BACK_MOVE_2(_tmp_1);
+                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2();
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2;
+                        _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex);
+                            _OpCache_BACK_MOVE_2.insert({param, _OpCache_with_parameter_BACK_MOVE_2});
                         }
 
-                        copiedState.stateAccessedVia = "BACK_MOVE_2";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_6 = _trid_6_ptr->second;
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_6) {
-                        Train_1_beebook_deterministic_MC_POR_v3::BLOCKS _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2 readState = state._projected_state_for_BACK_MOVE_2();
-
-                        auto _OpCache_with_parameter_BACK_MOVE_2_ptr = _OpCache_BACK_MOVE_2.find(param);
-                        if(_OpCache_with_parameter_BACK_MOVE_2_ptr == _OpCache_BACK_MOVE_2.end()) {
+                    } else {
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2 = _OpCache_with_parameter_BACK_MOVE_2_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_2.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_2.end()) {
+                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_BACK_MOVE_2(writeState);
+                        } else {
                             copiedState.BACK_MOVE_2(_tmp_1);
                             Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2;
-                            _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex);
-                                _OpCache_BACK_MOVE_2.insert({param, _OpCache_with_parameter_BACK_MOVE_2});
-                            }
-
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_BACK_MOVE_2::HashEqual> _OpCache_with_parameter_BACK_MOVE_2 = _OpCache_with_parameter_BACK_MOVE_2_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_BACK_MOVE_2.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_BACK_MOVE_2.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_BACK_MOVE_2(writeState);
-                            } else {
-                                copiedState.BACK_MOVE_2(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_BACK_MOVE_2 writeState = copiedState._update_for_BACK_MOVE_2();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_BACK_MOVE_2_lock(_ProjectionRead_BACK_MOVE_2_mutex);
-                                    _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_BACK_MOVE_2.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "BACK_MOVE_2";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "BACK_MOVE_2";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_point_positionning read__tr_point_positionning_state = state._projected_state_for__tr_point_positionning();
+                BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_7;
                 auto _trid_7_ptr = _OpCache_tr_point_positionning.find(read__tr_point_positionning_state);
                 if(_trid_7_ptr == _OpCache_tr_point_positionning.end()) {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_7 = state._tr_point_positionning();
+                    _trid_7 = state._tr_point_positionning();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_point_positionning_lock(_ProjectionRead__tr_point_positionning_mutex);
                         _OpCache_tr_point_positionning.insert({read__tr_point_positionning_state, _trid_7});
                     }
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_7) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning readState = state._projected_state_for_point_positionning();
+                } else {
+                    _trid_7 = _trid_7_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_point_positionning_ptr = _OpCache_point_positionning.find(param);
-                        if(_OpCache_with_parameter_point_positionning_ptr == _OpCache_point_positionning.end()) {
-                            copiedState.point_positionning(_tmp_1);
-                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning;
-                            _OpCache_with_parameter_point_positionning.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex);
-                                _OpCache_point_positionning.insert({param, _OpCache_with_parameter_point_positionning});
-                            }
+                for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_7) {
+                    Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning = _OpCache_with_parameter_point_positionning_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_point_positionning.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_point_positionning.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_point_positionning(writeState);
-                            } else {
-                                copiedState.point_positionning(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex);
-                                    _OpCache_with_parameter_point_positionning.insert({readState, writeState});
-                                }
-                            }
+                    Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
+                    Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning readState = state._projected_state_for_point_positionning();
+
+                    auto _OpCache_with_parameter_point_positionning_ptr = _OpCache_point_positionning.find(param);
+                    if(_OpCache_with_parameter_point_positionning_ptr == _OpCache_point_positionning.end()) {
+                        copiedState.point_positionning(_tmp_1);
+                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning();
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning;
+                        _OpCache_with_parameter_point_positionning.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex);
+                            _OpCache_point_positionning.insert({param, _OpCache_with_parameter_point_positionning});
                         }
 
-                        copiedState.stateAccessedVia = "point_positionning";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_7 = _trid_7_ptr->second;
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_7) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning readState = state._projected_state_for_point_positionning();
-
-                        auto _OpCache_with_parameter_point_positionning_ptr = _OpCache_point_positionning.find(param);
-                        if(_OpCache_with_parameter_point_positionning_ptr == _OpCache_point_positionning.end()) {
+                    } else {
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning = _OpCache_with_parameter_point_positionning_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_point_positionning.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_point_positionning.end()) {
+                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_point_positionning(writeState);
+                        } else {
                             copiedState.point_positionning(_tmp_1);
                             Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning;
-                            _OpCache_with_parameter_point_positionning.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex);
-                                _OpCache_point_positionning.insert({param, _OpCache_with_parameter_point_positionning});
-                            }
-
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_point_positionning::HashEqual> _OpCache_with_parameter_point_positionning = _OpCache_with_parameter_point_positionning_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_point_positionning.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_point_positionning.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_point_positionning(writeState);
-                            } else {
-                                copiedState.point_positionning(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_point_positionning writeState = copiedState._update_for_point_positionning();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_point_positionning_lock(_ProjectionRead_point_positionning_mutex);
-                                    _OpCache_with_parameter_point_positionning.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_point_positionning.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "point_positionning";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "point_positionning";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead__tr_route_formation read__tr_route_formation_state = state._projected_state_for__tr_route_formation();
+                BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_8;
                 auto _trid_8_ptr = _OpCache_tr_route_formation.find(read__tr_route_formation_state);
                 if(_trid_8_ptr == _OpCache_tr_route_formation.end()) {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_8 = state._tr_route_formation();
+                    _trid_8 = state._tr_route_formation();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_route_formation_lock(_ProjectionRead__tr_route_formation_mutex);
                         _OpCache_tr_route_formation.insert({read__tr_route_formation_state, _trid_8});
                     }
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_8) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation readState = state._projected_state_for_route_formation();
+                } else {
+                    _trid_8 = _trid_8_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_route_formation_ptr = _OpCache_route_formation.find(param);
-                        if(_OpCache_with_parameter_route_formation_ptr == _OpCache_route_formation.end()) {
-                            copiedState.route_formation(_tmp_1);
-                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation;
-                            _OpCache_with_parameter_route_formation.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex);
-                                _OpCache_route_formation.insert({param, _OpCache_with_parameter_route_formation});
-                            }
+                for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_8) {
+                    Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation = _OpCache_with_parameter_route_formation_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_route_formation.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_route_formation.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_route_formation(writeState);
-                            } else {
-                                copiedState.route_formation(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex);
-                                    _OpCache_with_parameter_route_formation.insert({readState, writeState});
-                                }
-                            }
+                    Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
+                    Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation readState = state._projected_state_for_route_formation();
+
+                    auto _OpCache_with_parameter_route_formation_ptr = _OpCache_route_formation.find(param);
+                    if(_OpCache_with_parameter_route_formation_ptr == _OpCache_route_formation.end()) {
+                        copiedState.route_formation(_tmp_1);
+                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation();
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation;
+                        _OpCache_with_parameter_route_formation.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex);
+                            _OpCache_route_formation.insert({param, _OpCache_with_parameter_route_formation});
                         }
 
-                        copiedState.stateAccessedVia = "route_formation";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_8 = _trid_8_ptr->second;
-                    for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_8) {
-                        Train_1_beebook_deterministic_MC_POR_v3::ROUTES _tmp_1 = param;
-
-                        Train_1_beebook_deterministic_MC_POR_v3 copiedState = state._copy();
-                        Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation readState = state._projected_state_for_route_formation();
-
-                        auto _OpCache_with_parameter_route_formation_ptr = _OpCache_route_formation.find(param);
-                        if(_OpCache_with_parameter_route_formation_ptr == _OpCache_route_formation.end()) {
+                    } else {
+                        std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation = _OpCache_with_parameter_route_formation_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_route_formation.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_route_formation.end()) {
+                            Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_route_formation(writeState);
+                        } else {
                             copiedState.route_formation(_tmp_1);
                             Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation();
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation;
-                            _OpCache_with_parameter_route_formation.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex);
-                                _OpCache_route_formation.insert({param, _OpCache_with_parameter_route_formation});
-                            }
-
-                        } else {
-                            std::unordered_map<Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::Hash, Train_1_beebook_deterministic_MC_POR_v3::_ProjectionRead_route_formation::HashEqual> _OpCache_with_parameter_route_formation = _OpCache_with_parameter_route_formation_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_route_formation.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_route_formation.end()) {
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_route_formation(writeState);
-                            } else {
-                                copiedState.route_formation(_tmp_1);
-                                Train_1_beebook_deterministic_MC_POR_v3::_ProjectionWrite_route_formation writeState = copiedState._update_for_route_formation();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_route_formation_lock(_ProjectionRead_route_formation_mutex);
-                                    _OpCache_with_parameter_route_formation.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_route_formation.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "route_formation";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "route_formation";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -4194,7 +3946,10 @@ class ModelChecker {
                     copiedState.route_reservation(_tmp_1);
                     copiedState.stateAccessedVia = "route_reservation";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_2 = state._tr_route_freeing();
                 for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_2) {
@@ -4204,7 +3959,10 @@ class ModelChecker {
                     copiedState.route_freeing(_tmp_1);
                     copiedState.stateAccessedVia = "route_freeing";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_3 = state._tr_FRONT_MOVE_1();
                 for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_3) {
@@ -4214,7 +3972,10 @@ class ModelChecker {
                     copiedState.FRONT_MOVE_1(_tmp_1);
                     copiedState.stateAccessedVia = "FRONT_MOVE_1";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_4 = state._tr_FRONT_MOVE_2();
                 for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_4) {
@@ -4224,7 +3985,10 @@ class ModelChecker {
                     copiedState.FRONT_MOVE_2(_tmp_1);
                     copiedState.stateAccessedVia = "FRONT_MOVE_2";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_5 = state._tr_BACK_MOVE_1();
                 for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_5) {
@@ -4234,7 +3998,10 @@ class ModelChecker {
                     copiedState.BACK_MOVE_1(_tmp_1);
                     copiedState.stateAccessedVia = "BACK_MOVE_1";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<Train_1_beebook_deterministic_MC_POR_v3::BLOCKS> _trid_6 = state._tr_BACK_MOVE_2();
                 for(const Train_1_beebook_deterministic_MC_POR_v3::BLOCKS& param : _trid_6) {
@@ -4244,7 +4011,10 @@ class ModelChecker {
                     copiedState.BACK_MOVE_2(_tmp_1);
                     copiedState.stateAccessedVia = "BACK_MOVE_2";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_7 = state._tr_point_positionning();
                 for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_7) {
@@ -4254,7 +4024,10 @@ class ModelChecker {
                     copiedState.point_positionning(_tmp_1);
                     copiedState.stateAccessedVia = "point_positionning";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<Train_1_beebook_deterministic_MC_POR_v3::ROUTES> _trid_8 = state._tr_route_formation();
                 for(const Train_1_beebook_deterministic_MC_POR_v3::ROUTES& param : _trid_8) {
@@ -4264,7 +4037,10 @@ class ModelChecker {
                     copiedState.route_formation(_tmp_1);
                     copiedState.stateAccessedVia = "route_formation";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/nota_v2.cpp b/benchmarks/model_checking_opreuse/C++/nota_v2.cpp
index df438e389753e9f980ad5f9d8403b0d4a451b49c..76d0f602d778388becab3cc7c732934806408c21 100644
--- a/benchmarks/model_checking_opreuse/C++/nota_v2.cpp
+++ b/benchmarks/model_checking_opreuse/C++/nota_v2.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -5261,12 +5260,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 nota_v2 state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<nota_v2, nota_v2::Hash, nota_v2::HashEqual> nextStates = generateNextStates(state);
@@ -5287,12 +5290,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -5302,24 +5307,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -5364,1262 +5372,779 @@ class ModelChecker {
             std::unordered_set<nota_v2, nota_v2::Hash, nota_v2::HashEqual> result = std::unordered_set<nota_v2, nota_v2::Hash, nota_v2::HashEqual>();
             if(isCaching) {
                 nota_v2::_ProjectionRead__tr_constructor_interconnectNode read__tr_constructor_interconnectNode_state = state._projected_state_for__tr_constructor_interconnectNode();
+                BSet<nota_v2::INTERCONNECTNODE> _trid_1;
                 auto _trid_1_ptr = _OpCache_tr_constructor_interconnectNode.find(read__tr_constructor_interconnectNode_state);
                 if(_trid_1_ptr == _OpCache_tr_constructor_interconnectNode.end()) {
-                    BSet<nota_v2::INTERCONNECTNODE> _trid_1 = state._tr_constructor_interconnectNode();
+                    _trid_1 = state._tr_constructor_interconnectNode();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_constructor_interconnectNode_lock(_ProjectionRead__tr_constructor_interconnectNode_mutex);
                         _OpCache_tr_constructor_interconnectNode.insert({read__tr_constructor_interconnectNode_state, _trid_1});
                     }
-                    for(const nota_v2::INTERCONNECTNODE& param : _trid_1) {
-                        nota_v2::INTERCONNECTNODE _tmp_1 = param;
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_constructor_interconnectNode readState = state._projected_state_for_constructor_interconnectNode();
+                } else {
+                    _trid_1 = _trid_1_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_constructor_interconnectNode_ptr = _OpCache_constructor_interconnectNode.find(param);
-                        if(_OpCache_with_parameter_constructor_interconnectNode_ptr == _OpCache_constructor_interconnectNode.end()) {
-                            copiedState.constructor_interconnectNode(_tmp_1);
-                            nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode();
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode;
-                            _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex);
-                                _OpCache_constructor_interconnectNode.insert({param, _OpCache_with_parameter_constructor_interconnectNode});
-                            }
+                for(const nota_v2::INTERCONNECTNODE& param : _trid_1) {
+                    nota_v2::INTERCONNECTNODE _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode = _OpCache_with_parameter_constructor_interconnectNode_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_constructor_interconnectNode.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_constructor_interconnectNode.end()) {
-                                nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_constructor_interconnectNode(writeState);
-                            } else {
-                                copiedState.constructor_interconnectNode(_tmp_1);
-                                nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex);
-                                    _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_constructor_interconnectNode readState = state._projected_state_for_constructor_interconnectNode();
+
+                    auto _OpCache_with_parameter_constructor_interconnectNode_ptr = _OpCache_constructor_interconnectNode.find(param);
+                    if(_OpCache_with_parameter_constructor_interconnectNode_ptr == _OpCache_constructor_interconnectNode.end()) {
+                        copiedState.constructor_interconnectNode(_tmp_1);
+                        nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode();
+                        std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode;
+                        _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex);
+                            _OpCache_constructor_interconnectNode.insert({param, _OpCache_with_parameter_constructor_interconnectNode});
                         }
 
-                        copiedState.stateAccessedVia = "constructor_interconnectNode";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<nota_v2::INTERCONNECTNODE> _trid_1 = _trid_1_ptr->second;
-                    for(const nota_v2::INTERCONNECTNODE& param : _trid_1) {
-                        nota_v2::INTERCONNECTNODE _tmp_1 = param;
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_constructor_interconnectNode readState = state._projected_state_for_constructor_interconnectNode();
-
-                        auto _OpCache_with_parameter_constructor_interconnectNode_ptr = _OpCache_constructor_interconnectNode.find(param);
-                        if(_OpCache_with_parameter_constructor_interconnectNode_ptr == _OpCache_constructor_interconnectNode.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode = _OpCache_with_parameter_constructor_interconnectNode_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_constructor_interconnectNode.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_constructor_interconnectNode.end()) {
+                            nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_constructor_interconnectNode(writeState);
+                        } else {
                             copiedState.constructor_interconnectNode(_tmp_1);
                             nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode();
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode;
-                            _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex);
-                                _OpCache_constructor_interconnectNode.insert({param, _OpCache_with_parameter_constructor_interconnectNode});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_interconnectNode, nota_v2::_ProjectionWrite_constructor_interconnectNode, nota_v2::_ProjectionRead_constructor_interconnectNode::Hash, nota_v2::_ProjectionRead_constructor_interconnectNode::HashEqual> _OpCache_with_parameter_constructor_interconnectNode = _OpCache_with_parameter_constructor_interconnectNode_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_constructor_interconnectNode.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_constructor_interconnectNode.end()) {
-                                nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_constructor_interconnectNode(writeState);
-                            } else {
-                                copiedState.constructor_interconnectNode(_tmp_1);
-                                nota_v2::_ProjectionWrite_constructor_interconnectNode writeState = copiedState._update_for_constructor_interconnectNode();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_constructor_interconnectNode_lock(_ProjectionRead_constructor_interconnectNode_mutex);
-                                    _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_constructor_interconnectNode.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "constructor_interconnectNode";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "constructor_interconnectNode";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_constructor_resourceManager read__tr_constructor_resourceManager_state = state._projected_state_for__tr_constructor_resourceManager();
+                BSet<nota_v2::RESOURCEMANAGER> _trid_2;
                 auto _trid_2_ptr = _OpCache_tr_constructor_resourceManager.find(read__tr_constructor_resourceManager_state);
                 if(_trid_2_ptr == _OpCache_tr_constructor_resourceManager.end()) {
-                    BSet<nota_v2::RESOURCEMANAGER> _trid_2 = state._tr_constructor_resourceManager();
+                    _trid_2 = state._tr_constructor_resourceManager();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_constructor_resourceManager_lock(_ProjectionRead__tr_constructor_resourceManager_mutex);
                         _OpCache_tr_constructor_resourceManager.insert({read__tr_constructor_resourceManager_state, _trid_2});
                     }
-                    for(const nota_v2::RESOURCEMANAGER& param : _trid_2) {
-                        nota_v2::RESOURCEMANAGER _tmp_1 = param;
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_constructor_resourceManager readState = state._projected_state_for_constructor_resourceManager();
+                } else {
+                    _trid_2 = _trid_2_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_constructor_resourceManager_ptr = _OpCache_constructor_resourceManager.find(param);
-                        if(_OpCache_with_parameter_constructor_resourceManager_ptr == _OpCache_constructor_resourceManager.end()) {
-                            copiedState.constructor_resourceManager(_tmp_1);
-                            nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager();
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager;
-                            _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex);
-                                _OpCache_constructor_resourceManager.insert({param, _OpCache_with_parameter_constructor_resourceManager});
-                            }
+                for(const nota_v2::RESOURCEMANAGER& param : _trid_2) {
+                    nota_v2::RESOURCEMANAGER _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager = _OpCache_with_parameter_constructor_resourceManager_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_constructor_resourceManager.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_constructor_resourceManager.end()) {
-                                nota_v2::_ProjectionWrite_constructor_resourceManager writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_constructor_resourceManager(writeState);
-                            } else {
-                                copiedState.constructor_resourceManager(_tmp_1);
-                                nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex);
-                                    _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_constructor_resourceManager readState = state._projected_state_for_constructor_resourceManager();
+
+                    auto _OpCache_with_parameter_constructor_resourceManager_ptr = _OpCache_constructor_resourceManager.find(param);
+                    if(_OpCache_with_parameter_constructor_resourceManager_ptr == _OpCache_constructor_resourceManager.end()) {
+                        copiedState.constructor_resourceManager(_tmp_1);
+                        nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager();
+                        std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager;
+                        _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex);
+                            _OpCache_constructor_resourceManager.insert({param, _OpCache_with_parameter_constructor_resourceManager});
                         }
 
-                        copiedState.stateAccessedVia = "constructor_resourceManager";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<nota_v2::RESOURCEMANAGER> _trid_2 = _trid_2_ptr->second;
-                    for(const nota_v2::RESOURCEMANAGER& param : _trid_2) {
-                        nota_v2::RESOURCEMANAGER _tmp_1 = param;
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_constructor_resourceManager readState = state._projected_state_for_constructor_resourceManager();
-
-                        auto _OpCache_with_parameter_constructor_resourceManager_ptr = _OpCache_constructor_resourceManager.find(param);
-                        if(_OpCache_with_parameter_constructor_resourceManager_ptr == _OpCache_constructor_resourceManager.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager = _OpCache_with_parameter_constructor_resourceManager_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_constructor_resourceManager.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_constructor_resourceManager.end()) {
+                            nota_v2::_ProjectionWrite_constructor_resourceManager writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_constructor_resourceManager(writeState);
+                        } else {
                             copiedState.constructor_resourceManager(_tmp_1);
                             nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager();
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager;
-                            _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex);
-                                _OpCache_constructor_resourceManager.insert({param, _OpCache_with_parameter_constructor_resourceManager});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_resourceManager, nota_v2::_ProjectionWrite_constructor_resourceManager, nota_v2::_ProjectionRead_constructor_resourceManager::Hash, nota_v2::_ProjectionRead_constructor_resourceManager::HashEqual> _OpCache_with_parameter_constructor_resourceManager = _OpCache_with_parameter_constructor_resourceManager_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_constructor_resourceManager.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_constructor_resourceManager.end()) {
-                                nota_v2::_ProjectionWrite_constructor_resourceManager writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_constructor_resourceManager(writeState);
-                            } else {
-                                copiedState.constructor_resourceManager(_tmp_1);
-                                nota_v2::_ProjectionWrite_constructor_resourceManager writeState = copiedState._update_for_constructor_resourceManager();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_constructor_resourceManager_lock(_ProjectionRead_constructor_resourceManager_mutex);
-                                    _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_constructor_resourceManager.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "constructor_resourceManager";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "constructor_resourceManager";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_constructor_service read__tr_constructor_service_state = state._projected_state_for__tr_constructor_service();
+                BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_3;
                 auto _trid_3_ptr = _OpCache_tr_constructor_service.find(read__tr_constructor_service_state);
                 if(_trid_3_ptr == _OpCache_tr_constructor_service.end()) {
-                    BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_3 = state._tr_constructor_service();
+                    _trid_3 = state._tr_constructor_service();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_constructor_service_lock(_ProjectionRead__tr_constructor_service_mutex);
                         _OpCache_tr_constructor_service.insert({read__tr_constructor_service_state, _trid_3});
                     }
-                    for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_3) {
-                        nota_v2::SERVICE _tmp_1 = param.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_constructor_service readState = state._projected_state_for_constructor_service();
+                } else {
+                    _trid_3 = _trid_3_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_constructor_service_ptr = _OpCache_constructor_service.find(param);
-                        if(_OpCache_with_parameter_constructor_service_ptr == _OpCache_constructor_service.end()) {
-                            copiedState.constructor_service(_tmp_2, _tmp_1);
-                            nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service();
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service;
-                            _OpCache_with_parameter_constructor_service.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex);
-                                _OpCache_constructor_service.insert({param, _OpCache_with_parameter_constructor_service});
-                            }
+                for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_3) {
+                    nota_v2::SERVICE _tmp_1 = param.projection2();
+                    nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service = _OpCache_with_parameter_constructor_service_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_constructor_service.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_constructor_service.end()) {
-                                nota_v2::_ProjectionWrite_constructor_service writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_constructor_service(writeState);
-                            } else {
-                                copiedState.constructor_service(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex);
-                                    _OpCache_with_parameter_constructor_service.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_constructor_service readState = state._projected_state_for_constructor_service();
+
+                    auto _OpCache_with_parameter_constructor_service_ptr = _OpCache_constructor_service.find(param);
+                    if(_OpCache_with_parameter_constructor_service_ptr == _OpCache_constructor_service.end()) {
+                        copiedState.constructor_service(_tmp_2, _tmp_1);
+                        nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service();
+                        std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service;
+                        _OpCache_with_parameter_constructor_service.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex);
+                            _OpCache_constructor_service.insert({param, _OpCache_with_parameter_constructor_service});
                         }
 
-                        copiedState.stateAccessedVia = "constructor_service";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_3 = _trid_3_ptr->second;
-                    for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_3) {
-                        nota_v2::SERVICE _tmp_1 = param.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_constructor_service readState = state._projected_state_for_constructor_service();
-
-                        auto _OpCache_with_parameter_constructor_service_ptr = _OpCache_constructor_service.find(param);
-                        if(_OpCache_with_parameter_constructor_service_ptr == _OpCache_constructor_service.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service = _OpCache_with_parameter_constructor_service_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_constructor_service.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_constructor_service.end()) {
+                            nota_v2::_ProjectionWrite_constructor_service writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_constructor_service(writeState);
+                        } else {
                             copiedState.constructor_service(_tmp_2, _tmp_1);
                             nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service();
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service;
-                            _OpCache_with_parameter_constructor_service.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex);
-                                _OpCache_constructor_service.insert({param, _OpCache_with_parameter_constructor_service});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_service, nota_v2::_ProjectionWrite_constructor_service, nota_v2::_ProjectionRead_constructor_service::Hash, nota_v2::_ProjectionRead_constructor_service::HashEqual> _OpCache_with_parameter_constructor_service = _OpCache_with_parameter_constructor_service_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_constructor_service.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_constructor_service.end()) {
-                                nota_v2::_ProjectionWrite_constructor_service writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_constructor_service(writeState);
-                            } else {
-                                copiedState.constructor_service(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_constructor_service writeState = copiedState._update_for_constructor_service();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_constructor_service_lock(_ProjectionRead_constructor_service_mutex);
-                                    _OpCache_with_parameter_constructor_service.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_constructor_service.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "constructor_service";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "constructor_service";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_constructor_socket read__tr_constructor_socket_state = state._projected_state_for__tr_constructor_socket();
+                BSet<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_4;
                 auto _trid_4_ptr = _OpCache_tr_constructor_socket.find(read__tr_constructor_socket_state);
                 if(_trid_4_ptr == _OpCache_tr_constructor_socket.end()) {
-                    BSet<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_4 = state._tr_constructor_socket();
+                    _trid_4 = state._tr_constructor_socket();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_constructor_socket_lock(_ProjectionRead__tr_constructor_socket_mutex);
                         _OpCache_tr_constructor_socket.insert({read__tr_constructor_socket_state, _trid_4});
                     }
-                    for(const BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_4) {
-                        nota_v2::SOCKET _tmp_1 = param.projection2();
-                        BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1();
-                        nota_v2::SID _tmp_3 = _tmp_2.projection2();
-                        BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID > _tmp_4 = _tmp_2.projection1();
-                        nota_v2::SID _tmp_5 = _tmp_4.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_6 = _tmp_4.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_constructor_socket readState = state._projected_state_for_constructor_socket();
-
-                        auto _OpCache_with_parameter_constructor_socket_ptr = _OpCache_constructor_socket.find(param);
-                        if(_OpCache_with_parameter_constructor_socket_ptr == _OpCache_constructor_socket.end()) {
-                            copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1);
-                            nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket();
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket;
-                            _OpCache_with_parameter_constructor_socket.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex);
-                                _OpCache_constructor_socket.insert({param, _OpCache_with_parameter_constructor_socket});
-                            }
+                } else {
+                    _trid_4 = _trid_4_ptr->second;
+                }
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket = _OpCache_with_parameter_constructor_socket_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_constructor_socket.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_constructor_socket.end()) {
-                                nota_v2::_ProjectionWrite_constructor_socket writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_constructor_socket(writeState);
-                            } else {
-                                copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex);
-                                    _OpCache_with_parameter_constructor_socket.insert({readState, writeState});
-                                }
-                            }
+                for(const BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_4) {
+                    nota_v2::SOCKET _tmp_1 = param.projection2();
+                    BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1();
+                    nota_v2::SID _tmp_3 = _tmp_2.projection2();
+                    BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID > _tmp_4 = _tmp_2.projection1();
+                    nota_v2::SID _tmp_5 = _tmp_4.projection2();
+                    nota_v2::INTERCONNECTNODE _tmp_6 = _tmp_4.projection1();
+
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_constructor_socket readState = state._projected_state_for_constructor_socket();
+
+                    auto _OpCache_with_parameter_constructor_socket_ptr = _OpCache_constructor_socket.find(param);
+                    if(_OpCache_with_parameter_constructor_socket_ptr == _OpCache_constructor_socket.end()) {
+                        copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1);
+                        nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket();
+                        std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket;
+                        _OpCache_with_parameter_constructor_socket.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex);
+                            _OpCache_constructor_socket.insert({param, _OpCache_with_parameter_constructor_socket});
                         }
 
-                        copiedState.stateAccessedVia = "constructor_socket";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_4 = _trid_4_ptr->second;
-                    for(const BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_4) {
-                        nota_v2::SOCKET _tmp_1 = param.projection2();
-                        BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1();
-                        nota_v2::SID _tmp_3 = _tmp_2.projection2();
-                        BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID > _tmp_4 = _tmp_2.projection1();
-                        nota_v2::SID _tmp_5 = _tmp_4.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_6 = _tmp_4.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_constructor_socket readState = state._projected_state_for_constructor_socket();
-
-                        auto _OpCache_with_parameter_constructor_socket_ptr = _OpCache_constructor_socket.find(param);
-                        if(_OpCache_with_parameter_constructor_socket_ptr == _OpCache_constructor_socket.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket = _OpCache_with_parameter_constructor_socket_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_constructor_socket.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_constructor_socket.end()) {
+                            nota_v2::_ProjectionWrite_constructor_socket writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_constructor_socket(writeState);
+                        } else {
                             copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1);
                             nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket();
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket;
-                            _OpCache_with_parameter_constructor_socket.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex);
-                                _OpCache_constructor_socket.insert({param, _OpCache_with_parameter_constructor_socket});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_constructor_socket, nota_v2::_ProjectionWrite_constructor_socket, nota_v2::_ProjectionRead_constructor_socket::Hash, nota_v2::_ProjectionRead_constructor_socket::HashEqual> _OpCache_with_parameter_constructor_socket = _OpCache_with_parameter_constructor_socket_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_constructor_socket.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_constructor_socket.end()) {
-                                nota_v2::_ProjectionWrite_constructor_socket writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_constructor_socket(writeState);
-                            } else {
-                                copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_constructor_socket writeState = copiedState._update_for_constructor_socket();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_constructor_socket_lock(_ProjectionRead_constructor_socket_mutex);
-                                    _OpCache_with_parameter_constructor_socket.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_constructor_socket.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "constructor_socket";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "constructor_socket";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_rm_register read__tr_rm_register_state = state._projected_state_for__tr_rm_register();
+                BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_5;
                 auto _trid_5_ptr = _OpCache_tr_rm_register.find(read__tr_rm_register_state);
                 if(_trid_5_ptr == _OpCache_tr_rm_register.end()) {
-                    BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_5 = state._tr_rm_register();
+                    _trid_5 = state._tr_rm_register();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_rm_register_lock(_ProjectionRead__tr_rm_register_mutex);
                         _OpCache_tr_rm_register.insert({read__tr_rm_register_state, _trid_5});
                     }
-                    for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_5) {
-                        nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2();
-                        BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1();
-                        nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
-                        nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_rm_register readState = state._projected_state_for_rm_register();
+                } else {
+                    _trid_5 = _trid_5_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_rm_register_ptr = _OpCache_rm_register.find(param);
-                        if(_OpCache_with_parameter_rm_register_ptr == _OpCache_rm_register.end()) {
-                            copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1);
-                            nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register();
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register;
-                            _OpCache_with_parameter_rm_register.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex);
-                                _OpCache_rm_register.insert({param, _OpCache_with_parameter_rm_register});
-                            }
+                for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_5) {
+                    nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2();
+                    BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1();
+                    nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
+                    nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register = _OpCache_with_parameter_rm_register_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_rm_register.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_rm_register.end()) {
-                                nota_v2::_ProjectionWrite_rm_register writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_rm_register(writeState);
-                            } else {
-                                copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex);
-                                    _OpCache_with_parameter_rm_register.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_rm_register readState = state._projected_state_for_rm_register();
+
+                    auto _OpCache_with_parameter_rm_register_ptr = _OpCache_rm_register.find(param);
+                    if(_OpCache_with_parameter_rm_register_ptr == _OpCache_rm_register.end()) {
+                        copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1);
+                        nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register();
+                        std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register;
+                        _OpCache_with_parameter_rm_register.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex);
+                            _OpCache_rm_register.insert({param, _OpCache_with_parameter_rm_register});
                         }
 
-                        copiedState.stateAccessedVia = "rm_register";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_5 = _trid_5_ptr->second;
-                    for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_5) {
-                        nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2();
-                        BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1();
-                        nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
-                        nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_rm_register readState = state._projected_state_for_rm_register();
-
-                        auto _OpCache_with_parameter_rm_register_ptr = _OpCache_rm_register.find(param);
-                        if(_OpCache_with_parameter_rm_register_ptr == _OpCache_rm_register.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register = _OpCache_with_parameter_rm_register_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_rm_register.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_rm_register.end()) {
+                            nota_v2::_ProjectionWrite_rm_register writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_rm_register(writeState);
+                        } else {
                             copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1);
                             nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register();
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register;
-                            _OpCache_with_parameter_rm_register.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex);
-                                _OpCache_rm_register.insert({param, _OpCache_with_parameter_rm_register});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_register, nota_v2::_ProjectionWrite_rm_register, nota_v2::_ProjectionRead_rm_register::Hash, nota_v2::_ProjectionRead_rm_register::HashEqual> _OpCache_with_parameter_rm_register = _OpCache_with_parameter_rm_register_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_rm_register.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_rm_register.end()) {
-                                nota_v2::_ProjectionWrite_rm_register writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_rm_register(writeState);
-                            } else {
-                                copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_rm_register writeState = copiedState._update_for_rm_register();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_rm_register_lock(_ProjectionRead_rm_register_mutex);
-                                    _OpCache_with_parameter_rm_register.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_rm_register.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "rm_register";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "rm_register";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_rm_deregister read__tr_rm_deregister_state = state._projected_state_for__tr_rm_deregister();
+                BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_6;
                 auto _trid_6_ptr = _OpCache_tr_rm_deregister.find(read__tr_rm_deregister_state);
                 if(_trid_6_ptr == _OpCache_tr_rm_deregister.end()) {
-                    BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_6 = state._tr_rm_deregister();
+                    _trid_6 = state._tr_rm_deregister();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_rm_deregister_lock(_ProjectionRead__tr_rm_deregister_mutex);
                         _OpCache_tr_rm_deregister.insert({read__tr_rm_deregister_state, _trid_6});
                     }
-                    for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_6) {
-                        nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2();
-                        BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1();
-                        nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
-                        nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_rm_deregister readState = state._projected_state_for_rm_deregister();
+                } else {
+                    _trid_6 = _trid_6_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_rm_deregister_ptr = _OpCache_rm_deregister.find(param);
-                        if(_OpCache_with_parameter_rm_deregister_ptr == _OpCache_rm_deregister.end()) {
-                            copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1);
-                            nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister();
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister;
-                            _OpCache_with_parameter_rm_deregister.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex);
-                                _OpCache_rm_deregister.insert({param, _OpCache_with_parameter_rm_deregister});
-                            }
+                for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_6) {
+                    nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2();
+                    BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1();
+                    nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
+                    nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister = _OpCache_with_parameter_rm_deregister_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_rm_deregister.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_rm_deregister.end()) {
-                                nota_v2::_ProjectionWrite_rm_deregister writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_rm_deregister(writeState);
-                            } else {
-                                copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex);
-                                    _OpCache_with_parameter_rm_deregister.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_rm_deregister readState = state._projected_state_for_rm_deregister();
+
+                    auto _OpCache_with_parameter_rm_deregister_ptr = _OpCache_rm_deregister.find(param);
+                    if(_OpCache_with_parameter_rm_deregister_ptr == _OpCache_rm_deregister.end()) {
+                        copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1);
+                        nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister();
+                        std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister;
+                        _OpCache_with_parameter_rm_deregister.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex);
+                            _OpCache_rm_deregister.insert({param, _OpCache_with_parameter_rm_deregister});
                         }
 
-                        copiedState.stateAccessedVia = "rm_deregister";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_6 = _trid_6_ptr->second;
-                    for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_6) {
-                        nota_v2::INTERCONNECTNODE _tmp_1 = param.projection2();
-                        BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE > _tmp_2 = param.projection1();
-                        nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
-                        nota_v2::RESOURCEMANAGER _tmp_4 = _tmp_2.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_rm_deregister readState = state._projected_state_for_rm_deregister();
-
-                        auto _OpCache_with_parameter_rm_deregister_ptr = _OpCache_rm_deregister.find(param);
-                        if(_OpCache_with_parameter_rm_deregister_ptr == _OpCache_rm_deregister.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister = _OpCache_with_parameter_rm_deregister_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_rm_deregister.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_rm_deregister.end()) {
+                            nota_v2::_ProjectionWrite_rm_deregister writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_rm_deregister(writeState);
+                        } else {
                             copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1);
                             nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister();
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister;
-                            _OpCache_with_parameter_rm_deregister.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex);
-                                _OpCache_rm_deregister.insert({param, _OpCache_with_parameter_rm_deregister});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_deregister, nota_v2::_ProjectionWrite_rm_deregister, nota_v2::_ProjectionRead_rm_deregister::Hash, nota_v2::_ProjectionRead_rm_deregister::HashEqual> _OpCache_with_parameter_rm_deregister = _OpCache_with_parameter_rm_deregister_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_rm_deregister.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_rm_deregister.end()) {
-                                nota_v2::_ProjectionWrite_rm_deregister writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_rm_deregister(writeState);
-                            } else {
-                                copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_rm_deregister writeState = copiedState._update_for_rm_deregister();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_rm_deregister_lock(_ProjectionRead_rm_deregister_mutex);
-                                    _OpCache_with_parameter_rm_deregister.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_rm_deregister.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "rm_deregister";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "rm_deregister";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_rm_getSid read__tr_rm_getSid_state = state._projected_state_for__tr_rm_getSid();
+                BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_7;
                 auto _trid_7_ptr = _OpCache_tr_rm_getSid.find(read__tr_rm_getSid_state);
                 if(_trid_7_ptr == _OpCache_tr_rm_getSid.end()) {
-                    BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_7 = state._tr_rm_getSid();
+                    _trid_7 = state._tr_rm_getSid();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_rm_getSid_lock(_ProjectionRead__tr_rm_getSid_mutex);
                         _OpCache_tr_rm_getSid.insert({read__tr_rm_getSid_state, _trid_7});
                     }
-                    for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_7) {
-                        nota_v2::SERVICE _tmp_1 = param.projection2();
-                        nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_rm_getSid readState = state._projected_state_for_rm_getSid();
+                } else {
+                    _trid_7 = _trid_7_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_rm_getSid_ptr = _OpCache_rm_getSid.find(param);
-                        if(_OpCache_with_parameter_rm_getSid_ptr == _OpCache_rm_getSid.end()) {
-                            copiedState.rm_getSid(_tmp_2, _tmp_1);
-                            nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid();
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid;
-                            _OpCache_with_parameter_rm_getSid.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex);
-                                _OpCache_rm_getSid.insert({param, _OpCache_with_parameter_rm_getSid});
-                            }
+                for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_7) {
+                    nota_v2::SERVICE _tmp_1 = param.projection2();
+                    nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid = _OpCache_with_parameter_rm_getSid_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_rm_getSid.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_rm_getSid.end()) {
-                                nota_v2::_ProjectionWrite_rm_getSid writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_rm_getSid(writeState);
-                            } else {
-                                copiedState.rm_getSid(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex);
-                                    _OpCache_with_parameter_rm_getSid.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_rm_getSid readState = state._projected_state_for_rm_getSid();
+
+                    auto _OpCache_with_parameter_rm_getSid_ptr = _OpCache_rm_getSid.find(param);
+                    if(_OpCache_with_parameter_rm_getSid_ptr == _OpCache_rm_getSid.end()) {
+                        copiedState.rm_getSid(_tmp_2, _tmp_1);
+                        nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid();
+                        std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid;
+                        _OpCache_with_parameter_rm_getSid.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex);
+                            _OpCache_rm_getSid.insert({param, _OpCache_with_parameter_rm_getSid});
                         }
 
-                        copiedState.stateAccessedVia = "rm_getSid";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_7 = _trid_7_ptr->second;
-                    for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_7) {
-                        nota_v2::SERVICE _tmp_1 = param.projection2();
-                        nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_rm_getSid readState = state._projected_state_for_rm_getSid();
-
-                        auto _OpCache_with_parameter_rm_getSid_ptr = _OpCache_rm_getSid.find(param);
-                        if(_OpCache_with_parameter_rm_getSid_ptr == _OpCache_rm_getSid.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid = _OpCache_with_parameter_rm_getSid_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_rm_getSid.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_rm_getSid.end()) {
+                            nota_v2::_ProjectionWrite_rm_getSid writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_rm_getSid(writeState);
+                        } else {
                             copiedState.rm_getSid(_tmp_2, _tmp_1);
                             nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid();
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid;
-                            _OpCache_with_parameter_rm_getSid.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex);
-                                _OpCache_rm_getSid.insert({param, _OpCache_with_parameter_rm_getSid});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_getSid, nota_v2::_ProjectionWrite_rm_getSid, nota_v2::_ProjectionRead_rm_getSid::Hash, nota_v2::_ProjectionRead_rm_getSid::HashEqual> _OpCache_with_parameter_rm_getSid = _OpCache_with_parameter_rm_getSid_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_rm_getSid.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_rm_getSid.end()) {
-                                nota_v2::_ProjectionWrite_rm_getSid writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_rm_getSid(writeState);
-                            } else {
-                                copiedState.rm_getSid(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_rm_getSid writeState = copiedState._update_for_rm_getSid();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_lock(_ProjectionRead_rm_getSid_mutex);
-                                    _OpCache_with_parameter_rm_getSid.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_rm_getSid.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "rm_getSid";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "rm_getSid";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_rm_getSid_Not_Found read__tr_rm_getSid_Not_Found_state = state._projected_state_for__tr_rm_getSid_Not_Found();
+                BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_8;
                 auto _trid_8_ptr = _OpCache_tr_rm_getSid_Not_Found.find(read__tr_rm_getSid_Not_Found_state);
                 if(_trid_8_ptr == _OpCache_tr_rm_getSid_Not_Found.end()) {
-                    BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_8 = state._tr_rm_getSid_Not_Found();
+                    _trid_8 = state._tr_rm_getSid_Not_Found();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_rm_getSid_Not_Found_lock(_ProjectionRead__tr_rm_getSid_Not_Found_mutex);
                         _OpCache_tr_rm_getSid_Not_Found.insert({read__tr_rm_getSid_Not_Found_state, _trid_8});
                     }
-                    for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_8) {
-                        nota_v2::SERVICE _tmp_1 = param.projection2();
-                        nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_rm_getSid_Not_Found readState = state._projected_state_for_rm_getSid_Not_Found();
+                } else {
+                    _trid_8 = _trid_8_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_rm_getSid_Not_Found_ptr = _OpCache_rm_getSid_Not_Found.find(param);
-                        if(_OpCache_with_parameter_rm_getSid_Not_Found_ptr == _OpCache_rm_getSid_Not_Found.end()) {
-                            copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1);
-                            nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found();
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found;
-                            _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex);
-                                _OpCache_rm_getSid_Not_Found.insert({param, _OpCache_with_parameter_rm_getSid_Not_Found});
-                            }
+                for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_8) {
+                    nota_v2::SERVICE _tmp_1 = param.projection2();
+                    nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found = _OpCache_with_parameter_rm_getSid_Not_Found_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_rm_getSid_Not_Found.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_rm_getSid_Not_Found.end()) {
-                                nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_rm_getSid_Not_Found(writeState);
-                            } else {
-                                copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex);
-                                    _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_rm_getSid_Not_Found readState = state._projected_state_for_rm_getSid_Not_Found();
+
+                    auto _OpCache_with_parameter_rm_getSid_Not_Found_ptr = _OpCache_rm_getSid_Not_Found.find(param);
+                    if(_OpCache_with_parameter_rm_getSid_Not_Found_ptr == _OpCache_rm_getSid_Not_Found.end()) {
+                        copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1);
+                        nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found();
+                        std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found;
+                        _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex);
+                            _OpCache_rm_getSid_Not_Found.insert({param, _OpCache_with_parameter_rm_getSid_Not_Found});
                         }
 
-                        copiedState.stateAccessedVia = "rm_getSid_Not_Found";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_8 = _trid_8_ptr->second;
-                    for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_8) {
-                        nota_v2::SERVICE _tmp_1 = param.projection2();
-                        nota_v2::RESOURCEMANAGER _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_rm_getSid_Not_Found readState = state._projected_state_for_rm_getSid_Not_Found();
-
-                        auto _OpCache_with_parameter_rm_getSid_Not_Found_ptr = _OpCache_rm_getSid_Not_Found.find(param);
-                        if(_OpCache_with_parameter_rm_getSid_Not_Found_ptr == _OpCache_rm_getSid_Not_Found.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found = _OpCache_with_parameter_rm_getSid_Not_Found_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_rm_getSid_Not_Found.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_rm_getSid_Not_Found.end()) {
+                            nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_rm_getSid_Not_Found(writeState);
+                        } else {
                             copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1);
                             nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found();
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found;
-                            _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex);
-                                _OpCache_rm_getSid_Not_Found.insert({param, _OpCache_with_parameter_rm_getSid_Not_Found});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_rm_getSid_Not_Found, nota_v2::_ProjectionWrite_rm_getSid_Not_Found, nota_v2::_ProjectionRead_rm_getSid_Not_Found::Hash, nota_v2::_ProjectionRead_rm_getSid_Not_Found::HashEqual> _OpCache_with_parameter_rm_getSid_Not_Found = _OpCache_with_parameter_rm_getSid_Not_Found_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_rm_getSid_Not_Found.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_rm_getSid_Not_Found.end()) {
-                                nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_rm_getSid_Not_Found(writeState);
-                            } else {
-                                copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_rm_getSid_Not_Found writeState = copiedState._update_for_rm_getSid_Not_Found();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_rm_getSid_Not_Found_lock(_ProjectionRead_rm_getSid_Not_Found_mutex);
-                                    _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_rm_getSid_Not_Found.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "rm_getSid_Not_Found";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "rm_getSid_Not_Found";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_in_announceResourceManager read__tr_in_announceResourceManager_state = state._projected_state_for__tr_in_announceResourceManager();
+                BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >> _trid_9;
                 auto _trid_9_ptr = _OpCache_tr_in_announceResourceManager.find(read__tr_in_announceResourceManager_state);
                 if(_trid_9_ptr == _OpCache_tr_in_announceResourceManager.end()) {
-                    BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >> _trid_9 = state._tr_in_announceResourceManager();
+                    _trid_9 = state._tr_in_announceResourceManager();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_in_announceResourceManager_lock(_ProjectionRead__tr_in_announceResourceManager_mutex);
                         _OpCache_tr_in_announceResourceManager.insert({read__tr_in_announceResourceManager_state, _trid_9});
                     }
-                    for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >& param : _trid_9) {
-                        nota_v2::RESOURCEMANAGER _tmp_1 = param.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_announceResourceManager readState = state._projected_state_for_in_announceResourceManager();
+                } else {
+                    _trid_9 = _trid_9_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_in_announceResourceManager_ptr = _OpCache_in_announceResourceManager.find(param);
-                        if(_OpCache_with_parameter_in_announceResourceManager_ptr == _OpCache_in_announceResourceManager.end()) {
-                            copiedState.in_announceResourceManager(_tmp_2, _tmp_1);
-                            nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager;
-                            _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex);
-                                _OpCache_in_announceResourceManager.insert({param, _OpCache_with_parameter_in_announceResourceManager});
-                            }
+                for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >& param : _trid_9) {
+                    nota_v2::RESOURCEMANAGER _tmp_1 = param.projection2();
+                    nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager = _OpCache_with_parameter_in_announceResourceManager_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_announceResourceManager.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_announceResourceManager.end()) {
-                                nota_v2::_ProjectionWrite_in_announceResourceManager writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_announceResourceManager(writeState);
-                            } else {
-                                copiedState.in_announceResourceManager(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex);
-                                    _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_in_announceResourceManager readState = state._projected_state_for_in_announceResourceManager();
+
+                    auto _OpCache_with_parameter_in_announceResourceManager_ptr = _OpCache_in_announceResourceManager.find(param);
+                    if(_OpCache_with_parameter_in_announceResourceManager_ptr == _OpCache_in_announceResourceManager.end()) {
+                        copiedState.in_announceResourceManager(_tmp_2, _tmp_1);
+                        nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager();
+                        std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager;
+                        _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex);
+                            _OpCache_in_announceResourceManager.insert({param, _OpCache_with_parameter_in_announceResourceManager});
                         }
 
-                        copiedState.stateAccessedVia = "in_announceResourceManager";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >> _trid_9 = _trid_9_ptr->second;
-                    for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >& param : _trid_9) {
-                        nota_v2::RESOURCEMANAGER _tmp_1 = param.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_announceResourceManager readState = state._projected_state_for_in_announceResourceManager();
-
-                        auto _OpCache_with_parameter_in_announceResourceManager_ptr = _OpCache_in_announceResourceManager.find(param);
-                        if(_OpCache_with_parameter_in_announceResourceManager_ptr == _OpCache_in_announceResourceManager.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager = _OpCache_with_parameter_in_announceResourceManager_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_in_announceResourceManager.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_in_announceResourceManager.end()) {
+                            nota_v2::_ProjectionWrite_in_announceResourceManager writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_in_announceResourceManager(writeState);
+                        } else {
                             copiedState.in_announceResourceManager(_tmp_2, _tmp_1);
                             nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager;
-                            _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex);
-                                _OpCache_in_announceResourceManager.insert({param, _OpCache_with_parameter_in_announceResourceManager});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_announceResourceManager, nota_v2::_ProjectionWrite_in_announceResourceManager, nota_v2::_ProjectionRead_in_announceResourceManager::Hash, nota_v2::_ProjectionRead_in_announceResourceManager::HashEqual> _OpCache_with_parameter_in_announceResourceManager = _OpCache_with_parameter_in_announceResourceManager_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_announceResourceManager.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_announceResourceManager.end()) {
-                                nota_v2::_ProjectionWrite_in_announceResourceManager writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_announceResourceManager(writeState);
-                            } else {
-                                copiedState.in_announceResourceManager(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_announceResourceManager writeState = copiedState._update_for_in_announceResourceManager();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_announceResourceManager_lock(_ProjectionRead_in_announceResourceManager_mutex);
-                                    _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_in_announceResourceManager.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "in_announceResourceManager";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "in_announceResourceManager";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_in_register_success read__tr_in_register_success_state = state._projected_state_for__tr_in_register_success();
+                BSet<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >> _trid_10;
                 auto _trid_10_ptr = _OpCache_tr_in_register_success.find(read__tr_in_register_success_state);
                 if(_trid_10_ptr == _OpCache_tr_in_register_success.end()) {
-                    BSet<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >> _trid_10 = state._tr_in_register_success();
+                    _trid_10 = state._tr_in_register_success();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_in_register_success_lock(_ProjectionRead__tr_in_register_success_mutex);
                         _OpCache_tr_in_register_success.insert({read__tr_in_register_success_state, _trid_10});
                     }
-                    for(const BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >& param : _trid_10) {
-                        nota_v2::SID _tmp_1 = param.projection2();
-                        BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE > _tmp_2 = param.projection1();
-                        nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_4 = _tmp_2.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_register_success readState = state._projected_state_for_in_register_success();
+                } else {
+                    _trid_10 = _trid_10_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_in_register_success_ptr = _OpCache_in_register_success.find(param);
-                        if(_OpCache_with_parameter_in_register_success_ptr == _OpCache_in_register_success.end()) {
-                            copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1);
-                            nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success;
-                            _OpCache_with_parameter_in_register_success.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex);
-                                _OpCache_in_register_success.insert({param, _OpCache_with_parameter_in_register_success});
-                            }
+                for(const BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >& param : _trid_10) {
+                    nota_v2::SID _tmp_1 = param.projection2();
+                    BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE > _tmp_2 = param.projection1();
+                    nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
+                    nota_v2::INTERCONNECTNODE _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success = _OpCache_with_parameter_in_register_success_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_register_success.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_register_success.end()) {
-                                nota_v2::_ProjectionWrite_in_register_success writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_register_success(writeState);
-                            } else {
-                                copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex);
-                                    _OpCache_with_parameter_in_register_success.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_in_register_success readState = state._projected_state_for_in_register_success();
+
+                    auto _OpCache_with_parameter_in_register_success_ptr = _OpCache_in_register_success.find(param);
+                    if(_OpCache_with_parameter_in_register_success_ptr == _OpCache_in_register_success.end()) {
+                        copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1);
+                        nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success();
+                        std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success;
+                        _OpCache_with_parameter_in_register_success.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex);
+                            _OpCache_in_register_success.insert({param, _OpCache_with_parameter_in_register_success});
                         }
 
-                        copiedState.stateAccessedVia = "in_register_success";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >> _trid_10 = _trid_10_ptr->second;
-                    for(const BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >& param : _trid_10) {
-                        nota_v2::SID _tmp_1 = param.projection2();
-                        BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE > _tmp_2 = param.projection1();
-                        nota_v2::SERVICE _tmp_3 = _tmp_2.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_4 = _tmp_2.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_register_success readState = state._projected_state_for_in_register_success();
-
-                        auto _OpCache_with_parameter_in_register_success_ptr = _OpCache_in_register_success.find(param);
-                        if(_OpCache_with_parameter_in_register_success_ptr == _OpCache_in_register_success.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success = _OpCache_with_parameter_in_register_success_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_in_register_success.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_in_register_success.end()) {
+                            nota_v2::_ProjectionWrite_in_register_success writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_in_register_success(writeState);
+                        } else {
                             copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1);
                             nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success;
-                            _OpCache_with_parameter_in_register_success.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex);
-                                _OpCache_in_register_success.insert({param, _OpCache_with_parameter_in_register_success});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_register_success, nota_v2::_ProjectionWrite_in_register_success, nota_v2::_ProjectionRead_in_register_success::Hash, nota_v2::_ProjectionRead_in_register_success::HashEqual> _OpCache_with_parameter_in_register_success = _OpCache_with_parameter_in_register_success_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_register_success.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_register_success.end()) {
-                                nota_v2::_ProjectionWrite_in_register_success writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_register_success(writeState);
-                            } else {
-                                copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_register_success writeState = copiedState._update_for_in_register_success();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_register_success_lock(_ProjectionRead_in_register_success_mutex);
-                                    _OpCache_with_parameter_in_register_success.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_in_register_success.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "in_register_success";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "in_register_success";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_in_register_failed read__tr_in_register_failed_state = state._projected_state_for__tr_in_register_failed();
+                BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_11;
                 auto _trid_11_ptr = _OpCache_tr_in_register_failed.find(read__tr_in_register_failed_state);
                 if(_trid_11_ptr == _OpCache_tr_in_register_failed.end()) {
-                    BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_11 = state._tr_in_register_failed();
+                    _trid_11 = state._tr_in_register_failed();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_in_register_failed_lock(_ProjectionRead__tr_in_register_failed_mutex);
                         _OpCache_tr_in_register_failed.insert({read__tr_in_register_failed_state, _trid_11});
                     }
-                    for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_11) {
-                        nota_v2::SERVICE _tmp_1 = param.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_register_failed readState = state._projected_state_for_in_register_failed();
+                } else {
+                    _trid_11 = _trid_11_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_in_register_failed_ptr = _OpCache_in_register_failed.find(param);
-                        if(_OpCache_with_parameter_in_register_failed_ptr == _OpCache_in_register_failed.end()) {
-                            copiedState.in_register_failed(_tmp_2, _tmp_1);
-                            nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed;
-                            _OpCache_with_parameter_in_register_failed.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex);
-                                _OpCache_in_register_failed.insert({param, _OpCache_with_parameter_in_register_failed});
-                            }
+                for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_11) {
+                    nota_v2::SERVICE _tmp_1 = param.projection2();
+                    nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed = _OpCache_with_parameter_in_register_failed_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_register_failed.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_register_failed.end()) {
-                                nota_v2::_ProjectionWrite_in_register_failed writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_register_failed(writeState);
-                            } else {
-                                copiedState.in_register_failed(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex);
-                                    _OpCache_with_parameter_in_register_failed.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_in_register_failed readState = state._projected_state_for_in_register_failed();
+
+                    auto _OpCache_with_parameter_in_register_failed_ptr = _OpCache_in_register_failed.find(param);
+                    if(_OpCache_with_parameter_in_register_failed_ptr == _OpCache_in_register_failed.end()) {
+                        copiedState.in_register_failed(_tmp_2, _tmp_1);
+                        nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed();
+                        std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed;
+                        _OpCache_with_parameter_in_register_failed.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex);
+                            _OpCache_in_register_failed.insert({param, _OpCache_with_parameter_in_register_failed});
                         }
 
-                        copiedState.stateAccessedVia = "in_register_failed";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_11 = _trid_11_ptr->second;
-                    for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_11) {
-                        nota_v2::SERVICE _tmp_1 = param.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_2 = param.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_register_failed readState = state._projected_state_for_in_register_failed();
-
-                        auto _OpCache_with_parameter_in_register_failed_ptr = _OpCache_in_register_failed.find(param);
-                        if(_OpCache_with_parameter_in_register_failed_ptr == _OpCache_in_register_failed.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed = _OpCache_with_parameter_in_register_failed_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_in_register_failed.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_in_register_failed.end()) {
+                            nota_v2::_ProjectionWrite_in_register_failed writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_in_register_failed(writeState);
+                        } else {
                             copiedState.in_register_failed(_tmp_2, _tmp_1);
                             nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed;
-                            _OpCache_with_parameter_in_register_failed.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex);
-                                _OpCache_in_register_failed.insert({param, _OpCache_with_parameter_in_register_failed});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_register_failed, nota_v2::_ProjectionWrite_in_register_failed, nota_v2::_ProjectionRead_in_register_failed::Hash, nota_v2::_ProjectionRead_in_register_failed::HashEqual> _OpCache_with_parameter_in_register_failed = _OpCache_with_parameter_in_register_failed_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_register_failed.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_register_failed.end()) {
-                                nota_v2::_ProjectionWrite_in_register_failed writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_register_failed(writeState);
-                            } else {
-                                copiedState.in_register_failed(_tmp_2, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_register_failed writeState = copiedState._update_for_in_register_failed();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_register_failed_lock(_ProjectionRead_in_register_failed_mutex);
-                                    _OpCache_with_parameter_in_register_failed.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_in_register_failed.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "in_register_failed";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "in_register_failed";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_in_requestTargetSocket_Granted read__tr_in_requestTargetSocket_Granted_state = state._projected_state_for__tr_in_requestTargetSocket_Granted();
+                BSet<BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_12;
                 auto _trid_12_ptr = _OpCache_tr_in_requestTargetSocket_Granted.find(read__tr_in_requestTargetSocket_Granted_state);
                 if(_trid_12_ptr == _OpCache_tr_in_requestTargetSocket_Granted.end()) {
-                    BSet<BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_12 = state._tr_in_requestTargetSocket_Granted();
+                    _trid_12 = state._tr_in_requestTargetSocket_Granted();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_in_requestTargetSocket_Granted_lock(_ProjectionRead__tr_in_requestTargetSocket_Granted_mutex);
                         _OpCache_tr_in_requestTargetSocket_Granted.insert({read__tr_in_requestTargetSocket_Granted_state, _trid_12});
                     }
-                    for(const BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_12) {
-                        nota_v2::SOCKET _tmp_1 = param.projection2();
-                        BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1();
-                        nota_v2::SID _tmp_3 = _tmp_2.projection2();
-                        BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_4 = _tmp_2.projection1();
-                        nota_v2::SID _tmp_5 = _tmp_4.projection2();
-                        BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_6 = _tmp_4.projection1();
-                        nota_v2::SOCKET _tmp_7 = _tmp_6.projection2();
-                        BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_8 = _tmp_6.projection1();
-                        nota_v2::INTERCONNECTNODE _tmp_9 = _tmp_8.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_10 = _tmp_8.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_requestTargetSocket_Granted readState = state._projected_state_for_in_requestTargetSocket_Granted();
-
-                        auto _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr = _OpCache_in_requestTargetSocket_Granted.find(param);
-                        if(_OpCache_with_parameter_in_requestTargetSocket_Granted_ptr == _OpCache_in_requestTargetSocket_Granted.end()) {
-                            copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
-                            nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted;
-                            _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex);
-                                _OpCache_in_requestTargetSocket_Granted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_Granted});
-                            }
+                } else {
+                    _trid_12 = _trid_12_ptr->second;
+                }
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted = _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_Granted.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_Granted.end()) {
-                                nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_requestTargetSocket_Granted(writeState);
-                            } else {
-                                copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex);
-                                    _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState});
-                                }
-                            }
+                for(const BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_12) {
+                    nota_v2::SOCKET _tmp_1 = param.projection2();
+                    BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1();
+                    nota_v2::SID _tmp_3 = _tmp_2.projection2();
+                    BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_4 = _tmp_2.projection1();
+                    nota_v2::SID _tmp_5 = _tmp_4.projection2();
+                    BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_6 = _tmp_4.projection1();
+                    nota_v2::SOCKET _tmp_7 = _tmp_6.projection2();
+                    BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_8 = _tmp_6.projection1();
+                    nota_v2::INTERCONNECTNODE _tmp_9 = _tmp_8.projection2();
+                    nota_v2::INTERCONNECTNODE _tmp_10 = _tmp_8.projection1();
+
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_in_requestTargetSocket_Granted readState = state._projected_state_for_in_requestTargetSocket_Granted();
+
+                    auto _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr = _OpCache_in_requestTargetSocket_Granted.find(param);
+                    if(_OpCache_with_parameter_in_requestTargetSocket_Granted_ptr == _OpCache_in_requestTargetSocket_Granted.end()) {
+                        copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
+                        nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted();
+                        std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted;
+                        _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex);
+                            _OpCache_in_requestTargetSocket_Granted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_Granted});
                         }
 
-                        copiedState.stateAccessedVia = "in_requestTargetSocket_Granted";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_12 = _trid_12_ptr->second;
-                    for(const BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_12) {
-                        nota_v2::SOCKET _tmp_1 = param.projection2();
-                        BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID > _tmp_2 = param.projection1();
-                        nota_v2::SID _tmp_3 = _tmp_2.projection2();
-                        BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_4 = _tmp_2.projection1();
-                        nota_v2::SID _tmp_5 = _tmp_4.projection2();
-                        BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_6 = _tmp_4.projection1();
-                        nota_v2::SOCKET _tmp_7 = _tmp_6.projection2();
-                        BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_8 = _tmp_6.projection1();
-                        nota_v2::INTERCONNECTNODE _tmp_9 = _tmp_8.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_10 = _tmp_8.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_requestTargetSocket_Granted readState = state._projected_state_for_in_requestTargetSocket_Granted();
-
-                        auto _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr = _OpCache_in_requestTargetSocket_Granted.find(param);
-                        if(_OpCache_with_parameter_in_requestTargetSocket_Granted_ptr == _OpCache_in_requestTargetSocket_Granted.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted = _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_Granted.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_Granted.end()) {
+                            nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_in_requestTargetSocket_Granted(writeState);
+                        } else {
                             copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
                             nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted;
-                            _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex);
-                                _OpCache_in_requestTargetSocket_Granted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_Granted});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_Granted, nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_Granted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_Granted = _OpCache_with_parameter_in_requestTargetSocket_Granted_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_Granted.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_Granted.end()) {
-                                nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_requestTargetSocket_Granted(writeState);
-                            } else {
-                                copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_requestTargetSocket_Granted writeState = copiedState._update_for_in_requestTargetSocket_Granted();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_Granted_lock(_ProjectionRead_in_requestTargetSocket_Granted_mutex);
-                                    _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_in_requestTargetSocket_Granted.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "in_requestTargetSocket_Granted";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "in_requestTargetSocket_Granted";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_in_requestTargetSocket_NotGranted read__tr_in_requestTargetSocket_NotGranted_state = state._projected_state_for__tr_in_requestTargetSocket_NotGranted();
+                BSet<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >> _trid_13;
                 auto _trid_13_ptr = _OpCache_tr_in_requestTargetSocket_NotGranted.find(read__tr_in_requestTargetSocket_NotGranted_state);
                 if(_trid_13_ptr == _OpCache_tr_in_requestTargetSocket_NotGranted.end()) {
-                    BSet<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >> _trid_13 = state._tr_in_requestTargetSocket_NotGranted();
+                    _trid_13 = state._tr_in_requestTargetSocket_NotGranted();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_in_requestTargetSocket_NotGranted_lock(_ProjectionRead__tr_in_requestTargetSocket_NotGranted_mutex);
                         _OpCache_tr_in_requestTargetSocket_NotGranted.insert({read__tr_in_requestTargetSocket_NotGranted_state, _trid_13});
                     }
-                    for(const BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >& param : _trid_13) {
-                        nota_v2::SID _tmp_1 = param.projection2();
-                        BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_2 = param.projection1();
-                        nota_v2::SID _tmp_3 = _tmp_2.projection2();
-                        BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_4 = _tmp_2.projection1();
-                        nota_v2::SOCKET _tmp_5 = _tmp_4.projection2();
-                        BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_6 = _tmp_4.projection1();
-                        nota_v2::INTERCONNECTNODE _tmp_7 = _tmp_6.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_8 = _tmp_6.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted readState = state._projected_state_for_in_requestTargetSocket_NotGranted();
-
-                        auto _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr = _OpCache_in_requestTargetSocket_NotGranted.find(param);
-                        if(_OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr == _OpCache_in_requestTargetSocket_NotGranted.end()) {
-                            copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
-                            nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted;
-                            _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex);
-                                _OpCache_in_requestTargetSocket_NotGranted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_NotGranted});
-                            }
+                } else {
+                    _trid_13 = _trid_13_ptr->second;
+                }
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted = _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_NotGranted.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_NotGranted.end()) {
-                                nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_requestTargetSocket_NotGranted(writeState);
-                            } else {
-                                copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex);
-                                    _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState});
-                                }
-                            }
+                for(const BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >& param : _trid_13) {
+                    nota_v2::SID _tmp_1 = param.projection2();
+                    BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_2 = param.projection1();
+                    nota_v2::SID _tmp_3 = _tmp_2.projection2();
+                    BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_4 = _tmp_2.projection1();
+                    nota_v2::SOCKET _tmp_5 = _tmp_4.projection2();
+                    BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_6 = _tmp_4.projection1();
+                    nota_v2::INTERCONNECTNODE _tmp_7 = _tmp_6.projection2();
+                    nota_v2::INTERCONNECTNODE _tmp_8 = _tmp_6.projection1();
+
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted readState = state._projected_state_for_in_requestTargetSocket_NotGranted();
+
+                    auto _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr = _OpCache_in_requestTargetSocket_NotGranted.find(param);
+                    if(_OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr == _OpCache_in_requestTargetSocket_NotGranted.end()) {
+                        copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
+                        nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted();
+                        std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted;
+                        _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex);
+                            _OpCache_in_requestTargetSocket_NotGranted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_NotGranted});
                         }
 
-                        copiedState.stateAccessedVia = "in_requestTargetSocket_NotGranted";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >> _trid_13 = _trid_13_ptr->second;
-                    for(const BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >& param : _trid_13) {
-                        nota_v2::SID _tmp_1 = param.projection2();
-                        BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID > _tmp_2 = param.projection1();
-                        nota_v2::SID _tmp_3 = _tmp_2.projection2();
-                        BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET > _tmp_4 = _tmp_2.projection1();
-                        nota_v2::SOCKET _tmp_5 = _tmp_4.projection2();
-                        BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE > _tmp_6 = _tmp_4.projection1();
-                        nota_v2::INTERCONNECTNODE _tmp_7 = _tmp_6.projection2();
-                        nota_v2::INTERCONNECTNODE _tmp_8 = _tmp_6.projection1();
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted readState = state._projected_state_for_in_requestTargetSocket_NotGranted();
-
-                        auto _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr = _OpCache_in_requestTargetSocket_NotGranted.find(param);
-                        if(_OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr == _OpCache_in_requestTargetSocket_NotGranted.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted = _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_NotGranted.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_NotGranted.end()) {
+                            nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_in_requestTargetSocket_NotGranted(writeState);
+                        } else {
                             copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
                             nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted();
-                            std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted;
-                            _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex);
-                                _OpCache_in_requestTargetSocket_NotGranted.insert({param, _OpCache_with_parameter_in_requestTargetSocket_NotGranted});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::Hash, nota_v2::_ProjectionRead_in_requestTargetSocket_NotGranted::HashEqual> _OpCache_with_parameter_in_requestTargetSocket_NotGranted = _OpCache_with_parameter_in_requestTargetSocket_NotGranted_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_in_requestTargetSocket_NotGranted.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_in_requestTargetSocket_NotGranted.end()) {
-                                nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_in_requestTargetSocket_NotGranted(writeState);
-                            } else {
-                                copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
-                                nota_v2::_ProjectionWrite_in_requestTargetSocket_NotGranted writeState = copiedState._update_for_in_requestTargetSocket_NotGranted();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_in_requestTargetSocket_NotGranted_lock(_ProjectionRead_in_requestTargetSocket_NotGranted_mutex);
-                                    _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_in_requestTargetSocket_NotGranted.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "in_requestTargetSocket_NotGranted";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "in_requestTargetSocket_NotGranted";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 nota_v2::_ProjectionRead__tr_svc_register read__tr_svc_register_state = state._projected_state_for__tr_svc_register();
+                BSet<nota_v2::SERVICE> _trid_14;
                 auto _trid_14_ptr = _OpCache_tr_svc_register.find(read__tr_svc_register_state);
                 if(_trid_14_ptr == _OpCache_tr_svc_register.end()) {
-                    BSet<nota_v2::SERVICE> _trid_14 = state._tr_svc_register();
+                    _trid_14 = state._tr_svc_register();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_svc_register_lock(_ProjectionRead__tr_svc_register_mutex);
                         _OpCache_tr_svc_register.insert({read__tr_svc_register_state, _trid_14});
                     }
-                    for(const nota_v2::SERVICE& param : _trid_14) {
-                        nota_v2::SERVICE _tmp_1 = param;
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_svc_register readState = state._projected_state_for_svc_register();
+                } else {
+                    _trid_14 = _trid_14_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_svc_register_ptr = _OpCache_svc_register.find(param);
-                        if(_OpCache_with_parameter_svc_register_ptr == _OpCache_svc_register.end()) {
-                            copiedState.svc_register(_tmp_1);
-                            nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register();
-                            std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register;
-                            _OpCache_with_parameter_svc_register.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex);
-                                _OpCache_svc_register.insert({param, _OpCache_with_parameter_svc_register});
-                            }
+                for(const nota_v2::SERVICE& param : _trid_14) {
+                    nota_v2::SERVICE _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register = _OpCache_with_parameter_svc_register_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_svc_register.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_svc_register.end()) {
-                                nota_v2::_ProjectionWrite_svc_register writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_svc_register(writeState);
-                            } else {
-                                copiedState.svc_register(_tmp_1);
-                                nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex);
-                                    _OpCache_with_parameter_svc_register.insert({readState, writeState});
-                                }
-                            }
+                    nota_v2 copiedState = state._copy();
+                    nota_v2::_ProjectionRead_svc_register readState = state._projected_state_for_svc_register();
+
+                    auto _OpCache_with_parameter_svc_register_ptr = _OpCache_svc_register.find(param);
+                    if(_OpCache_with_parameter_svc_register_ptr == _OpCache_svc_register.end()) {
+                        copiedState.svc_register(_tmp_1);
+                        nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register();
+                        std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register;
+                        _OpCache_with_parameter_svc_register.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex);
+                            _OpCache_svc_register.insert({param, _OpCache_with_parameter_svc_register});
                         }
 
-                        copiedState.stateAccessedVia = "svc_register";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<nota_v2::SERVICE> _trid_14 = _trid_14_ptr->second;
-                    for(const nota_v2::SERVICE& param : _trid_14) {
-                        nota_v2::SERVICE _tmp_1 = param;
-
-                        nota_v2 copiedState = state._copy();
-                        nota_v2::_ProjectionRead_svc_register readState = state._projected_state_for_svc_register();
-
-                        auto _OpCache_with_parameter_svc_register_ptr = _OpCache_svc_register.find(param);
-                        if(_OpCache_with_parameter_svc_register_ptr == _OpCache_svc_register.end()) {
+                    } else {
+                        std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register = _OpCache_with_parameter_svc_register_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_svc_register.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_svc_register.end()) {
+                            nota_v2::_ProjectionWrite_svc_register writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_svc_register(writeState);
+                        } else {
                             copiedState.svc_register(_tmp_1);
                             nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register();
-                            std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register;
-                            _OpCache_with_parameter_svc_register.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex);
-                                _OpCache_svc_register.insert({param, _OpCache_with_parameter_svc_register});
-                            }
-
-                        } else {
-                            std::unordered_map<nota_v2::_ProjectionRead_svc_register, nota_v2::_ProjectionWrite_svc_register, nota_v2::_ProjectionRead_svc_register::Hash, nota_v2::_ProjectionRead_svc_register::HashEqual> _OpCache_with_parameter_svc_register = _OpCache_with_parameter_svc_register_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_svc_register.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_svc_register.end()) {
-                                nota_v2::_ProjectionWrite_svc_register writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_svc_register(writeState);
-                            } else {
-                                copiedState.svc_register(_tmp_1);
-                                nota_v2::_ProjectionWrite_svc_register writeState = copiedState._update_for_svc_register();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_svc_register_lock(_ProjectionRead_svc_register_mutex);
-                                    _OpCache_with_parameter_svc_register.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_svc_register.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "svc_register";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "svc_register";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -6633,7 +6158,10 @@ class ModelChecker {
                     copiedState.constructor_interconnectNode(_tmp_1);
                     copiedState.stateAccessedVia = "constructor_interconnectNode";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<nota_v2::RESOURCEMANAGER> _trid_2 = state._tr_constructor_resourceManager();
                 for(const nota_v2::RESOURCEMANAGER& param : _trid_2) {
@@ -6643,7 +6171,10 @@ class ModelChecker {
                     copiedState.constructor_resourceManager(_tmp_1);
                     copiedState.stateAccessedVia = "constructor_resourceManager";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_3 = state._tr_constructor_service();
                 for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_3) {
@@ -6654,7 +6185,10 @@ class ModelChecker {
                     copiedState.constructor_service(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "constructor_service";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_4 = state._tr_constructor_socket();
                 for(const BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_4) {
@@ -6669,7 +6203,10 @@ class ModelChecker {
                     copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "constructor_socket";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_5 = state._tr_rm_register();
                 for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_5) {
@@ -6682,7 +6219,10 @@ class ModelChecker {
                     copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "rm_register";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >> _trid_6 = state._tr_rm_deregister();
                 for(const BTuple<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >, nota_v2::INTERCONNECTNODE >& param : _trid_6) {
@@ -6695,7 +6235,10 @@ class ModelChecker {
                     copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "rm_deregister";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_7 = state._tr_rm_getSid();
                 for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_7) {
@@ -6706,7 +6249,10 @@ class ModelChecker {
                     copiedState.rm_getSid(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "rm_getSid";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >> _trid_8 = state._tr_rm_getSid_Not_Found();
                 for(const BTuple<nota_v2::RESOURCEMANAGER, nota_v2::SERVICE >& param : _trid_8) {
@@ -6717,7 +6263,10 @@ class ModelChecker {
                     copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "rm_getSid_Not_Found";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >> _trid_9 = state._tr_in_announceResourceManager();
                 for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::RESOURCEMANAGER >& param : _trid_9) {
@@ -6728,7 +6277,10 @@ class ModelChecker {
                     copiedState.in_announceResourceManager(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "in_announceResourceManager";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >> _trid_10 = state._tr_in_register_success();
                 for(const BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >, nota_v2::SID >& param : _trid_10) {
@@ -6741,7 +6293,10 @@ class ModelChecker {
                     copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "in_register_success";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >> _trid_11 = state._tr_in_register_failed();
                 for(const BTuple<nota_v2::INTERCONNECTNODE, nota_v2::SERVICE >& param : _trid_11) {
@@ -6752,7 +6307,10 @@ class ModelChecker {
                     copiedState.in_register_failed(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "in_register_failed";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >> _trid_12 = state._tr_in_requestTargetSocket_Granted();
                 for(const BTuple<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >, nota_v2::SOCKET >& param : _trid_12) {
@@ -6771,7 +6329,10 @@ class ModelChecker {
                     copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "in_requestTargetSocket_Granted";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >> _trid_13 = state._tr_in_requestTargetSocket_NotGranted();
                 for(const BTuple<BTuple<BTuple<BTuple<nota_v2::INTERCONNECTNODE, nota_v2::INTERCONNECTNODE >, nota_v2::SOCKET >, nota_v2::SID >, nota_v2::SID >& param : _trid_13) {
@@ -6788,7 +6349,10 @@ class ModelChecker {
                     copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "in_requestTargetSocket_NotGranted";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<nota_v2::SERVICE> _trid_14 = state._tr_svc_register();
                 for(const nota_v2::SERVICE& param : _trid_14) {
@@ -6798,7 +6362,10 @@ class ModelChecker {
                     copiedState.svc_register(_tmp_1);
                     copiedState.stateAccessedVia = "svc_register";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/obsw_M001_1.cpp b/benchmarks/model_checking_opreuse/C++/obsw_M001_1.cpp
index c0876aa0d4d091e1cc05eb05f702e3e8de6fa057..add4539c66f9544dfaff2a535a5dd8528031ab84 100644
--- a/benchmarks/model_checking_opreuse/C++/obsw_M001_1.cpp
+++ b/benchmarks/model_checking_opreuse/C++/obsw_M001_1.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -5597,12 +5596,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 obsw_M001_1 state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<obsw_M001_1, obsw_M001_1::Hash, obsw_M001_1::HashEqual> nextStates = generateNextStates(state);
@@ -5623,12 +5626,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -5638,24 +5643,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -5700,1819 +5708,1131 @@ class ModelChecker {
             std::unordered_set<obsw_M001_1, obsw_M001_1::Hash, obsw_M001_1::HashEqual> result = std::unordered_set<obsw_M001_1, obsw_M001_1::Hash, obsw_M001_1::HashEqual>();
             if(isCaching) {
                 obsw_M001_1::_ProjectionRead__tr_env_Receive_TC read__tr_env_Receive_TC_state = state._projected_state_for__tr_env_Receive_TC();
+                BSet<BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1;
                 auto _trid_1_ptr = _OpCache_tr_env_Receive_TC.find(read__tr_env_Receive_TC_state);
                 if(_trid_1_ptr == _OpCache_tr_env_Receive_TC.end()) {
-                    BSet<BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1 = state._tr_env_Receive_TC();
+                    _trid_1 = state._tr_env_Receive_TC();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_Receive_TC_lock(_ProjectionRead__tr_env_Receive_TC_mutex);
                         _OpCache_tr_env_Receive_TC.insert({read__tr_env_Receive_TC_state, _trid_1});
                     }
-                    for(const BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_1::TC_SET _tmp_2 = param.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC();
+                } else {
+                    _trid_1 = _trid_1_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param);
-                        if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) {
-                            copiedState.env_Receive_TC(_tmp_2, _tmp_1);
-                            obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC;
-                            _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
-                                _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC});
-                            }
+                for(const BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
+                    obsw_M001_1::TC_SET _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_Receive_TC(writeState);
-                            } else {
-                                copiedState.env_Receive_TC(_tmp_2, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
-                                    _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC();
+
+                    auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param);
+                    if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) {
+                        copiedState.env_Receive_TC(_tmp_2, _tmp_1);
+                        obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC;
+                        _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
+                            _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC});
                         }
 
-                        copiedState.stateAccessedVia = "env_Receive_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1 = _trid_1_ptr->second;
-                    for(const BTuple<obsw_M001_1::TC_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_1::TC_SET _tmp_2 = param.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC();
-
-                        auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param);
-                        if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) {
+                            obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_Receive_TC(writeState);
+                        } else {
                             copiedState.env_Receive_TC(_tmp_2, _tmp_1);
                             obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC;
-                            _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
-                                _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_env_Receive_TC, obsw_M001_1::_ProjectionWrite_env_Receive_TC, obsw_M001_1::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_1::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_Receive_TC(writeState);
-                            } else {
-                                copiedState.env_Receive_TC(_tmp_2, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
-                                    _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_Receive_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_Receive_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Poll_TC read__tr_Poll_TC_state = state._projected_state_for__tr_Poll_TC();
+                BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2;
                 auto _trid_2_ptr = _OpCache_tr_Poll_TC.find(read__tr_Poll_TC_state);
                 if(_trid_2_ptr == _OpCache_tr_Poll_TC.end()) {
-                    BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = state._tr_Poll_TC();
+                    _trid_2 = state._tr_Poll_TC();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Poll_TC_lock(_ProjectionRead__tr_Poll_TC_mutex);
                         _OpCache_tr_Poll_TC.insert({read__tr_Poll_TC_state, _trid_2});
                     }
-                    for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC();
+                } else {
+                    _trid_2 = _trid_2_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param);
-                        if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) {
-                            copiedState.Poll_TC(_tmp_2, _tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC;
-                            _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
-                                _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC});
-                            }
+                for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Poll_TC(writeState);
-                            } else {
-                                copiedState.Poll_TC(_tmp_2, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
-                                    _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC();
+
+                    auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param);
+                    if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) {
+                        copiedState.Poll_TC(_tmp_2, _tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC;
+                        _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
+                            _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC});
                         }
 
-                        copiedState.stateAccessedVia = "Poll_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = _trid_2_ptr->second;
-                    for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC();
-
-                        auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param);
-                        if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) {
+                            obsw_M001_1::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Poll_TC(writeState);
+                        } else {
                             copiedState.Poll_TC(_tmp_2, _tmp_1);
                             obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC;
-                            _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
-                                _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Poll_TC, obsw_M001_1::_ProjectionWrite_Poll_TC, obsw_M001_1::_ProjectionRead_Poll_TC::Hash, obsw_M001_1::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Poll_TC(writeState);
-                            } else {
-                                copiedState.Poll_TC(_tmp_2, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
-                                    _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Poll_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Poll_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Accept_TC read__tr_Accept_TC_state = state._projected_state_for__tr_Accept_TC();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3;
                 auto _trid_3_ptr = _OpCache_tr_Accept_TC.find(read__tr_Accept_TC_state);
                 if(_trid_3_ptr == _OpCache_tr_Accept_TC.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = state._tr_Accept_TC();
+                    _trid_3 = state._tr_Accept_TC();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Accept_TC_lock(_ProjectionRead__tr_Accept_TC_mutex);
                         _OpCache_tr_Accept_TC.insert({read__tr_Accept_TC_state, _trid_3});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC();
+                } else {
+                    _trid_3 = _trid_3_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param);
-                        if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) {
-                            copiedState.Accept_TC(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC;
-                            _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
-                                _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Accept_TC(writeState);
-                            } else {
-                                copiedState.Accept_TC(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
-                                    _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC();
+
+                    auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param);
+                    if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) {
+                        copiedState.Accept_TC(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC;
+                        _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
+                            _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC});
                         }
 
-                        copiedState.stateAccessedVia = "Accept_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = _trid_3_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC();
-
-                        auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param);
-                        if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) {
+                            obsw_M001_1::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Accept_TC(writeState);
+                        } else {
                             copiedState.Accept_TC(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC;
-                            _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
-                                _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Accept_TC, obsw_M001_1::_ProjectionWrite_Accept_TC, obsw_M001_1::_ProjectionRead_Accept_TC::Hash, obsw_M001_1::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Accept_TC(writeState);
-                            } else {
-                                copiedState.Accept_TC(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
-                                    _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Accept_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Accept_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Reject_TC read__tr_Reject_TC_state = state._projected_state_for__tr_Reject_TC();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4;
                 auto _trid_4_ptr = _OpCache_tr_Reject_TC.find(read__tr_Reject_TC_state);
                 if(_trid_4_ptr == _OpCache_tr_Reject_TC.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = state._tr_Reject_TC();
+                    _trid_4 = state._tr_Reject_TC();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Reject_TC_lock(_ProjectionRead__tr_Reject_TC_mutex);
                         _OpCache_tr_Reject_TC.insert({read__tr_Reject_TC_state, _trid_4});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC();
+                } else {
+                    _trid_4 = _trid_4_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param);
-                        if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) {
-                            copiedState.Reject_TC(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC;
-                            _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
-                                _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Reject_TC(writeState);
-                            } else {
-                                copiedState.Reject_TC(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
-                                    _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC();
+
+                    auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param);
+                    if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) {
+                        copiedState.Reject_TC(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC;
+                        _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
+                            _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC});
                         }
 
-                        copiedState.stateAccessedVia = "Reject_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = _trid_4_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC();
-
-                        auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param);
-                        if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) {
+                            obsw_M001_1::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Reject_TC(writeState);
+                        } else {
                             copiedState.Reject_TC(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC;
-                            _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
-                                _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Reject_TC, obsw_M001_1::_ProjectionWrite_Reject_TC, obsw_M001_1::_ProjectionRead_Reject_TC::Hash, obsw_M001_1::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Reject_TC(writeState);
-                            } else {
-                                copiedState.Reject_TC(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
-                                    _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Reject_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Reject_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Report_TC_Acceptance read__tr_Report_TC_Acceptance_state = state._projected_state_for__tr_Report_TC_Acceptance();
+                BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5;
                 auto _trid_5_ptr = _OpCache_tr_Report_TC_Acceptance.find(read__tr_Report_TC_Acceptance_state);
                 if(_trid_5_ptr == _OpCache_tr_Report_TC_Acceptance.end()) {
-                    BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = state._tr_Report_TC_Acceptance();
+                    _trid_5 = state._tr_Report_TC_Acceptance();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Acceptance_lock(_ProjectionRead__tr_Report_TC_Acceptance_mutex);
                         _OpCache_tr_Report_TC_Acceptance.insert({read__tr_Report_TC_Acceptance_state, _trid_5});
                     }
-                    for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance();
+                } else {
+                    _trid_5 = _trid_5_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) {
-                            copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance;
-                            _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
-                                _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance});
-                            }
+                for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
+                    obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) {
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Acceptance(writeState);
-                            } else {
-                                copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
-                                    _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance();
+
+                    auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param);
+                    if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) {
+                        copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance;
+                        _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
+                            _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance});
                         }
 
-                        copiedState.stateAccessedVia = "Report_TC_Acceptance";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = _trid_5_ptr->second;
-                    for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance();
-
-                        auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) {
+                            obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Report_TC_Acceptance(writeState);
+                        } else {
                             copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
                             obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance;
-                            _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
-                                _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Acceptance, obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) {
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Acceptance(writeState);
-                            } else {
-                                copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
-                                    _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Report_TC_Acceptance";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Report_TC_Acceptance";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Skip_TC_Acceptance_Report read__tr_Skip_TC_Acceptance_Report_state = state._projected_state_for__tr_Skip_TC_Acceptance_Report();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6;
                 auto _trid_6_ptr = _OpCache_tr_Skip_TC_Acceptance_Report.find(read__tr_Skip_TC_Acceptance_Report_state);
                 if(_trid_6_ptr == _OpCache_tr_Skip_TC_Acceptance_Report.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = state._tr_Skip_TC_Acceptance_Report();
+                    _trid_6 = state._tr_Skip_TC_Acceptance_Report();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Acceptance_Report_lock(_ProjectionRead__tr_Skip_TC_Acceptance_Report_mutex);
                         _OpCache_tr_Skip_TC_Acceptance_Report.insert({read__tr_Skip_TC_Acceptance_Report_state, _trid_6});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report();
+                } else {
+                    _trid_6 = _trid_6_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) {
-                            copiedState.Skip_TC_Acceptance_Report(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report;
-                            _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
-                                _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) {
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Acceptance_Report(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report();
+
+                    auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param);
+                    if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) {
+                        copiedState.Skip_TC_Acceptance_Report(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report;
+                        _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
+                            _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report});
                         }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = _trid_6_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report();
-
-                        auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) {
+                            obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState);
+                        } else {
                             copiedState.Skip_TC_Acceptance_Report(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report;
-                            _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
-                                _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) {
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Acceptance_Report(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Report_TC_Rejection read__tr_Report_TC_Rejection_state = state._projected_state_for__tr_Report_TC_Rejection();
+                BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7;
                 auto _trid_7_ptr = _OpCache_tr_Report_TC_Rejection.find(read__tr_Report_TC_Rejection_state);
                 if(_trid_7_ptr == _OpCache_tr_Report_TC_Rejection.end()) {
-                    BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = state._tr_Report_TC_Rejection();
+                    _trid_7 = state._tr_Report_TC_Rejection();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Rejection_lock(_ProjectionRead__tr_Report_TC_Rejection_mutex);
                         _OpCache_tr_Report_TC_Rejection.insert({read__tr_Report_TC_Rejection_state, _trid_7});
                     }
-                    for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection();
+                } else {
+                    _trid_7 = _trid_7_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) {
-                            copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection;
-                            _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
-                                _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection});
-                            }
+                for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
+                    obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) {
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Rejection(writeState);
-                            } else {
-                                copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
-                                    _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection();
+
+                    auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param);
+                    if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) {
+                        copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection;
+                        _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
+                            _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection});
                         }
 
-                        copiedState.stateAccessedVia = "Report_TC_Rejection";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = _trid_7_ptr->second;
-                    for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection();
-
-                        auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) {
+                            obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Report_TC_Rejection(writeState);
+                        } else {
                             copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
                             obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection;
-                            _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
-                                _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Rejection, obsw_M001_1::_ProjectionWrite_Report_TC_Rejection, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) {
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Rejection(writeState);
-                            } else {
-                                copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
-                                    _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Report_TC_Rejection";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Report_TC_Rejection";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Skip_TC_Rejection_Report read__tr_Skip_TC_Rejection_Report_state = state._projected_state_for__tr_Skip_TC_Rejection_Report();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8;
                 auto _trid_8_ptr = _OpCache_tr_Skip_TC_Rejection_Report.find(read__tr_Skip_TC_Rejection_Report_state);
                 if(_trid_8_ptr == _OpCache_tr_Skip_TC_Rejection_Report.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = state._tr_Skip_TC_Rejection_Report();
+                    _trid_8 = state._tr_Skip_TC_Rejection_Report();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Rejection_Report_lock(_ProjectionRead__tr_Skip_TC_Rejection_Report_mutex);
                         _OpCache_tr_Skip_TC_Rejection_Report.insert({read__tr_Skip_TC_Rejection_Report_state, _trid_8});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report();
+                } else {
+                    _trid_8 = _trid_8_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) {
-                            copiedState.Skip_TC_Rejection_Report(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report;
-                            _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
-                                _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) {
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Rejection_Report(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report();
+
+                    auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param);
+                    if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) {
+                        copiedState.Skip_TC_Rejection_Report(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report;
+                        _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
+                            _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report});
                         }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Rejection_Report";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = _trid_8_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report();
-
-                        auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) {
+                            obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState);
+                        } else {
                             copiedState.Skip_TC_Rejection_Report(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report;
-                            _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
-                                _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) {
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Rejection_Report(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Rejection_Report";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Skip_TC_Rejection_Report";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Execute_TC_Successfully read__tr_Execute_TC_Successfully_state = state._projected_state_for__tr_Execute_TC_Successfully();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9;
                 auto _trid_9_ptr = _OpCache_tr_Execute_TC_Successfully.find(read__tr_Execute_TC_Successfully_state);
                 if(_trid_9_ptr == _OpCache_tr_Execute_TC_Successfully.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = state._tr_Execute_TC_Successfully();
+                    _trid_9 = state._tr_Execute_TC_Successfully();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Execute_TC_Successfully_lock(_ProjectionRead__tr_Execute_TC_Successfully_mutex);
                         _OpCache_tr_Execute_TC_Successfully.insert({read__tr_Execute_TC_Successfully_state, _trid_9});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully();
+                } else {
+                    _trid_9 = _trid_9_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param);
-                        if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) {
-                            copiedState.Execute_TC_Successfully(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully;
-                            _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
-                                _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) {
-                                obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Execute_TC_Successfully(writeState);
-                            } else {
-                                copiedState.Execute_TC_Successfully(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
-                                    _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully();
+
+                    auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param);
+                    if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) {
+                        copiedState.Execute_TC_Successfully(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully;
+                        _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
+                            _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully});
                         }
 
-                        copiedState.stateAccessedVia = "Execute_TC_Successfully";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = _trid_9_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully();
-
-                        auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param);
-                        if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) {
+                            obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Execute_TC_Successfully(writeState);
+                        } else {
                             copiedState.Execute_TC_Successfully(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully;
-                            _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
-                                _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Execute_TC_Successfully, obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_1::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) {
-                                obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Execute_TC_Successfully(writeState);
-                            } else {
-                                copiedState.Execute_TC_Successfully(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
-                                    _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Execute_TC_Successfully";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Execute_TC_Successfully";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Reset_TM_Buffer read__tr_Reset_TM_Buffer_state = state._projected_state_for__tr_Reset_TM_Buffer();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10;
                 auto _trid_10_ptr = _OpCache_tr_Reset_TM_Buffer.find(read__tr_Reset_TM_Buffer_state);
                 if(_trid_10_ptr == _OpCache_tr_Reset_TM_Buffer.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = state._tr_Reset_TM_Buffer();
+                    _trid_10 = state._tr_Reset_TM_Buffer();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Reset_TM_Buffer_lock(_ProjectionRead__tr_Reset_TM_Buffer_mutex);
                         _OpCache_tr_Reset_TM_Buffer.insert({read__tr_Reset_TM_Buffer_state, _trid_10});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer();
+                } else {
+                    _trid_10 = _trid_10_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param);
-                        if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) {
-                            copiedState.Reset_TM_Buffer(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer;
-                            _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
-                                _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) {
-                                obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Reset_TM_Buffer(writeState);
-                            } else {
-                                copiedState.Reset_TM_Buffer(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
-                                    _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer();
+
+                    auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param);
+                    if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) {
+                        copiedState.Reset_TM_Buffer(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer;
+                        _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
+                            _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer});
                         }
 
-                        copiedState.stateAccessedVia = "Reset_TM_Buffer";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = _trid_10_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer();
-
-                        auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param);
-                        if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) {
+                            obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Reset_TM_Buffer(writeState);
+                        } else {
                             copiedState.Reset_TM_Buffer(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer;
-                            _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
-                                _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Reset_TM_Buffer, obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_1::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) {
-                                obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Reset_TM_Buffer(writeState);
-                            } else {
-                                copiedState.Reset_TM_Buffer(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
-                                    _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Reset_TM_Buffer";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Reset_TM_Buffer";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Fail_TC_Execution read__tr_Fail_TC_Execution_state = state._projected_state_for__tr_Fail_TC_Execution();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11;
                 auto _trid_11_ptr = _OpCache_tr_Fail_TC_Execution.find(read__tr_Fail_TC_Execution_state);
                 if(_trid_11_ptr == _OpCache_tr_Fail_TC_Execution.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = state._tr_Fail_TC_Execution();
+                    _trid_11 = state._tr_Fail_TC_Execution();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Fail_TC_Execution_lock(_ProjectionRead__tr_Fail_TC_Execution_mutex);
                         _OpCache_tr_Fail_TC_Execution.insert({read__tr_Fail_TC_Execution_state, _trid_11});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution();
+                } else {
+                    _trid_11 = _trid_11_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param);
-                        if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) {
-                            copiedState.Fail_TC_Execution(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution;
-                            _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
-                                _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) {
-                                obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Fail_TC_Execution(writeState);
-                            } else {
-                                copiedState.Fail_TC_Execution(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
-                                    _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution();
+
+                    auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param);
+                    if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) {
+                        copiedState.Fail_TC_Execution(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution;
+                        _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
+                            _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution});
                         }
 
-                        copiedState.stateAccessedVia = "Fail_TC_Execution";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = _trid_11_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution();
-
-                        auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param);
-                        if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) {
+                            obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Fail_TC_Execution(writeState);
+                        } else {
                             copiedState.Fail_TC_Execution(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution;
-                            _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
-                                _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Fail_TC_Execution, obsw_M001_1::_ProjectionWrite_Fail_TC_Execution, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_1::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) {
-                                obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Fail_TC_Execution(writeState);
-                            } else {
-                                copiedState.Fail_TC_Execution(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
-                                    _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Fail_TC_Execution";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Fail_TC_Execution";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Report_TC_Execution_Success read__tr_Report_TC_Execution_Success_state = state._projected_state_for__tr_Report_TC_Execution_Success();
+                BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12;
                 auto _trid_12_ptr = _OpCache_tr_Report_TC_Execution_Success.find(read__tr_Report_TC_Execution_Success_state);
                 if(_trid_12_ptr == _OpCache_tr_Report_TC_Execution_Success.end()) {
-                    BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = state._tr_Report_TC_Execution_Success();
+                    _trid_12 = state._tr_Report_TC_Execution_Success();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Execution_Success_lock(_ProjectionRead__tr_Report_TC_Execution_Success_mutex);
                         _OpCache_tr_Report_TC_Execution_Success.insert({read__tr_Report_TC_Execution_Success_state, _trid_12});
                     }
-                    for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success();
+                } else {
+                    _trid_12 = _trid_12_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) {
-                            copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success;
-                            _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
-                                _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success});
-                            }
+                for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
+                    obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) {
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Execution_Success(writeState);
-                            } else {
-                                copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
-                                    _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success();
+
+                    auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param);
+                    if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) {
+                        copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success;
+                        _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
+                            _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success});
                         }
 
-                        copiedState.stateAccessedVia = "Report_TC_Execution_Success";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = _trid_12_ptr->second;
-                    for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success();
-
-                        auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) {
+                            obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Report_TC_Execution_Success(writeState);
+                        } else {
                             copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
                             obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success;
-                            _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
-                                _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) {
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Execution_Success(writeState);
-                            } else {
-                                copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
-                                    _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Report_TC_Execution_Success";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Report_TC_Execution_Success";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Skip_TC_Success_Report read__tr_Skip_TC_Success_Report_state = state._projected_state_for__tr_Skip_TC_Success_Report();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13;
                 auto _trid_13_ptr = _OpCache_tr_Skip_TC_Success_Report.find(read__tr_Skip_TC_Success_Report_state);
                 if(_trid_13_ptr == _OpCache_tr_Skip_TC_Success_Report.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = state._tr_Skip_TC_Success_Report();
+                    _trid_13 = state._tr_Skip_TC_Success_Report();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Success_Report_lock(_ProjectionRead__tr_Skip_TC_Success_Report_mutex);
                         _OpCache_tr_Skip_TC_Success_Report.insert({read__tr_Skip_TC_Success_Report_state, _trid_13});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report();
+                } else {
+                    _trid_13 = _trid_13_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) {
-                            copiedState.Skip_TC_Success_Report(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report;
-                            _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
-                                _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) {
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Success_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Success_Report(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report();
+
+                    auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param);
+                    if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) {
+                        copiedState.Skip_TC_Success_Report(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report;
+                        _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
+                            _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report});
                         }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Success_Report";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = _trid_13_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report();
-
-                        auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) {
+                            obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Skip_TC_Success_Report(writeState);
+                        } else {
                             copiedState.Skip_TC_Success_Report(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report;
-                            _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
-                                _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) {
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Success_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Success_Report(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Success_Report";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Skip_TC_Success_Report";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Report_TC_Execution_Failure read__tr_Report_TC_Execution_Failure_state = state._projected_state_for__tr_Report_TC_Execution_Failure();
+                BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14;
                 auto _trid_14_ptr = _OpCache_tr_Report_TC_Execution_Failure.find(read__tr_Report_TC_Execution_Failure_state);
                 if(_trid_14_ptr == _OpCache_tr_Report_TC_Execution_Failure.end()) {
-                    BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = state._tr_Report_TC_Execution_Failure();
+                    _trid_14 = state._tr_Report_TC_Execution_Failure();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Execution_Failure_lock(_ProjectionRead__tr_Report_TC_Execution_Failure_mutex);
                         _OpCache_tr_Report_TC_Execution_Failure.insert({read__tr_Report_TC_Execution_Failure_state, _trid_14});
                     }
-                    for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure();
+                } else {
+                    _trid_14 = _trid_14_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) {
-                            copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure;
-                            _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
-                                _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure});
-                            }
+                for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
+                    obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) {
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Execution_Failure(writeState);
-                            } else {
-                                copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
-                                    _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure();
+
+                    auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param);
+                    if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) {
+                        copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure;
+                        _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
+                            _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure});
                         }
 
-                        copiedState.stateAccessedVia = "Report_TC_Execution_Failure";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = _trid_14_ptr->second;
-                    for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_1::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure();
-
-                        auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) {
+                            obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Report_TC_Execution_Failure(writeState);
+                        } else {
                             copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
                             obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure;
-                            _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
-                                _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_1::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) {
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Execution_Failure(writeState);
-                            } else {
-                                copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
-                                    _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Report_TC_Execution_Failure";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Report_TC_Execution_Failure";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Skip_TC_Failure_Report read__tr_Skip_TC_Failure_Report_state = state._projected_state_for__tr_Skip_TC_Failure_Report();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15;
                 auto _trid_15_ptr = _OpCache_tr_Skip_TC_Failure_Report.find(read__tr_Skip_TC_Failure_Report_state);
                 if(_trid_15_ptr == _OpCache_tr_Skip_TC_Failure_Report.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = state._tr_Skip_TC_Failure_Report();
+                    _trid_15 = state._tr_Skip_TC_Failure_Report();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Failure_Report_lock(_ProjectionRead__tr_Skip_TC_Failure_Report_mutex);
                         _OpCache_tr_Skip_TC_Failure_Report.insert({read__tr_Skip_TC_Failure_Report_state, _trid_15});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report();
+                } else {
+                    _trid_15 = _trid_15_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) {
-                            copiedState.Skip_TC_Failure_Report(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report;
-                            _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
-                                _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) {
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Failure_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Failure_Report(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report();
+
+                    auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param);
+                    if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) {
+                        copiedState.Skip_TC_Failure_Report(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report;
+                        _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
+                            _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report});
                         }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Failure_Report";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = _trid_15_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report();
-
-                        auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) {
+                            obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Skip_TC_Failure_Report(writeState);
+                        } else {
                             copiedState.Skip_TC_Failure_Report(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report;
-                            _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
-                                _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_1::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) {
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Failure_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Failure_Report(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Failure_Report";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Skip_TC_Failure_Report";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Drop_TC read__tr_Drop_TC_state = state._projected_state_for__tr_Drop_TC();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16;
                 auto _trid_16_ptr = _OpCache_tr_Drop_TC.find(read__tr_Drop_TC_state);
                 if(_trid_16_ptr == _OpCache_tr_Drop_TC.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = state._tr_Drop_TC();
-                    {
-                        std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TC_lock(_ProjectionRead__tr_Drop_TC_mutex);
-                        _OpCache_tr_Drop_TC.insert({read__tr_Drop_TC_state, _trid_16});
-                    }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC();
-
-                        auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param);
-                        if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) {
-                            copiedState.Drop_TC(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC;
-                            _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
-                                _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Drop_TC(writeState);
-                            } else {
-                                copiedState.Drop_TC(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
-                                    _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
-                                }
-                            }
-                        }
-
-                        copiedState.stateAccessedVia = "Drop_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
+                    _trid_16 = state._tr_Drop_TC();
+                    {
+                        std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TC_lock(_ProjectionRead__tr_Drop_TC_mutex);
+                        _OpCache_tr_Drop_TC.insert({read__tr_Drop_TC_state, _trid_16});
                     }
                 } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = _trid_16_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
+                    _trid_16 = _trid_16_ptr->second;
+                }
 
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC();
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
+
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC();
+
+                    auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param);
+                    if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) {
+                        copiedState.Drop_TC(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC;
+                        _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
+                            _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC});
+                        }
 
-                        auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param);
-                        if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) {
+                            obsw_M001_1::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Drop_TC(writeState);
+                        } else {
                             copiedState.Drop_TC(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC;
-                            _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
-                                _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TC, obsw_M001_1::_ProjectionWrite_Drop_TC, obsw_M001_1::_ProjectionRead_Drop_TC::Hash, obsw_M001_1::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) {
-                                obsw_M001_1::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Drop_TC(writeState);
-                            } else {
-                                copiedState.Drop_TC(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
-                                    _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Drop_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Drop_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Produce_TM read__tr_Produce_TM_state = state._projected_state_for__tr_Produce_TM();
+                BSet<BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17;
                 auto _trid_17_ptr = _OpCache_tr_Produce_TM.find(read__tr_Produce_TM_state);
                 if(_trid_17_ptr == _OpCache_tr_Produce_TM.end()) {
-                    BSet<BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = state._tr_Produce_TM();
+                    _trid_17 = state._tr_Produce_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Produce_TM_lock(_ProjectionRead__tr_Produce_TM_mutex);
                         _OpCache_tr_Produce_TM.insert({read__tr_Produce_TM_state, _trid_17});
                     }
-                    for(const BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        obsw_M001_1::TM_SET _tmp_2 = param.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM();
+                } else {
+                    _trid_17 = _trid_17_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param);
-                        if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) {
-                            copiedState.Produce_TM(_tmp_2, _tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM;
-                            _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
-                                _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM});
-                            }
+                for(const BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    obsw_M001_1::TM_SET _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Produce_TM(writeState);
-                            } else {
-                                copiedState.Produce_TM(_tmp_2, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
-                                    _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM();
+
+                    auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param);
+                    if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) {
+                        copiedState.Produce_TM(_tmp_2, _tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM;
+                        _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
+                            _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM});
                         }
 
-                        copiedState.stateAccessedVia = "Produce_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = _trid_17_ptr->second;
-                    for(const BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        obsw_M001_1::TM_SET _tmp_2 = param.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM();
-
-                        auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param);
-                        if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) {
+                            obsw_M001_1::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Produce_TM(writeState);
+                        } else {
                             copiedState.Produce_TM(_tmp_2, _tmp_1);
                             obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM;
-                            _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
-                                _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Produce_TM, obsw_M001_1::_ProjectionWrite_Produce_TM, obsw_M001_1::_ProjectionRead_Produce_TM::Hash, obsw_M001_1::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Produce_TM(writeState);
-                            } else {
-                                copiedState.Produce_TM(_tmp_2, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
-                                    _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Produce_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Produce_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Pass_TM read__tr_Pass_TM_state = state._projected_state_for__tr_Pass_TM();
+                BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18;
                 auto _trid_18_ptr = _OpCache_tr_Pass_TM.find(read__tr_Pass_TM_state);
                 if(_trid_18_ptr == _OpCache_tr_Pass_TM.end()) {
-                    BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = state._tr_Pass_TM();
+                    _trid_18 = state._tr_Pass_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Pass_TM_lock(_ProjectionRead__tr_Pass_TM_mutex);
                         _OpCache_tr_Pass_TM.insert({read__tr_Pass_TM_state, _trid_18});
                     }
-                    for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM();
+                } else {
+                    _trid_18 = _trid_18_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param);
-                        if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) {
-                            copiedState.Pass_TM(_tmp_2, _tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM;
-                            _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
-                                _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM});
-                            }
+                for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2();
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Pass_TM(writeState);
-                            } else {
-                                copiedState.Pass_TM(_tmp_2, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
-                                    _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM();
+
+                    auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param);
+                    if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) {
+                        copiedState.Pass_TM(_tmp_2, _tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM;
+                        _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
+                            _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM});
                         }
 
-                        copiedState.stateAccessedVia = "Pass_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = _trid_18_ptr->second;
-                    for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1();
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM();
-
-                        auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param);
-                        if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) {
+                            obsw_M001_1::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Pass_TM(writeState);
+                        } else {
                             copiedState.Pass_TM(_tmp_2, _tmp_1);
                             obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM;
-                            _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
-                                _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Pass_TM, obsw_M001_1::_ProjectionWrite_Pass_TM, obsw_M001_1::_ProjectionRead_Pass_TM::Hash, obsw_M001_1::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Pass_TM(writeState);
-                            } else {
-                                copiedState.Pass_TM(_tmp_2, _tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
-                                    _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Pass_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Pass_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Cancel_TM read__tr_Cancel_TM_state = state._projected_state_for__tr_Cancel_TM();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19;
                 auto _trid_19_ptr = _OpCache_tr_Cancel_TM.find(read__tr_Cancel_TM_state);
                 if(_trid_19_ptr == _OpCache_tr_Cancel_TM.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = state._tr_Cancel_TM();
+                    _trid_19 = state._tr_Cancel_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Cancel_TM_lock(_ProjectionRead__tr_Cancel_TM_mutex);
                         _OpCache_tr_Cancel_TM.insert({read__tr_Cancel_TM_state, _trid_19});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM();
+                } else {
+                    _trid_19 = _trid_19_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param);
-                        if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) {
-                            copiedState.Cancel_TM(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM;
-                            _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
-                                _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Cancel_TM(writeState);
-                            } else {
-                                copiedState.Cancel_TM(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
-                                    _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM();
+
+                    auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param);
+                    if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) {
+                        copiedState.Cancel_TM(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM;
+                        _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
+                            _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM});
                         }
 
-                        copiedState.stateAccessedVia = "Cancel_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = _trid_19_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM();
-
-                        auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param);
-                        if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) {
+                            obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Cancel_TM(writeState);
+                        } else {
                             copiedState.Cancel_TM(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM;
-                            _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
-                                _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Cancel_TM, obsw_M001_1::_ProjectionWrite_Cancel_TM, obsw_M001_1::_ProjectionRead_Cancel_TM::Hash, obsw_M001_1::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Cancel_TM(writeState);
-                            } else {
-                                copiedState.Cancel_TM(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
-                                    _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Cancel_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Cancel_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_Drop_TM read__tr_Drop_TM_state = state._projected_state_for__tr_Drop_TM();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20;
                 auto _trid_20_ptr = _OpCache_tr_Drop_TM.find(read__tr_Drop_TM_state);
                 if(_trid_20_ptr == _OpCache_tr_Drop_TM.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = state._tr_Drop_TM();
+                    _trid_20 = state._tr_Drop_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TM_lock(_ProjectionRead__tr_Drop_TM_mutex);
                         _OpCache_tr_Drop_TM.insert({read__tr_Drop_TM_state, _trid_20});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM();
+                } else {
+                    _trid_20 = _trid_20_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param);
-                        if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) {
-                            copiedState.Drop_TM(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM;
-                            _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
-                                _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Drop_TM(writeState);
-                            } else {
-                                copiedState.Drop_TM(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
-                                    _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM();
+
+                    auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param);
+                    if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) {
+                        copiedState.Drop_TM(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM;
+                        _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
+                            _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM});
                         }
 
-                        copiedState.stateAccessedVia = "Drop_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = _trid_20_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM();
-
-                        auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param);
-                        if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) {
+                            obsw_M001_1::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Drop_TM(writeState);
+                        } else {
                             copiedState.Drop_TM(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM;
-                            _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
-                                _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_Drop_TM, obsw_M001_1::_ProjectionWrite_Drop_TM, obsw_M001_1::_ProjectionRead_Drop_TM::Hash, obsw_M001_1::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Drop_TM(writeState);
-                            } else {
-                                copiedState.Drop_TM(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
-                                    _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Drop_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Drop_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_1::_ProjectionRead__tr_env_Deliver_TM read__tr_env_Deliver_TM_state = state._projected_state_for__tr_env_Deliver_TM();
+                BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21;
                 auto _trid_21_ptr = _OpCache_tr_env_Deliver_TM.find(read__tr_env_Deliver_TM_state);
                 if(_trid_21_ptr == _OpCache_tr_env_Deliver_TM.end()) {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = state._tr_env_Deliver_TM();
+                    _trid_21 = state._tr_env_Deliver_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_Deliver_TM_lock(_ProjectionRead__tr_env_Deliver_TM_mutex);
                         _OpCache_tr_env_Deliver_TM.insert({read__tr_env_Deliver_TM_state, _trid_21});
                     }
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM();
+                } else {
+                    _trid_21 = _trid_21_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param);
-                        if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) {
-                            copiedState.env_Deliver_TM(_tmp_1);
-                            obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM;
-                            _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
-                                _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM});
-                            }
+                for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) {
+                    obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_Deliver_TM(writeState);
-                            } else {
-                                copiedState.env_Deliver_TM(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
-                                    _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_1 copiedState = state._copy();
+                    obsw_M001_1::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM();
+
+                    auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param);
+                    if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) {
+                        copiedState.env_Deliver_TM(_tmp_1);
+                        obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM;
+                        _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
+                            _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM});
                         }
 
-                        copiedState.stateAccessedVia = "env_Deliver_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = _trid_21_ptr->second;
-                    for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) {
-                        obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param;
-
-                        obsw_M001_1 copiedState = state._copy();
-                        obsw_M001_1::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM();
-
-                        auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param);
-                        if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) {
+                            obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_Deliver_TM(writeState);
+                        } else {
                             copiedState.env_Deliver_TM(_tmp_1);
                             obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM;
-                            _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
-                                _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_1::_ProjectionRead_env_Deliver_TM, obsw_M001_1::_ProjectionWrite_env_Deliver_TM, obsw_M001_1::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_1::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) {
-                                obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_Deliver_TM(writeState);
-                            } else {
-                                copiedState.env_Deliver_TM(_tmp_1);
-                                obsw_M001_1::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
-                                    _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_Deliver_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_Deliver_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -7527,7 +6847,10 @@ class ModelChecker {
                     copiedState.env_Receive_TC(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "env_Receive_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = state._tr_Poll_TC();
                 for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) {
@@ -7538,7 +6861,10 @@ class ModelChecker {
                     copiedState.Poll_TC(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "Poll_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = state._tr_Accept_TC();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) {
@@ -7548,7 +6874,10 @@ class ModelChecker {
                     copiedState.Accept_TC(_tmp_1);
                     copiedState.stateAccessedVia = "Accept_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = state._tr_Reject_TC();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) {
@@ -7558,7 +6887,10 @@ class ModelChecker {
                     copiedState.Reject_TC(_tmp_1);
                     copiedState.stateAccessedVia = "Reject_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = state._tr_Report_TC_Acceptance();
                 for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) {
@@ -7571,7 +6903,10 @@ class ModelChecker {
                     copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "Report_TC_Acceptance";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = state._tr_Skip_TC_Acceptance_Report();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) {
@@ -7581,7 +6916,10 @@ class ModelChecker {
                     copiedState.Skip_TC_Acceptance_Report(_tmp_1);
                     copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = state._tr_Report_TC_Rejection();
                 for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) {
@@ -7594,7 +6932,10 @@ class ModelChecker {
                     copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "Report_TC_Rejection";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = state._tr_Skip_TC_Rejection_Report();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) {
@@ -7604,7 +6945,10 @@ class ModelChecker {
                     copiedState.Skip_TC_Rejection_Report(_tmp_1);
                     copiedState.stateAccessedVia = "Skip_TC_Rejection_Report";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = state._tr_Execute_TC_Successfully();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) {
@@ -7614,7 +6958,10 @@ class ModelChecker {
                     copiedState.Execute_TC_Successfully(_tmp_1);
                     copiedState.stateAccessedVia = "Execute_TC_Successfully";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = state._tr_Reset_TM_Buffer();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) {
@@ -7624,7 +6971,10 @@ class ModelChecker {
                     copiedState.Reset_TM_Buffer(_tmp_1);
                     copiedState.stateAccessedVia = "Reset_TM_Buffer";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = state._tr_Fail_TC_Execution();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) {
@@ -7634,7 +6984,10 @@ class ModelChecker {
                     copiedState.Fail_TC_Execution(_tmp_1);
                     copiedState.stateAccessedVia = "Fail_TC_Execution";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = state._tr_Report_TC_Execution_Success();
                 for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) {
@@ -7647,7 +7000,10 @@ class ModelChecker {
                     copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "Report_TC_Execution_Success";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = state._tr_Skip_TC_Success_Report();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) {
@@ -7657,7 +7013,10 @@ class ModelChecker {
                     copiedState.Skip_TC_Success_Report(_tmp_1);
                     copiedState.stateAccessedVia = "Skip_TC_Success_Report";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = state._tr_Report_TC_Execution_Failure();
                 for(const BTuple<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_1::TM_SET >, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) {
@@ -7670,7 +7029,10 @@ class ModelChecker {
                     copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "Report_TC_Execution_Failure";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = state._tr_Skip_TC_Failure_Report();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) {
@@ -7680,7 +7042,10 @@ class ModelChecker {
                     copiedState.Skip_TC_Failure_Report(_tmp_1);
                     copiedState.stateAccessedVia = "Skip_TC_Failure_Report";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = state._tr_Drop_TC();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) {
@@ -7690,7 +7055,10 @@ class ModelChecker {
                     copiedState.Drop_TC(_tmp_1);
                     copiedState.stateAccessedVia = "Drop_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = state._tr_Produce_TM();
                 for(const BTuple<obsw_M001_1::TM_SET, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) {
@@ -7701,7 +7069,10 @@ class ModelChecker {
                     copiedState.Produce_TM(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "Produce_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = state._tr_Pass_TM();
                 for(const BTuple<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) {
@@ -7712,7 +7083,10 @@ class ModelChecker {
                     copiedState.Pass_TM(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "Pass_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = state._tr_Cancel_TM();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) {
@@ -7722,7 +7096,10 @@ class ModelChecker {
                     copiedState.Cancel_TM(_tmp_1);
                     copiedState.stateAccessedVia = "Cancel_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = state._tr_Drop_TM();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) {
@@ -7732,7 +7109,10 @@ class ModelChecker {
                     copiedState.Drop_TM(_tmp_1);
                     copiedState.stateAccessedVia = "Drop_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = state._tr_env_Deliver_TM();
                 for(const obsw_M001_1::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) {
@@ -7742,7 +7122,10 @@ class ModelChecker {
                     copiedState.env_Deliver_TM(_tmp_1);
                     copiedState.stateAccessedVia = "env_Deliver_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/obsw_M001_2.cpp b/benchmarks/model_checking_opreuse/C++/obsw_M001_2.cpp
index 35f402cdc2db10c9e3e09438d18ebe49530aa5e8..0af3a1dfadfcb752b6f4611851979181e0a56bfc 100644
--- a/benchmarks/model_checking_opreuse/C++/obsw_M001_2.cpp
+++ b/benchmarks/model_checking_opreuse/C++/obsw_M001_2.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -5597,12 +5596,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 obsw_M001_2 state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<obsw_M001_2, obsw_M001_2::Hash, obsw_M001_2::HashEqual> nextStates = generateNextStates(state);
@@ -5623,12 +5626,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -5638,24 +5643,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -5700,1819 +5708,1131 @@ class ModelChecker {
             std::unordered_set<obsw_M001_2, obsw_M001_2::Hash, obsw_M001_2::HashEqual> result = std::unordered_set<obsw_M001_2, obsw_M001_2::Hash, obsw_M001_2::HashEqual>();
             if(isCaching) {
                 obsw_M001_2::_ProjectionRead__tr_env_Receive_TC read__tr_env_Receive_TC_state = state._projected_state_for__tr_env_Receive_TC();
+                BSet<BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1;
                 auto _trid_1_ptr = _OpCache_tr_env_Receive_TC.find(read__tr_env_Receive_TC_state);
                 if(_trid_1_ptr == _OpCache_tr_env_Receive_TC.end()) {
-                    BSet<BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1 = state._tr_env_Receive_TC();
+                    _trid_1 = state._tr_env_Receive_TC();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_Receive_TC_lock(_ProjectionRead__tr_env_Receive_TC_mutex);
                         _OpCache_tr_env_Receive_TC.insert({read__tr_env_Receive_TC_state, _trid_1});
                     }
-                    for(const BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_2::TC_SET _tmp_2 = param.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC();
+                } else {
+                    _trid_1 = _trid_1_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param);
-                        if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) {
-                            copiedState.env_Receive_TC(_tmp_2, _tmp_1);
-                            obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC;
-                            _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
-                                _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC});
-                            }
+                for(const BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
+                    obsw_M001_2::TC_SET _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_Receive_TC(writeState);
-                            } else {
-                                copiedState.env_Receive_TC(_tmp_2, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
-                                    _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC();
+
+                    auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param);
+                    if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) {
+                        copiedState.env_Receive_TC(_tmp_2, _tmp_1);
+                        obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC;
+                        _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
+                            _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC});
                         }
 
-                        copiedState.stateAccessedVia = "env_Receive_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_1 = _trid_1_ptr->second;
-                    for(const BTuple<obsw_M001_2::TC_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_1) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_2::TC_SET _tmp_2 = param.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_env_Receive_TC readState = state._projected_state_for_env_Receive_TC();
-
-                        auto _OpCache_with_parameter_env_Receive_TC_ptr = _OpCache_env_Receive_TC.find(param);
-                        if(_OpCache_with_parameter_env_Receive_TC_ptr == _OpCache_env_Receive_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) {
+                            obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_Receive_TC(writeState);
+                        } else {
                             copiedState.env_Receive_TC(_tmp_2, _tmp_1);
                             obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC;
-                            _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
-                                _OpCache_env_Receive_TC.insert({param, _OpCache_with_parameter_env_Receive_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_env_Receive_TC, obsw_M001_2::_ProjectionWrite_env_Receive_TC, obsw_M001_2::_ProjectionRead_env_Receive_TC::Hash, obsw_M001_2::_ProjectionRead_env_Receive_TC::HashEqual> _OpCache_with_parameter_env_Receive_TC = _OpCache_with_parameter_env_Receive_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_Receive_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_Receive_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_Receive_TC(writeState);
-                            } else {
-                                copiedState.env_Receive_TC(_tmp_2, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_env_Receive_TC writeState = copiedState._update_for_env_Receive_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_Receive_TC_lock(_ProjectionRead_env_Receive_TC_mutex);
-                                    _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_Receive_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_Receive_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_Receive_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Poll_TC read__tr_Poll_TC_state = state._projected_state_for__tr_Poll_TC();
+                BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2;
                 auto _trid_2_ptr = _OpCache_tr_Poll_TC.find(read__tr_Poll_TC_state);
                 if(_trid_2_ptr == _OpCache_tr_Poll_TC.end()) {
-                    BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = state._tr_Poll_TC();
+                    _trid_2 = state._tr_Poll_TC();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Poll_TC_lock(_ProjectionRead__tr_Poll_TC_mutex);
                         _OpCache_tr_Poll_TC.insert({read__tr_Poll_TC_state, _trid_2});
                     }
-                    for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC();
+                } else {
+                    _trid_2 = _trid_2_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param);
-                        if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) {
-                            copiedState.Poll_TC(_tmp_2, _tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC;
-                            _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
-                                _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC});
-                            }
+                for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Poll_TC(writeState);
-                            } else {
-                                copiedState.Poll_TC(_tmp_2, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
-                                    _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC();
+
+                    auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param);
+                    if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) {
+                        copiedState.Poll_TC(_tmp_2, _tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC;
+                        _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
+                            _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC});
                         }
 
-                        copiedState.stateAccessedVia = "Poll_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = _trid_2_ptr->second;
-                    for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_2 = param.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Poll_TC readState = state._projected_state_for_Poll_TC();
-
-                        auto _OpCache_with_parameter_Poll_TC_ptr = _OpCache_Poll_TC.find(param);
-                        if(_OpCache_with_parameter_Poll_TC_ptr == _OpCache_Poll_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) {
+                            obsw_M001_2::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Poll_TC(writeState);
+                        } else {
                             copiedState.Poll_TC(_tmp_2, _tmp_1);
                             obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC;
-                            _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
-                                _OpCache_Poll_TC.insert({param, _OpCache_with_parameter_Poll_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Poll_TC, obsw_M001_2::_ProjectionWrite_Poll_TC, obsw_M001_2::_ProjectionRead_Poll_TC::Hash, obsw_M001_2::_ProjectionRead_Poll_TC::HashEqual> _OpCache_with_parameter_Poll_TC = _OpCache_with_parameter_Poll_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Poll_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Poll_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_Poll_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Poll_TC(writeState);
-                            } else {
-                                copiedState.Poll_TC(_tmp_2, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Poll_TC writeState = copiedState._update_for_Poll_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Poll_TC_lock(_ProjectionRead_Poll_TC_mutex);
-                                    _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Poll_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Poll_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Poll_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Accept_TC read__tr_Accept_TC_state = state._projected_state_for__tr_Accept_TC();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3;
                 auto _trid_3_ptr = _OpCache_tr_Accept_TC.find(read__tr_Accept_TC_state);
                 if(_trid_3_ptr == _OpCache_tr_Accept_TC.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = state._tr_Accept_TC();
+                    _trid_3 = state._tr_Accept_TC();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Accept_TC_lock(_ProjectionRead__tr_Accept_TC_mutex);
                         _OpCache_tr_Accept_TC.insert({read__tr_Accept_TC_state, _trid_3});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC();
+                } else {
+                    _trid_3 = _trid_3_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param);
-                        if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) {
-                            copiedState.Accept_TC(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC;
-                            _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
-                                _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Accept_TC(writeState);
-                            } else {
-                                copiedState.Accept_TC(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
-                                    _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC();
+
+                    auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param);
+                    if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) {
+                        copiedState.Accept_TC(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC;
+                        _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
+                            _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC});
                         }
 
-                        copiedState.stateAccessedVia = "Accept_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = _trid_3_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Accept_TC readState = state._projected_state_for_Accept_TC();
-
-                        auto _OpCache_with_parameter_Accept_TC_ptr = _OpCache_Accept_TC.find(param);
-                        if(_OpCache_with_parameter_Accept_TC_ptr == _OpCache_Accept_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) {
+                            obsw_M001_2::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Accept_TC(writeState);
+                        } else {
                             copiedState.Accept_TC(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC;
-                            _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
-                                _OpCache_Accept_TC.insert({param, _OpCache_with_parameter_Accept_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Accept_TC, obsw_M001_2::_ProjectionWrite_Accept_TC, obsw_M001_2::_ProjectionRead_Accept_TC::Hash, obsw_M001_2::_ProjectionRead_Accept_TC::HashEqual> _OpCache_with_parameter_Accept_TC = _OpCache_with_parameter_Accept_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Accept_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Accept_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_Accept_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Accept_TC(writeState);
-                            } else {
-                                copiedState.Accept_TC(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Accept_TC writeState = copiedState._update_for_Accept_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Accept_TC_lock(_ProjectionRead_Accept_TC_mutex);
-                                    _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Accept_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Accept_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Accept_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Reject_TC read__tr_Reject_TC_state = state._projected_state_for__tr_Reject_TC();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4;
                 auto _trid_4_ptr = _OpCache_tr_Reject_TC.find(read__tr_Reject_TC_state);
                 if(_trid_4_ptr == _OpCache_tr_Reject_TC.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = state._tr_Reject_TC();
+                    _trid_4 = state._tr_Reject_TC();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Reject_TC_lock(_ProjectionRead__tr_Reject_TC_mutex);
                         _OpCache_tr_Reject_TC.insert({read__tr_Reject_TC_state, _trid_4});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC();
+                } else {
+                    _trid_4 = _trid_4_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param);
-                        if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) {
-                            copiedState.Reject_TC(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC;
-                            _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
-                                _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Reject_TC(writeState);
-                            } else {
-                                copiedState.Reject_TC(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
-                                    _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC();
+
+                    auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param);
+                    if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) {
+                        copiedState.Reject_TC(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC;
+                        _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
+                            _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC});
                         }
 
-                        copiedState.stateAccessedVia = "Reject_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = _trid_4_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Reject_TC readState = state._projected_state_for_Reject_TC();
-
-                        auto _OpCache_with_parameter_Reject_TC_ptr = _OpCache_Reject_TC.find(param);
-                        if(_OpCache_with_parameter_Reject_TC_ptr == _OpCache_Reject_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) {
+                            obsw_M001_2::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Reject_TC(writeState);
+                        } else {
                             copiedState.Reject_TC(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC;
-                            _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
-                                _OpCache_Reject_TC.insert({param, _OpCache_with_parameter_Reject_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Reject_TC, obsw_M001_2::_ProjectionWrite_Reject_TC, obsw_M001_2::_ProjectionRead_Reject_TC::Hash, obsw_M001_2::_ProjectionRead_Reject_TC::HashEqual> _OpCache_with_parameter_Reject_TC = _OpCache_with_parameter_Reject_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Reject_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Reject_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_Reject_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Reject_TC(writeState);
-                            } else {
-                                copiedState.Reject_TC(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Reject_TC writeState = copiedState._update_for_Reject_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Reject_TC_lock(_ProjectionRead_Reject_TC_mutex);
-                                    _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Reject_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Reject_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Reject_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Report_TC_Acceptance read__tr_Report_TC_Acceptance_state = state._projected_state_for__tr_Report_TC_Acceptance();
+                BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5;
                 auto _trid_5_ptr = _OpCache_tr_Report_TC_Acceptance.find(read__tr_Report_TC_Acceptance_state);
                 if(_trid_5_ptr == _OpCache_tr_Report_TC_Acceptance.end()) {
-                    BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = state._tr_Report_TC_Acceptance();
+                    _trid_5 = state._tr_Report_TC_Acceptance();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Acceptance_lock(_ProjectionRead__tr_Report_TC_Acceptance_mutex);
                         _OpCache_tr_Report_TC_Acceptance.insert({read__tr_Report_TC_Acceptance_state, _trid_5});
                     }
-                    for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance();
+                } else {
+                    _trid_5 = _trid_5_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) {
-                            copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance;
-                            _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
-                                _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance});
-                            }
+                for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
+                    obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) {
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Acceptance(writeState);
-                            } else {
-                                copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
-                                    _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance();
+
+                    auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param);
+                    if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) {
+                        copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance;
+                        _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
+                            _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance});
                         }
 
-                        copiedState.stateAccessedVia = "Report_TC_Acceptance";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = _trid_5_ptr->second;
-                    for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Report_TC_Acceptance readState = state._projected_state_for_Report_TC_Acceptance();
-
-                        auto _OpCache_with_parameter_Report_TC_Acceptance_ptr = _OpCache_Report_TC_Acceptance.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Acceptance_ptr == _OpCache_Report_TC_Acceptance.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) {
+                            obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Report_TC_Acceptance(writeState);
+                        } else {
                             copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
                             obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance;
-                            _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
-                                _OpCache_Report_TC_Acceptance.insert({param, _OpCache_with_parameter_Report_TC_Acceptance});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Acceptance, obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Acceptance::HashEqual> _OpCache_with_parameter_Report_TC_Acceptance = _OpCache_with_parameter_Report_TC_Acceptance_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Acceptance.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Acceptance.end()) {
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Acceptance(writeState);
-                            } else {
-                                copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Acceptance writeState = copiedState._update_for_Report_TC_Acceptance();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Acceptance_lock(_ProjectionRead_Report_TC_Acceptance_mutex);
-                                    _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Report_TC_Acceptance.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Report_TC_Acceptance";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Report_TC_Acceptance";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Skip_TC_Acceptance_Report read__tr_Skip_TC_Acceptance_Report_state = state._projected_state_for__tr_Skip_TC_Acceptance_Report();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6;
                 auto _trid_6_ptr = _OpCache_tr_Skip_TC_Acceptance_Report.find(read__tr_Skip_TC_Acceptance_Report_state);
                 if(_trid_6_ptr == _OpCache_tr_Skip_TC_Acceptance_Report.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = state._tr_Skip_TC_Acceptance_Report();
+                    _trid_6 = state._tr_Skip_TC_Acceptance_Report();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Acceptance_Report_lock(_ProjectionRead__tr_Skip_TC_Acceptance_Report_mutex);
                         _OpCache_tr_Skip_TC_Acceptance_Report.insert({read__tr_Skip_TC_Acceptance_Report_state, _trid_6});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report();
+                } else {
+                    _trid_6 = _trid_6_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) {
-                            copiedState.Skip_TC_Acceptance_Report(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report;
-                            _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
-                                _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) {
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Acceptance_Report(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report();
+
+                    auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param);
+                    if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) {
+                        copiedState.Skip_TC_Acceptance_Report(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report;
+                        _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
+                            _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report});
                         }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = _trid_6_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report readState = state._projected_state_for_Skip_TC_Acceptance_Report();
-
-                        auto _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr = _OpCache_Skip_TC_Acceptance_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr == _OpCache_Skip_TC_Acceptance_Report.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) {
+                            obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState);
+                        } else {
                             copiedState.Skip_TC_Acceptance_Report(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report;
-                            _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
-                                _OpCache_Skip_TC_Acceptance_Report.insert({param, _OpCache_with_parameter_Skip_TC_Acceptance_Report});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Acceptance_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Acceptance_Report = _OpCache_with_parameter_Skip_TC_Acceptance_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Acceptance_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Acceptance_Report.end()) {
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Acceptance_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Acceptance_Report(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Acceptance_Report writeState = copiedState._update_for_Skip_TC_Acceptance_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Acceptance_Report_lock(_ProjectionRead_Skip_TC_Acceptance_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Skip_TC_Acceptance_Report.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Report_TC_Rejection read__tr_Report_TC_Rejection_state = state._projected_state_for__tr_Report_TC_Rejection();
+                BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7;
                 auto _trid_7_ptr = _OpCache_tr_Report_TC_Rejection.find(read__tr_Report_TC_Rejection_state);
                 if(_trid_7_ptr == _OpCache_tr_Report_TC_Rejection.end()) {
-                    BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = state._tr_Report_TC_Rejection();
+                    _trid_7 = state._tr_Report_TC_Rejection();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Rejection_lock(_ProjectionRead__tr_Report_TC_Rejection_mutex);
                         _OpCache_tr_Report_TC_Rejection.insert({read__tr_Report_TC_Rejection_state, _trid_7});
                     }
-                    for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection();
+                } else {
+                    _trid_7 = _trid_7_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) {
-                            copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection;
-                            _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
-                                _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection});
-                            }
+                for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
+                    obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) {
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Rejection(writeState);
-                            } else {
-                                copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
-                                    _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection();
+
+                    auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param);
+                    if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) {
+                        copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection;
+                        _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
+                            _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection});
                         }
 
-                        copiedState.stateAccessedVia = "Report_TC_Rejection";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = _trid_7_ptr->second;
-                    for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Report_TC_Rejection readState = state._projected_state_for_Report_TC_Rejection();
-
-                        auto _OpCache_with_parameter_Report_TC_Rejection_ptr = _OpCache_Report_TC_Rejection.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Rejection_ptr == _OpCache_Report_TC_Rejection.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) {
+                            obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Report_TC_Rejection(writeState);
+                        } else {
                             copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
                             obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection;
-                            _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
-                                _OpCache_Report_TC_Rejection.insert({param, _OpCache_with_parameter_Report_TC_Rejection});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Rejection, obsw_M001_2::_ProjectionWrite_Report_TC_Rejection, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Rejection::HashEqual> _OpCache_with_parameter_Report_TC_Rejection = _OpCache_with_parameter_Report_TC_Rejection_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Rejection.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Rejection.end()) {
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Rejection(writeState);
-                            } else {
-                                copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Rejection writeState = copiedState._update_for_Report_TC_Rejection();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Rejection_lock(_ProjectionRead_Report_TC_Rejection_mutex);
-                                    _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Report_TC_Rejection.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Report_TC_Rejection";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Report_TC_Rejection";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Skip_TC_Rejection_Report read__tr_Skip_TC_Rejection_Report_state = state._projected_state_for__tr_Skip_TC_Rejection_Report();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8;
                 auto _trid_8_ptr = _OpCache_tr_Skip_TC_Rejection_Report.find(read__tr_Skip_TC_Rejection_Report_state);
                 if(_trid_8_ptr == _OpCache_tr_Skip_TC_Rejection_Report.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = state._tr_Skip_TC_Rejection_Report();
+                    _trid_8 = state._tr_Skip_TC_Rejection_Report();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Rejection_Report_lock(_ProjectionRead__tr_Skip_TC_Rejection_Report_mutex);
                         _OpCache_tr_Skip_TC_Rejection_Report.insert({read__tr_Skip_TC_Rejection_Report_state, _trid_8});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report();
+                } else {
+                    _trid_8 = _trid_8_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) {
-                            copiedState.Skip_TC_Rejection_Report(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report;
-                            _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
-                                _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) {
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Rejection_Report(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report();
+
+                    auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param);
+                    if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) {
+                        copiedState.Skip_TC_Rejection_Report(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report;
+                        _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
+                            _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report});
                         }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Rejection_Report";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = _trid_8_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report readState = state._projected_state_for_Skip_TC_Rejection_Report();
-
-                        auto _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr = _OpCache_Skip_TC_Rejection_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Rejection_Report_ptr == _OpCache_Skip_TC_Rejection_Report.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) {
+                            obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState);
+                        } else {
                             copiedState.Skip_TC_Rejection_Report(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report;
-                            _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
-                                _OpCache_Skip_TC_Rejection_Report.insert({param, _OpCache_with_parameter_Skip_TC_Rejection_Report});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Rejection_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Rejection_Report = _OpCache_with_parameter_Skip_TC_Rejection_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Rejection_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Rejection_Report.end()) {
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Rejection_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Rejection_Report(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Rejection_Report writeState = copiedState._update_for_Skip_TC_Rejection_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Rejection_Report_lock(_ProjectionRead_Skip_TC_Rejection_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Skip_TC_Rejection_Report.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Rejection_Report";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Skip_TC_Rejection_Report";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Execute_TC_Successfully read__tr_Execute_TC_Successfully_state = state._projected_state_for__tr_Execute_TC_Successfully();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9;
                 auto _trid_9_ptr = _OpCache_tr_Execute_TC_Successfully.find(read__tr_Execute_TC_Successfully_state);
                 if(_trid_9_ptr == _OpCache_tr_Execute_TC_Successfully.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = state._tr_Execute_TC_Successfully();
+                    _trid_9 = state._tr_Execute_TC_Successfully();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Execute_TC_Successfully_lock(_ProjectionRead__tr_Execute_TC_Successfully_mutex);
                         _OpCache_tr_Execute_TC_Successfully.insert({read__tr_Execute_TC_Successfully_state, _trid_9});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully();
+                } else {
+                    _trid_9 = _trid_9_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param);
-                        if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) {
-                            copiedState.Execute_TC_Successfully(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully;
-                            _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
-                                _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) {
-                                obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Execute_TC_Successfully(writeState);
-                            } else {
-                                copiedState.Execute_TC_Successfully(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
-                                    _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully();
+
+                    auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param);
+                    if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) {
+                        copiedState.Execute_TC_Successfully(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully;
+                        _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
+                            _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully});
                         }
 
-                        copiedState.stateAccessedVia = "Execute_TC_Successfully";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = _trid_9_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Execute_TC_Successfully readState = state._projected_state_for_Execute_TC_Successfully();
-
-                        auto _OpCache_with_parameter_Execute_TC_Successfully_ptr = _OpCache_Execute_TC_Successfully.find(param);
-                        if(_OpCache_with_parameter_Execute_TC_Successfully_ptr == _OpCache_Execute_TC_Successfully.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) {
+                            obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Execute_TC_Successfully(writeState);
+                        } else {
                             copiedState.Execute_TC_Successfully(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully;
-                            _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
-                                _OpCache_Execute_TC_Successfully.insert({param, _OpCache_with_parameter_Execute_TC_Successfully});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Execute_TC_Successfully, obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::Hash, obsw_M001_2::_ProjectionRead_Execute_TC_Successfully::HashEqual> _OpCache_with_parameter_Execute_TC_Successfully = _OpCache_with_parameter_Execute_TC_Successfully_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Execute_TC_Successfully.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Execute_TC_Successfully.end()) {
-                                obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Execute_TC_Successfully(writeState);
-                            } else {
-                                copiedState.Execute_TC_Successfully(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Execute_TC_Successfully writeState = copiedState._update_for_Execute_TC_Successfully();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Execute_TC_Successfully_lock(_ProjectionRead_Execute_TC_Successfully_mutex);
-                                    _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Execute_TC_Successfully.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Execute_TC_Successfully";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Execute_TC_Successfully";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Reset_TM_Buffer read__tr_Reset_TM_Buffer_state = state._projected_state_for__tr_Reset_TM_Buffer();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10;
                 auto _trid_10_ptr = _OpCache_tr_Reset_TM_Buffer.find(read__tr_Reset_TM_Buffer_state);
                 if(_trid_10_ptr == _OpCache_tr_Reset_TM_Buffer.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = state._tr_Reset_TM_Buffer();
+                    _trid_10 = state._tr_Reset_TM_Buffer();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Reset_TM_Buffer_lock(_ProjectionRead__tr_Reset_TM_Buffer_mutex);
                         _OpCache_tr_Reset_TM_Buffer.insert({read__tr_Reset_TM_Buffer_state, _trid_10});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer();
+                } else {
+                    _trid_10 = _trid_10_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param);
-                        if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) {
-                            copiedState.Reset_TM_Buffer(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer;
-                            _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
-                                _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) {
-                                obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Reset_TM_Buffer(writeState);
-                            } else {
-                                copiedState.Reset_TM_Buffer(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
-                                    _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer();
+
+                    auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param);
+                    if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) {
+                        copiedState.Reset_TM_Buffer(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer;
+                        _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
+                            _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer});
                         }
 
-                        copiedState.stateAccessedVia = "Reset_TM_Buffer";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = _trid_10_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Reset_TM_Buffer readState = state._projected_state_for_Reset_TM_Buffer();
-
-                        auto _OpCache_with_parameter_Reset_TM_Buffer_ptr = _OpCache_Reset_TM_Buffer.find(param);
-                        if(_OpCache_with_parameter_Reset_TM_Buffer_ptr == _OpCache_Reset_TM_Buffer.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) {
+                            obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Reset_TM_Buffer(writeState);
+                        } else {
                             copiedState.Reset_TM_Buffer(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer;
-                            _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
-                                _OpCache_Reset_TM_Buffer.insert({param, _OpCache_with_parameter_Reset_TM_Buffer});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Reset_TM_Buffer, obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::Hash, obsw_M001_2::_ProjectionRead_Reset_TM_Buffer::HashEqual> _OpCache_with_parameter_Reset_TM_Buffer = _OpCache_with_parameter_Reset_TM_Buffer_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Reset_TM_Buffer.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Reset_TM_Buffer.end()) {
-                                obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Reset_TM_Buffer(writeState);
-                            } else {
-                                copiedState.Reset_TM_Buffer(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Reset_TM_Buffer writeState = copiedState._update_for_Reset_TM_Buffer();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Reset_TM_Buffer_lock(_ProjectionRead_Reset_TM_Buffer_mutex);
-                                    _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Reset_TM_Buffer.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Reset_TM_Buffer";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Reset_TM_Buffer";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Fail_TC_Execution read__tr_Fail_TC_Execution_state = state._projected_state_for__tr_Fail_TC_Execution();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11;
                 auto _trid_11_ptr = _OpCache_tr_Fail_TC_Execution.find(read__tr_Fail_TC_Execution_state);
                 if(_trid_11_ptr == _OpCache_tr_Fail_TC_Execution.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = state._tr_Fail_TC_Execution();
+                    _trid_11 = state._tr_Fail_TC_Execution();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Fail_TC_Execution_lock(_ProjectionRead__tr_Fail_TC_Execution_mutex);
                         _OpCache_tr_Fail_TC_Execution.insert({read__tr_Fail_TC_Execution_state, _trid_11});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution();
+                } else {
+                    _trid_11 = _trid_11_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param);
-                        if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) {
-                            copiedState.Fail_TC_Execution(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution;
-                            _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
-                                _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) {
-                                obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Fail_TC_Execution(writeState);
-                            } else {
-                                copiedState.Fail_TC_Execution(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
-                                    _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution();
+
+                    auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param);
+                    if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) {
+                        copiedState.Fail_TC_Execution(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution;
+                        _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
+                            _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution});
                         }
 
-                        copiedState.stateAccessedVia = "Fail_TC_Execution";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = _trid_11_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Fail_TC_Execution readState = state._projected_state_for_Fail_TC_Execution();
-
-                        auto _OpCache_with_parameter_Fail_TC_Execution_ptr = _OpCache_Fail_TC_Execution.find(param);
-                        if(_OpCache_with_parameter_Fail_TC_Execution_ptr == _OpCache_Fail_TC_Execution.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) {
+                            obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Fail_TC_Execution(writeState);
+                        } else {
                             copiedState.Fail_TC_Execution(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution;
-                            _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
-                                _OpCache_Fail_TC_Execution.insert({param, _OpCache_with_parameter_Fail_TC_Execution});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Fail_TC_Execution, obsw_M001_2::_ProjectionWrite_Fail_TC_Execution, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::Hash, obsw_M001_2::_ProjectionRead_Fail_TC_Execution::HashEqual> _OpCache_with_parameter_Fail_TC_Execution = _OpCache_with_parameter_Fail_TC_Execution_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Fail_TC_Execution.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Fail_TC_Execution.end()) {
-                                obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Fail_TC_Execution(writeState);
-                            } else {
-                                copiedState.Fail_TC_Execution(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Fail_TC_Execution writeState = copiedState._update_for_Fail_TC_Execution();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Fail_TC_Execution_lock(_ProjectionRead_Fail_TC_Execution_mutex);
-                                    _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Fail_TC_Execution.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Fail_TC_Execution";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Fail_TC_Execution";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Report_TC_Execution_Success read__tr_Report_TC_Execution_Success_state = state._projected_state_for__tr_Report_TC_Execution_Success();
+                BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12;
                 auto _trid_12_ptr = _OpCache_tr_Report_TC_Execution_Success.find(read__tr_Report_TC_Execution_Success_state);
                 if(_trid_12_ptr == _OpCache_tr_Report_TC_Execution_Success.end()) {
-                    BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = state._tr_Report_TC_Execution_Success();
+                    _trid_12 = state._tr_Report_TC_Execution_Success();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Execution_Success_lock(_ProjectionRead__tr_Report_TC_Execution_Success_mutex);
                         _OpCache_tr_Report_TC_Execution_Success.insert({read__tr_Report_TC_Execution_Success_state, _trid_12});
                     }
-                    for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success();
+                } else {
+                    _trid_12 = _trid_12_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) {
-                            copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success;
-                            _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
-                                _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success});
-                            }
+                for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
+                    obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) {
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Execution_Success(writeState);
-                            } else {
-                                copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
-                                    _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success();
+
+                    auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param);
+                    if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) {
+                        copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success;
+                        _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
+                            _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success});
                         }
 
-                        copiedState.stateAccessedVia = "Report_TC_Execution_Success";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = _trid_12_ptr->second;
-                    for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success readState = state._projected_state_for_Report_TC_Execution_Success();
-
-                        auto _OpCache_with_parameter_Report_TC_Execution_Success_ptr = _OpCache_Report_TC_Execution_Success.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Execution_Success_ptr == _OpCache_Report_TC_Execution_Success.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) {
+                            obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Report_TC_Execution_Success(writeState);
+                        } else {
                             copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
                             obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success;
-                            _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
-                                _OpCache_Report_TC_Execution_Success.insert({param, _OpCache_with_parameter_Report_TC_Execution_Success});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Success::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Success = _OpCache_with_parameter_Report_TC_Execution_Success_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Success.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Success.end()) {
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Execution_Success(writeState);
-                            } else {
-                                copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Success writeState = copiedState._update_for_Report_TC_Execution_Success();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Success_lock(_ProjectionRead_Report_TC_Execution_Success_mutex);
-                                    _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Report_TC_Execution_Success.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Report_TC_Execution_Success";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Report_TC_Execution_Success";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Skip_TC_Success_Report read__tr_Skip_TC_Success_Report_state = state._projected_state_for__tr_Skip_TC_Success_Report();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13;
                 auto _trid_13_ptr = _OpCache_tr_Skip_TC_Success_Report.find(read__tr_Skip_TC_Success_Report_state);
                 if(_trid_13_ptr == _OpCache_tr_Skip_TC_Success_Report.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = state._tr_Skip_TC_Success_Report();
+                    _trid_13 = state._tr_Skip_TC_Success_Report();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Success_Report_lock(_ProjectionRead__tr_Skip_TC_Success_Report_mutex);
                         _OpCache_tr_Skip_TC_Success_Report.insert({read__tr_Skip_TC_Success_Report_state, _trid_13});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report();
+                } else {
+                    _trid_13 = _trid_13_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) {
-                            copiedState.Skip_TC_Success_Report(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report;
-                            _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
-                                _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) {
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Success_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Success_Report(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report();
+
+                    auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param);
+                    if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) {
+                        copiedState.Skip_TC_Success_Report(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report;
+                        _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
+                            _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report});
                         }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Success_Report";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = _trid_13_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report readState = state._projected_state_for_Skip_TC_Success_Report();
-
-                        auto _OpCache_with_parameter_Skip_TC_Success_Report_ptr = _OpCache_Skip_TC_Success_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Success_Report_ptr == _OpCache_Skip_TC_Success_Report.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) {
+                            obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Skip_TC_Success_Report(writeState);
+                        } else {
                             copiedState.Skip_TC_Success_Report(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report;
-                            _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
-                                _OpCache_Skip_TC_Success_Report.insert({param, _OpCache_with_parameter_Skip_TC_Success_Report});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Success_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Success_Report = _OpCache_with_parameter_Skip_TC_Success_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Success_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Success_Report.end()) {
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Success_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Success_Report(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Success_Report writeState = copiedState._update_for_Skip_TC_Success_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Success_Report_lock(_ProjectionRead_Skip_TC_Success_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Skip_TC_Success_Report.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Success_Report";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Skip_TC_Success_Report";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Report_TC_Execution_Failure read__tr_Report_TC_Execution_Failure_state = state._projected_state_for__tr_Report_TC_Execution_Failure();
+                BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14;
                 auto _trid_14_ptr = _OpCache_tr_Report_TC_Execution_Failure.find(read__tr_Report_TC_Execution_Failure_state);
                 if(_trid_14_ptr == _OpCache_tr_Report_TC_Execution_Failure.end()) {
-                    BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = state._tr_Report_TC_Execution_Failure();
+                    _trid_14 = state._tr_Report_TC_Execution_Failure();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Report_TC_Execution_Failure_lock(_ProjectionRead__tr_Report_TC_Execution_Failure_mutex);
                         _OpCache_tr_Report_TC_Execution_Failure.insert({read__tr_Report_TC_Execution_Failure_state, _trid_14});
                     }
-                    for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure();
+                } else {
+                    _trid_14 = _trid_14_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) {
-                            copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure;
-                            _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
-                                _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure});
-                            }
+                for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
+                    obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) {
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Execution_Failure(writeState);
-                            } else {
-                                copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
-                                    _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure();
+
+                    auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param);
+                    if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) {
+                        copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure;
+                        _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
+                            _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure});
                         }
 
-                        copiedState.stateAccessedVia = "Report_TC_Execution_Failure";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = _trid_14_ptr->second;
-                    for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET > _tmp_2 = param.projection1();
-                        obsw_M001_2::TM_SET _tmp_3 = _tmp_2.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_4 = _tmp_2.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure readState = state._projected_state_for_Report_TC_Execution_Failure();
-
-                        auto _OpCache_with_parameter_Report_TC_Execution_Failure_ptr = _OpCache_Report_TC_Execution_Failure.find(param);
-                        if(_OpCache_with_parameter_Report_TC_Execution_Failure_ptr == _OpCache_Report_TC_Execution_Failure.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) {
+                            obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Report_TC_Execution_Failure(writeState);
+                        } else {
                             copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
                             obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure;
-                            _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
-                                _OpCache_Report_TC_Execution_Failure.insert({param, _OpCache_with_parameter_Report_TC_Execution_Failure});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::Hash, obsw_M001_2::_ProjectionRead_Report_TC_Execution_Failure::HashEqual> _OpCache_with_parameter_Report_TC_Execution_Failure = _OpCache_with_parameter_Report_TC_Execution_Failure_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Report_TC_Execution_Failure.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Report_TC_Execution_Failure.end()) {
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Report_TC_Execution_Failure(writeState);
-                            } else {
-                                copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Report_TC_Execution_Failure writeState = copiedState._update_for_Report_TC_Execution_Failure();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Report_TC_Execution_Failure_lock(_ProjectionRead_Report_TC_Execution_Failure_mutex);
-                                    _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Report_TC_Execution_Failure.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Report_TC_Execution_Failure";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Report_TC_Execution_Failure";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Skip_TC_Failure_Report read__tr_Skip_TC_Failure_Report_state = state._projected_state_for__tr_Skip_TC_Failure_Report();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15;
                 auto _trid_15_ptr = _OpCache_tr_Skip_TC_Failure_Report.find(read__tr_Skip_TC_Failure_Report_state);
                 if(_trid_15_ptr == _OpCache_tr_Skip_TC_Failure_Report.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = state._tr_Skip_TC_Failure_Report();
+                    _trid_15 = state._tr_Skip_TC_Failure_Report();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Skip_TC_Failure_Report_lock(_ProjectionRead__tr_Skip_TC_Failure_Report_mutex);
                         _OpCache_tr_Skip_TC_Failure_Report.insert({read__tr_Skip_TC_Failure_Report_state, _trid_15});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report();
+                } else {
+                    _trid_15 = _trid_15_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) {
-                            copiedState.Skip_TC_Failure_Report(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report;
-                            _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
-                                _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) {
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Failure_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Failure_Report(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report();
+
+                    auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param);
+                    if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) {
+                        copiedState.Skip_TC_Failure_Report(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report;
+                        _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
+                            _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report});
                         }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Failure_Report";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = _trid_15_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report readState = state._projected_state_for_Skip_TC_Failure_Report();
-
-                        auto _OpCache_with_parameter_Skip_TC_Failure_Report_ptr = _OpCache_Skip_TC_Failure_Report.find(param);
-                        if(_OpCache_with_parameter_Skip_TC_Failure_Report_ptr == _OpCache_Skip_TC_Failure_Report.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) {
+                            obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Skip_TC_Failure_Report(writeState);
+                        } else {
                             copiedState.Skip_TC_Failure_Report(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report;
-                            _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
-                                _OpCache_Skip_TC_Failure_Report.insert({param, _OpCache_with_parameter_Skip_TC_Failure_Report});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::Hash, obsw_M001_2::_ProjectionRead_Skip_TC_Failure_Report::HashEqual> _OpCache_with_parameter_Skip_TC_Failure_Report = _OpCache_with_parameter_Skip_TC_Failure_Report_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Skip_TC_Failure_Report.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Skip_TC_Failure_Report.end()) {
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Skip_TC_Failure_Report(writeState);
-                            } else {
-                                copiedState.Skip_TC_Failure_Report(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Skip_TC_Failure_Report writeState = copiedState._update_for_Skip_TC_Failure_Report();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Skip_TC_Failure_Report_lock(_ProjectionRead_Skip_TC_Failure_Report_mutex);
-                                    _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Skip_TC_Failure_Report.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Skip_TC_Failure_Report";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Skip_TC_Failure_Report";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Drop_TC read__tr_Drop_TC_state = state._projected_state_for__tr_Drop_TC();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16;
                 auto _trid_16_ptr = _OpCache_tr_Drop_TC.find(read__tr_Drop_TC_state);
                 if(_trid_16_ptr == _OpCache_tr_Drop_TC.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = state._tr_Drop_TC();
-                    {
-                        std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TC_lock(_ProjectionRead__tr_Drop_TC_mutex);
-                        _OpCache_tr_Drop_TC.insert({read__tr_Drop_TC_state, _trid_16});
-                    }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC();
-
-                        auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param);
-                        if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) {
-                            copiedState.Drop_TC(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC;
-                            _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
-                                _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Drop_TC(writeState);
-                            } else {
-                                copiedState.Drop_TC(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
-                                    _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
-                                }
-                            }
-                        }
-
-                        copiedState.stateAccessedVia = "Drop_TC";
-                        result.insert(copiedState);
-                        transitions += 1;
+                    _trid_16 = state._tr_Drop_TC();
+                    {
+                        std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TC_lock(_ProjectionRead__tr_Drop_TC_mutex);
+                        _OpCache_tr_Drop_TC.insert({read__tr_Drop_TC_state, _trid_16});
                     }
                 } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = _trid_16_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
+                    _trid_16 = _trid_16_ptr->second;
+                }
 
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC();
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL _tmp_1 = param;
+
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Drop_TC readState = state._projected_state_for_Drop_TC();
+
+                    auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param);
+                    if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) {
+                        copiedState.Drop_TC(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC;
+                        _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
+                            _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC});
+                        }
 
-                        auto _OpCache_with_parameter_Drop_TC_ptr = _OpCache_Drop_TC.find(param);
-                        if(_OpCache_with_parameter_Drop_TC_ptr == _OpCache_Drop_TC.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) {
+                            obsw_M001_2::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Drop_TC(writeState);
+                        } else {
                             copiedState.Drop_TC(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC;
-                            _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
-                                _OpCache_Drop_TC.insert({param, _OpCache_with_parameter_Drop_TC});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TC, obsw_M001_2::_ProjectionWrite_Drop_TC, obsw_M001_2::_ProjectionRead_Drop_TC::Hash, obsw_M001_2::_ProjectionRead_Drop_TC::HashEqual> _OpCache_with_parameter_Drop_TC = _OpCache_with_parameter_Drop_TC_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Drop_TC.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Drop_TC.end()) {
-                                obsw_M001_2::_ProjectionWrite_Drop_TC writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Drop_TC(writeState);
-                            } else {
-                                copiedState.Drop_TC(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Drop_TC writeState = copiedState._update_for_Drop_TC();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Drop_TC_lock(_ProjectionRead_Drop_TC_mutex);
-                                    _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Drop_TC.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Drop_TC";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Drop_TC";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Produce_TM read__tr_Produce_TM_state = state._projected_state_for__tr_Produce_TM();
+                BSet<BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17;
                 auto _trid_17_ptr = _OpCache_tr_Produce_TM.find(read__tr_Produce_TM_state);
                 if(_trid_17_ptr == _OpCache_tr_Produce_TM.end()) {
-                    BSet<BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = state._tr_Produce_TM();
+                    _trid_17 = state._tr_Produce_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Produce_TM_lock(_ProjectionRead__tr_Produce_TM_mutex);
                         _OpCache_tr_Produce_TM.insert({read__tr_Produce_TM_state, _trid_17});
                     }
-                    for(const BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        obsw_M001_2::TM_SET _tmp_2 = param.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM();
+                } else {
+                    _trid_17 = _trid_17_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param);
-                        if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) {
-                            copiedState.Produce_TM(_tmp_2, _tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM;
-                            _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
-                                _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM});
-                            }
+                for(const BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
+                    obsw_M001_2::TM_SET _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Produce_TM(writeState);
-                            } else {
-                                copiedState.Produce_TM(_tmp_2, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
-                                    _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM();
+
+                    auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param);
+                    if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) {
+                        copiedState.Produce_TM(_tmp_2, _tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM;
+                        _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
+                            _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM});
                         }
 
-                        copiedState.stateAccessedVia = "Produce_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = _trid_17_ptr->second;
-                    for(const BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param.projection2();
-                        obsw_M001_2::TM_SET _tmp_2 = param.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Produce_TM readState = state._projected_state_for_Produce_TM();
-
-                        auto _OpCache_with_parameter_Produce_TM_ptr = _OpCache_Produce_TM.find(param);
-                        if(_OpCache_with_parameter_Produce_TM_ptr == _OpCache_Produce_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) {
+                            obsw_M001_2::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Produce_TM(writeState);
+                        } else {
                             copiedState.Produce_TM(_tmp_2, _tmp_1);
                             obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM;
-                            _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
-                                _OpCache_Produce_TM.insert({param, _OpCache_with_parameter_Produce_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Produce_TM, obsw_M001_2::_ProjectionWrite_Produce_TM, obsw_M001_2::_ProjectionRead_Produce_TM::Hash, obsw_M001_2::_ProjectionRead_Produce_TM::HashEqual> _OpCache_with_parameter_Produce_TM = _OpCache_with_parameter_Produce_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Produce_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Produce_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_Produce_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Produce_TM(writeState);
-                            } else {
-                                copiedState.Produce_TM(_tmp_2, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Produce_TM writeState = copiedState._update_for_Produce_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Produce_TM_lock(_ProjectionRead_Produce_TM_mutex);
-                                    _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Produce_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Produce_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Produce_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Pass_TM read__tr_Pass_TM_state = state._projected_state_for__tr_Pass_TM();
+                BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18;
                 auto _trid_18_ptr = _OpCache_tr_Pass_TM.find(read__tr_Pass_TM_state);
                 if(_trid_18_ptr == _OpCache_tr_Pass_TM.end()) {
-                    BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = state._tr_Pass_TM();
+                    _trid_18 = state._tr_Pass_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Pass_TM_lock(_ProjectionRead__tr_Pass_TM_mutex);
                         _OpCache_tr_Pass_TM.insert({read__tr_Pass_TM_state, _trid_18});
                     }
-                    for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM();
+                } else {
+                    _trid_18 = _trid_18_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param);
-                        if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) {
-                            copiedState.Pass_TM(_tmp_2, _tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM;
-                            _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
-                                _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM});
-                            }
+                for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2();
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Pass_TM(writeState);
-                            } else {
-                                copiedState.Pass_TM(_tmp_2, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
-                                    _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM();
+
+                    auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param);
+                    if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) {
+                        copiedState.Pass_TM(_tmp_2, _tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM;
+                        _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
+                            _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM});
                         }
 
-                        copiedState.stateAccessedVia = "Pass_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = _trid_18_ptr->second;
-                    for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param.projection2();
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_2 = param.projection1();
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Pass_TM readState = state._projected_state_for_Pass_TM();
-
-                        auto _OpCache_with_parameter_Pass_TM_ptr = _OpCache_Pass_TM.find(param);
-                        if(_OpCache_with_parameter_Pass_TM_ptr == _OpCache_Pass_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) {
+                            obsw_M001_2::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Pass_TM(writeState);
+                        } else {
                             copiedState.Pass_TM(_tmp_2, _tmp_1);
                             obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM;
-                            _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
-                                _OpCache_Pass_TM.insert({param, _OpCache_with_parameter_Pass_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Pass_TM, obsw_M001_2::_ProjectionWrite_Pass_TM, obsw_M001_2::_ProjectionRead_Pass_TM::Hash, obsw_M001_2::_ProjectionRead_Pass_TM::HashEqual> _OpCache_with_parameter_Pass_TM = _OpCache_with_parameter_Pass_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Pass_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Pass_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_Pass_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Pass_TM(writeState);
-                            } else {
-                                copiedState.Pass_TM(_tmp_2, _tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Pass_TM writeState = copiedState._update_for_Pass_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Pass_TM_lock(_ProjectionRead_Pass_TM_mutex);
-                                    _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Pass_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Pass_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Pass_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Cancel_TM read__tr_Cancel_TM_state = state._projected_state_for__tr_Cancel_TM();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19;
                 auto _trid_19_ptr = _OpCache_tr_Cancel_TM.find(read__tr_Cancel_TM_state);
                 if(_trid_19_ptr == _OpCache_tr_Cancel_TM.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = state._tr_Cancel_TM();
+                    _trid_19 = state._tr_Cancel_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Cancel_TM_lock(_ProjectionRead__tr_Cancel_TM_mutex);
                         _OpCache_tr_Cancel_TM.insert({read__tr_Cancel_TM_state, _trid_19});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM();
+                } else {
+                    _trid_19 = _trid_19_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param);
-                        if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) {
-                            copiedState.Cancel_TM(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM;
-                            _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
-                                _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Cancel_TM(writeState);
-                            } else {
-                                copiedState.Cancel_TM(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
-                                    _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM();
+
+                    auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param);
+                    if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) {
+                        copiedState.Cancel_TM(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM;
+                        _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
+                            _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM});
                         }
 
-                        copiedState.stateAccessedVia = "Cancel_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = _trid_19_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Cancel_TM readState = state._projected_state_for_Cancel_TM();
-
-                        auto _OpCache_with_parameter_Cancel_TM_ptr = _OpCache_Cancel_TM.find(param);
-                        if(_OpCache_with_parameter_Cancel_TM_ptr == _OpCache_Cancel_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) {
+                            obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Cancel_TM(writeState);
+                        } else {
                             copiedState.Cancel_TM(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM;
-                            _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
-                                _OpCache_Cancel_TM.insert({param, _OpCache_with_parameter_Cancel_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Cancel_TM, obsw_M001_2::_ProjectionWrite_Cancel_TM, obsw_M001_2::_ProjectionRead_Cancel_TM::Hash, obsw_M001_2::_ProjectionRead_Cancel_TM::HashEqual> _OpCache_with_parameter_Cancel_TM = _OpCache_with_parameter_Cancel_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Cancel_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Cancel_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Cancel_TM(writeState);
-                            } else {
-                                copiedState.Cancel_TM(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Cancel_TM writeState = copiedState._update_for_Cancel_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Cancel_TM_lock(_ProjectionRead_Cancel_TM_mutex);
-                                    _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Cancel_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Cancel_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Cancel_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_Drop_TM read__tr_Drop_TM_state = state._projected_state_for__tr_Drop_TM();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20;
                 auto _trid_20_ptr = _OpCache_tr_Drop_TM.find(read__tr_Drop_TM_state);
                 if(_trid_20_ptr == _OpCache_tr_Drop_TM.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = state._tr_Drop_TM();
+                    _trid_20 = state._tr_Drop_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_Drop_TM_lock(_ProjectionRead__tr_Drop_TM_mutex);
                         _OpCache_tr_Drop_TM.insert({read__tr_Drop_TM_state, _trid_20});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM();
+                } else {
+                    _trid_20 = _trid_20_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param);
-                        if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) {
-                            copiedState.Drop_TM(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM;
-                            _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
-                                _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Drop_TM(writeState);
-                            } else {
-                                copiedState.Drop_TM(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
-                                    _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM();
+
+                    auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param);
+                    if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) {
+                        copiedState.Drop_TM(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM;
+                        _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
+                            _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM});
                         }
 
-                        copiedState.stateAccessedVia = "Drop_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = _trid_20_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_Drop_TM readState = state._projected_state_for_Drop_TM();
-
-                        auto _OpCache_with_parameter_Drop_TM_ptr = _OpCache_Drop_TM.find(param);
-                        if(_OpCache_with_parameter_Drop_TM_ptr == _OpCache_Drop_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) {
+                            obsw_M001_2::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_Drop_TM(writeState);
+                        } else {
                             copiedState.Drop_TM(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM;
-                            _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
-                                _OpCache_Drop_TM.insert({param, _OpCache_with_parameter_Drop_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_Drop_TM, obsw_M001_2::_ProjectionWrite_Drop_TM, obsw_M001_2::_ProjectionRead_Drop_TM::Hash, obsw_M001_2::_ProjectionRead_Drop_TM::HashEqual> _OpCache_with_parameter_Drop_TM = _OpCache_with_parameter_Drop_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_Drop_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_Drop_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_Drop_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_Drop_TM(writeState);
-                            } else {
-                                copiedState.Drop_TM(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_Drop_TM writeState = copiedState._update_for_Drop_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_Drop_TM_lock(_ProjectionRead_Drop_TM_mutex);
-                                    _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_Drop_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "Drop_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "Drop_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 obsw_M001_2::_ProjectionRead__tr_env_Deliver_TM read__tr_env_Deliver_TM_state = state._projected_state_for__tr_env_Deliver_TM();
+                BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21;
                 auto _trid_21_ptr = _OpCache_tr_env_Deliver_TM.find(read__tr_env_Deliver_TM_state);
                 if(_trid_21_ptr == _OpCache_tr_env_Deliver_TM.end()) {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = state._tr_env_Deliver_TM();
+                    _trid_21 = state._tr_env_Deliver_TM();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_env_Deliver_TM_lock(_ProjectionRead__tr_env_Deliver_TM_mutex);
                         _OpCache_tr_env_Deliver_TM.insert({read__tr_env_Deliver_TM_state, _trid_21});
                     }
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM();
+                } else {
+                    _trid_21 = _trid_21_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param);
-                        if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) {
-                            copiedState.env_Deliver_TM(_tmp_1);
-                            obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM;
-                            _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
-                                _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM});
-                            }
+                for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) {
+                    obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_Deliver_TM(writeState);
-                            } else {
-                                copiedState.env_Deliver_TM(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
-                                    _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
-                                }
-                            }
+                    obsw_M001_2 copiedState = state._copy();
+                    obsw_M001_2::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM();
+
+                    auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param);
+                    if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) {
+                        copiedState.env_Deliver_TM(_tmp_1);
+                        obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM;
+                        _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
+                            _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM});
                         }
 
-                        copiedState.stateAccessedVia = "env_Deliver_TM";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = _trid_21_ptr->second;
-                    for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) {
-                        obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER _tmp_1 = param;
-
-                        obsw_M001_2 copiedState = state._copy();
-                        obsw_M001_2::_ProjectionRead_env_Deliver_TM readState = state._projected_state_for_env_Deliver_TM();
-
-                        auto _OpCache_with_parameter_env_Deliver_TM_ptr = _OpCache_env_Deliver_TM.find(param);
-                        if(_OpCache_with_parameter_env_Deliver_TM_ptr == _OpCache_env_Deliver_TM.end()) {
+                    } else {
+                        std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) {
+                            obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_env_Deliver_TM(writeState);
+                        } else {
                             copiedState.env_Deliver_TM(_tmp_1);
                             obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM;
-                            _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
-                                _OpCache_env_Deliver_TM.insert({param, _OpCache_with_parameter_env_Deliver_TM});
-                            }
-
-                        } else {
-                            std::unordered_map<obsw_M001_2::_ProjectionRead_env_Deliver_TM, obsw_M001_2::_ProjectionWrite_env_Deliver_TM, obsw_M001_2::_ProjectionRead_env_Deliver_TM::Hash, obsw_M001_2::_ProjectionRead_env_Deliver_TM::HashEqual> _OpCache_with_parameter_env_Deliver_TM = _OpCache_with_parameter_env_Deliver_TM_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_env_Deliver_TM.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_env_Deliver_TM.end()) {
-                                obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_env_Deliver_TM(writeState);
-                            } else {
-                                copiedState.env_Deliver_TM(_tmp_1);
-                                obsw_M001_2::_ProjectionWrite_env_Deliver_TM writeState = copiedState._update_for_env_Deliver_TM();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_env_Deliver_TM_lock(_ProjectionRead_env_Deliver_TM_mutex);
-                                    _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_env_Deliver_TM.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "env_Deliver_TM";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "env_Deliver_TM";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -7527,7 +6847,10 @@ class ModelChecker {
                     copiedState.env_Receive_TC(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "env_Receive_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >> _trid_2 = state._tr_Poll_TC();
                 for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_BUFFER >& param : _trid_2) {
@@ -7538,7 +6861,10 @@ class ModelChecker {
                     copiedState.Poll_TC(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "Poll_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_3 = state._tr_Accept_TC();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_3) {
@@ -7548,7 +6874,10 @@ class ModelChecker {
                     copiedState.Accept_TC(_tmp_1);
                     copiedState.stateAccessedVia = "Accept_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_4 = state._tr_Reject_TC();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_4) {
@@ -7558,7 +6887,10 @@ class ModelChecker {
                     copiedState.Reject_TC(_tmp_1);
                     copiedState.stateAccessedVia = "Reject_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_5 = state._tr_Report_TC_Acceptance();
                 for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_5) {
@@ -7571,7 +6903,10 @@ class ModelChecker {
                     copiedState.Report_TC_Acceptance(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "Report_TC_Acceptance";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_6 = state._tr_Skip_TC_Acceptance_Report();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_6) {
@@ -7581,7 +6916,10 @@ class ModelChecker {
                     copiedState.Skip_TC_Acceptance_Report(_tmp_1);
                     copiedState.stateAccessedVia = "Skip_TC_Acceptance_Report";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_7 = state._tr_Report_TC_Rejection();
                 for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_7) {
@@ -7594,7 +6932,10 @@ class ModelChecker {
                     copiedState.Report_TC_Rejection(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "Report_TC_Rejection";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_8 = state._tr_Skip_TC_Rejection_Report();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_8) {
@@ -7604,7 +6945,10 @@ class ModelChecker {
                     copiedState.Skip_TC_Rejection_Report(_tmp_1);
                     copiedState.stateAccessedVia = "Skip_TC_Rejection_Report";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_9 = state._tr_Execute_TC_Successfully();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_9) {
@@ -7614,7 +6958,10 @@ class ModelChecker {
                     copiedState.Execute_TC_Successfully(_tmp_1);
                     copiedState.stateAccessedVia = "Execute_TC_Successfully";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_10 = state._tr_Reset_TM_Buffer();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_10) {
@@ -7624,7 +6971,10 @@ class ModelChecker {
                     copiedState.Reset_TM_Buffer(_tmp_1);
                     copiedState.stateAccessedVia = "Reset_TM_Buffer";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_11 = state._tr_Fail_TC_Execution();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_11) {
@@ -7634,7 +6984,10 @@ class ModelChecker {
                     copiedState.Fail_TC_Execution(_tmp_1);
                     copiedState.stateAccessedVia = "Fail_TC_Execution";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_12 = state._tr_Report_TC_Execution_Success();
                 for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_12) {
@@ -7647,7 +7000,10 @@ class ModelChecker {
                     copiedState.Report_TC_Execution_Success(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "Report_TC_Execution_Success";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_13 = state._tr_Skip_TC_Success_Report();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_13) {
@@ -7657,7 +7013,10 @@ class ModelChecker {
                     copiedState.Skip_TC_Success_Report(_tmp_1);
                     copiedState.stateAccessedVia = "Skip_TC_Success_Report";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_14 = state._tr_Report_TC_Execution_Failure();
                 for(const BTuple<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL, obsw_M001_2::TM_SET >, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_14) {
@@ -7670,7 +7029,10 @@ class ModelChecker {
                     copiedState.Report_TC_Execution_Failure(_tmp_4, _tmp_3, _tmp_1);
                     copiedState.stateAccessedVia = "Report_TC_Execution_Failure";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_15 = state._tr_Skip_TC_Failure_Report();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_15) {
@@ -7680,7 +7042,10 @@ class ModelChecker {
                     copiedState.Skip_TC_Failure_Report(_tmp_1);
                     copiedState.stateAccessedVia = "Skip_TC_Failure_Report";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL> _trid_16 = state._tr_Drop_TC();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TC_POOL& param : _trid_16) {
@@ -7690,7 +7055,10 @@ class ModelChecker {
                     copiedState.Drop_TC(_tmp_1);
                     copiedState.stateAccessedVia = "Drop_TC";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >> _trid_17 = state._tr_Produce_TM();
                 for(const BTuple<obsw_M001_2::TM_SET, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL >& param : _trid_17) {
@@ -7701,7 +7069,10 @@ class ModelChecker {
                     copiedState.Produce_TM(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "Produce_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >> _trid_18 = state._tr_Pass_TM();
                 for(const BTuple<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL, obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER >& param : _trid_18) {
@@ -7712,7 +7083,10 @@ class ModelChecker {
                     copiedState.Pass_TM(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "Pass_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_19 = state._tr_Cancel_TM();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_19) {
@@ -7722,7 +7096,10 @@ class ModelChecker {
                     copiedState.Cancel_TM(_tmp_1);
                     copiedState.stateAccessedVia = "Cancel_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL> _trid_20 = state._tr_Drop_TM();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_POOL& param : _trid_20) {
@@ -7732,7 +7109,10 @@ class ModelChecker {
                     copiedState.Drop_TM(_tmp_1);
                     copiedState.stateAccessedVia = "Drop_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER> _trid_21 = state._tr_env_Deliver_TM();
                 for(const obsw_M001_2::PACKET_START_ADDRESSES_IN_TM_BUFFER& param : _trid_21) {
@@ -7742,7 +7122,10 @@ class ModelChecker {
                     copiedState.env_Deliver_TM(_tmp_1);
                     copiedState.stateAccessedVia = "env_Deliver_TM";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/prob_oneway8seq.cpp b/benchmarks/model_checking_opreuse/C++/prob_oneway8seq.cpp
index 60fb0372e970055b4eb398490753f3a3ae128023..93255438c38e526fff2f918e91042ee38b5497b2 100644
--- a/benchmarks/model_checking_opreuse/C++/prob_oneway8seq.cpp
+++ b/benchmarks/model_checking_opreuse/C++/prob_oneway8seq.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -3556,12 +3555,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 prob_oneway8seq state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<prob_oneway8seq, prob_oneway8seq::Hash, prob_oneway8seq::HashEqual> nextStates = generateNextStates(state);
@@ -3582,12 +3585,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -3597,24 +3602,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -3703,7 +3711,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "move0";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 prob_oneway8seq::_ProjectionRead__tr_move1 read__tr_move1_state = state._projected_state_for__tr_move1();
                 bool _trid_2;
@@ -3750,7 +3761,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "move1";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 prob_oneway8seq::_ProjectionRead__tr_move2 read__tr_move2_state = state._projected_state_for__tr_move2();
                 bool _trid_3;
@@ -3797,7 +3811,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "move2";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 prob_oneway8seq::_ProjectionRead__tr_move3 read__tr_move3_state = state._projected_state_for__tr_move3();
                 bool _trid_4;
@@ -3844,7 +3861,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "move3";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 prob_oneway8seq::_ProjectionRead__tr_move4 read__tr_move4_state = state._projected_state_for__tr_move4();
                 bool _trid_5;
@@ -3891,7 +3911,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "move4";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 prob_oneway8seq::_ProjectionRead__tr_move5 read__tr_move5_state = state._projected_state_for__tr_move5();
                 bool _trid_6;
@@ -3938,7 +3961,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "move5";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 prob_oneway8seq::_ProjectionRead__tr_move6 read__tr_move6_state = state._projected_state_for__tr_move6();
                 bool _trid_7;
@@ -3985,7 +4011,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "move6";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 prob_oneway8seq::_ProjectionRead__tr_move7 read__tr_move7_state = state._projected_state_for__tr_move7();
                 bool _trid_8;
@@ -4032,7 +4061,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "move7";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 prob_oneway8seq::_ProjectionRead__tr_arrived read__tr_arrived_state = state._projected_state_for__tr_arrived();
                 bool _trid_9;
@@ -4079,7 +4111,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "arrived";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             } else {
@@ -4088,63 +4123,90 @@ class ModelChecker {
                     copiedState.move0();
                     copiedState.stateAccessedVia = "move0";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_move1()) {
                     prob_oneway8seq copiedState = state._copy();
                     copiedState.move1();
                     copiedState.stateAccessedVia = "move1";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_move2()) {
                     prob_oneway8seq copiedState = state._copy();
                     copiedState.move2();
                     copiedState.stateAccessedVia = "move2";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_move3()) {
                     prob_oneway8seq copiedState = state._copy();
                     copiedState.move3();
                     copiedState.stateAccessedVia = "move3";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_move4()) {
                     prob_oneway8seq copiedState = state._copy();
                     copiedState.move4();
                     copiedState.stateAccessedVia = "move4";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_move5()) {
                     prob_oneway8seq copiedState = state._copy();
                     copiedState.move5();
                     copiedState.stateAccessedVia = "move5";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_move6()) {
                     prob_oneway8seq copiedState = state._copy();
                     copiedState.move6();
                     copiedState.stateAccessedVia = "move6";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_move7()) {
                     prob_oneway8seq copiedState = state._copy();
                     copiedState.move7();
                     copiedState.stateAccessedVia = "move7";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_arrived()) {
                     prob_oneway8seq copiedState = state._copy();
                     copiedState.arrived();
                     copiedState.stateAccessedVia = "arrived";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/rether.cpp b/benchmarks/model_checking_opreuse/C++/rether.cpp
index facfa6718f4ccc381075bfd2738a8d6f790d48df..4290bdc23dd6b2a8b33063ce53b70eb4f8511668 100644
--- a/benchmarks/model_checking_opreuse/C++/rether.cpp
+++ b/benchmarks/model_checking_opreuse/C++/rether.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -2273,12 +2272,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 rether state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<rether, rether::Hash, rether::HashEqual> nextStates = generateNextStates(state);
@@ -2299,12 +2302,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -2314,24 +2319,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -2376,696 +2384,433 @@ class ModelChecker {
             std::unordered_set<rether, rether::Hash, rether::HashEqual> result = std::unordered_set<rether, rether::Hash, rether::HashEqual>();
             if(isCaching) {
                 rether::_ProjectionRead__tr_elapse_time read__tr_elapse_time_state = state._projected_state_for__tr_elapse_time();
+                BSet<BTuple<rether::Slots, rether::Slots >> _trid_1;
                 auto _trid_1_ptr = _OpCache_tr_elapse_time.find(read__tr_elapse_time_state);
                 if(_trid_1_ptr == _OpCache_tr_elapse_time.end()) {
-                    BSet<BTuple<rether::Slots, rether::Slots >> _trid_1 = state._tr_elapse_time();
+                    _trid_1 = state._tr_elapse_time();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_elapse_time_lock(_ProjectionRead__tr_elapse_time_mutex);
                         _OpCache_tr_elapse_time.insert({read__tr_elapse_time_state, _trid_1});
                     }
-                    for(const BTuple<rether::Slots, rether::Slots >& param : _trid_1) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Slots _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_elapse_time readState = state._projected_state_for_elapse_time();
+                } else {
+                    _trid_1 = _trid_1_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_elapse_time_ptr = _OpCache_elapse_time.find(param);
-                        if(_OpCache_with_parameter_elapse_time_ptr == _OpCache_elapse_time.end()) {
-                            copiedState.elapse_time(_tmp_2, _tmp_1);
-                            rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time();
-                            std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time;
-                            _OpCache_with_parameter_elapse_time.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex);
-                                _OpCache_elapse_time.insert({param, _OpCache_with_parameter_elapse_time});
-                            }
+                for(const BTuple<rether::Slots, rether::Slots >& param : _trid_1) {
+                    rether::Slots _tmp_1 = param.projection2();
+                    rether::Slots _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time = _OpCache_with_parameter_elapse_time_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_elapse_time.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_elapse_time.end()) {
-                                rether::_ProjectionWrite_elapse_time writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_elapse_time(writeState);
-                            } else {
-                                copiedState.elapse_time(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex);
-                                    _OpCache_with_parameter_elapse_time.insert({readState, writeState});
-                                }
-                            }
+                    rether copiedState = state._copy();
+                    rether::_ProjectionRead_elapse_time readState = state._projected_state_for_elapse_time();
+
+                    auto _OpCache_with_parameter_elapse_time_ptr = _OpCache_elapse_time.find(param);
+                    if(_OpCache_with_parameter_elapse_time_ptr == _OpCache_elapse_time.end()) {
+                        copiedState.elapse_time(_tmp_2, _tmp_1);
+                        rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time();
+                        std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time;
+                        _OpCache_with_parameter_elapse_time.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex);
+                            _OpCache_elapse_time.insert({param, _OpCache_with_parameter_elapse_time});
                         }
 
-                        copiedState.stateAccessedVia = "elapse_time";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<rether::Slots, rether::Slots >> _trid_1 = _trid_1_ptr->second;
-                    for(const BTuple<rether::Slots, rether::Slots >& param : _trid_1) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Slots _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_elapse_time readState = state._projected_state_for_elapse_time();
-
-                        auto _OpCache_with_parameter_elapse_time_ptr = _OpCache_elapse_time.find(param);
-                        if(_OpCache_with_parameter_elapse_time_ptr == _OpCache_elapse_time.end()) {
+                    } else {
+                        std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time = _OpCache_with_parameter_elapse_time_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_elapse_time.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_elapse_time.end()) {
+                            rether::_ProjectionWrite_elapse_time writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_elapse_time(writeState);
+                        } else {
                             copiedState.elapse_time(_tmp_2, _tmp_1);
                             rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time();
-                            std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time;
-                            _OpCache_with_parameter_elapse_time.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex);
-                                _OpCache_elapse_time.insert({param, _OpCache_with_parameter_elapse_time});
-                            }
-
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_elapse_time, rether::_ProjectionWrite_elapse_time, rether::_ProjectionRead_elapse_time::Hash, rether::_ProjectionRead_elapse_time::HashEqual> _OpCache_with_parameter_elapse_time = _OpCache_with_parameter_elapse_time_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_elapse_time.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_elapse_time.end()) {
-                                rether::_ProjectionWrite_elapse_time writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_elapse_time(writeState);
-                            } else {
-                                copiedState.elapse_time(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_elapse_time writeState = copiedState._update_for_elapse_time();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_elapse_time_lock(_ProjectionRead_elapse_time_mutex);
-                                    _OpCache_with_parameter_elapse_time.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_elapse_time.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "elapse_time";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "elapse_time";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 rether::_ProjectionRead__tr_reserve read__tr_reserve_state = state._projected_state_for__tr_reserve();
+                BSet<BTuple<rether::Nodes, rether::Slots >> _trid_2;
                 auto _trid_2_ptr = _OpCache_tr_reserve.find(read__tr_reserve_state);
                 if(_trid_2_ptr == _OpCache_tr_reserve.end()) {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_2 = state._tr_reserve();
+                    _trid_2 = state._tr_reserve();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_reserve_lock(_ProjectionRead__tr_reserve_mutex);
                         _OpCache_tr_reserve.insert({read__tr_reserve_state, _trid_2});
                     }
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_2) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_reserve readState = state._projected_state_for_reserve();
+                } else {
+                    _trid_2 = _trid_2_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_reserve_ptr = _OpCache_reserve.find(param);
-                        if(_OpCache_with_parameter_reserve_ptr == _OpCache_reserve.end()) {
-                            copiedState.reserve(_tmp_2, _tmp_1);
-                            rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve();
-                            std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve;
-                            _OpCache_with_parameter_reserve.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex);
-                                _OpCache_reserve.insert({param, _OpCache_with_parameter_reserve});
-                            }
+                for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_2) {
+                    rether::Slots _tmp_1 = param.projection2();
+                    rether::Nodes _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve = _OpCache_with_parameter_reserve_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_reserve.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_reserve.end()) {
-                                rether::_ProjectionWrite_reserve writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_reserve(writeState);
-                            } else {
-                                copiedState.reserve(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex);
-                                    _OpCache_with_parameter_reserve.insert({readState, writeState});
-                                }
-                            }
+                    rether copiedState = state._copy();
+                    rether::_ProjectionRead_reserve readState = state._projected_state_for_reserve();
+
+                    auto _OpCache_with_parameter_reserve_ptr = _OpCache_reserve.find(param);
+                    if(_OpCache_with_parameter_reserve_ptr == _OpCache_reserve.end()) {
+                        copiedState.reserve(_tmp_2, _tmp_1);
+                        rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve();
+                        std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve;
+                        _OpCache_with_parameter_reserve.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex);
+                            _OpCache_reserve.insert({param, _OpCache_with_parameter_reserve});
                         }
 
-                        copiedState.stateAccessedVia = "reserve";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_2 = _trid_2_ptr->second;
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_2) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_reserve readState = state._projected_state_for_reserve();
-
-                        auto _OpCache_with_parameter_reserve_ptr = _OpCache_reserve.find(param);
-                        if(_OpCache_with_parameter_reserve_ptr == _OpCache_reserve.end()) {
+                    } else {
+                        std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve = _OpCache_with_parameter_reserve_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_reserve.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_reserve.end()) {
+                            rether::_ProjectionWrite_reserve writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_reserve(writeState);
+                        } else {
                             copiedState.reserve(_tmp_2, _tmp_1);
                             rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve();
-                            std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve;
-                            _OpCache_with_parameter_reserve.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex);
-                                _OpCache_reserve.insert({param, _OpCache_with_parameter_reserve});
-                            }
-
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_reserve, rether::_ProjectionWrite_reserve, rether::_ProjectionRead_reserve::Hash, rether::_ProjectionRead_reserve::HashEqual> _OpCache_with_parameter_reserve = _OpCache_with_parameter_reserve_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_reserve.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_reserve.end()) {
-                                rether::_ProjectionWrite_reserve writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_reserve(writeState);
-                            } else {
-                                copiedState.reserve(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_reserve writeState = copiedState._update_for_reserve();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_reserve_lock(_ProjectionRead_reserve_mutex);
-                                    _OpCache_with_parameter_reserve.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_reserve.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "reserve";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "reserve";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 rether::_ProjectionRead__tr_release read__tr_release_state = state._projected_state_for__tr_release();
+                BSet<BTuple<rether::Nodes, rether::Slots >> _trid_3;
                 auto _trid_3_ptr = _OpCache_tr_release.find(read__tr_release_state);
                 if(_trid_3_ptr == _OpCache_tr_release.end()) {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_3 = state._tr_release();
+                    _trid_3 = state._tr_release();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_release_lock(_ProjectionRead__tr_release_mutex);
                         _OpCache_tr_release.insert({read__tr_release_state, _trid_3});
                     }
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_3) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_release readState = state._projected_state_for_release();
+                } else {
+                    _trid_3 = _trid_3_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_release_ptr = _OpCache_release.find(param);
-                        if(_OpCache_with_parameter_release_ptr == _OpCache_release.end()) {
-                            copiedState.release(_tmp_2, _tmp_1);
-                            rether::_ProjectionWrite_release writeState = copiedState._update_for_release();
-                            std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release;
-                            _OpCache_with_parameter_release.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex);
-                                _OpCache_release.insert({param, _OpCache_with_parameter_release});
-                            }
+                for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_3) {
+                    rether::Slots _tmp_1 = param.projection2();
+                    rether::Nodes _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release = _OpCache_with_parameter_release_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_release.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_release.end()) {
-                                rether::_ProjectionWrite_release writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_release(writeState);
-                            } else {
-                                copiedState.release(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_release writeState = copiedState._update_for_release();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex);
-                                    _OpCache_with_parameter_release.insert({readState, writeState});
-                                }
-                            }
+                    rether copiedState = state._copy();
+                    rether::_ProjectionRead_release readState = state._projected_state_for_release();
+
+                    auto _OpCache_with_parameter_release_ptr = _OpCache_release.find(param);
+                    if(_OpCache_with_parameter_release_ptr == _OpCache_release.end()) {
+                        copiedState.release(_tmp_2, _tmp_1);
+                        rether::_ProjectionWrite_release writeState = copiedState._update_for_release();
+                        std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release;
+                        _OpCache_with_parameter_release.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex);
+                            _OpCache_release.insert({param, _OpCache_with_parameter_release});
                         }
 
-                        copiedState.stateAccessedVia = "release";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_3 = _trid_3_ptr->second;
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_3) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_release readState = state._projected_state_for_release();
-
-                        auto _OpCache_with_parameter_release_ptr = _OpCache_release.find(param);
-                        if(_OpCache_with_parameter_release_ptr == _OpCache_release.end()) {
+                    } else {
+                        std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release = _OpCache_with_parameter_release_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_release.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_release.end()) {
+                            rether::_ProjectionWrite_release writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_release(writeState);
+                        } else {
                             copiedState.release(_tmp_2, _tmp_1);
                             rether::_ProjectionWrite_release writeState = copiedState._update_for_release();
-                            std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release;
-                            _OpCache_with_parameter_release.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex);
-                                _OpCache_release.insert({param, _OpCache_with_parameter_release});
-                            }
-
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_release, rether::_ProjectionWrite_release, rether::_ProjectionRead_release::Hash, rether::_ProjectionRead_release::HashEqual> _OpCache_with_parameter_release = _OpCache_with_parameter_release_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_release.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_release.end()) {
-                                rether::_ProjectionWrite_release writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_release(writeState);
-                            } else {
-                                copiedState.release(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_release writeState = copiedState._update_for_release();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_release_lock(_ProjectionRead_release_mutex);
-                                    _OpCache_with_parameter_release.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_release.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "release";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "release";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 rether::_ProjectionRead__tr_grant read__tr_grant_state = state._projected_state_for__tr_grant();
+                BSet<BTuple<rether::Nodes, rether::Slots >> _trid_4;
                 auto _trid_4_ptr = _OpCache_tr_grant.find(read__tr_grant_state);
                 if(_trid_4_ptr == _OpCache_tr_grant.end()) {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_4 = state._tr_grant();
+                    _trid_4 = state._tr_grant();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_grant_lock(_ProjectionRead__tr_grant_mutex);
                         _OpCache_tr_grant.insert({read__tr_grant_state, _trid_4});
                     }
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_4) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_grant readState = state._projected_state_for_grant();
+                } else {
+                    _trid_4 = _trid_4_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_grant_ptr = _OpCache_grant.find(param);
-                        if(_OpCache_with_parameter_grant_ptr == _OpCache_grant.end()) {
-                            copiedState.grant(_tmp_2, _tmp_1);
-                            rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant();
-                            std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant;
-                            _OpCache_with_parameter_grant.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex);
-                                _OpCache_grant.insert({param, _OpCache_with_parameter_grant});
-                            }
+                for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_4) {
+                    rether::Slots _tmp_1 = param.projection2();
+                    rether::Nodes _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant = _OpCache_with_parameter_grant_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_grant.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_grant.end()) {
-                                rether::_ProjectionWrite_grant writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_grant(writeState);
-                            } else {
-                                copiedState.grant(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex);
-                                    _OpCache_with_parameter_grant.insert({readState, writeState});
-                                }
-                            }
+                    rether copiedState = state._copy();
+                    rether::_ProjectionRead_grant readState = state._projected_state_for_grant();
+
+                    auto _OpCache_with_parameter_grant_ptr = _OpCache_grant.find(param);
+                    if(_OpCache_with_parameter_grant_ptr == _OpCache_grant.end()) {
+                        copiedState.grant(_tmp_2, _tmp_1);
+                        rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant();
+                        std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant;
+                        _OpCache_with_parameter_grant.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex);
+                            _OpCache_grant.insert({param, _OpCache_with_parameter_grant});
                         }
 
-                        copiedState.stateAccessedVia = "grant";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_4 = _trid_4_ptr->second;
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_4) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_grant readState = state._projected_state_for_grant();
-
-                        auto _OpCache_with_parameter_grant_ptr = _OpCache_grant.find(param);
-                        if(_OpCache_with_parameter_grant_ptr == _OpCache_grant.end()) {
+                    } else {
+                        std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant = _OpCache_with_parameter_grant_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_grant.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_grant.end()) {
+                            rether::_ProjectionWrite_grant writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_grant(writeState);
+                        } else {
                             copiedState.grant(_tmp_2, _tmp_1);
                             rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant();
-                            std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant;
-                            _OpCache_with_parameter_grant.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex);
-                                _OpCache_grant.insert({param, _OpCache_with_parameter_grant});
-                            }
-
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_grant, rether::_ProjectionWrite_grant, rether::_ProjectionRead_grant::Hash, rether::_ProjectionRead_grant::HashEqual> _OpCache_with_parameter_grant = _OpCache_with_parameter_grant_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_grant.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_grant.end()) {
-                                rether::_ProjectionWrite_grant writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_grant(writeState);
-                            } else {
-                                copiedState.grant(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_grant writeState = copiedState._update_for_grant();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_grant_lock(_ProjectionRead_grant_mutex);
-                                    _OpCache_with_parameter_grant.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_grant.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "grant";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "grant";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 rether::_ProjectionRead__tr_no_grant read__tr_no_grant_state = state._projected_state_for__tr_no_grant();
+                BSet<BTuple<rether::Nodes, rether::Slots >> _trid_5;
                 auto _trid_5_ptr = _OpCache_tr_no_grant.find(read__tr_no_grant_state);
                 if(_trid_5_ptr == _OpCache_tr_no_grant.end()) {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_5 = state._tr_no_grant();
+                    _trid_5 = state._tr_no_grant();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_no_grant_lock(_ProjectionRead__tr_no_grant_mutex);
                         _OpCache_tr_no_grant.insert({read__tr_no_grant_state, _trid_5});
                     }
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_5) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_no_grant readState = state._projected_state_for_no_grant();
+                } else {
+                    _trid_5 = _trid_5_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_no_grant_ptr = _OpCache_no_grant.find(param);
-                        if(_OpCache_with_parameter_no_grant_ptr == _OpCache_no_grant.end()) {
-                            copiedState.no_grant(_tmp_2, _tmp_1);
-                            rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant();
-                            std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant;
-                            _OpCache_with_parameter_no_grant.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex);
-                                _OpCache_no_grant.insert({param, _OpCache_with_parameter_no_grant});
-                            }
+                for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_5) {
+                    rether::Slots _tmp_1 = param.projection2();
+                    rether::Nodes _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant = _OpCache_with_parameter_no_grant_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_no_grant.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_no_grant.end()) {
-                                rether::_ProjectionWrite_no_grant writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_no_grant(writeState);
-                            } else {
-                                copiedState.no_grant(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex);
-                                    _OpCache_with_parameter_no_grant.insert({readState, writeState});
-                                }
-                            }
+                    rether copiedState = state._copy();
+                    rether::_ProjectionRead_no_grant readState = state._projected_state_for_no_grant();
+
+                    auto _OpCache_with_parameter_no_grant_ptr = _OpCache_no_grant.find(param);
+                    if(_OpCache_with_parameter_no_grant_ptr == _OpCache_no_grant.end()) {
+                        copiedState.no_grant(_tmp_2, _tmp_1);
+                        rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant();
+                        std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant;
+                        _OpCache_with_parameter_no_grant.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex);
+                            _OpCache_no_grant.insert({param, _OpCache_with_parameter_no_grant});
                         }
 
-                        copiedState.stateAccessedVia = "no_grant";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_5 = _trid_5_ptr->second;
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_5) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_no_grant readState = state._projected_state_for_no_grant();
-
-                        auto _OpCache_with_parameter_no_grant_ptr = _OpCache_no_grant.find(param);
-                        if(_OpCache_with_parameter_no_grant_ptr == _OpCache_no_grant.end()) {
+                    } else {
+                        std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant = _OpCache_with_parameter_no_grant_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_no_grant.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_no_grant.end()) {
+                            rether::_ProjectionWrite_no_grant writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_no_grant(writeState);
+                        } else {
                             copiedState.no_grant(_tmp_2, _tmp_1);
                             rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant();
-                            std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant;
-                            _OpCache_with_parameter_no_grant.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex);
-                                _OpCache_no_grant.insert({param, _OpCache_with_parameter_no_grant});
-                            }
-
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_no_grant, rether::_ProjectionWrite_no_grant, rether::_ProjectionRead_no_grant::Hash, rether::_ProjectionRead_no_grant::HashEqual> _OpCache_with_parameter_no_grant = _OpCache_with_parameter_no_grant_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_no_grant.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_no_grant.end()) {
-                                rether::_ProjectionWrite_no_grant writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_no_grant(writeState);
-                            } else {
-                                copiedState.no_grant(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_no_grant writeState = copiedState._update_for_no_grant();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_no_grant_lock(_ProjectionRead_no_grant_mutex);
-                                    _OpCache_with_parameter_no_grant.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_no_grant.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "no_grant";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "no_grant";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 rether::_ProjectionRead__tr_use_RT_Slot read__tr_use_RT_Slot_state = state._projected_state_for__tr_use_RT_Slot();
+                BSet<BTuple<rether::Nodes, rether::Slots >> _trid_6;
                 auto _trid_6_ptr = _OpCache_tr_use_RT_Slot.find(read__tr_use_RT_Slot_state);
                 if(_trid_6_ptr == _OpCache_tr_use_RT_Slot.end()) {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_6 = state._tr_use_RT_Slot();
+                    _trid_6 = state._tr_use_RT_Slot();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_use_RT_Slot_lock(_ProjectionRead__tr_use_RT_Slot_mutex);
                         _OpCache_tr_use_RT_Slot.insert({read__tr_use_RT_Slot_state, _trid_6});
                     }
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_6) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_use_RT_Slot readState = state._projected_state_for_use_RT_Slot();
+                } else {
+                    _trid_6 = _trid_6_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_use_RT_Slot_ptr = _OpCache_use_RT_Slot.find(param);
-                        if(_OpCache_with_parameter_use_RT_Slot_ptr == _OpCache_use_RT_Slot.end()) {
-                            copiedState.use_RT_Slot(_tmp_2, _tmp_1);
-                            rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot();
-                            std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot;
-                            _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex);
-                                _OpCache_use_RT_Slot.insert({param, _OpCache_with_parameter_use_RT_Slot});
-                            }
+                for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_6) {
+                    rether::Slots _tmp_1 = param.projection2();
+                    rether::Nodes _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot = _OpCache_with_parameter_use_RT_Slot_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_use_RT_Slot.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_use_RT_Slot.end()) {
-                                rether::_ProjectionWrite_use_RT_Slot writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_use_RT_Slot(writeState);
-                            } else {
-                                copiedState.use_RT_Slot(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex);
-                                    _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState});
-                                }
-                            }
+                    rether copiedState = state._copy();
+                    rether::_ProjectionRead_use_RT_Slot readState = state._projected_state_for_use_RT_Slot();
+
+                    auto _OpCache_with_parameter_use_RT_Slot_ptr = _OpCache_use_RT_Slot.find(param);
+                    if(_OpCache_with_parameter_use_RT_Slot_ptr == _OpCache_use_RT_Slot.end()) {
+                        copiedState.use_RT_Slot(_tmp_2, _tmp_1);
+                        rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot();
+                        std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot;
+                        _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex);
+                            _OpCache_use_RT_Slot.insert({param, _OpCache_with_parameter_use_RT_Slot});
                         }
 
-                        copiedState.stateAccessedVia = "use_RT_Slot";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_6 = _trid_6_ptr->second;
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_6) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_use_RT_Slot readState = state._projected_state_for_use_RT_Slot();
-
-                        auto _OpCache_with_parameter_use_RT_Slot_ptr = _OpCache_use_RT_Slot.find(param);
-                        if(_OpCache_with_parameter_use_RT_Slot_ptr == _OpCache_use_RT_Slot.end()) {
+                    } else {
+                        std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot = _OpCache_with_parameter_use_RT_Slot_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_use_RT_Slot.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_use_RT_Slot.end()) {
+                            rether::_ProjectionWrite_use_RT_Slot writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_use_RT_Slot(writeState);
+                        } else {
                             copiedState.use_RT_Slot(_tmp_2, _tmp_1);
                             rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot();
-                            std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot;
-                            _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex);
-                                _OpCache_use_RT_Slot.insert({param, _OpCache_with_parameter_use_RT_Slot});
-                            }
-
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_use_RT_Slot, rether::_ProjectionWrite_use_RT_Slot, rether::_ProjectionRead_use_RT_Slot::Hash, rether::_ProjectionRead_use_RT_Slot::HashEqual> _OpCache_with_parameter_use_RT_Slot = _OpCache_with_parameter_use_RT_Slot_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_use_RT_Slot.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_use_RT_Slot.end()) {
-                                rether::_ProjectionWrite_use_RT_Slot writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_use_RT_Slot(writeState);
-                            } else {
-                                copiedState.use_RT_Slot(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_use_RT_Slot writeState = copiedState._update_for_use_RT_Slot();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_use_RT_Slot_lock(_ProjectionRead_use_RT_Slot_mutex);
-                                    _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_use_RT_Slot.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "use_RT_Slot";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "use_RT_Slot";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 rether::_ProjectionRead__tr_use_NRT_Slot read__tr_use_NRT_Slot_state = state._projected_state_for__tr_use_NRT_Slot();
+                BSet<BTuple<rether::Nodes, rether::Slots >> _trid_7;
                 auto _trid_7_ptr = _OpCache_tr_use_NRT_Slot.find(read__tr_use_NRT_Slot_state);
                 if(_trid_7_ptr == _OpCache_tr_use_NRT_Slot.end()) {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_7 = state._tr_use_NRT_Slot();
+                    _trid_7 = state._tr_use_NRT_Slot();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_use_NRT_Slot_lock(_ProjectionRead__tr_use_NRT_Slot_mutex);
                         _OpCache_tr_use_NRT_Slot.insert({read__tr_use_NRT_Slot_state, _trid_7});
                     }
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_7) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_use_NRT_Slot readState = state._projected_state_for_use_NRT_Slot();
+                } else {
+                    _trid_7 = _trid_7_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_use_NRT_Slot_ptr = _OpCache_use_NRT_Slot.find(param);
-                        if(_OpCache_with_parameter_use_NRT_Slot_ptr == _OpCache_use_NRT_Slot.end()) {
-                            copiedState.use_NRT_Slot(_tmp_2, _tmp_1);
-                            rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot();
-                            std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot;
-                            _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex);
-                                _OpCache_use_NRT_Slot.insert({param, _OpCache_with_parameter_use_NRT_Slot});
-                            }
+                for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_7) {
+                    rether::Slots _tmp_1 = param.projection2();
+                    rether::Nodes _tmp_2 = param.projection1();
 
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot = _OpCache_with_parameter_use_NRT_Slot_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_use_NRT_Slot.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_use_NRT_Slot.end()) {
-                                rether::_ProjectionWrite_use_NRT_Slot writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_use_NRT_Slot(writeState);
-                            } else {
-                                copiedState.use_NRT_Slot(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex);
-                                    _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState});
-                                }
-                            }
+                    rether copiedState = state._copy();
+                    rether::_ProjectionRead_use_NRT_Slot readState = state._projected_state_for_use_NRT_Slot();
+
+                    auto _OpCache_with_parameter_use_NRT_Slot_ptr = _OpCache_use_NRT_Slot.find(param);
+                    if(_OpCache_with_parameter_use_NRT_Slot_ptr == _OpCache_use_NRT_Slot.end()) {
+                        copiedState.use_NRT_Slot(_tmp_2, _tmp_1);
+                        rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot();
+                        std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot;
+                        _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex);
+                            _OpCache_use_NRT_Slot.insert({param, _OpCache_with_parameter_use_NRT_Slot});
                         }
 
-                        copiedState.stateAccessedVia = "use_NRT_Slot";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<BTuple<rether::Nodes, rether::Slots >> _trid_7 = _trid_7_ptr->second;
-                    for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_7) {
-                        rether::Slots _tmp_1 = param.projection2();
-                        rether::Nodes _tmp_2 = param.projection1();
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_use_NRT_Slot readState = state._projected_state_for_use_NRT_Slot();
-
-                        auto _OpCache_with_parameter_use_NRT_Slot_ptr = _OpCache_use_NRT_Slot.find(param);
-                        if(_OpCache_with_parameter_use_NRT_Slot_ptr == _OpCache_use_NRT_Slot.end()) {
+                    } else {
+                        std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot = _OpCache_with_parameter_use_NRT_Slot_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_use_NRT_Slot.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_use_NRT_Slot.end()) {
+                            rether::_ProjectionWrite_use_NRT_Slot writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_use_NRT_Slot(writeState);
+                        } else {
                             copiedState.use_NRT_Slot(_tmp_2, _tmp_1);
                             rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot();
-                            std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot;
-                            _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex);
-                                _OpCache_use_NRT_Slot.insert({param, _OpCache_with_parameter_use_NRT_Slot});
-                            }
-
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_use_NRT_Slot, rether::_ProjectionWrite_use_NRT_Slot, rether::_ProjectionRead_use_NRT_Slot::Hash, rether::_ProjectionRead_use_NRT_Slot::HashEqual> _OpCache_with_parameter_use_NRT_Slot = _OpCache_with_parameter_use_NRT_Slot_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_use_NRT_Slot.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_use_NRT_Slot.end()) {
-                                rether::_ProjectionWrite_use_NRT_Slot writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_use_NRT_Slot(writeState);
-                            } else {
-                                copiedState.use_NRT_Slot(_tmp_2, _tmp_1);
-                                rether::_ProjectionWrite_use_NRT_Slot writeState = copiedState._update_for_use_NRT_Slot();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_use_NRT_Slot_lock(_ProjectionRead_use_NRT_Slot_mutex);
-                                    _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_use_NRT_Slot.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "use_NRT_Slot";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "use_NRT_Slot";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
                 rether::_ProjectionRead__tr_pass_token read__tr_pass_token_state = state._projected_state_for__tr_pass_token();
+                BSet<rether::Nodes> _trid_8;
                 auto _trid_8_ptr = _OpCache_tr_pass_token.find(read__tr_pass_token_state);
                 if(_trid_8_ptr == _OpCache_tr_pass_token.end()) {
-                    BSet<rether::Nodes> _trid_8 = state._tr_pass_token();
+                    _trid_8 = state._tr_pass_token();
                     {
                         std::unique_lock<std::mutex> _ProjectionRead__tr_pass_token_lock(_ProjectionRead__tr_pass_token_mutex);
                         _OpCache_tr_pass_token.insert({read__tr_pass_token_state, _trid_8});
                     }
-                    for(const rether::Nodes& param : _trid_8) {
-                        rether::Nodes _tmp_1 = param;
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_pass_token readState = state._projected_state_for_pass_token();
+                } else {
+                    _trid_8 = _trid_8_ptr->second;
+                }
 
-                        auto _OpCache_with_parameter_pass_token_ptr = _OpCache_pass_token.find(param);
-                        if(_OpCache_with_parameter_pass_token_ptr == _OpCache_pass_token.end()) {
-                            copiedState.pass_token(_tmp_1);
-                            rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token();
-                            std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token;
-                            _OpCache_with_parameter_pass_token.insert({readState, writeState});
-                            {
-                                std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex);
-                                _OpCache_pass_token.insert({param, _OpCache_with_parameter_pass_token});
-                            }
+                for(const rether::Nodes& param : _trid_8) {
+                    rether::Nodes _tmp_1 = param;
 
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token = _OpCache_with_parameter_pass_token_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_pass_token.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_pass_token.end()) {
-                                rether::_ProjectionWrite_pass_token writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_pass_token(writeState);
-                            } else {
-                                copiedState.pass_token(_tmp_1);
-                                rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex);
-                                    _OpCache_with_parameter_pass_token.insert({readState, writeState});
-                                }
-                            }
+                    rether copiedState = state._copy();
+                    rether::_ProjectionRead_pass_token readState = state._projected_state_for_pass_token();
+
+                    auto _OpCache_with_parameter_pass_token_ptr = _OpCache_pass_token.find(param);
+                    if(_OpCache_with_parameter_pass_token_ptr == _OpCache_pass_token.end()) {
+                        copiedState.pass_token(_tmp_1);
+                        rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token();
+                        std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token;
+                        _OpCache_with_parameter_pass_token.insert({readState, writeState});
+                        {
+                            std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex);
+                            _OpCache_pass_token.insert({param, _OpCache_with_parameter_pass_token});
                         }
 
-                        copiedState.stateAccessedVia = "pass_token";
-                        result.insert(copiedState);
-                        transitions += 1;
-                    }
-                } else {
-                    BSet<rether::Nodes> _trid_8 = _trid_8_ptr->second;
-                    for(const rether::Nodes& param : _trid_8) {
-                        rether::Nodes _tmp_1 = param;
-
-                        rether copiedState = state._copy();
-                        rether::_ProjectionRead_pass_token readState = state._projected_state_for_pass_token();
-
-                        auto _OpCache_with_parameter_pass_token_ptr = _OpCache_pass_token.find(param);
-                        if(_OpCache_with_parameter_pass_token_ptr == _OpCache_pass_token.end()) {
+                    } else {
+                        std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token = _OpCache_with_parameter_pass_token_ptr->second;
+                        auto writeState_ptr = _OpCache_with_parameter_pass_token.find(readState);
+                        if(writeState_ptr != _OpCache_with_parameter_pass_token.end()) {
+                            rether::_ProjectionWrite_pass_token writeState = writeState_ptr->second;
+                            copiedState._apply_update_for_pass_token(writeState);
+                        } else {
                             copiedState.pass_token(_tmp_1);
                             rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token();
-                            std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token;
-                            _OpCache_with_parameter_pass_token.insert({readState, writeState});
                             {
                                 std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex);
-                                _OpCache_pass_token.insert({param, _OpCache_with_parameter_pass_token});
-                            }
-
-                        } else {
-                            std::unordered_map<rether::_ProjectionRead_pass_token, rether::_ProjectionWrite_pass_token, rether::_ProjectionRead_pass_token::Hash, rether::_ProjectionRead_pass_token::HashEqual> _OpCache_with_parameter_pass_token = _OpCache_with_parameter_pass_token_ptr->second;
-                            auto writeState_ptr = _OpCache_with_parameter_pass_token.find(readState);
-                            if(writeState_ptr != _OpCache_with_parameter_pass_token.end()) {
-                                rether::_ProjectionWrite_pass_token writeState = writeState_ptr->second;
-                                copiedState._apply_update_for_pass_token(writeState);
-                            } else {
-                                copiedState.pass_token(_tmp_1);
-                                rether::_ProjectionWrite_pass_token writeState = copiedState._update_for_pass_token();
-                                {
-                                    std::unique_lock<std::mutex> _ProjectionRead_pass_token_lock(_ProjectionRead_pass_token_mutex);
-                                    _OpCache_with_parameter_pass_token.insert({readState, writeState});
-                                }
+                                _OpCache_with_parameter_pass_token.insert({readState, writeState});
                             }
                         }
+                    }
 
-                        copiedState.stateAccessedVia = "pass_token";
-                        result.insert(copiedState);
+                    copiedState.stateAccessedVia = "pass_token";
+                    result.insert(copiedState);
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
                         transitions += 1;
                     }
                 }
@@ -3080,7 +2825,10 @@ class ModelChecker {
                     copiedState.elapse_time(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "elapse_time";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<rether::Nodes, rether::Slots >> _trid_2 = state._tr_reserve();
                 for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_2) {
@@ -3091,7 +2839,10 @@ class ModelChecker {
                     copiedState.reserve(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "reserve";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<rether::Nodes, rether::Slots >> _trid_3 = state._tr_release();
                 for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_3) {
@@ -3102,7 +2853,10 @@ class ModelChecker {
                     copiedState.release(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "release";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<rether::Nodes, rether::Slots >> _trid_4 = state._tr_grant();
                 for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_4) {
@@ -3113,7 +2867,10 @@ class ModelChecker {
                     copiedState.grant(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "grant";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<rether::Nodes, rether::Slots >> _trid_5 = state._tr_no_grant();
                 for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_5) {
@@ -3124,7 +2881,10 @@ class ModelChecker {
                     copiedState.no_grant(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "no_grant";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<rether::Nodes, rether::Slots >> _trid_6 = state._tr_use_RT_Slot();
                 for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_6) {
@@ -3135,7 +2895,10 @@ class ModelChecker {
                     copiedState.use_RT_Slot(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "use_RT_Slot";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<BTuple<rether::Nodes, rether::Slots >> _trid_7 = state._tr_use_NRT_Slot();
                 for(const BTuple<rether::Nodes, rether::Slots >& param : _trid_7) {
@@ -3146,7 +2909,10 @@ class ModelChecker {
                     copiedState.use_NRT_Slot(_tmp_2, _tmp_1);
                     copiedState.stateAccessedVia = "use_NRT_Slot";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 BSet<rether::Nodes> _trid_8 = state._tr_pass_token();
                 for(const rether::Nodes& param : _trid_8) {
@@ -3156,7 +2922,10 @@ class ModelChecker {
                     copiedState.pass_token(_tmp_1);
                     copiedState.stateAccessedVia = "pass_token";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }
diff --git a/benchmarks/model_checking_opreuse/C++/sort_m2_data1000_MC.cpp b/benchmarks/model_checking_opreuse/C++/sort_m2_data1000_MC.cpp
index 2792972a9f864aeefc2ab8f33414ced598c0f20c..19178e7ab3b1c3a0254a00ecb7b1969f96e52499 100644
--- a/benchmarks/model_checking_opreuse/C++/sort_m2_data1000_MC.cpp
+++ b/benchmarks/model_checking_opreuse/C++/sort_m2_data1000_MC.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 #include <any>
 #include <mutex>
-#include <shared_mutex>
 #include <future>
 #include <boost/asio/post.hpp>
 #include <boost/asio/thread_pool.hpp>
@@ -1540,12 +1539,16 @@ class ModelChecker {
             states.insert(machine);
             unvisitedStates.push_back(machine);
 
-            std::atomic<bool> stopThreads(false);
+            std::atomic<bool> stopThreads;
+            stopThreads = false;
             std::atomic<int> possibleQueueChanges;
             possibleQueueChanges = 0;
 
-            while(!unvisitedStates.empty() && !stopThreads.load()) {
-                possibleQueueChanges.fetch_add(1);
+            std::atomic<bool> waitFlag;
+            waitFlag = true;
+
+            while(!unvisitedStates.empty() && !stopThreads) {
+                possibleQueueChanges += 1;
                 sort_m2_data1000_MC state = next();
                 std::packaged_task<void()> task([&, state] {
                     std::unordered_set<sort_m2_data1000_MC, sort_m2_data1000_MC::Hash, sort_m2_data1000_MC::HashEqual> nextStates = generateNextStates(state);
@@ -1566,12 +1569,14 @@ class ModelChecker {
                         }
                     }
 
-                    possibleQueueChanges.fetch_sub(1);
                     {
                         std::unique_lock<std::mutex> lock(mutex);
-                        if (!unvisitedStates.empty() || possibleQueueChanges.load() == 0) {
+                        possibleQueueChanges -= 1;
+                        int running = possibleQueueChanges;
+                        if (!unvisitedStates.empty() || running == 0) {
                             {
                                 std::unique_lock<std::mutex> lock(waitMutex);
+                                waitFlag = false;
                                 waitCV.notify_one();
                             }
                         }
@@ -1581,24 +1586,27 @@ class ModelChecker {
                     if(invariantViolated(state)) {
                         invariantViolatedBool = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                     if(nextStates.empty()) {
                         deadlockDetected = true;
                         counterExampleState = state;
-                        stopThreads.store(true);
+                        stopThreads = true;
                     }
 
                 });
 
+                waitFlag = true;
                 boost::asio::post(workers, std::move(task));
 
                 {
                     std::unique_lock<std::mutex> lock(waitMutex);
-                    waitCV.wait(lock, [&] {
-                        return !unvisitedStates.empty() || possibleQueueChanges == 0;
-                    });
+                    if(unvisitedStates.empty() && possibleQueueChanges > 0) {
+                        waitCV.wait(lock, [&] {
+                            return waitFlag == false;
+                        });
+                    }
                 }
             }
             workers.join();
@@ -1687,7 +1695,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "progress";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 sort_m2_data1000_MC::_ProjectionRead__tr_prog1 read__tr_prog1_state = state._projected_state_for__tr_prog1();
                 bool _trid_2;
@@ -1734,7 +1745,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "prog1";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 sort_m2_data1000_MC::_ProjectionRead__tr_prog2 read__tr_prog2_state = state._projected_state_for__tr_prog2();
                 bool _trid_3;
@@ -1781,7 +1795,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "prog2";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 sort_m2_data1000_MC::_ProjectionRead__tr_final_evt read__tr_final_evt_state = state._projected_state_for__tr_final_evt();
                 bool _trid_4;
@@ -1828,7 +1845,10 @@ class ModelChecker {
 
                     copiedState.stateAccessedVia = "final_evt";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             } else {
@@ -1837,28 +1857,40 @@ class ModelChecker {
                     copiedState.progress();
                     copiedState.stateAccessedVia = "progress";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_prog1()) {
                     sort_m2_data1000_MC copiedState = state._copy();
                     copiedState.prog1();
                     copiedState.stateAccessedVia = "prog1";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_prog2()) {
                     sort_m2_data1000_MC copiedState = state._copy();
                     copiedState.prog2();
                     copiedState.stateAccessedVia = "prog2";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
                 if(state._tr_final_evt()) {
                     sort_m2_data1000_MC copiedState = state._copy();
                     copiedState.final_evt();
                     copiedState.stateAccessedVia = "final_evt";
                     result.insert(copiedState);
-                    transitions += 1;
+                    {
+                        std::unique_lock<std::mutex> lock(mutex);
+                        transitions += 1;
+                    }
                 }
 
             }