diff --git a/soh/soh/Enhancements/randomizer/randomizer_logic_tracker.cpp b/soh/soh/Enhancements/randomizer/randomizer_logic_tracker.cpp
index a738e755f..19939406d 100644
--- a/soh/soh/Enhancements/randomizer/randomizer_logic_tracker.cpp
+++ b/soh/soh/Enhancements/randomizer/randomizer_logic_tracker.cpp
@@ -23,7 +23,7 @@ struct ExpressionTable {
         std::optional<LogicExpression::ValueVariant> ChildNight;
         std::optional<LogicExpression::ValueVariant> AdultDay;
         std::optional<LogicExpression::ValueVariant> AdultNight;
-        bool Expanded;
+        bool Expanded = false;
     };
 
     ExpressionRow Root;
@@ -35,7 +35,7 @@ struct ExpressionTable {
 struct LogicTrackerNode {
     struct Connection {
         std::string ParentName;
-        RandomizerRegion ParentRandomizerRegion;
+        RandomizerRegion ParentRandomizerRegion = RR_NONE;
         ExpressionTable ExpressionTable;
 
         bool ChildDayAccess = false;
@@ -46,7 +46,7 @@ struct LogicTrackerNode {
 
     std::string NodeName;
     std::vector<Connection> Connections;
-    int NodeId;
+    int NodeId = -1;
 };
 
 bool expandingNode = false;
@@ -109,6 +109,56 @@ static std::tuple<bool, bool, bool> CalculateCombines(const ExpressionTable::Exp
     return {combineAll, combineChild, combineAdult};
 }
 
+static void PopulateConnectionExpression(LogicTrackerNode::Connection& connection, std::string expressionStr) {
+    connection.ExpressionTable.Root = CreateExpressionRows(LogicExpression::Parse(expressionStr));
+
+    if (connection.ChildDayAccess) {
+        logic->IsChild = true;
+        logic->AtDay = true;
+
+        const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
+        PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::ChildDay);
+
+        logic->IsChild = false;
+        logic->AtDay = false;
+    }
+    if (connection.ChildNightAccess) {
+        logic->IsChild = true;
+        logic->AtNight = true;
+
+        const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
+        PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::ChildNight);
+
+        logic->IsChild = false;
+        logic->AtNight = false;
+    }
+    if (connection.AdultDayAccess) {
+        logic->IsAdult = true;
+        logic->AtDay = true;
+
+        const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
+        PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::AdultDay);
+
+        logic->IsAdult = false;
+        logic->AtDay = false;
+    }
+    if (connection.AdultNightAccess) {
+        logic->IsAdult = true;
+        logic->AtNight = true;
+
+        const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
+        PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::AdultNight);
+
+        logic->IsAdult = false;
+        logic->AtNight = false;
+    }
+
+    auto [combineAll, combineChild, combineAdult] = CalculateCombines(connection.ExpressionTable.Root);
+    connection.ExpressionTable.CombineAll = combineAll;
+    connection.ExpressionTable.CombineChild = combineChild;
+    connection.ExpressionTable.CombineAdult = combineAdult;
+}
+
 void LogicTrackerWindow::ShowRandomizerCheck(RandomizerCheck randomizerCheck) {
     const auto& location = Rando::StaticData::GetLocation(randomizerCheck);
 
@@ -125,57 +175,12 @@ void LogicTrackerWindow::ShowRandomizerCheck(RandomizerCheck randomizerCheck) {
                 LogicTrackerNode::Connection connection;
                 connection.ParentName = region.regionName;
                 connection.ParentRandomizerRegion = RandomizerRegion(randomizerRegion);
-                connection.ExpressionTable.Root = CreateExpressionRows(LogicExpression::Parse(locationAccess.GetConditionStr()));
                 connection.ChildDayAccess = region.childDay;
                 connection.ChildNightAccess = region.childNight;
                 connection.AdultDayAccess = region.adultDay;
                 connection.AdultNightAccess = region.adultNight;
 
-                if (connection.ChildDayAccess) {
-                    logic->IsChild = true;
-                    logic->AtDay = true;
-
-                    const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
-                    PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::ChildDay);
-
-                    logic->IsChild = false;
-                    logic->AtDay = false;
-                }
-                if (connection.ChildNightAccess) {
-                    logic->IsChild = true;
-                    logic->AtNight = true;
-
-                    const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
-                    PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::ChildNight);
-
-                    logic->IsChild = false;
-                    logic->AtNight = false;
-                }
-                if (connection.AdultDayAccess) {
-                    logic->IsAdult = true;
-                    logic->AtDay = true;
-
-                    const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
-                    PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::AdultDay);
-
-                    logic->IsAdult = false;
-                    logic->AtDay = false;
-                }
-                if (connection.AdultNightAccess) {
-                    logic->IsAdult = true;
-                    logic->AtNight = true;
-
-                    const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
-                    PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::AdultNight);
-
-                    logic->IsAdult = false;
-                    logic->AtNight = false;
-                }
-
-                auto [combineAll, combineChild, combineAdult] = CalculateCombines(connection.ExpressionTable.Root);
-                connection.ExpressionTable.CombineAll = combineAll;
-                connection.ExpressionTable.CombineChild = combineChild;
-                connection.ExpressionTable.CombineAdult = combineAdult;
+                PopulateConnectionExpression(connection, locationAccess.GetConditionStr());
 
                 node.Connections.emplace_back(std::move(connection));
             }
@@ -203,58 +208,12 @@ void LogicTrackerWindow::ShowRandomizerRegion(RandomizerRegion randomizerRegion)
         LogicTrackerNode::Connection connection;
         connection.ParentName = parentRegion->regionName;
         connection.ParentRandomizerRegion = entrance->GetParentRegionKey();
-        connection.ExpressionTable.Root =
-            CreateExpressionRows(LogicExpression::Parse(entrance->GetConditionStr()));
         connection.ChildDayAccess = parentRegion->childDay;
         connection.ChildNightAccess = parentRegion->childNight;
         connection.AdultDayAccess = parentRegion->adultDay;
         connection.AdultNightAccess = parentRegion->adultNight;
 
-        if (connection.ChildDayAccess) {
-            logic->IsChild = true;
-            logic->AtDay = true;
-
-            const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
-            PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::ChildDay);
-
-            logic->IsChild = false;
-            logic->AtDay = false;
-        }
-        if (connection.ChildNightAccess) {
-            logic->IsChild = true;
-            logic->AtNight = true;
-
-            const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
-            PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::ChildNight);
-
-            logic->IsChild = false;
-            logic->AtNight = false;
-        }
-        if (connection.AdultDayAccess) {
-            logic->IsAdult = true;
-            logic->AtDay = true;
-
-            const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
-            PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::AdultDay);
-
-            logic->IsAdult = false;
-            logic->AtDay = false;
-        }
-        if (connection.AdultNightAccess) {
-            logic->IsAdult = true;
-            logic->AtNight = true;
-
-            const auto& eval = EvaluateExpression(connection.ExpressionTable.Root.Expression);
-            PopulateExpressionValues(connection.ExpressionTable.Root, eval, AgeTime::AdultNight);
-
-            logic->IsAdult = false;
-            logic->AtNight = false;
-        }
-
-        auto [combineAll, combineChild, combineAdult] = CalculateCombines(connection.ExpressionTable.Root);
-        connection.ExpressionTable.CombineAll = combineAll;
-        connection.ExpressionTable.CombineChild = combineChild;
-        connection.ExpressionTable.CombineAdult = combineAdult;
+        PopulateConnectionExpression(connection, entrance->GetConditionStr());
 
         node.Connections.emplace_back(std::move(connection));
     }
@@ -449,8 +408,10 @@ static void DrawExpressionTable(ExpressionTable& table) {
 }
 
 static void DrawNodeConnection(LogicTrackerNode& node, LogicTrackerNode::Connection& connection) {
+    ImGui::PushID(connection.ParentName.c_str());
+
     ImGui::TextUnformatted("Parent Access:");
-    if (ImGui::BeginTable(("##" + connection.ParentName).c_str(), 4,
+    if (ImGui::BeginTable("", 4,
                           ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_NoHostExtendX)) {
         ImGui::TableSetupColumn("Child Day", ImGuiTableColumnFlags_WidthFixed);
         ImGui::TableSetupColumn("Child Night", ImGuiTableColumnFlags_WidthFixed);
@@ -481,7 +442,7 @@ static void DrawNodeConnection(LogicTrackerNode& node, LogicTrackerNode::Connect
 
     if (connection.ParentRandomizerRegion != RR_NONE) {
         ImGui::SameLine();
-        if (ImGui::Button(("Show Region Logic##" + connection.ParentName).c_str())) {
+        if (ImGui::Button("Show Region Logic")) {
             while (nodes.back().NodeId > node.NodeId) {
                 nodes.pop_back();
             }
@@ -492,9 +453,13 @@ static void DrawNodeConnection(LogicTrackerNode& node, LogicTrackerNode::Connect
 
     ImGui::TextUnformatted("Node Access:");
     DrawExpressionTable(connection.ExpressionTable);
+
+    ImGui::PopID();
 }
 
 static void DrawNode(LogicTrackerNode& node) {
+    ImGui::PushID(node.NodeId);
+
     if (expandingNode) {
         ImGui::SetNextItemOpen(expandNodeId == node.NodeId, ImGuiCond_Always);
     }
@@ -510,6 +475,8 @@ static void DrawNode(LogicTrackerNode& node) {
         }
         ImGui::Unindent(25.0f);
     }
+
+    ImGui::PopID();
 }
 
 void LogicTrackerWindow::DrawElement() {