Tabs -> spaces everywhere

9 files changed, 1168 insertions, 1168 deletions

@@ -3,106 +3,106 @@
 
 // Modify an opcode to use RNG2 instead of main RNG
 void ChallengeRandomizer::AdjustRng(int offset) {
-        int currentRng = _memory->ReadData<int>({offset}, 0x1)[0];
-        _memory->WriteData<int>({offset}, {currentRng + 0x20});
+    int currentRng = _memory->ReadData<int>({offset}, 0x1)[0];
+    _memory->WriteData<int>({offset}, {currentRng + 0x20});
 }
 
 // Overwrite the pointer for the lightmap_generator (which is unused, afaict) to point to a secondary RNG.
 // Then, adjust all the RNG functions in challenge/doors to use this RNG.
 ChallengeRandomizer::ChallengeRandomizer(const std::shared_ptr<Memory>& memory, int seed) : _memory(memory)
 {
-        RNG_ADDR = _memory->ReadData<int>({GLOBALS + 0x10}, 1)[0];
-        RNG2_ADDR = _memory->ReadData<int>({GLOBALS + 0x30}, 1)[0];
-        bool alreadyInjected = (RNG2_ADDR == RNG_ADDR + 4);
+    RNG_ADDR = _memory->ReadData<int>({GLOBALS + 0x10}, 1)[0];
+    RNG2_ADDR = _memory->ReadData<int>({GLOBALS + 0x30}, 1)[0];
+    bool alreadyInjected = (RNG2_ADDR == RNG_ADDR + 4);
 
-        if (!alreadyInjected) _memory->WriteData<int>({GLOBALS + 0x30}, {RNG_ADDR + 4});
-        _memory->WriteData<int>({GLOBALS + 0x30, 0}, {seed});
+    if (!alreadyInjected) _memory->WriteData<int>({GLOBALS + 0x30}, {RNG_ADDR + 4});
+    _memory->WriteData<int>({GLOBALS + 0x30, 0}, {seed});
 
-        // do_success_side_effects
-        _memory->AddSigScan({0xFF, 0xC8, 0x99, 0x2B, 0xC2, 0xD1, 0xF8, 0x8B, 0xD0}, [&](int index) {
-                if (GLOBALS == 0x5B28C0) { // Version differences.
-                        index += 0x3E;
-                } else if (GLOBALS == 0x62D0A0) {
-                        index += 0x42;
-                }
-                // Overwritten bytes start just after the movsxd rax, dword ptr ds:[rdi + 0x230]
-                // aka test eax, eax; jle 2C; imul rcx, rax, 34
-                _memory->WriteData<byte>({index}, {
-                        0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00,                     // mov ecx, [0x00000000] ;This is going to be the address of the custom RNG
-                        0x67, 0xC7, 0x01, 0x00, 0x00, 0x00, 0x00,       // mov dword ptr ds:[ecx], 0x00000000 ;This is going to be the seed value
-                        0x48, 0x83, 0xF8, 0x02,                                         // cmp rax, 0x2 ;This is the short solve on the record player (which turns it off)
-                        0x90, 0x90, 0x90                                                        // nop nop nop
-                });
-                int target = (GLOBALS + 0x30) - (index + 0x6); // +6 is for the length of the line
-                _memory->WriteData<int>({index + 0x2}, {target});
-                _memory->WriteData<int>({index + 0x9}, {seed}); // Because we're resetting seed every challenge, we need to run this injection every time.
-        });
+    // do_success_side_effects
+    _memory->AddSigScan({0xFF, 0xC8, 0x99, 0x2B, 0xC2, 0xD1, 0xF8, 0x8B, 0xD0}, [&](int index) {
+        if (GLOBALS == 0x5B28C0) { // Version differences.
+            index += 0x3E;
+        } else if (GLOBALS == 0x62D0A0) {
+            index += 0x42;
+        }
+        // Overwritten bytes start just after the movsxd rax, dword ptr ds:[rdi + 0x230]
+        // aka test eax, eax; jle 2C; imul rcx, rax, 34
+        _memory->WriteData<byte>({index}, {
+            0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00,            // mov ecx, [0x00000000] ;This is going to be the address of the custom RNG
+            0x67, 0xC7, 0x01, 0x00, 0x00, 0x00, 0x00,    // mov dword ptr ds:[ecx], 0x00000000 ;This is going to be the seed value
+            0x48, 0x83, 0xF8, 0x02,                        // cmp rax, 0x2 ;This is the short solve on the record player (which turns it off)
+            0x90, 0x90, 0x90                            // nop nop nop
+        });
+        int target = (GLOBALS + 0x30) - (index + 0x6); // +6 is for the length of the line
+        _memory->WriteData<int>({index + 0x2}, {target});
+        _memory->WriteData<int>({index + 0x9}, {seed}); // Because we're resetting seed every challenge, we need to run this injection every time.
+    });
 
-        if (!alreadyInjected) {
-                // shuffle_integers
-                _memory->AddSigScan({0x48, 0x89, 0x5C, 0x24, 0x10, 0x56, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x63, 0xDA, 0x48, 0x8B, 0xF1, 0x83, 0xFB, 0x01}, [&](int index) {
-                        AdjustRng(index + 0x23);
-                });
-                // shuffle<int>
-                _memory->AddSigScan({0x33, 0xF6, 0x48, 0x8B, 0xD9, 0x39, 0x31, 0x7E, 0x51}, [&](int index) {
-                        AdjustRng(index - 0x4);
-                });
-                // cut_random_edges
-                _memory->AddSigScan({0x89, 0x44, 0x24, 0x3C, 0x33, 0xC0, 0x85, 0xC0, 0x75, 0xFA}, [&](int index) {
-                        AdjustRng(index + 0x3B);
-                });
-                // get_empty_decoration_slot
-                _memory->AddSigScan({0x42, 0x83, 0x3C, 0x80, 0x00, 0x75, 0xDF}, [&](int index) {
-                        AdjustRng(index - 0x17);
-                });
-                // get_empty_dot_spot
-                _memory->AddSigScan({0xF7, 0xF3, 0x85, 0xD2, 0x74, 0xEC}, [&](int index) {
-                        AdjustRng(index - 0xB);
-                });
-                // add_exactly_this_many_bisection_dots
-                _memory->AddSigScan({0x48, 0x8B, 0xB4, 0x24, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xBC, 0x24, 0xB0, 0x00, 0x00, 0x00}, [&](int index) {
-                        AdjustRng(index - 0x4);
-                });
-                // make_a_shaper
-                _memory->AddSigScan({0xF7, 0xE3, 0xD1, 0xEA, 0x8D, 0x0C, 0x52}, [&](int index) {
-                        AdjustRng(index - 0x10);
-                        AdjustRng(index + 0x1C);
-                        AdjustRng(index + 0x49);
-                });
-                // Entity_Machine_Panel::init_pattern_data_lotus
-                _memory->AddSigScan({0x40, 0x55, 0x56, 0x48, 0x8D, 0x6C, 0x24, 0xB1}, [&](int index) {
-                        AdjustRng(index + 0x433);
-                        AdjustRng(index + 0x45B);
-                        AdjustRng(index + 0x5A7);
-                        AdjustRng(index + 0x5D6);
-                        AdjustRng(index + 0x6F6);
-                        AdjustRng(index + 0xD17);
-                        AdjustRng(index + 0xFDA);
-                });
-                // Entity_Record_Player::reroll_lotus_eater_stuff
-                _memory->AddSigScan({0xB8, 0xAB, 0xAA, 0xAA, 0xAA, 0x41, 0xC1, 0xE8}, [&](int index) {
-                        AdjustRng(index - 0x13);
-                        AdjustRng(index + 0x34);
-                });
+    if (!alreadyInjected) {
+        // shuffle_integers
+        _memory->AddSigScan({0x48, 0x89, 0x5C, 0x24, 0x10, 0x56, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x63, 0xDA, 0x48, 0x8B, 0xF1, 0x83, 0xFB, 0x01}, [&](int index) {
+            AdjustRng(index + 0x23);
+        });
+        // shuffle<int>
+        _memory->AddSigScan({0x33, 0xF6, 0x48, 0x8B, 0xD9, 0x39, 0x31, 0x7E, 0x51}, [&](int index) {
+            AdjustRng(index - 0x4);
+        });
+        // cut_random_edges
+        _memory->AddSigScan({0x89, 0x44, 0x24, 0x3C, 0x33, 0xC0, 0x85, 0xC0, 0x75, 0xFA}, [&](int index) {
+            AdjustRng(index + 0x3B);
+        });
+        // get_empty_decoration_slot
+        _memory->AddSigScan({0x42, 0x83, 0x3C, 0x80, 0x00, 0x75, 0xDF}, [&](int index) {
+            AdjustRng(index - 0x17);
+        });
+        // get_empty_dot_spot
+        _memory->AddSigScan({0xF7, 0xF3, 0x85, 0xD2, 0x74, 0xEC}, [&](int index) {
+            AdjustRng(index - 0xB);
+        });
+        // add_exactly_this_many_bisection_dots
+        _memory->AddSigScan({0x48, 0x8B, 0xB4, 0x24, 0xB8, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xBC, 0x24, 0xB0, 0x00, 0x00, 0x00}, [&](int index) {
+            AdjustRng(index - 0x4);
+        });
+        // make_a_shaper
+        _memory->AddSigScan({0xF7, 0xE3, 0xD1, 0xEA, 0x8D, 0x0C, 0x52}, [&](int index) {
+            AdjustRng(index - 0x10);
+            AdjustRng(index + 0x1C);
+            AdjustRng(index + 0x49);
+        });
+        // Entity_Machine_Panel::init_pattern_data_lotus
+        _memory->AddSigScan({0x40, 0x55, 0x56, 0x48, 0x8D, 0x6C, 0x24, 0xB1}, [&](int index) {
+            AdjustRng(index + 0x433);
+            AdjustRng(index + 0x45B);
+            AdjustRng(index + 0x5A7);
+            AdjustRng(index + 0x5D6);
+            AdjustRng(index + 0x6F6);
+            AdjustRng(index + 0xD17);
+            AdjustRng(index + 0xFDA);
+        });
+        // Entity_Record_Player::reroll_lotus_eater_stuff
+        _memory->AddSigScan({0xB8, 0xAB, 0xAA, 0xAA, 0xAA, 0x41, 0xC1, 0xE8}, [&](int index) {
+            AdjustRng(index - 0x13);
+            AdjustRng(index + 0x34);
+        });
 
-                // These disable the random locations on timer panels, which would otherwise increment the RNG.
-                // I'm writing 31 C0 (xor eax, eax), then 3 NOPs, which pretends the RNG returns 0.
-                // do_lotus_minutes
-                _memory->AddSigScan({0x0F, 0xBE, 0x6C, 0x08, 0xFF, 0x45}, [&](int index) {
-                        _memory->WriteData<byte>({index + 0x410}, {0x31, 0xC0, 0x90, 0x90, 0x90});
-                });
-                // do_lotus_tenths
-                _memory->AddSigScan({0x00, 0x04, 0x00, 0x00, 0x41, 0x8D, 0x50, 0x09}, [&](int index) {
-                        _memory->WriteData<byte>({index + 0xA2}, {0x31, 0xC0, 0x90, 0x90, 0x90});
-                });
-                // do_lotus_eighths
-                _memory->AddSigScan({0x75, 0xF5, 0x0F, 0xBE, 0x44, 0x08, 0xFF}, [&](int index) {
-                        _memory->WriteData<byte>({index + 0x1AE}, {0x31, 0xC0, 0x90, 0x90, 0x90});
-                });
-        }
+        // These disable the random locations on timer panels, which would otherwise increment the RNG.
+        // I'm writing 31 C0 (xor eax, eax), then 3 NOPs, which pretends the RNG returns 0.
+        // do_lotus_minutes
+        _memory->AddSigScan({0x0F, 0xBE, 0x6C, 0x08, 0xFF, 0x45}, [&](int index) {
+            _memory->WriteData<byte>({index + 0x410}, {0x31, 0xC0, 0x90, 0x90, 0x90});
+        });
+        // do_lotus_tenths
+        _memory->AddSigScan({0x00, 0x04, 0x00, 0x00, 0x41, 0x8D, 0x50, 0x09}, [&](int index) {
+            _memory->WriteData<byte>({index + 0xA2}, {0x31, 0xC0, 0x90, 0x90, 0x90});
+        });
+        // do_lotus_eighths
+        _memory->AddSigScan({0x75, 0xF5, 0x0F, 0xBE, 0x44, 0x08, 0xFF}, [&](int index) {
+            _memory->WriteData<byte>({index + 0x1AE}, {0x31, 0xC0, 0x90, 0x90, 0x90});
+        });
+    }
 
-        int failed = _memory->ExecuteSigScans();
-        if (failed != 0) {
-                std::cout << "Failed " << failed << " sigscans";
-        }
+    int failed = _memory->ExecuteSigScans();
+    if (failed != 0) {
+        std::cout << "Failed " << failed << " sigscans";
+    }
 }
@@ -4,12 +4,12 @@
 
 class ChallengeRandomizer {
 public:
-        ChallengeRandomizer(const std::shared_ptr<Memory>& memory, int seed);
+    ChallengeRandomizer(const std::shared_ptr<Memory>& memory, int seed);
 
 private:
-        void AdjustRng(int offset);
-        std::shared_ptr<Memory> _memory;
+    void AdjustRng(int offset);
+    std::shared_ptr<Memory> _memory;
 
-        int RNG_ADDR;
-        int RNG2_ADDR;
+    int RNG_ADDR;
+    int RNG2_ADDR;
 };
@@ -73,124 +73,124 @@ void Memory::Heartbeat(HWND window) {
 
 [[nodiscard]]
 bool Memory::Initialize() {
-        // First, get the handle of the process
-        PROCESSENTRY32W entry;
-        entry.dwSize = sizeof(entry);
-        HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-        while (Process32NextW(snapshot, &entry)) {
-                if (_processName == entry.szExeFile) {
-                        _handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, entry.th32ProcessID);
-                        break;
-                }
-        }
-        if (!_handle) {
-                std::cerr << "Couldn't find " << _processName.c_str() << ", is it open?" << std::endl;
+    // First, get the handle of the process
+    PROCESSENTRY32W entry;
+    entry.dwSize = sizeof(entry);
+    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+    while (Process32NextW(snapshot, &entry)) {
+        if (_processName == entry.szExeFile) {
+            _handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, entry.th32ProcessID);
+            break;
+        }
+    }
+    if (!_handle) {
+        std::cerr << "Couldn't find " << _processName.c_str() << ", is it open?" << std::endl;
         return false;
-        }
-
-        // Next, get the process base address
-        DWORD numModules;
-        std::vector<HMODULE> moduleList(1024);
-        EnumProcessModulesEx(_handle, &moduleList[0], static_cast<DWORD>(moduleList.size()), &numModules, 3);
-
-        std::wstring name(64, '\0');
-        for (DWORD i = 0; i < numModules / sizeof(HMODULE); i++) {
-                int length = GetModuleBaseNameW(_handle, moduleList[i], &name[0], static_cast<DWORD>(name.size()));
-                name.resize(length);
-                if (_processName == name) {
-                        _baseAddress = (uintptr_t)moduleList[i];
-                        break;
-                }
-        }
-        if (_baseAddress == 0) {
+    }
+
+    // Next, get the process base address
+    DWORD numModules;
+    std::vector<HMODULE> moduleList(1024);
+    EnumProcessModulesEx(_handle, &moduleList[0], static_cast<DWORD>(moduleList.size()), &numModules, 3);
+
+    std::wstring name(64, '\0');
+    for (DWORD i = 0; i < numModules / sizeof(HMODULE); i++) {
+        int length = GetModuleBaseNameW(_handle, moduleList[i], &name[0], static_cast<DWORD>(name.size()));
+        name.resize(length);
+        if (_processName == name) {
+            _baseAddress = (uintptr_t)moduleList[i];
+            break;
+        }
+    }
+    if (_baseAddress == 0) {
         std::cerr << "Couldn't locate base address" << std::endl;
         return false;
-        }
+    }
 
     return true;
 }
 
 void Memory::AddSigScan(const std::vector<byte>& scanBytes, const std::function<void(int index)>& scanFunc)
 {
-        _sigScans[scanBytes] = {scanFunc, false};
+    _sigScans[scanBytes] = {scanFunc, false};
 }
 
 int find(const std::vector<byte> &data, const std::vector<byte>& search, size_t startIndex = 0) {
-        for (size_t i=startIndex; i<data.size() - search.size(); i++) {
-                bool match = true;
-                for (size_t j=0; j<search.size(); j++) {
-                        if (data[i+j] == search[j]) {
-                                continue;
-                        }
-                        match = false;
-                        break;
-                }
-                if (match) return static_cast<int>(i);
-        }
-        return -1;
+    for (size_t i=startIndex; i<data.size() - search.size(); i++) {
+        bool match = true;
+        for (size_t j=0; j<search.size(); j++) {
+            if (data[i+j] == search[j]) {
+                continue;
+            }
+            match = false;
+            break;
+        }
+        if (match) return static_cast<int>(i);
+    }
+    return -1;
 }
 
 int Memory::ExecuteSigScans()
 {
-        for (int i=0; i<0x200000; i+=0x1000) {
-                std::vector<byte> data = ReadData<byte>({i}, 0x1100);
-
-                for (auto& [scanBytes, sigScan] : _sigScans) {
-                        if (sigScan.found) continue;
-                        int index = find(data, scanBytes);
-                        if (index == -1) continue;
-                        sigScan.scanFunc(i + index);
-                        sigScan.found = true;
-                }
-        }
-
-        int notFound = 0;
-        for (auto it : _sigScans) {
-                if (it.second.found == false) notFound++;
-        }
-        return notFound;
+    for (int i=0; i<0x200000; i+=0x1000) {
+        std::vector<byte> data = ReadData<byte>({i}, 0x1100);
+
+        for (auto& [scanBytes, sigScan] : _sigScans) {
+            if (sigScan.found) continue;
+            int index = find(data, scanBytes);
+            if (index == -1) continue;
+            sigScan.scanFunc(i + index);
+            sigScan.found = true;
+        }
+    }
+
+    int notFound = 0;
+    for (auto it : _sigScans) {
+        if (it.second.found == false) notFound++;
+    }
+    return notFound;
 }
 
 void Memory::ThrowError() {
-        std::wstring message(256, '\0');
+    std::wstring message(256, '\0');
     DWORD error = GetLastError();
-        int length = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, error, 1024, &message[0], static_cast<DWORD>(message.size()), nullptr);
-        message.resize(length);
+    int length = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, error, 1024, &message[0], static_cast<DWORD>(message.size()), nullptr);
+    message.resize(length);
 #ifndef NDEBUG
     MessageBox(NULL, message.c_str(), L"Please tell darkid about this", MB_OK);
 #endif
 }
 
 void* Memory::ComputeOffset(std::vector<int> offsets) {
-        // Leave off the last offset, since it will be either read/write, and may not be of type uintptr_t.
-        int final_offset = offsets.back();
-        offsets.pop_back();
+    // Leave off the last offset, since it will be either read/write, and may not be of type uintptr_t.
+    int final_offset = offsets.back();
+    offsets.pop_back();
 
-        uintptr_t cumulativeAddress = _baseAddress;
-        for (const int offset : offsets) {
-                cumulativeAddress += offset;
+    uintptr_t cumulativeAddress = _baseAddress;
+    for (const int offset : offsets) {
+        cumulativeAddress += offset;
 
-                const auto search = _computedAddresses.find(cumulativeAddress);
+        const auto search = _computedAddresses.find(cumulativeAddress);
         // This is an issue with re-randomization. Always. Just disable it in debug mode!
 #ifdef NDEBUG
-            if (search == std::end(_computedAddresses)) {
+        if (search == std::end(_computedAddresses)) {
 #endif
-                        // If the address is not yet computed, then compute it.
-                        uintptr_t computedAddress = 0;
-                        if (bool result = !ReadProcessMemory(_handle, reinterpret_cast<LPVOID>(cumulativeAddress), &computedAddress, sizeof(uintptr_t), NULL)) {
-                                ThrowError();
-                        }
+            // If the address is not yet computed, then compute it.
+            uintptr_t computedAddress = 0;
+            if (bool result = !ReadProcessMemory(_handle, reinterpret_cast<LPVOID>(cumulativeAddress), &computedAddress, sizeof(uintptr_t), NULL)) {
+                ThrowError();
+            }
             if (computedAddress == 0) { // Attempting to dereference a nullptr
                 ThrowError();
             }
-                        _computedAddresses[cumulativeAddress] = computedAddress;
+            _computedAddresses[cumulativeAddress] = computedAddress;
 #ifdef NDEBUG
-                }
+        }
 #endif
 
-                cumulativeAddress = _computedAddresses[cumulativeAddress];
-        }
-        return reinterpret_cast<void*>(cumulativeAddress + final_offset);
+        cumulativeAddress = _computedAddresses[cumulativeAddress];
+    }
+    return reinterpret_cast<void*>(cumulativeAddress + final_offset);
 }
 
 uintptr_t Memory::Allocate(size_t bytes) {
@@ -3,752 +3,752 @@
 
 // Some of these (the puzzle ones) are duplicated elsewhere
 std::vector<int> lasers = {
-        0x0360D, // Symmetry
-        0x03615, // Swamp
-        0x09DE0, // Bunker
-        0x17CA4, // Monastery
-        0x032F5, // Town
-        0x03613, // Treehouse
-        0x0360E, // Keep Front Laser
-//      0x03317, // Keep Back Laser
-//      0x03608, // Desert
-        0x03612, // Quarry
-        0x03616, // Jungle
-        0x19650, // Shadows
+    0x0360D, // Symmetry
+    0x03615, // Swamp
+    0x09DE0, // Bunker
+    0x17CA4, // Monastery
+    0x032F5, // Town
+    0x03613, // Treehouse
+    0x0360E, // Keep Front Laser
+//    0x03317, // Keep Back Laser
+//    0x03608, // Desert
+    0x03612, // Quarry
+    0x03616, // Jungle
+    0x19650, // Shadows
 };
 
 // Note: Some of these (non-controls) are duplicated elsewhere
 // TODO: Gave up
 std::vector<int> leftRightPanels = {
-        0x01A54, // Glass Factory Entry
-        0x00086, // Glass Factory Vertical Symmetry 1
-        0x00087, // Glass Factory Vertical Symmetry 2
-        0x00059, // Glass Factory Vertical Symmetry 3
-        0x00062, // Glass Factory Vertical Symmetry 4
-        0x00025, // Symmetry Island Black Dots 4
-        0x00026, // Symmetry Island Black Dots 5
-        0x00072, // Symmetry Island Fading Lines 3
+    0x01A54, // Glass Factory Entry
+    0x00086, // Glass Factory Vertical Symmetry 1
+    0x00087, // Glass Factory Vertical Symmetry 2
+    0x00059, // Glass Factory Vertical Symmetry 3
+    0x00062, // Glass Factory Vertical Symmetry 4
+    0x00025, // Symmetry Island Black Dots 4
+    0x00026, // Symmetry Island Black Dots 5
+    0x00072, // Symmetry Island Fading Lines 3
 
-        0x17D02, // Town Windmill Control
+    0x17D02, // Town Windmill Control
 };
 
 // Note: Some of these (non-controls) are duplicated elsewhere
 std::vector<int> upDownPanels = {
-        0x0008D, // Glass Factory Rotational Symmetry 1
-        0x00081, // Glass Factory Rotational Symmetry 2
-        0x00083, // Glass Factory Rotational Symmetry 3
-        0x00084, // Glass Factory Melting 1
-        0x00070, // Symmetry Island Fading Lines 5
-        0x01E5A, // Mill Entry Door Left
-        0x28AC7, // Town Blue 1
-        0x28AC8, // Town Blue 2
-        0x28ACA, // Town Blue 3
-        0x28ACB, // Town Blue 4
-        0x28ACC, // Town Blue 5
-        0x00029, // UTM Invisible Dots Symmetry 3
-        0x288AA, // UTM Perspective 4
+    0x0008D, // Glass Factory Rotational Symmetry 1
+    0x00081, // Glass Factory Rotational Symmetry 2
+    0x00083, // Glass Factory Rotational Symmetry 3
+    0x00084, // Glass Factory Melting 1
+    0x00070, // Symmetry Island Fading Lines 5
+    0x01E5A, // Mill Entry Door Left
+    0x28AC7, // Town Blue 1
+    0x28AC8, // Town Blue 2
+    0x28ACA, // Town Blue 3
+    0x28ACB, // Town Blue 4
+    0x28ACC, // Town Blue 5
+    0x00029, // UTM Invisible Dots Symmetry 3
+    0x288AA, // UTM Perspective 4
 
-        0x0A3B5, // Tutorial Back Left
-        0x17CC4, // Mill Elevator Control
-//      0x335AB, // UTM In Elevator Control
-//      0x3369D, // UTM Lower Elevator Control
-//      0x335AC, // UTM Upper Elevator Control
+    0x0A3B5, // Tutorial Back Left
+    0x17CC4, // Mill Elevator Control
+//    0x335AB, // UTM In Elevator Control
+//    0x3369D, // UTM Lower Elevator Control
+//    0x335AC, // UTM Upper Elevator Control
 };
 
 // Note: Some of these (non-controls) are duplicated elsewhere
 std::vector<int> leftForwardRightPanels = {
-        0x00075, // Symmetry Island Colored Dots 3
-        0x288EA, // UTM Perspective 1
-        0x288FC, // UTM Perspective 2
-        0x289E7, // UTM Perspective 3
+    0x00075, // Symmetry Island Colored Dots 3
+    0x288EA, // UTM Perspective 1
+    0x288FC, // UTM Perspective 2
+    0x289E7, // UTM Perspective 3
 
-        0x17DD1, // Treehouse Left Orange 9
-        0x17CE3, // Treehouse Right Orange 4
-        0x17DB7, // Treehouse Right Orange 10
-        0x17E52, // Treehouse Green 4
+    0x17DD1, // Treehouse Left Orange 9
+    0x17CE3, // Treehouse Right Orange 4
+    0x17DB7, // Treehouse Right Orange 10
+    0x17E52, // Treehouse Green 4
 };
 
 std::vector<int> pillars = {
-        0x0383D, // Mountain 3 Left Pillar 1
-        0x0383F, // Mountain 3 Left Pillar 2
-        0x03859, // Mountain 3 Left Pillar 3
-        0x339BB, // Mountain 3 Left Pillar 4
-        0x3C113, // Mountain 3 Left Open Door
-        0x0383A, // Mountain 3 Right Pillar 1
-        0x09E56, // Mountain 3 Right Pillar 2
-        0x09E5A, // Mountain 3 Right Pillar 3
-        0x33961, // Mountain 3 Right Pillar 4
-        0x3C114, // Mountain 3 Right Open Door
-//      0x09DD5, // UTM Challenge Pillar
+    0x0383D, // Mountain 3 Left Pillar 1
+    0x0383F, // Mountain 3 Left Pillar 2
+    0x03859, // Mountain 3 Left Pillar 3
+    0x339BB, // Mountain 3 Left Pillar 4
+    0x3C113, // Mountain 3 Left Open Door
+    0x0383A, // Mountain 3 Right Pillar 1
+    0x09E56, // Mountain 3 Right Pillar 2
+    0x09E5A, // Mountain 3 Right Pillar 3
+    0x33961, // Mountain 3 Right Pillar 4
+    0x3C114, // Mountain 3 Right Open Door
+//    0x09DD5, // UTM Challenge Pillar
 };
 
 std::vector<int> challengePanels = {
-        0x0A332, // Challenge Record Start
-        0x0088E, // Challenge Easy Maze
-        0x00BAF, // Challenge Hard Maze
-        0x00BF3, // Challenge Stones Maze
-        0x00C09, // Challenge Pedestal
-        0x0051F, // Challenge Column Bottom Left
-        0x00524, // Challenge Column Top Right
-        0x00CDB, // Challenge Column Top Left
-        0x00CD4, // Challenge Column Far Panel
-        0x00C80, // Challenge Triple 1 Left
-        0x00CA1, // Challenge Triple 1 Center
-        0x00CB9, // Challenge Triple 1 Right
-        0x00C22, // Challenge Triple 2 Left
-        0x00C59, // Challenge Triple 2 Center
-        0x00C68, // Challenge Triple 2 Right
-//      0x04CB3, // Challenge Left Timer
-//      0x04CB5, // Challenge Middle Timer
-//      0x04CB6, // Challenge Right Timer
-        0x034EC, // Challenge Triangle
-        0x034F4, // Challenge Triangle
-        0x1C31A, // Challenge Left Pillar
-        0x1C319, // Challenge Right Pillar
-//      0x0356B, // Challenge Vault Box
+    0x0A332, // Challenge Record Start
+    0x0088E, // Challenge Easy Maze
+    0x00BAF, // Challenge Hard Maze
+    0x00BF3, // Challenge Stones Maze
+    0x00C09, // Challenge Pedestal
+    0x0051F, // Challenge Column Bottom Left
+    0x00524, // Challenge Column Top Right
+    0x00CDB, // Challenge Column Top Left
+    0x00CD4, // Challenge Column Far Panel
+    0x00C80, // Challenge Triple 1 Left
+    0x00CA1, // Challenge Triple 1 Center
+    0x00CB9, // Challenge Triple 1 Right
+    0x00C22, // Challenge Triple 2 Left
+    0x00C59, // Challenge Triple 2 Center
+    0x00C68, // Challenge Triple 2 Right
+//    0x04CB3, // Challenge Left Timer
+//    0x04CB5, // Challenge Middle Timer
+//    0x04CB6, // Challenge Right Timer
+    0x034EC, // Challenge Triangle
+    0x034F4, // Challenge Triangle
+    0x1C31A, // Challenge Left Pillar
+    0x1C319, // Challenge Right Pillar
+//    0x0356B, // Challenge Vault Box
 };
 
 std::vector<int> mountainMultipanel = {
-        0x09FCC, // Mountain 2 Multipanel 1
-        0x09FCE, // Mountain 2 Multipanel 2
-        0x09FCF, // Mountain 2 Multipanel 3
-        0x09FD0, // Mountain 2 Multipanel 4
-        0x09FD1, // Mountain 2 Multipanel 5
-        0x09FD2, // Mountain 2 Multipanel 6
+    0x09FCC, // Mountain 2 Multipanel 1
+    0x09FCE, // Mountain 2 Multipanel 2
+    0x09FCF, // Mountain 2 Multipanel 3
+    0x09FD0, // Mountain 2 Multipanel 4
+    0x09FD1, // Mountain 2 Multipanel 5
+    0x09FD2, // Mountain 2 Multipanel 6
 };
 
 std::vector<int> squarePanels = {
-        0x00064, // Tutorial Straight
-        0x00182, // Tutorial Bend
-        0x0A3B2, // Tutorial Back Right
-        0x00295, // Tutorial Center Left
-        0x00293, // Tutorial Front Center
-        0x002C2, // Tutorial Front Left
-        0x0005D, // Outside Tutorial Dots Tutorial 1
-        0x0005E, // Outside Tutorial Dots Tutorial 2
-        0x0005F, // Outside Tutorial Dots Tutorial 3
-        0x00060, // Outside Tutorial Dots Tutorial 4
-        0x00061, // Outside Tutorial Dots Tutorial 5
-        0x018AF, // Outside Tutorial Stones Tutorial 1
-        0x0001B, // Outside Tutorial Stones Tutorial 2
-        0x012C9, // Outside Tutorial Stones Tutorial 3
-        0x0001C, // Outside Tutorial Stones Tutorial 4
-        0x0001D, // Outside Tutorial Stones Tutorial 5
-        0x0001E, // Outside Tutorial Stones Tutorial 6
-        0x0001F, // Outside Tutorial Stones Tutorial 7
-        0x00020, // Outside Tutorial Stones Tutorial 8
-        0x00021, // Outside Tutorial Stones Tutorial 9
-        0x033D4, // Outside Tutorial Vault
-        0x0A171, // Tutorial Optional Door 1
-        0x04CA4, // Tutorial Optional Door 2
-        0x17CFB, // Outside Tutorial Discard
-        0x3C12B, // Glass Factory Discard
-        0x01A54, // Glass Factory Entry
-        0x00086, // Glass Factory Vertical Symmetry 1
-        0x00087, // Glass Factory Vertical Symmetry 2
-        0x00059, // Glass Factory Vertical Symmetry 3
-        0x00062, // Glass Factory Vertical Symmetry 4
-        0x0008D, // Glass Factory Rotational Symmetry 1
-        0x00081, // Glass Factory Rotational Symmetry 2
-        0x00083, // Glass Factory Rotational Symmetry 3
-        0x00084, // Glass Factory Melting 1
-        0x00082, // Glass Factory Melting 2
-        0x0343A, // Glass Factory Melting 3
-        0x000B0, // Symmetry Island Door 1
-        0x00022, // Symmetry Island Black Dots 1
-        0x00023, // Symmetry Island Black Dots 2
-        0x00024, // Symmetry Island Black Dots 3
-        0x00025, // Symmetry Island Black Dots 4
-        0x00026, // Symmetry Island Black Dots 5
-        0x0007C, // Symmetry Island Colored Dots 1
-        0x0007E, // Symmetry Island Colored Dots 2
-        0x00075, // Symmetry Island Colored Dots 3
-        0x00073, // Symmetry Island Colored Dots 4
-        0x00077, // Symmetry Island Colored Dots 5
-        0x00079, // Symmetry Island Colored Dots 6
-        0x00065, // Symmetry Island Fading Lines 1
-        0x0006D, // Symmetry Island Fading Lines 2
-        0x00072, // Symmetry Island Fading Lines 3
-        0x0006F, // Symmetry Island Fading Lines 4
-        0x00070, // Symmetry Island Fading Lines 5
-        0x00071, // Symmetry Island Fading Lines 6
-        0x00076, // Symmetry Island Fading Lines 7
-        0x00A52, // Symmetry Island Laser Yellow 1
-        0x00A57, // Symmetry Island Laser Yellow 2
-        0x00A5B, // Symmetry Island Laser Yellow 3
-        0x00A61, // Symmetry Island Laser Blue 1
-        0x00A64, // Symmetry Island Laser Blue 2
-        0x00A68, // Symmetry Island Laser Blue 3
-        0x17CE7, // Desert Discard
-        0x0CC7B, // Desert Vault
-        0x01E5A, // Mill Entry Door Left
-        0x01E59, // Mill Entry Door Right
-        0x00E0C, // Mill Lower Row 1
-        0x01489, // Mill Lower Row 2
-        0x0148A, // Mill Lower Row 3
-        0x014D9, // Mill Lower Row 4
-        0x014E7, // Mill Lower Row 5
-        0x014E8, // Mill Lower Row 6
-        0x00557, // Mill Upper Row 1
-        0x005F1, // Mill Upper Row 2
-        0x00620, // Mill Upper Row 3
-        0x009F5, // Mill Upper Row 4
-        0x0146C, // Mill Upper Row 5
-        0x3C12D, // Mill Upper Row 6
-        0x03686, // Mill Upper Row 7
-        0x014E9, // Mill Upper Row 8
-        0x0367C, // Mill Control Room 1
-        0x3C125, // Mill Control Room 2
-        0x03677, // Mill Stairs Control
-        0x17CF0, // Mill Discard
-        0x03612, // Quarry Laser
-        0x021D5, // Boathouse Ramp Activation Shapers
-        0x034D4, // Boathouse Ramp Activation Stars
-        0x021B3, // Boathouse Erasers and Shapers 1
-        0x021B4, // Boathouse Erasers and Shapers 2
-        0x021B0, // Boathouse Erasers and Shapers 3
-        0x021AF, // Boathouse Erasers and Shapers 4
-        0x021AE, // Boathouse Erasers and Shapers 5
-        0x021B5, // Boathouse Erasers and Stars 1
-        0x021B6, // Boathouse Erasers and Stars 2
-        0x021B7, // Boathouse Erasers and Stars 3
-        0x021BB, // Boathouse Erasers and Stars 4
-        0x09DB5, // Boathouse Erasers and Stars 5
-        0x09DB1, // Boathouse Erasers and Stars 6
-        0x3C124, // Boathouse Erasers and Stars 7
-        0x09DB3, // Boathouse Erasers Shapers and Stars 1
-        0x09DB4, // Boathouse Erasers Shapers and Stars 2
-        0x0A3CB, // Boathouse Erasers Shapers and Stars 3
-        0x0A3CC, // Boathouse Erasers Shapers and Stars 4
-        0x0A3D0, // Boathouse Erasers Shapers and Stars 5
-        0x09E57, // Quarry Entry Gate 1
-        0x17C09, // Quarry Entry Gate 2
-        0x0288C, // Treehouse Door 1
-        0x02886, // Treehouse Door 2
-        0x17D72, // Treehouse Yellow 1
-        0x17D8F, // Treehouse Yellow 2
-        0x17D74, // Treehouse Yellow 3
-        0x17DAC, // Treehouse Yellow 4
-        0x17D9E, // Treehouse Yellow 5
-        0x17DB9, // Treehouse Yellow 6
-        0x17D9C, // Treehouse Yellow 7
-        0x17DC2, // Treehouse Yellow 8
-        0x17DC4, // Treehouse Yellow 9
-        0x0A182, // Treehouse Door 3
-        0x17DC8, // Treehouse First Purple 1
-        0x17DC7, // Treehouse First Purple 2
-        0x17CE4, // Treehouse First Purple 3
-        0x17D2D, // Treehouse First Purple 4
-        0x17D6C, // Treehouse First Purple 5
-        0x17D9B, // Treehouse Second Purple 1
-        0x17D99, // Treehouse Second Purple 2
-        0x17DAA, // Treehouse Second Purple 3
-        0x17D97, // Treehouse Second Purple 4
-        0x17BDF, // Treehouse Second Purple 5
-        0x17D91, // Treehouse Second Purple 6
-        0x17DC6, // Treehouse Second Purple 7
-        0x17DB3, // Treehouse Left Orange 1
-        0x17DB5, // Treehouse Left Orange 2
-        0x17DB6, // Treehouse Left Orange 3
-        0x17DC0, // Treehouse Left Orange 4
-        0x17DD7, // Treehouse Left Orange 5
-        0x17DD9, // Treehouse Left Orange 6
-        0x17DB8, // Treehouse Left Orange 7
-        0x17DDC, // Treehouse Left Orange 8
-        0x17DDE, // Treehouse Left Orange 10
-        0x17DE3, // Treehouse Left Orange 11
-        0x17DEC, // Treehouse Left Orange 12
-        0x17DAE, // Treehouse Left Orange 13
-        0x17DB0, // Treehouse Left Orange 14
-        0x17DDB, // Treehouse Left Orange 15
-        0x17D88, // Treehouse Right Orange 1
-        0x17DB4, // Treehouse Right Orange 2
-        0x17D8C, // Treehouse Right Orange 3
-        0x17DCD, // Treehouse Right Orange 5
-        0x17DB2, // Treehouse Right Orange 6
-        0x17DCC, // Treehouse Right Orange 7
-        0x17DCA, // Treehouse Right Orange 8
-        0x17D8E, // Treehouse Right Orange 9
-        0x17DB1, // Treehouse Right Orange 11
-        0x17DA2, // Treehouse Right Orange 12
-        0x17E3C, // Treehouse Green 1
-        0x17E4D, // Treehouse Green 2
-        0x17E4F, // Treehouse Green 3
-        0x17E5B, // Treehouse Green 5
-        0x17E5F, // Treehouse Green 6
-        0x17E61, // Treehouse Green 7
-        0x17FA9, // Treehouse Green Bridge Discard
-        0x17FA0, // Treehouse Laser Discard
-        0x00139, // Keep Hedges 1
-        0x019DC, // Keep Hedges 2
-        0x019E7, // Keep Hedges 3
-        0x01A0F, // Keep Hedges 4
-        0x0360E, // Keep Front Laser
-        0x03317, // Keep Back Laser
-        0x17D27, // Keep Discard
-        0x17D28, // Shipwreck Discard
-        0x00AFB, // Shipwreck Vault
-        0x2899C, // Town 25 Dots 1
-        0x28A33, // Town 25 Dots 2
-        0x28ABF, // Town 25 Dots 3
-        0x28AC0, // Town 25 Dots 4
-        0x28AC1, // Town 25 Dots 5
-        0x28938, // Town Apple Tree
-        0x28AC7, // Town Blue 1
-        0x28AC8, // Town Blue 2
-        0x28ACA, // Town Blue 3
-        0x28ACB, // Town Blue 4
-        0x28ACC, // Town Blue 5
-        0x28A0D, // Town Church Stars
-        0x28AD9, // Town Eraser
-        0x28998, // Town Green Door
-        0x0A0C8, // Town Orange Crate
-        0x17D01, // Town Orange Crate Discard
-        0x03C08, // Town RGB Stars
-        0x03C0C, // Town RGB Stones
-        0x17C71, // Town Rooftop Discard
-        0x17F5F, // Town Windmill Door
-        0x17F89, // Theater Entrance
-        0x17CF7, // Theater Discard
-        0x33AB2, // Theater Corona Exit
-        0x0A168, // Theater Sun Exit
-        0x00B10, // Monastery Left Door
-        0x00C92, // Monastery Right Door
-        0x17C2E, // Bunker Entry Door
-        0x0056E, // Swamp Entry
-        0x00469, // Swamp Tutorial 1
-        0x00472, // Swamp Tutorial 2
-        0x00262, // Swamp Tutorial 3
-        0x00474, // Swamp Tutorial 4
-        0x00553, // Swamp Tutorial 5
-        0x0056F, // Swamp Tutorial 6
-        0x00390, // Swamp Tutorial 7
-        0x010CA, // Swamp Tutorial 8
-        0x00983, // Swamp Tutorial 9
-        0x00984, // Swamp Tutorial 10
-        0x00986, // Swamp Tutorial 11
-        0x00985, // Swamp Tutorial 12
-        0x00987, // Swamp Tutorial 13
-        0x181A9, // Swamp Tutorial 14
-        0x00982, // Swamp Red 1
-        0x0097F, // Swamp Red 2
-        0x0098F, // Swamp Red 3
-        0x00990, // Swamp Red 4
-        0x17C0D, // Swamp Red Shortcut 1
-        0x17C0E, // Swamp Red Shortcut 2
-        0x00999, // Swamp Discontinuous 1
-        0x0099D, // Swamp Discontinuous 2
-        0x009A0, // Swamp Discontinuous 3
-        0x009A1, // Swamp Discontinuous 4
-        0x00007, // Swamp Rotation Tutorial 1
-        0x00008, // Swamp Rotation Tutorial 2
-        0x00009, // Swamp Rotation Tutorial 3
-        0x0000A, // Swamp Rotation Tutorial 4
-        0x009AB, // Swamp Blue Underwater 1
-        0x009AD, // Swamp Blue Underwater 2
-        0x009AE, // Swamp Blue Underwater 3
-        0x009AF, // Swamp Blue Underwater 4
-        0x00006, // Swamp Blue Underwater 5
-        0x003B2, // Swamp Rotation Advanced 1
-        0x00A1E, // Swamp Rotation Advanced 2
-        0x00C2E, // Swamp Rotation Advanced 3
-        0x00E3A, // Swamp Rotation Advanced 4
-        0x009A6, // Swamp Purple Tetris
-        0x00002, // Swamp Teal Underwater 1
-        0x00004, // Swamp Teal Underwater 2
-        0x00005, // Swamp Teal Underwater 3
-        0x013E6, // Swamp Teal Underwater 4
-        0x00596, // Swamp Teal Underwater 5
-        0x00001, // Swamp Red Underwater 1
-        0x014D2, // Swamp Red Underwater 2
-        0x014D4, // Swamp Red Underwater 3
-        0x014D1, // Swamp Red Underwater 4
-        0x17C05, // Swamp Laser Shortcut 1
-        0x17C02, // Swamp Laser Shortcut 2
-        0x17F9B, // Jungle Discard
-        0x09E73, // Mountain 1 Orange 1
-        0x09E75, // Mountain 1 Orange 2
-        0x09E78, // Mountain 1 Orange 3
-        0x09E79, // Mountain 1 Orange 4
-        0x09E6C, // Mountain 1 Orange 5
-        0x09E6F, // Mountain 1 Orange 6
-        0x09E6B, // Mountain 1 Orange 7
-        0x09EAD, // Mountain 1 Purple 1
-        0x09EAF, // Mountain 1 Purple 2
-        0x09E7A, // Mountain 1 Green 1
-        0x09E71, // Mountain 1 Green 2
-        0x09E72, // Mountain 1 Green 3
-        0x09E69, // Mountain 1 Green 4
-        0x09E7B, // Mountain 1 Green 5
-        0x09FD3, // Mountain 2 Rainbow 1
-        0x09FD4, // Mountain 2 Rainbow 2
-        0x09FD6, // Mountain 2 Rainbow 3
-        0x09FD7, // Mountain 2 Rainbow 4
-        0x17F93, // Mountain 2 Discard
-        0x17FA2, // Mountain 3 Secret Door
-        0x17C42, // Mountainside Discard
-        0x002A6, // Mountainside Vault
-        0x0042D, // Mountaintop River
-        0x00FF8, // UTM Entrance Door
-        0x0A16B, // UTM Green Dots 1
-        0x0A2CE, // UTM Green Dots 2
-        0x0A2D7, // UTM Green Dots 3
-        0x0A2DD, // UTM Green Dots 4
-        0x0A2EA, // UTM Green Dots 5
-        0x17FB9, // UTM Green Dots 6
-        0x0008F, // UTM Invisible Dots 1
-        0x0006B, // UTM Invisible Dots 2
-        0x0008B, // UTM Invisible Dots 3
-        0x0008C, // UTM Invisible Dots 4
-        0x0008A, // UTM Invisible Dots 5
-        0x00089, // UTM Invisible Dots 6
-        0x0006A, // UTM Invisible Dots 7
-        0x0006C, // UTM Invisible Dots 8
-        0x00027, // UTM Invisible Dots Symmetry 1
-        0x00028, // UTM Invisible Dots Symmetry 2
-        0x00029, // UTM Invisible Dots Symmetry 3
-        0x021D7, // UTM Mountainside Shortcut
-        0x00B71, // UTM Quarry
-        0x01A31, // UTM Rainbow
-        0x32962, // UTM Swamp
-        0x32966, // UTM Treehouse
-        0x17CF2, // UTM Waterfall Shortcut
-        0x00A72, // UTM Blue Cave In
-        0x009A4, // UTM Blue Discontinuous
-        0x018A0, // UTM Blue Easy Symmetry
-        0x01A0D, // UTM Blue Hard Symmetry
-        0x008B8, // UTM Blue Left 1
-        0x00973, // UTM Blue Left 2
-        0x0097B, // UTM Blue Left 3
-        0x0097D, // UTM Blue Left 4
-        0x0097E, // UTM Blue Left 5
-        0x00994, // UTM Blue Right Far 1
-        0x334D5, // UTM Blue Right Far 2
-        0x00995, // UTM Blue Right Far 3
-        0x00996, // UTM Blue Right Far 4
-        0x00998, // UTM Blue Right Far 5
-        0x00190, // UTM Blue Right Near 1
-        0x00558, // UTM Blue Right Near 2
-        0x00567, // UTM Blue Right Near 3
-        0x006FE, // UTM Blue Right Near 4
-        0x0A16E, // UTM Challenge Entrance
-        0x039B4, // Tunnels Theater Catwalk
-        0x09E85, // Tunnels Town Shortcut
+    0x00064, // Tutorial Straight
+    0x00182, // Tutorial Bend
+    0x0A3B2, // Tutorial Back Right
+    0x00295, // Tutorial Center Left
+    0x00293, // Tutorial Front Center
+    0x002C2, // Tutorial Front Left
+    0x0005D, // Outside Tutorial Dots Tutorial 1
+    0x0005E, // Outside Tutorial Dots Tutorial 2
+    0x0005F, // Outside Tutorial Dots Tutorial 3
+    0x00060, // Outside Tutorial Dots Tutorial 4
+    0x00061, // Outside Tutorial Dots Tutorial 5
+    0x018AF, // Outside Tutorial Stones Tutorial 1
+    0x0001B, // Outside Tutorial Stones Tutorial 2
+    0x012C9, // Outside Tutorial Stones Tutorial 3
+    0x0001C, // Outside Tutorial Stones Tutorial 4
+    0x0001D, // Outside Tutorial Stones Tutorial 5
+    0x0001E, // Outside Tutorial Stones Tutorial 6
+    0x0001F, // Outside Tutorial Stones Tutorial 7
+    0x00020, // Outside Tutorial Stones Tutorial 8
+    0x00021, // Outside Tutorial Stones Tutorial 9
+    0x033D4, // Outside Tutorial Vault
+    0x0A171, // Tutorial Optional Door 1
+    0x04CA4, // Tutorial Optional Door 2
+    0x17CFB, // Outside Tutorial Discard
+    0x3C12B, // Glass Factory Discard
+    0x01A54, // Glass Factory Entry
+    0x00086, // Glass Factory Vertical Symmetry 1
+    0x00087, // Glass Factory Vertical Symmetry 2
+    0x00059, // Glass Factory Vertical Symmetry 3
+    0x00062, // Glass Factory Vertical Symmetry 4
+    0x0008D, // Glass Factory Rotational Symmetry 1
+    0x00081, // Glass Factory Rotational Symmetry 2
+    0x00083, // Glass Factory Rotational Symmetry 3
+    0x00084, // Glass Factory Melting 1
+    0x00082, // Glass Factory Melting 2
+    0x0343A, // Glass Factory Melting 3
+    0x000B0, // Symmetry Island Door 1
+    0x00022, // Symmetry Island Black Dots 1
+    0x00023, // Symmetry Island Black Dots 2
+    0x00024, // Symmetry Island Black Dots 3
+    0x00025, // Symmetry Island Black Dots 4
+    0x00026, // Symmetry Island Black Dots 5
+    0x0007C, // Symmetry Island Colored Dots 1
+    0x0007E, // Symmetry Island Colored Dots 2
+    0x00075, // Symmetry Island Colored Dots 3
+    0x00073, // Symmetry Island Colored Dots 4
+    0x00077, // Symmetry Island Colored Dots 5
+    0x00079, // Symmetry Island Colored Dots 6
+    0x00065, // Symmetry Island Fading Lines 1
+    0x0006D, // Symmetry Island Fading Lines 2
+    0x00072, // Symmetry Island Fading Lines 3
+    0x0006F, // Symmetry Island Fading Lines 4
+    0x00070, // Symmetry Island Fading Lines 5
+    0x00071, // Symmetry Island Fading Lines 6
+    0x00076, // Symmetry Island Fading Lines 7
+    0x00A52, // Symmetry Island Laser Yellow 1
+    0x00A57, // Symmetry Island Laser Yellow 2
+    0x00A5B, // Symmetry Island Laser Yellow 3
+    0x00A61, // Symmetry Island Laser Blue 1
+    0x00A64, // Symmetry Island Laser Blue 2
+    0x00A68, // Symmetry Island Laser Blue 3
+    0x17CE7, // Desert Discard
+    0x0CC7B, // Desert Vault
+    0x01E5A, // Mill Entry Door Left
+    0x01E59, // Mill Entry Door Right
+    0x00E0C, // Mill Lower Row 1
+    0x01489, // Mill Lower Row 2
+    0x0148A, // Mill Lower Row 3
+    0x014D9, // Mill Lower Row 4
+    0x014E7, // Mill Lower Row 5
+    0x014E8, // Mill Lower Row 6
+    0x00557, // Mill Upper Row 1
+    0x005F1, // Mill Upper Row 2
+    0x00620, // Mill Upper Row 3
+    0x009F5, // Mill Upper Row 4
+    0x0146C, // Mill Upper Row 5
+    0x3C12D, // Mill Upper Row 6
+    0x03686, // Mill Upper Row 7
+    0x014E9, // Mill Upper Row 8
+    0x0367C, // Mill Control Room 1
+    0x3C125, // Mill Control Room 2
+    0x03677, // Mill Stairs Control
+    0x17CF0, // Mill Discard
+    0x03612, // Quarry Laser
+    0x021D5, // Boathouse Ramp Activation Shapers
+    0x034D4, // Boathouse Ramp Activation Stars
+    0x021B3, // Boathouse Erasers and Shapers 1
+    0x021B4, // Boathouse Erasers and Shapers 2
+    0x021B0, // Boathouse Erasers and Shapers 3
+    0x021AF, // Boathouse Erasers and Shapers 4
+    0x021AE, // Boathouse Erasers and Shapers 5
+    0x021B5, // Boathouse Erasers and Stars 1
+    0x021B6, // Boathouse Erasers and Stars 2
+    0x021B7, // Boathouse Erasers and Stars 3
+    0x021BB, // Boathouse Erasers and Stars 4
+    0x09DB5, // Boathouse Erasers and Stars 5
+    0x09DB1, // Boathouse Erasers and Stars 6
+    0x3C124, // Boathouse Erasers and Stars 7
+    0x09DB3, // Boathouse Erasers Shapers and Stars 1
+    0x09DB4, // Boathouse Erasers Shapers and Stars 2
+    0x0A3CB, // Boathouse Erasers Shapers and Stars 3
+    0x0A3CC, // Boathouse Erasers Shapers and Stars 4
+    0x0A3D0, // Boathouse Erasers Shapers and Stars 5
+    0x09E57, // Quarry Entry Gate 1
+    0x17C09, // Quarry Entry Gate 2
+    0x0288C, // Treehouse Door 1
+    0x02886, // Treehouse Door 2
+    0x17D72, // Treehouse Yellow 1
+    0x17D8F, // Treehouse Yellow 2
+    0x17D74, // Treehouse Yellow 3
+    0x17DAC, // Treehouse Yellow 4
+    0x17D9E, // Treehouse Yellow 5
+    0x17DB9, // Treehouse Yellow 6
+    0x17D9C, // Treehouse Yellow 7
+    0x17DC2, // Treehouse Yellow 8
+    0x17DC4, // Treehouse Yellow 9
+    0x0A182, // Treehouse Door 3
+    0x17DC8, // Treehouse First Purple 1
+    0x17DC7, // Treehouse First Purple 2
+    0x17CE4, // Treehouse First Purple 3
+    0x17D2D, // Treehouse First Purple 4
+    0x17D6C, // Treehouse First Purple 5
+    0x17D9B, // Treehouse Second Purple 1
+    0x17D99, // Treehouse Second Purple 2
+    0x17DAA, // Treehouse Second Purple 3
+    0x17D97, // Treehouse Second Purple 4
+    0x17BDF, // Treehouse Second Purple 5
+    0x17D91, // Treehouse Second Purple 6
+    0x17DC6, // Treehouse Second Purple 7
+    0x17DB3, // Treehouse Left Orange 1
+    0x17DB5, // Treehouse Left Orange 2
+    0x17DB6, // Treehouse Left Orange 3
+    0x17DC0, // Treehouse Left Orange 4
+    0x17DD7, // Treehouse Left Orange 5
+    0x17DD9, // Treehouse Left Orange 6
+    0x17DB8, // Treehouse Left Orange 7
+    0x17DDC, // Treehouse Left Orange 8
+    0x17DDE, // Treehouse Left Orange 10
+    0x17DE3, // Treehouse Left Orange 11
+    0x17DEC, // Treehouse Left Orange 12
+    0x17DAE, // Treehouse Left Orange 13
+    0x17DB0, // Treehouse Left Orange 14
+    0x17DDB, // Treehouse Left Orange 15
+    0x17D88, // Treehouse Right Orange 1
+    0x17DB4, // Treehouse Right Orange 2
+    0x17D8C, // Treehouse Right Orange 3
+    0x17DCD, // Treehouse Right Orange 5
+    0x17DB2, // Treehouse Right Orange 6
+    0x17DCC, // Treehouse Right Orange 7
+    0x17DCA, // Treehouse Right Orange 8
+    0x17D8E, // Treehouse Right Orange 9
+    0x17DB1, // Treehouse Right Orange 11
+    0x17DA2, // Treehouse Right Orange 12
+    0x17E3C, // Treehouse Green 1
+    0x17E4D, // Treehouse Green 2
+    0x17E4F, // Treehouse Green 3
+    0x17E5B, // Treehouse Green 5
+    0x17E5F, // Treehouse Green 6
+    0x17E61, // Treehouse Green 7
+    0x17FA9, // Treehouse Green Bridge Discard
+    0x17FA0, // Treehouse Laser Discard
+    0x00139, // Keep Hedges 1
+    0x019DC, // Keep Hedges 2
+    0x019E7, // Keep Hedges 3
+    0x01A0F, // Keep Hedges 4
+    0x0360E, // Keep Front Laser
+    0x03317, // Keep Back Laser
+    0x17D27, // Keep Discard
+    0x17D28, // Shipwreck Discard
+    0x00AFB, // Shipwreck Vault
+    0x2899C, // Town 25 Dots 1
+    0x28A33, // Town 25 Dots 2
+    0x28ABF, // Town 25 Dots 3
+    0x28AC0, // Town 25 Dots 4
+    0x28AC1, // Town 25 Dots 5
+    0x28938, // Town Apple Tree
+    0x28AC7, // Town Blue 1
+    0x28AC8, // Town Blue 2
+    0x28ACA, // Town Blue 3
+    0x28ACB, // Town Blue 4
+    0x28ACC, // Town Blue 5
+    0x28A0D, // Town Church Stars
+    0x28AD9, // Town Eraser
+    0x28998, // Town Green Door
+    0x0A0C8, // Town Orange Crate
+    0x17D01, // Town Orange Crate Discard
+    0x03C08, // Town RGB Stars
+    0x03C0C, // Town RGB Stones
+    0x17C71, // Town Rooftop Discard
+    0x17F5F, // Town Windmill Door
+    0x17F89, // Theater Entrance
+    0x17CF7, // Theater Discard
+    0x33AB2, // Theater Corona Exit
+    0x0A168, // Theater Sun Exit
+    0x00B10, // Monastery Left Door
+    0x00C92, // Monastery Right Door
+    0x17C2E, // Bunker Entry Door
+    0x0056E, // Swamp Entry
+    0x00469, // Swamp Tutorial 1
+    0x00472, // Swamp Tutorial 2
+    0x00262, // Swamp Tutorial 3
+    0x00474, // Swamp Tutorial 4
+    0x00553, // Swamp Tutorial 5
+    0x0056F, // Swamp Tutorial 6
+    0x00390, // Swamp Tutorial 7
+    0x010CA, // Swamp Tutorial 8
+    0x00983, // Swamp Tutorial 9
+    0x00984, // Swamp Tutorial 10
+    0x00986, // Swamp Tutorial 11
+    0x00985, // Swamp Tutorial 12
+    0x00987, // Swamp Tutorial 13
+    0x181A9, // Swamp Tutorial 14
+    0x00982, // Swamp Red 1
+    0x0097F, // Swamp Red 2
+    0x0098F, // Swamp Red 3
+    0x00990, // Swamp Red 4
+    0x17C0D, // Swamp Red Shortcut 1
+    0x17C0E, // Swamp Red Shortcut 2
+    0x00999, // Swamp Discontinuous 1
+    0x0099D, // Swamp Discontinuous 2
+    0x009A0, // Swamp Discontinuous 3
+    0x009A1, // Swamp Discontinuous 4
+    0x00007, // Swamp Rotation Tutorial 1
+    0x00008, // Swamp Rotation Tutorial 2
+    0x00009, // Swamp Rotation Tutorial 3
+    0x0000A, // Swamp Rotation Tutorial 4
+    0x009AB, // Swamp Blue Underwater 1
+    0x009AD, // Swamp Blue Underwater 2
+    0x009AE, // Swamp Blue Underwater 3
+    0x009AF, // Swamp Blue Underwater 4
+    0x00006, // Swamp Blue Underwater 5
+    0x003B2, // Swamp Rotation Advanced 1
+    0x00A1E, // Swamp Rotation Advanced 2
+    0x00C2E, // Swamp Rotation Advanced 3
+    0x00E3A, // Swamp Rotation Advanced 4
+    0x009A6, // Swamp Purple Tetris
+    0x00002, // Swamp Teal Underwater 1
+    0x00004, // Swamp Teal Underwater 2
+    0x00005, // Swamp Teal Underwater 3
+    0x013E6, // Swamp Teal Underwater 4
+    0x00596, // Swamp Teal Underwater 5
+    0x00001, // Swamp Red Underwater 1
+    0x014D2, // Swamp Red Underwater 2
+    0x014D4, // Swamp Red Underwater 3
+    0x014D1, // Swamp Red Underwater 4
+    0x17C05, // Swamp Laser Shortcut 1
+    0x17C02, // Swamp Laser Shortcut 2
+    0x17F9B, // Jungle Discard
+    0x09E73, // Mountain 1 Orange 1
+    0x09E75, // Mountain 1 Orange 2
+    0x09E78, // Mountain 1 Orange 3
+    0x09E79, // Mountain 1 Orange 4
+    0x09E6C, // Mountain 1 Orange 5
+    0x09E6F, // Mountain 1 Orange 6
+    0x09E6B, // Mountain 1 Orange 7
+    0x09EAD, // Mountain 1 Purple 1
+    0x09EAF, // Mountain 1 Purple 2
+    0x09E7A, // Mountain 1 Green 1
+    0x09E71, // Mountain 1 Green 2
+    0x09E72, // Mountain 1 Green 3
+    0x09E69, // Mountain 1 Green 4
+    0x09E7B, // Mountain 1 Green 5
+    0x09FD3, // Mountain 2 Rainbow 1
+    0x09FD4, // Mountain 2 Rainbow 2
+    0x09FD6, // Mountain 2 Rainbow 3
+    0x09FD7, // Mountain 2 Rainbow 4
+    0x17F93, // Mountain 2 Discard
+    0x17FA2, // Mountain 3 Secret Door
+    0x17C42, // Mountainside Discard
+    0x002A6, // Mountainside Vault
+    0x0042D, // Mountaintop River
+    0x00FF8, // UTM Entrance Door
+    0x0A16B, // UTM Green Dots 1
+    0x0A2CE, // UTM Green Dots 2
+    0x0A2D7, // UTM Green Dots 3
+    0x0A2DD, // UTM Green Dots 4
+    0x0A2EA, // UTM Green Dots 5
+    0x17FB9, // UTM Green Dots 6
+    0x0008F, // UTM Invisible Dots 1
+    0x0006B, // UTM Invisible Dots 2
+    0x0008B, // UTM Invisible Dots 3
+    0x0008C, // UTM Invisible Dots 4
+    0x0008A, // UTM Invisible Dots 5
+    0x00089, // UTM Invisible Dots 6
+    0x0006A, // UTM Invisible Dots 7
+    0x0006C, // UTM Invisible Dots 8
+    0x00027, // UTM Invisible Dots Symmetry 1
+    0x00028, // UTM Invisible Dots Symmetry 2
+    0x00029, // UTM Invisible Dots Symmetry 3
+    0x021D7, // UTM Mountainside Shortcut
+    0x00B71, // UTM Quarry
+    0x01A31, // UTM Rainbow
+    0x32962, // UTM Swamp
+    0x32966, // UTM Treehouse
+    0x17CF2, // UTM Waterfall Shortcut
+    0x00A72, // UTM Blue Cave In
+    0x009A4, // UTM Blue Discontinuous
+    0x018A0, // UTM Blue Easy Symmetry
+    0x01A0D, // UTM Blue Hard Symmetry
+    0x008B8, // UTM Blue Left 1
+    0x00973, // UTM Blue Left 2
+    0x0097B, // UTM Blue Left 3
+    0x0097D, // UTM Blue Left 4
+    0x0097E, // UTM Blue Left 5
+    0x00994, // UTM Blue Right Far 1
+    0x334D5, // UTM Blue Right Far 2
+    0x00995, // UTM Blue Right Far 3
+    0x00996, // UTM Blue Right Far 4
+    0x00998, // UTM Blue Right Far 5
+    0x00190, // UTM Blue Right Near 1
+    0x00558, // UTM Blue Right Near 2
+    0x00567, // UTM Blue Right Near 3
+    0x006FE, // UTM Blue Right Near 4
+    0x0A16E, // UTM Challenge Entrance
+    0x039B4, // Tunnels Theater Catwalk
+    0x09E85, // Tunnels Town Shortcut
 };
 
 std::vector<int> desertPanels = {
-        0x00698, // Desert Surface 1
-        0x0048F, // Desert Surface 2
-        0x09F92, // Desert Surface 3
-        0x0A036, // Desert Surface 4
-        0x09DA6, // Desert Surface 5
-        0x0A049, // Desert Surface 6
-        0x0A053, // Desert Surface 7
-        0x09F94, // Desert Surface 8
-        0x00422, // Desert Light 1
-        0x006E3, // Desert Light 2
-        0x0A02D, // Desert Light 3
-        0x00C72, // Desert Pond 1
-        0x0129D, // Desert Pond 2
-        0x008BB, // Desert Pond 3
-        0x0078D, // Desert Pond 4
-        0x18313, // Desert Pond 5
-        0x04D18, // Desert Flood 1
-        0x01205, // Desert Flood 2
-        0x181AB, // Desert Flood 3
-        0x0117A, // Desert Flood 4
-        0x17ECA, // Desert Flood 5
-//      0x18076, // Desert Flood Exit
-//      0x0A15C, // Desert Final Left Convex
-//      0x09FFF, // Desert Final Left Concave
-//      0x0A15F, // Desert Final Near
-        0x012D7, // Desert Final Far
+    0x00698, // Desert Surface 1
+    0x0048F, // Desert Surface 2
+    0x09F92, // Desert Surface 3
+    0x0A036, // Desert Surface 4
+    0x09DA6, // Desert Surface 5
+    0x0A049, // Desert Surface 6
+    0x0A053, // Desert Surface 7
+    0x09F94, // Desert Surface 8
+    0x00422, // Desert Light 1
+    0x006E3, // Desert Light 2
+    0x0A02D, // Desert Light 3
+    0x00C72, // Desert Pond 1
+    0x0129D, // Desert Pond 2
+    0x008BB, // Desert Pond 3
+    0x0078D, // Desert Pond 4
+    0x18313, // Desert Pond 5
+    0x04D18, // Desert Flood 1
+    0x01205, // Desert Flood 2
+    0x181AB, // Desert Flood 3
+    0x0117A, // Desert Flood 4
+    0x17ECA, // Desert Flood 5
+//    0x18076, // Desert Flood Exit
+//    0x0A15C, // Desert Final Left Convex
+//    0x09FFF, // Desert Final Left Concave
+//    0x0A15F, // Desert Final Near
+    0x012D7, // Desert Final Far
 };
 
 std::vector<int> shadowsPanels = {
-        0x198B5, // Shadows Tutorial 1
-        0x198BD, // Shadows Tutorial 2
-        0x198BF, // Shadows Tutorial 3
-        0x19771, // Shadows Tutorial 4
-        0x0A8DC, // Shadows Tutorial 5
-        0x0AC74, // Shadows Tutorial 6
-        0x0AC7A, // Shadows Tutorial 7
-        0x0A8E0, // Shadows Tutorial 8
-        0x386FA, // Shadows Avoid 1
-        0x1C33F, // Shadows Avoid 2
-        0x196E2, // Shadows Avoid 3
-        0x1972A, // Shadows Avoid 4
-        0x19809, // Shadows Avoid 5
-        0x19806, // Shadows Avoid 6
-        0x196F8, // Shadows Avoid 7
-        0x1972F, // Shadows Avoid 8
-        0x19797, // Shadows Follow 1
-        0x1979A, // Shadows Follow 2
-        0x197E0, // Shadows Follow 3
-        0x197E8, // Shadows Follow 4
-        0x197E5, // Shadows Follow 5
-        0x19650, // Shadows Laser
+    0x198B5, // Shadows Tutorial 1
+    0x198BD, // Shadows Tutorial 2
+    0x198BF, // Shadows Tutorial 3
+    0x19771, // Shadows Tutorial 4
+    0x0A8DC, // Shadows Tutorial 5
+    0x0AC74, // Shadows Tutorial 6
+    0x0AC7A, // Shadows Tutorial 7
+    0x0A8E0, // Shadows Tutorial 8
+    0x386FA, // Shadows Avoid 1
+    0x1C33F, // Shadows Avoid 2
+    0x196E2, // Shadows Avoid 3
+    0x1972A, // Shadows Avoid 4
+    0x19809, // Shadows Avoid 5
+    0x19806, // Shadows Avoid 6
+    0x196F8, // Shadows Avoid 7
+    0x1972F, // Shadows Avoid 8
+    0x19797, // Shadows Follow 1
+    0x1979A, // Shadows Follow 2
+    0x197E0, // Shadows Follow 3
+    0x197E8, // Shadows Follow 4
+    0x197E5, // Shadows Follow 5
+    0x19650, // Shadows Laser
 };
 
 std::vector<int> monasteryPanels = {
-        0x00B10, // Monastery Left Door
-        0x00C92, // Monastery Right Door
-        0x00290, // Monastery Exterior 1
-        0x00038, // Monastery Exterior 2
-        0x00037, // Monastery Exterior 3
-//      0x09D9B, // Monastery Bonsai
-        0x193A7, // Monastery Interior 1
-        0x193AA, // Monastery Interior 2
-        0x193AB, // Monastery Interior 3
-        0x193A6, // Monastery Interior 4
-//      0x03713, // Monastery Shortcut
-        0x17CA4, // Monastery Laser
+    0x00B10, // Monastery Left Door
+    0x00C92, // Monastery Right Door
+    0x00290, // Monastery Exterior 1
+    0x00038, // Monastery Exterior 2
+    0x00037, // Monastery Exterior 3
+//    0x09D9B, // Monastery Bonsai
+    0x193A7, // Monastery Interior 1
+    0x193AA, // Monastery Interior 2
+    0x193AB, // Monastery Interior 3
+    0x193A6, // Monastery Interior 4
+//    0x03713, // Monastery Shortcut
+    0x17CA4, // Monastery Laser
 };
 
 std::vector<int> bunkerPanels = {
-        0x09F7D, // Bunker Tutorial 1
-        0x09FDC, // Bunker Tutorial 2
-        0x09FF7, // Bunker Tutorial 3
-        0x09F82, // Bunker Tutorial 4
-        0x09FF8, // Bunker Tutorial 5
-        0x09D9F, // Bunker Advanced 1
-        0x09DA1, // Bunker Advanced 2
-        0x09DA2, // Bunker Advanced 3
-        0x09DAF, // Bunker Advanced 4
-//      0x0A099, // Bunker Glass Door
-        0x0A010, // Bunker Glass 1
-        0x0A01B, // Bunker Glass 2
-        0x0A01F, // Bunker Glass 3
-        0x17E63, // Bunker Ultraviolet 1
-        0x17E67, // Bunker Ultraviolet 2
-        0x34BC5, // Bunker Open Ultraviolet
-        0x34BC6, // Bunker Close Ultraviolet
-        0x0A079, // Bunker Elevator
+    0x09F7D, // Bunker Tutorial 1
+    0x09FDC, // Bunker Tutorial 2
+    0x09FF7, // Bunker Tutorial 3
+    0x09F82, // Bunker Tutorial 4
+    0x09FF8, // Bunker Tutorial 5
+    0x09D9F, // Bunker Advanced 1
+    0x09DA1, // Bunker Advanced 2
+    0x09DA2, // Bunker Advanced 3
+    0x09DAF, // Bunker Advanced 4
+//    0x0A099, // Bunker Glass Door
+    0x0A010, // Bunker Glass 1
+    0x0A01B, // Bunker Glass 2
+    0x0A01F, // Bunker Glass 3
+    0x17E63, // Bunker Ultraviolet 1
+    0x17E67, // Bunker Ultraviolet 2
+    0x34BC5, // Bunker Open Ultraviolet
+    0x34BC6, // Bunker Close Ultraviolet
+    0x0A079, // Bunker Elevator
 };
 
 std::vector<int> junglePanels = {
-        0x002C4, // Jungle Waves 1
-        0x00767, // Jungle Waves 2
-        0x002C6, // Jungle Waves 3
-        0x0070E, // Jungle Waves 4
-        0x0070F, // Jungle Waves 5
-        0x0087D, // Jungle Waves 6
-        0x002C7, // Jungle Waves 7
-//      0x17CAB, // Jungle Pop-up Wall
-        0x0026D, // Jungle Dots 1
-        0x0026E, // Jungle Dots 2
-        0x0026F, // Jungle Dots 3
-        0x00C3F, // Jungle Dots 4
-        0x00C41, // Jungle Dots 5
-        0x014B2, // Jungle Dots 6
-        0x03616, // Jungle Laser
+    0x002C4, // Jungle Waves 1
+    0x00767, // Jungle Waves 2
+    0x002C6, // Jungle Waves 3
+    0x0070E, // Jungle Waves 4
+    0x0070F, // Jungle Waves 5
+    0x0087D, // Jungle Waves 6
+    0x002C7, // Jungle Waves 7
+//    0x17CAB, // Jungle Pop-up Wall
+    0x0026D, // Jungle Dots 1
+    0x0026E, // Jungle Dots 2
+    0x0026F, // Jungle Dots 3
+    0x00C3F, // Jungle Dots 4
+    0x00C41, // Jungle Dots 5
+    0x014B2, // Jungle Dots 6
+    0x03616, // Jungle Laser
 };
 
 std::vector<int> audiologs = {
-        0x3C0F7, // Boat Treehouse Rock
-        0x3C0FD, // Boat Broken Boat
-        0x32A00, // Bunker Green Room
-        0x3C0FE, // Desert Broken Wall
-//      0x338B0, // Easter Egg Ending Briefcase (?)
-//      0x338B7, // Easter Egg Ending Briefcase (?)
-//      0x338AD, // Easter Egg Ending Briefcase (iOS)
-//      0x338A5, // Easter Egg Ending Wine Table
-//      0x338AE, // Easter Egg Ending Briefcase
-//      0x338AF, // Easter Egg Ending Briefcase (?)
-//      0x338A7, // Easter Egg Ending Record
-//      0x338A3, // Easter Egg Ending Countertop
-//      0x338A4, // Easter Egg Ending Sunbathing
-//      0x3C108, // Easter Egg Ending Pool
-//      0x338EF, // Easter Egg Ending Pillow
-//      0x336E5, // Easter Egg Ending Apple
-//      0x338A6, // Easter Egg Ending Purple Flowers
-        0x3C100, // Jungle Entrance Right
-        0x3C0F4, // Jungle Entrance Left
-        0x3C102, // Jungle Laser
-        0x3C10D, // Jungle Beach
-        0x3C10E, // Keep Corridor
-        0x3C10B, // Keep Guitar Amp
-        0x0074F, // Keep Front Wall
-        0x012C7, // Keep Throne
-        0x329FF, // Mill Stairs
-        0x3C106, // Monastery Left Shutters
-        0x33AFF, // Mountain 1 Purple Path Panel
-        0x011F9, // Mountain 1 Junk Column
-        0x00763, // Mountain 1 Blue Panels
-        0x32A08, // Mountain 2 Blue Path Panel
-        0x3C101, // Mountain 3 Giant Floor
-        0x3C0FF, // Mountain 3 Peekaboo
-        0x3C103, // Mountainside Cloud Cycle
-        0x00A0F, // Mountaintop 
-        0x339A9, // Outside Tutorial Discard
-        0x015C0, // Outside Tutorial Stones
-        0x33B36, // Peninsula 
-        0x3C10C, // Shadows Laser
-        0x32A0E, // Shadows Orange Crate
-        0x329FE, // Shipwreck Bridge
-        0x32A07, // Swamp Purple Underwater
-        0x00761, // Swamp Shortcut
-        0x3C109, // Symmetry Island Behind Laser
-        0x33B37, // Symmetry Island Fading Lines
-        0x3C107, // Town Laser Redirect
-        0x3C0F3, // Town Bell Tower
-        0x015B7, // Town Obelisk
-        0x3C10A, // Town Lattice Panel Right
-        0x32A0A, // Town Lattice Panel Left
-        0x015C1, // Treehouse Green Bridge
-        0x3C12A, // Treehouse Shipwreck Shore
-        0x3C104, // Treehouse Docks
-//      0x3C105, // Tunnels Box
-        0x339A8, // Tutorial Patio Roof
-        0x0050A, // Tutorial Gate
-//      0x338BD, // UTM Town Shortcut
-//      0x3C135, // UTM Cave In
-//      0x338C9, // UTM Mountainside Shortcut
-//      0x338D7, // UTM Stairwell
-//      0x338C1, // UTM Challenge Water
-//      0x338CA, // UTM Invisible Dots
+    0x3C0F7, // Boat Treehouse Rock
+    0x3C0FD, // Boat Broken Boat
+    0x32A00, // Bunker Green Room
+    0x3C0FE, // Desert Broken Wall
+//    0x338B0, // Easter Egg Ending Briefcase (?)
+//    0x338B7, // Easter Egg Ending Briefcase (?)
+//    0x338AD, // Easter Egg Ending Briefcase (iOS)
+//    0x338A5, // Easter Egg Ending Wine Table
+//    0x338AE, // Easter Egg Ending Briefcase
+//    0x338AF, // Easter Egg Ending Briefcase (?)
+//    0x338A7, // Easter Egg Ending Record
+//    0x338A3, // Easter Egg Ending Countertop
+//    0x338A4, // Easter Egg Ending Sunbathing
+//    0x3C108, // Easter Egg Ending Pool
+//    0x338EF, // Easter Egg Ending Pillow
+//    0x336E5, // Easter Egg Ending Apple
+//    0x338A6, // Easter Egg Ending Purple Flowers
+    0x3C100, // Jungle Entrance Right
+    0x3C0F4, // Jungle Entrance Left
+    0x3C102, // Jungle Laser
+    0x3C10D, // Jungle Beach
+    0x3C10E, // Keep Corridor
+    0x3C10B, // Keep Guitar Amp
+    0x0074F, // Keep Front Wall
+    0x012C7, // Keep Throne
+    0x329FF, // Mill Stairs
+    0x3C106, // Monastery Left Shutters
+    0x33AFF, // Mountain 1 Purple Path Panel
+    0x011F9, // Mountain 1 Junk Column
+    0x00763, // Mountain 1 Blue Panels
+    0x32A08, // Mountain 2 Blue Path Panel
+    0x3C101, // Mountain 3 Giant Floor
+    0x3C0FF, // Mountain 3 Peekaboo
+    0x3C103, // Mountainside Cloud Cycle
+    0x00A0F, // Mountaintop
+    0x339A9, // Outside Tutorial Discard
+    0x015C0, // Outside Tutorial Stones
+    0x33B36, // Peninsula
+    0x3C10C, // Shadows Laser
+    0x32A0E, // Shadows Orange Crate
+    0x329FE, // Shipwreck Bridge
+    0x32A07, // Swamp Purple Underwater
+    0x00761, // Swamp Shortcut
+    0x3C109, // Symmetry Island Behind Laser
+    0x33B37, // Symmetry Island Fading Lines
+    0x3C107, // Town Laser Redirect
+    0x3C0F3, // Town Bell Tower
+    0x015B7, // Town Obelisk
+    0x3C10A, // Town Lattice Panel Right
+    0x32A0A, // Town Lattice Panel Left
+    0x015C1, // Treehouse Green Bridge
+    0x3C12A, // Treehouse Shipwreck Shore
+    0x3C104, // Treehouse Docks
+//    0x3C105, // Tunnels Box
+    0x339A8, // Tutorial Patio Roof
+    0x0050A, // Tutorial Gate
+//    0x338BD, // UTM Town Shortcut
+//    0x3C135, // UTM Cave In
+//    0x338C9, // UTM Mountainside Shortcut
+//    0x338D7, // UTM Stairwell
+//    0x338C1, // UTM Challenge Water
+//    0x338CA, // UTM Invisible Dots
 };
 
 std::vector<int> orchard {
-        0x00143, // Orchard Apple Tree 1
-        0x0003B, // Orchard Apple Tree 2
-        0x00055, // Orchard Apple Tree 3
-        0x032F7, // Orchard Apple Tree 4
-        0x032FF, // Orchard Apple Tree 5
+    0x00143, // Orchard Apple Tree 1
+    0x0003B, // Orchard Apple Tree 2
+    0x00055, // Orchard Apple Tree 3
+    0x032F7, // Orchard Apple Tree 4
+    0x032FF, // Orchard Apple Tree 5
 };
 
 std::vector<int> transparent {
-        0x009B8, // Symmetry Island Transparent 1
-        0x003E8, // Symmetry Island Transparent 2
-        0x00A15, // Symmetry Island Transparent 3
-        0x00B53, // Symmetry Island Transparent 4
-        0x00B8D, // Symmetry Island Transparent 5
+    0x009B8, // Symmetry Island Transparent 1
+    0x003E8, // Symmetry Island Transparent 2
+    0x00A15, // Symmetry Island Transparent 3
+    0x00B53, // Symmetry Island Transparent 4
+    0x00B8D, // Symmetry Island Transparent 5
 };
 
 // There might be something to do with these, I haven't decided yet.
 std::vector<int> nothingPanels = {
 // Doors & Shortcuts & Shortcut doors & Door controls
-        0x0C339, // Desert Surface Door
-        0x0A249, // Desert Pond Exit Door
-        0x275ED, // Mill EP Door
-        0x17CAC, // Mill Stairs Shortcut Door
-        0x38663, // Boathouse Shortcut
-        0x09E49, // Keep Shadows Shortcut
-        0x0361B, // Keep Tower Shortcut
-        0x334DC, // Shadows Inner Door Control
-        0x334DB, // Shadows Outer Door Control
-        0x2700B, // Treehouse Exterior Door Control
-        0x17CBC, // Treehouse Interior Door Control
-        0x337FA, // Jungle Shortcut
+    0x0C339, // Desert Surface Door
+    0x0A249, // Desert Pond Exit Door
+    0x275ED, // Mill EP Door
+    0x17CAC, // Mill Stairs Shortcut Door
+    0x38663, // Boathouse Shortcut
+    0x09E49, // Keep Shadows Shortcut
+    0x0361B, // Keep Tower Shortcut
+    0x334DC, // Shadows Inner Door Control
+    0x334DB, // Shadows Outer Door Control
+    0x2700B, // Treehouse Exterior Door Control
+    0x17CBC, // Treehouse Interior Door Control
+    0x337FA, // Jungle Shortcut
 
 // Controls (?)
-        0x09FA0, // Desert Surface 3 Control
-        0x09F86, // Desert Surface 8 Control
-        0x1C2DF, // Desert Flood Control Lower Far Left
-        0x1831E, // Desert Flood Control Lower Far Right
-        0x1C260, // Desert Flood Control Lower Near Left
-        0x1831C, // Desert Flood Control Lower Near Right
-        0x1C2F3, // Desert Flood Control Raise Far Left
-        0x1831D, // Desert Flood Control Raise Far Right
-        0x1C2B1, // Desert Flood Control Raise Near Left
-        0x1831B, // Desert Flood Control Raise Near Right
-        0x0A015, // Desert Final Far Control
-        0x03678, // Mill Lower Ramp Contol
-        0x03679, // Mill Lower Lift Control
-        0x03675, // Mill Upper Lift Control
-        0x03676, // Mill Upper Ramp Control
-        0x03852, // Boathouse Ramp Angle Control
-        0x03858, // Boathouse Ramp Position Control
-        0x275FA, // Boathouse Hook Control
-        0x037FF, // Treehouse Drawbridge Control
-        0x09F98, // Town Laser Redirect Control
-        0x334D8, // Town RGB Light Control
-        0x17E2B, // Swamp Flood Gate Control
-        0x00609, // Swamp Surface Sliding Bridge Control
-        0x18488, // Swamp Underwater Sliding Bridge Control
-        0x17C0A, // Swamp Island Control 1
-        0x17E07, // Swamp Island Control 2
-        0x181F5, // Swamp Rotating Bridge Control
+    0x09FA0, // Desert Surface 3 Control
+    0x09F86, // Desert Surface 8 Control
+    0x1C2DF, // Desert Flood Control Lower Far Left
+    0x1831E, // Desert Flood Control Lower Far Right
+    0x1C260, // Desert Flood Control Lower Near Left
+    0x1831C, // Desert Flood Control Lower Near Right
+    0x1C2F3, // Desert Flood Control Raise Far Left
+    0x1831D, // Desert Flood Control Raise Far Right
+    0x1C2B1, // Desert Flood Control Raise Near Left
+    0x1831B, // Desert Flood Control Raise Near Right
+    0x0A015, // Desert Final Far Control
+    0x03678, // Mill Lower Ramp Contol
+    0x03679, // Mill Lower Lift Control
+    0x03675, // Mill Upper Lift Control
+    0x03676, // Mill Upper Ramp Control
+    0x03852, // Boathouse Ramp Angle Control
+    0x03858, // Boathouse Ramp Position Control
+    0x275FA, // Boathouse Hook Control
+    0x037FF, // Treehouse Drawbridge Control
+    0x09F98, // Town Laser Redirect Control
+    0x334D8, // Town RGB Light Control
+    0x17E2B, // Swamp Flood Gate Control
+    0x00609, // Swamp Surface Sliding Bridge Control
+    0x18488, // Swamp Underwater Sliding Bridge Control
+    0x17C0A, // Swamp Island Control 1
+    0x17E07, // Swamp Island Control 2
+    0x181F5, // Swamp Rotating Bridge Control
 
 // Vault Boxes
-        0x03481, // Outside Tutorial Vault Box
-        0x0339E, // Desert Vault Box
-        0x03535, // Shipwreck Vault Box
-        0x03702, // Jungle Vault Box
-        0x03542, // Mountainside Vault Box
-        0x2FAF6, // Tunnels Vault Box
+    0x03481, // Outside Tutorial Vault Box
+    0x0339E, // Desert Vault Box
+    0x03535, // Shipwreck Vault Box
+    0x03702, // Jungle Vault Box
+    0x03542, // Mountainside Vault Box
+    0x2FAF6, // Tunnels Vault Box
 
 // Boat Summons
-        0x17CC8, // Glass Factory Summon Boat
-        0x17CA6, // Boathouse Summon Boat
-        0x17C95, // Treehouse Summon Boat
-        0x0A054, // Town Summon Boat
-        0x09DB8, // Swamp Summon Boat
-        0x17CDF, // Jungle Summon Boat
+    0x17CC8, // Glass Factory Summon Boat
+    0x17CA6, // Boathouse Summon Boat
+    0x17C95, // Treehouse Summon Boat
+    0x0A054, // Town Summon Boat
+    0x09DB8, // Swamp Summon Boat
+    0x17CDF, // Jungle Summon Boat
 
 // Misc
-        0x03629, // Tutorial Gate Open
-        0x09FAA, // Desert Lightswitch
-        0x0C335, // Tutorial Pillar
-        0x0C373, // Tutorial Patio floor
-        0x1C349, // Symmetry Island Door 2 - Collision fails here, sadly
-        0x033EA, // Keep Yellow Pressure Plates
-        0x0A3A8, // Keep Yellow Reset
-        0x01BE9, // Keep Purple Pressure Plates
-        0x0A3B9, // Keep Purple Reset
-        0x01CD3, // Keep Green Pressure Plates
-        0x0A3BB, // Keep Green Reset
-        0x01D3F, // Keep Blue Pressure Plates
-        0x0A3AD, // Keep Blue Reset
-        0x2896A, // Town Bridge
-        0x28A69, // Town Lattice
-        0x28A79, // Town Maze
-        0x28B39, // Town Red Hexagonal
-        0x034E3, // Town Soundproof Dots
-        0x034E4, // Town Soundproof Waves
-        0x079DF, // Town Triple
-        0x00815, // Theater Video Input
-        0x03553, // Theater Tutorial Video
-        0x03552, // Theater Desert Video
-        0x0354E, // Theater Jungle Video
-        0x03549, // Theater Challenge Video
-        0x0354F, // Theater Shipwreck Video
-        0x03545, // Theater Mountain Video
-        0x18590, // Town Transparent
-        0x28AE3, // Town Wire
+    0x03629, // Tutorial Gate Open
+    0x09FAA, // Desert Lightswitch
+    0x0C335, // Tutorial Pillar
+    0x0C373, // Tutorial Patio floor
+    0x1C349, // Symmetry Island Door 2 - Collision fails here, sadly
+    0x033EA, // Keep Yellow Pressure Plates
+    0x0A3A8, // Keep Yellow Reset
+    0x01BE9, // Keep Purple Pressure Plates
+    0x0A3B9, // Keep Purple Reset
+    0x01CD3, // Keep Green Pressure Plates
+    0x0A3BB, // Keep Green Reset
+    0x01D3F, // Keep Blue Pressure Plates
+    0x0A3AD, // Keep Blue Reset
+    0x2896A, // Town Bridge
+    0x28A69, // Town Lattice
+    0x28A79, // Town Maze
+    0x28B39, // Town Red Hexagonal
+    0x034E3, // Town Soundproof Dots
+    0x034E4, // Town Soundproof Waves
+    0x079DF, // Town Triple
+    0x00815, // Theater Video Input
+    0x03553, // Theater Tutorial Video
+    0x03552, // Theater Desert Video
+    0x0354E, // Theater Jungle Video
+    0x03549, // Theater Challenge Video
+    0x0354F, // Theater Shipwreck Video
+    0x03545, // Theater Mountain Video
+    0x18590, // Town Transparent
+    0x28AE3, // Town Wire
 
 
-        0x09E39, // Mountain 1 Purple Pathway
-//      0x33AF5, // Mountain 1 Blue 1
-//      0x33AF7, // Mountain 1 Blue 2
-//      0x09F6E, // Mountain 1 Blue 3
-//      0x09FD8, // Mountain 2 Rainbow 5
-        0x09E86, // Mountain 2 Blue Pathway
-        0x09ED8, // Mountain 2 Orange Pathway
-        0x09F8E, // Mountain 3 Near Right Floor
-        0x09FC1, // Mountain 3 Near Left Floor
-        0x09F01, // Mountain 3 Far Right Floor
-        0x09EFF, // Mountain 3 Far Left Floor
-        0x09FDA, // Mountain 3 Giant Floor
-//      0x01983, // Mountain 3 Left Peekaboo
-//      0x01987, // Mountain 3 Right Peekaboo
-//      0x3D9A6, // Mountain 3 Left Close Door
-//      0x3D9A7, // Mountain 3 Right Close Door
-//      0x3D9AA, // Mountain 3 Left Activate Elevator
-//      0x3D9A8, // Mountain 3 Right Activate Elevator
-//      0x3D9A9, // Mountain 3 Launch Elevator
-//      0x3C113, // Mountain 3 Left Open Door
-//      0x3C114, // Mountain 3 Right Open Door
-        0x09F7F, // Mountaintop Laser Box
-        0x17C34, // Mountaintop Perspective
-//      0x334E1, // UTM Secret Door Control
-//      0x2773D, // Tunnels Desert Shortcut
-//      0x27732, // Tunnels Theater Shortcut
-//      0x0A099, // Bunker Glass Door
-//      0x15ADD, // Jungle Vault
-//      0x17CAA, // Jungle Courtyard Gate
-        0x0005C, // Glass Factory Vertical Symmetry 5
-        0x17C31, // Desert Final Transparent
-        0x19650, // Shadows Laser
-        0x09EEB, // Mountain 2 Elevator
+    0x09E39, // Mountain 1 Purple Pathway
+//    0x33AF5, // Mountain 1 Blue 1
+//    0x33AF7, // Mountain 1 Blue 2
+//    0x09F6E, // Mountain 1 Blue 3
+//    0x09FD8, // Mountain 2 Rainbow 5
+    0x09E86, // Mountain 2 Blue Pathway
+    0x09ED8, // Mountain 2 Orange Pathway
+    0x09F8E, // Mountain 3 Near Right Floor
+    0x09FC1, // Mountain 3 Near Left Floor
+    0x09F01, // Mountain 3 Far Right Floor
+    0x09EFF, // Mountain 3 Far Left Floor
+    0x09FDA, // Mountain 3 Giant Floor
+//    0x01983, // Mountain 3 Left Peekaboo
+//    0x01987, // Mountain 3 Right Peekaboo
+//    0x3D9A6, // Mountain 3 Left Close Door
+//    0x3D9A7, // Mountain 3 Right Close Door
+//    0x3D9AA, // Mountain 3 Left Activate Elevator
+//    0x3D9A8, // Mountain 3 Right Activate Elevator
+//    0x3D9A9, // Mountain 3 Launch Elevator
+//    0x3C113, // Mountain 3 Left Open Door
+//    0x3C114, // Mountain 3 Right Open Door
+    0x09F7F, // Mountaintop Laser Box
+    0x17C34, // Mountaintop Perspective
+//    0x334E1, // UTM Secret Door Control
+//    0x2773D, // Tunnels Desert Shortcut
+//    0x27732, // Tunnels Theater Shortcut
+//    0x0A099, // Bunker Glass Door
+//    0x15ADD, // Jungle Vault
+//    0x17CAA, // Jungle Courtyard Gate
+    0x0005C, // Glass Factory Vertical Symmetry 5
+    0x17C31, // Desert Final Transparent
+    0x19650, // Shadows Laser
+    0x09EEB, // Mountain 2 Elevator
 };
@@ -53,9 +53,9 @@ private:
     std::shared_ptr<Memory> _memory;
 
     std::vector<float> _intersectionLocations;
-        std::vector<int> _intersectionFlags;
-        std::vector<int> _connectionsA;
-        std::vector<int> _connectionsB;
+    std::vector<int> _intersectionFlags;
+    std::vector<int> _connectionsA;
+    std::vector<int> _connectionsB;
     std::vector<std::tuple<int, int, int>> _endpointLocations;
 
     float MIN, MAX, WIDTH_INTERVAL, HEIGHT_INTERVAL, HORIZ_GAP_SIZE, VERTI_GAP_SIZE;
@@ -4,11 +4,11 @@
 int Random::s_seed = static_cast<int>(time(nullptr)); // Seed from the time in milliseconds
 
 void Random::SetSeed(int seed) {
-        s_seed = seed;
+    s_seed = seed;
 }
 
 // Returns a random integer in [min, max]
 int Random::RandInt(int min, int max) {
-        s_seed = (214013 * s_seed + 2531011) % 2147483648;
-        return (s_seed % (max - min + 1)) + min;
+    s_seed = (214013 * s_seed + 2531011) % 2147483648;
+    return (s_seed % (max - min + 1)) + min;
 }
@@ -4,9 +4,9 @@
 class Random
 {
 public:
-        static void SetSeed(int seed);
-        static int RandInt(int min, int max);
+    static void SetSeed(int seed);
+    static int RandInt(int min, int max);
 
 private:
-        static int s_seed;
+    static int s_seed;
 };
@@ -102,356 +102,356 @@ Things to do for V2:
 
 template <class T>
 int find(const std::vector<T> &data, T search, size_t startIndex = 0) {
-        for (size_t i=startIndex ; i<data.size(); i++) {
-                if (data[i] == search) return static_cast<int>(i);
-        }
-        std::cout << "Couldn't find " << search << " in data!" << std::endl;
-        throw std::exception("Couldn't find value in data!");
+    for (size_t i=startIndex ; i<data.size(); i++) {
+        if (data[i] == search) return static_cast<int>(i);
+    }
+    std::cout << "Couldn't find " << search << " in data!" << std::endl;
+    throw std::exception("Couldn't find value in data!");
 }
 
 Randomizer::Randomizer(const std::shared_ptr<Memory>& memory) : _memory(memory) {}
 
 void Randomizer::Randomize() {
-        // reveal_exit_hall - Prevent actually ending the game (EEE)
-        _memory->AddSigScan({0x45, 0x8B, 0xF7, 0x48, 0x8B, 0x4D}, [&](int index){
-                _memory->WriteData<byte>({index + 0x15}, {0xEB}); // jz -> jmp
-        });
-
-        // begin_endgame_1 - Prevent actually ending the game (Wonkavator)
-        _memory->AddSigScan({0x83, 0x7C, 0x01, 0xD0, 0x04}, [&](int index){
-                if (GLOBALS == 0x5B28C0) { // Version differences.
-                        index += 0x75;
-                } else if (GLOBALS == 0x62D0A0) {
-                        index += 0x86;
-                }
-                _memory->WriteData<byte>({index}, {0xEB}); // jz -> jmp
-        });
+    // reveal_exit_hall - Prevent actually ending the game (EEE)
+    _memory->AddSigScan({0x45, 0x8B, 0xF7, 0x48, 0x8B, 0x4D}, [&](int index){
+        _memory->WriteData<byte>({index + 0x15}, {0xEB}); // jz -> jmp
+    });
+
+    // begin_endgame_1 - Prevent actually ending the game (Wonkavator)
+    _memory->AddSigScan({0x83, 0x7C, 0x01, 0xD0, 0x04}, [&](int index){
+        if (GLOBALS == 0x5B28C0) { // Version differences.
+            index += 0x75;
+        } else if (GLOBALS == 0x62D0A0) {
+            index += 0x86;
+        }
+        _memory->WriteData<byte>({index}, {0xEB}); // jz -> jmp
+    });
     // Sig scans will be run during challenge randomization.
 
-        // Seed challenge first for future-proofing
-        RandomizeChallenge();
-
-        // Content swaps -- must happen before squarePanels
-        Randomize(upDownPanels, SWAP::LINES | SWAP::COLORS);
-        Randomize(leftForwardRightPanels, SWAP::LINES | SWAP::COLORS);
-
-        Randomize(squarePanels, SWAP::LINES | SWAP::COLORS);
-
-        // Individual area modifications
-        RandomizeTutorial();
-        RandomizeDesert();
-        RandomizeQuarry();
-        RandomizeTreehouse();
-        RandomizeKeep();
-        RandomizeShadows();
-        RandomizeMonastery();
-        RandomizeBunker();
-        RandomizeJungle();
-        RandomizeSwamp();
-        RandomizeMountain();
-        RandomizeTown();
-        RandomizeSymmetry();
-        // RandomizeAudioLogs();
+    // Seed challenge first for future-proofing
+    RandomizeChallenge();
+
+    // Content swaps -- must happen before squarePanels
+    Randomize(upDownPanels, SWAP::LINES | SWAP::COLORS);
+    Randomize(leftForwardRightPanels, SWAP::LINES | SWAP::COLORS);
+
+    Randomize(squarePanels, SWAP::LINES | SWAP::COLORS);
+
+    // Individual area modifications
+    RandomizeTutorial();
+    RandomizeDesert();
+    RandomizeQuarry();
+    RandomizeTreehouse();
+    RandomizeKeep();
+    RandomizeShadows();
+    RandomizeMonastery();
+    RandomizeBunker();
+    RandomizeJungle();
+    RandomizeSwamp();
+    RandomizeMountain();
+    RandomizeTown();
+    RandomizeSymmetry();
+    // RandomizeAudioLogs();
 }
 
 void Randomizer::AdjustSpeed() {
-        // Desert Surface Final Control
-        _memory->WriteEntityData<float>(0x09F95, OPEN_RATE, {0.04f}); // 4x
-        // Swamp Sliding Bridge
-        _memory->WriteEntityData<float>(0x0061A, OPEN_RATE, {0.1f}); // 4x
-        // Mountain 2 Elevator
-        _memory->WriteEntityData<float>(0x09EEC, OPEN_RATE, {0.075f}); // 3x
+    // Desert Surface Final Control
+    _memory->WriteEntityData<float>(0x09F95, OPEN_RATE, {0.04f}); // 4x
+    // Swamp Sliding Bridge
+    _memory->WriteEntityData<float>(0x0061A, OPEN_RATE, {0.1f}); // 4x
+    // Mountain 2 Elevator
+    _memory->WriteEntityData<float>(0x09EEC, OPEN_RATE, {0.075f}); // 3x
 }
 
 void Randomizer::RandomizeLasers() {
-        Randomize(lasers, SWAP::TARGETS);
-        // Read the target of keep front laser, and write it to keep back laser.
-        std::vector<int> keepFrontLaserTarget = _memory->ReadEntityData<int>(0x0360E, TARGET, 1);
-        _memory->WriteEntityData<int>(0x03317, TARGET, keepFrontLaserTarget);
+    Randomize(lasers, SWAP::TARGETS);
+    // Read the target of keep front laser, and write it to keep back laser.
+    std::vector<int> keepFrontLaserTarget = _memory->ReadEntityData<int>(0x0360E, TARGET, 1);
+    _memory->WriteEntityData<int>(0x03317, TARGET, keepFrontLaserTarget);
 }
 
 void Randomizer::PreventSnipes()
 {
-        // Distance-gate swamp snipe 1 to prevent RNG swamp snipe
-        _memory->WriteEntityData<float>(0x17C05, MAX_BROADCAST_DISTANCE, {15.0});
-        // Distance-gate shadows laser to prevent sniping through the bars
-        _memory->WriteEntityData<float>(0x19650, MAX_BROADCAST_DISTANCE, {2.5});
+    // Distance-gate swamp snipe 1 to prevent RNG swamp snipe
+    _memory->WriteEntityData<float>(0x17C05, MAX_BROADCAST_DISTANCE, {15.0});
+    // Distance-gate shadows laser to prevent sniping through the bars
+    _memory->WriteEntityData<float>(0x19650, MAX_BROADCAST_DISTANCE, {2.5});
 }
 
 // Private methods
 void Randomizer::RandomizeTutorial() {
-        // Disable tutorial cursor speed modifications (not working?)
-        _memory->WriteEntityData<float>(0x00295, CURSOR_SPEED_SCALE, {1.0});
-        _memory->WriteEntityData<float>(0x0C373, CURSOR_SPEED_SCALE, {1.0});
-        _memory->WriteEntityData<float>(0x00293, CURSOR_SPEED_SCALE, {1.0});
-        _memory->WriteEntityData<float>(0x002C2, CURSOR_SPEED_SCALE, {1.0});
+    // Disable tutorial cursor speed modifications (not working?)
+    _memory->WriteEntityData<float>(0x00295, CURSOR_SPEED_SCALE, {1.0});
+    _memory->WriteEntityData<float>(0x0C373, CURSOR_SPEED_SCALE, {1.0});
+    _memory->WriteEntityData<float>(0x00293, CURSOR_SPEED_SCALE, {1.0});
+    _memory->WriteEntityData<float>(0x002C2, CURSOR_SPEED_SCALE, {1.0});
 }
 
 void Randomizer::RandomizeSymmetry() {
-        std::vector<int> randomOrder(transparent.size(), 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        RandomizeRange(randomOrder, SWAP::NONE, 1, 5);
-        ReassignTargets(transparent, randomOrder);
+    std::vector<int> randomOrder(transparent.size(), 0);
+    std::iota(randomOrder.begin(), randomOrder.end(), 0);
+    RandomizeRange(randomOrder, SWAP::NONE, 1, 5);
+    ReassignTargets(transparent, randomOrder);
 }
 
 void Randomizer::RandomizeDesert() {
-        Randomize(desertPanels, SWAP::LINES);
-
-        // Turn off desert surface 8
-        _memory->WriteEntityData<float>(0x09F94, POWER, {0.0, 0.0});
-        // Turn off desert flood final
-        _memory->WriteEntityData<float>(0x18076, POWER, {0.0, 0.0});
-        // Change desert floating target to desert flood final
-        _memory->WriteEntityData<int>(0x17ECA, TARGET, {0x18077});
+    Randomize(desertPanels, SWAP::LINES);
+
+    // Turn off desert surface 8
+    _memory->WriteEntityData<float>(0x09F94, POWER, {0.0, 0.0});
+    // Turn off desert flood final
+    _memory->WriteEntityData<float>(0x18076, POWER, {0.0, 0.0});
+    // Change desert floating target to desert flood final
+    _memory->WriteEntityData<int>(0x17ECA, TARGET, {0x18077});
 }
 
 void Randomizer::RandomizeQuarry() {
 }
 
 void Randomizer::RandomizeTreehouse() {
-        // Ensure that whatever pivot panels we have are flagged as "pivotable"
-        int panelFlags = _memory->ReadEntityData<int>(0x17DD1, STYLE_FLAGS, 1)[0];
-        _memory->WriteEntityData<int>(0x17DD1, STYLE_FLAGS, {panelFlags | 0x8000});
-        panelFlags = _memory->ReadEntityData<int>(0x17CE3, STYLE_FLAGS, 1)[0];
-        _memory->WriteEntityData<int>(0x17CE3, STYLE_FLAGS, {panelFlags | 0x8000});
-        panelFlags = _memory->ReadEntityData<int>(0x17DB7, STYLE_FLAGS, 1)[0];
-        _memory->WriteEntityData<int>(0x17DB7, STYLE_FLAGS, {panelFlags | 0x8000});
-        panelFlags = _memory->ReadEntityData<int>(0x17E52, STYLE_FLAGS, 1)[0];
-        _memory->WriteEntityData<int>(0x17E52, STYLE_FLAGS, {panelFlags | 0x8000});
+    // Ensure that whatever pivot panels we have are flagged as "pivotable"
+    int panelFlags = _memory->ReadEntityData<int>(0x17DD1, STYLE_FLAGS, 1)[0];
+    _memory->WriteEntityData<int>(0x17DD1, STYLE_FLAGS, {panelFlags | 0x8000});
+    panelFlags = _memory->ReadEntityData<int>(0x17CE3, STYLE_FLAGS, 1)[0];
+    _memory->WriteEntityData<int>(0x17CE3, STYLE_FLAGS, {panelFlags | 0x8000});
+    panelFlags = _memory->ReadEntityData<int>(0x17DB7, STYLE_FLAGS, 1)[0];
+    _memory->WriteEntityData<int>(0x17DB7, STYLE_FLAGS, {panelFlags | 0x8000});
+    panelFlags = _memory->ReadEntityData<int>(0x17E52, STYLE_FLAGS, 1)[0];
+    _memory->WriteEntityData<int>(0x17E52, STYLE_FLAGS, {panelFlags | 0x8000});
 }
 
 void Randomizer::RandomizeKeep() {
 }
 
 void Randomizer::RandomizeShadows() {
-        // Change the shadows tutorial cable to only activate avoid
-        _memory->WriteEntityData<int>(0x319A8, CABLE_TARGET_2, {0});
-        // Change shadows avoid 8 to power shadows follow
-        _memory->WriteEntityData<int>(0x1972F, TARGET, {0x1C34C});
-
-        std::vector<int> randomOrder(shadowsPanels.size(), 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        RandomizeRange(randomOrder, SWAP::NONE, 0, 8); // Tutorial
-        RandomizeRange(randomOrder, SWAP::NONE, 8, 16); // Avoid
-        RandomizeRange(randomOrder, SWAP::NONE, 16, 21); // Follow
-        ReassignTargets(shadowsPanels, randomOrder);
-        // Turn off original starting panel
-        _memory->WriteEntityData<float>(shadowsPanels[0], POWER, {0.0f, 0.0f});
-        // Turn on new starting panel
-        _memory->WriteEntityData<float>(shadowsPanels[randomOrder[0]], POWER, {1.0f, 1.0f});
+    // Change the shadows tutorial cable to only activate avoid
+    _memory->WriteEntityData<int>(0x319A8, CABLE_TARGET_2, {0});
+    // Change shadows avoid 8 to power shadows follow
+    _memory->WriteEntityData<int>(0x1972F, TARGET, {0x1C34C});
+
+    std::vector<int> randomOrder(shadowsPanels.size(), 0);
+    std::iota(randomOrder.begin(), randomOrder.end(), 0);
+    RandomizeRange(randomOrder, SWAP::NONE, 0, 8); // Tutorial
+    RandomizeRange(randomOrder, SWAP::NONE, 8, 16); // Avoid
+    RandomizeRange(randomOrder, SWAP::NONE, 16, 21); // Follow
+    ReassignTargets(shadowsPanels, randomOrder);
+    // Turn off original starting panel
+    _memory->WriteEntityData<float>(shadowsPanels[0], POWER, {0.0f, 0.0f});
+    // Turn on new starting panel
+    _memory->WriteEntityData<float>(shadowsPanels[randomOrder[0]], POWER, {1.0f, 1.0f});
 }
 
 void Randomizer::RandomizeTown() {
     // @Hack...? To open the gate at the end
-        std::vector<int> randomOrder(orchard.size() + 1, 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        RandomizeRange(randomOrder, SWAP::NONE, 1, 5);
+    std::vector<int> randomOrder(orchard.size() + 1, 0);
+    std::iota(randomOrder.begin(), randomOrder.end(), 0);
+    RandomizeRange(randomOrder, SWAP::NONE, 1, 5);
     // Ensure that we open the gate before the final puzzle (by swapping)
     int panel3Index = find(randomOrder, 3);
     int panel4Index = find(randomOrder, 4);
     randomOrder[min(panel3Index, panel4Index)] = 3;
     randomOrder[max(panel3Index, panel4Index)] = 4;
-        ReassignTargets(orchard, randomOrder);
+    ReassignTargets(orchard, randomOrder);
 }
 
 void Randomizer::RandomizeMonastery() {
-        std::vector<int> randomOrder(monasteryPanels.size(), 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        RandomizeRange(randomOrder, SWAP::NONE, 3, 9); // Outer 2 & 3, Inner 1-4
-        ReassignTargets(monasteryPanels, randomOrder);
+    std::vector<int> randomOrder(monasteryPanels.size(), 0);
+    std::iota(randomOrder.begin(), randomOrder.end(), 0);
+    RandomizeRange(randomOrder, SWAP::NONE, 3, 9); // Outer 2 & 3, Inner 1-4
+    ReassignTargets(monasteryPanels, randomOrder);
 }
 
 void Randomizer::RandomizeBunker() {
-        std::vector<int> randomOrder(bunkerPanels.size(), 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        // Randomize Tutorial 2-Advanced Tutorial 4 + Glass 1
-        // Tutorial 1 cannot be randomized, since no other panel can start on
-        // Glass 1 will become door + glass 1, due to the targetting system
-        RandomizeRange(randomOrder, SWAP::NONE, 1, 10);
-        // Randomize Glass 1-3 into everything after the door/glass 1
-        const size_t glass1Index = find(randomOrder, 9);
-        RandomizeRange(randomOrder, SWAP::NONE, glass1Index + 1, 12);
-        ReassignTargets(bunkerPanels, randomOrder);
+    std::vector<int> randomOrder(bunkerPanels.size(), 0);
+    std::iota(randomOrder.begin(), randomOrder.end(), 0);
+    // Randomize Tutorial 2-Advanced Tutorial 4 + Glass 1
+    // Tutorial 1 cannot be randomized, since no other panel can start on
+    // Glass 1 will become door + glass 1, due to the targetting system
+    RandomizeRange(randomOrder, SWAP::NONE, 1, 10);
+    // Randomize Glass 1-3 into everything after the door/glass 1
+    const size_t glass1Index = find(randomOrder, 9);
+    RandomizeRange(randomOrder, SWAP::NONE, glass1Index + 1, 12);
+    ReassignTargets(bunkerPanels, randomOrder);
 }
 
 void Randomizer::RandomizeJungle() {
-        std::vector<int> randomOrder(junglePanels.size(), 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        // Waves 1 cannot be randomized, since no other panel can start on
-        RandomizeRange(randomOrder, SWAP::NONE, 1, 7); // Waves 2-7
-        RandomizeRange(randomOrder, SWAP::NONE, 8, 13); // Pitches 1-6
-        ReassignTargets(junglePanels, randomOrder);
-
-        // Fix the wall's target to point back to the cable, and the cable to point to the pitches panel.
-        // auto wallTarget = _memory->ReadPanelData<int>(junglePanels[7], TARGET, 1);
-        // _memory->WritePanelData<int>(junglePanels[7], TARGET, {0x3C113});
-        // _memory->WritePanelData<int>(0x3C112, CABLE_TARGET_1, wallTarget);
+    std::vector<int> randomOrder(junglePanels.size(), 0);
+    std::iota(randomOrder.begin(), randomOrder.end(), 0);
+    // Waves 1 cannot be randomized, since no other panel can start on
+    RandomizeRange(randomOrder, SWAP::NONE, 1, 7); // Waves 2-7
+    RandomizeRange(randomOrder, SWAP::NONE, 8, 13); // Pitches 1-6
+    ReassignTargets(junglePanels, randomOrder);
+
+    // Fix the wall's target to point back to the cable, and the cable to point to the pitches panel.
+    // auto wallTarget = _memory->ReadPanelData<int>(junglePanels[7], TARGET, 1);
+    // _memory->WritePanelData<int>(junglePanels[7], TARGET, {0x3C113});
+    // _memory->WritePanelData<int>(0x3C112, CABLE_TARGET_1, wallTarget);
 }
 
 void Randomizer::RandomizeSwamp() {
 }
 
 void Randomizer::RandomizeMountain() {
-        // Randomize multipanel
-        Randomize(mountainMultipanel, SWAP::LINES | SWAP::COLORS);
-
-        // Randomize final pillars order
-        std::vector<int> targets = {pillars[0] + 1};
-        for (const int pillar : pillars) {
-                int target = _memory->ReadEntityData<int>(pillar, TARGET, 1)[0];
-                targets.push_back(target);
-        }
-        targets[5] = pillars[5] + 1;
-
-        std::vector<int> randomOrder(pillars.size(), 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        RandomizeRange(randomOrder, SWAP::NONE, 0, 4); // Left Pillars 1-4
-        RandomizeRange(randomOrder, SWAP::NONE, 5, 9); // Right Pillars 1-4
-        ReassignTargets(pillars, randomOrder, targets);
-        // Turn off original starting panels
-        _memory->WriteEntityData<float>(pillars[0], POWER, {0.0f, 0.0f});
-        _memory->WriteEntityData<float>(pillars[5], POWER, {0.0f, 0.0f});
-        // Turn on new starting panels
-        _memory->WriteEntityData<float>(pillars[randomOrder[0]], POWER, {1.0f, 1.0f});
-        _memory->WriteEntityData<float>(pillars[randomOrder[5]], POWER, {1.0f, 1.0f});
+    // Randomize multipanel
+    Randomize(mountainMultipanel, SWAP::LINES | SWAP::COLORS);
+
+    // Randomize final pillars order
+    std::vector<int> targets = {pillars[0] + 1};
+    for (const int pillar : pillars) {
+        int target = _memory->ReadEntityData<int>(pillar, TARGET, 1)[0];
+        targets.push_back(target);
+    }
+    targets[5] = pillars[5] + 1;
+
+    std::vector<int> randomOrder(pillars.size(), 0);
+    std::iota(randomOrder.begin(), randomOrder.end(), 0);
+    RandomizeRange(randomOrder, SWAP::NONE, 0, 4); // Left Pillars 1-4
+    RandomizeRange(randomOrder, SWAP::NONE, 5, 9); // Right Pillars 1-4
+    ReassignTargets(pillars, randomOrder, targets);
+    // Turn off original starting panels
+    _memory->WriteEntityData<float>(pillars[0], POWER, {0.0f, 0.0f});
+    _memory->WriteEntityData<float>(pillars[5], POWER, {0.0f, 0.0f});
+    // Turn on new starting panels
+    _memory->WriteEntityData<float>(pillars[randomOrder[0]], POWER, {1.0f, 1.0f});
+    _memory->WriteEntityData<float>(pillars[randomOrder[5]], POWER, {1.0f, 1.0f});
 }
 
 void Randomizer::RandomizeChallenge() {
-        ChallengeRandomizer cr(_memory, Random::RandInt(1, 0x7FFFFFFF)); // 0 will trigger an "RNG not initialized" block
-        for (int panel : challengePanels) {
-                _memory->WriteEntityData<int>(panel, POWER_OFF_ON_FAIL, {0});
-        }
+    ChallengeRandomizer cr(_memory, Random::RandInt(1, 0x7FFFFFFF)); // 0 will trigger an "RNG not initialized" block
+    for (int panel : challengePanels) {
+        _memory->WriteEntityData<int>(panel, POWER_OFF_ON_FAIL, {0});
+    }
 }
 
 void Randomizer::RandomizeAudioLogs() {
-        std::vector<int> randomOrder(audiologs.size(), 0);
-        std::iota(randomOrder.begin(), randomOrder.end(), 0);
-        Randomize(randomOrder, SWAP::NONE);
-        ReassignNames(audiologs, randomOrder);
+    std::vector<int> randomOrder(audiologs.size(), 0);
+    std::iota(randomOrder.begin(), randomOrder.end(), 0);
+    Randomize(randomOrder, SWAP::NONE);
+    ReassignNames(audiologs, randomOrder);
 }
 
 void Randomizer::Randomize(std::vector<int>& panels, int flags) {
-        return RandomizeRange(panels, flags, 0, panels.size());
+    return RandomizeRange(panels, flags, 0, panels.size());
 }
 
 // Range is [start, end)
 void Randomizer::RandomizeRange(std::vector<int> &panels, int flags, size_t startIndex, size_t endIndex) {
-        if (panels.size() == 0) return;
-        if (startIndex >= endIndex) return;
-        if (endIndex >= panels.size()) endIndex = static_cast<int>(panels.size());
-        for (size_t i = endIndex-1; i > startIndex; i--) {
-                const int target = Random::RandInt(static_cast<int>(startIndex), static_cast<int>(i));
-                if (i != target) {
-                        // std::cout << "Swapping panels " << std::hex << panels[i] << " and " << std::hex << panels[target] << std::endl;
-                        SwapPanels(panels[i], panels[target], flags);
-                        std::swap(panels[i], panels[target]); // Panel indices in the array
-                }
-        }
+    if (panels.size() == 0) return;
+    if (startIndex >= endIndex) return;
+    if (endIndex >= panels.size()) endIndex = static_cast<int>(panels.size());
+    for (size_t i = endIndex-1; i > startIndex; i--) {
+        const int target = Random::RandInt(static_cast<int>(startIndex), static_cast<int>(i));
+        if (i != target) {
+            // std::cout << "Swapping panels " << std::hex << panels[i] << " and " << std::hex << panels[target] << std::endl;
+            SwapPanels(panels[i], panels[target], flags);
+            std::swap(panels[i], panels[target]); // Panel indices in the array
+        }
+    }
 }
 
 void Randomizer::SwapPanels(int panel1, int panel2, int flags) {
-        std::map<int, int> offsets;
-
-        if (flags & SWAP::TARGETS) {
-                offsets[TARGET] = sizeof(int);
-        }
-        if (flags & SWAP::AUDIO_NAMES) {
-                offsets[AUDIO_LOG_NAME] = sizeof(void*);
-        }
-        if (flags & SWAP::COLORS) {
-                offsets[PATH_COLOR] = 16;
-                offsets[REFLECTION_PATH_COLOR] = 16;
-                offsets[DOT_COLOR] = 16;
-                offsets[ACTIVE_COLOR] = 16;
-                offsets[BACKGROUND_REGION_COLOR] = 12; // Not copying alpha to preserve transparency.
-                offsets[SUCCESS_COLOR_A] = 16;
-                offsets[SUCCESS_COLOR_B] = 16;
-                offsets[STROBE_COLOR_A] = 16;
-                offsets[STROBE_COLOR_B] = 16;
-                offsets[ERROR_COLOR] = 16;
-                offsets[PATTERN_POINT_COLOR] = 16;
-                offsets[PATTERN_POINT_COLOR_A] = 16;
-                offsets[PATTERN_POINT_COLOR_B] = 16;
-                offsets[SYMBOL_A] = 16;
-                offsets[SYMBOL_B] = 16;
-                offsets[SYMBOL_C] = 16;
-                offsets[SYMBOL_D] = 16;
-                offsets[SYMBOL_E] = 16;
-                offsets[PUSH_SYMBOL_COLORS] = sizeof(int);
-                offsets[OUTER_BACKGROUND] = 16;
-                offsets[OUTER_BACKGROUND_MODE] = sizeof(int);
-                // These two control the "burn intensity", but I can't swap out burn marks in new ver, so they should probably stay tied to each frame.
-                // offsets[SPECULAR_ADD] = sizeof(float);
-                // offsets[SPECULAR_POWER] = sizeof(int);
-                offsets[NUM_COLORED_REGIONS] = sizeof(int);
-                offsets[COLORED_REGIONS] = sizeof(void*);
-        }
-        if (flags & SWAP::LINES) {
-                offsets[TRACED_EDGES] = 16;
-                offsets[AUDIO_PREFIX] = sizeof(void*);
-//              offsets[IS_CYLINDER] = sizeof(int);
-//              offsets[CYLINDER_Z0] = sizeof(float);
-//              offsets[CYLINDER_Z1] = sizeof(float);
-//              offsets[CYLINDER_RADIUS] = sizeof(float);
-                offsets[PATH_WIDTH_SCALE] = sizeof(float);
-                offsets[STARTPOINT_SCALE] = sizeof(float);
-                offsets[NUM_DOTS] = sizeof(int);
-                offsets[NUM_CONNECTIONS] = sizeof(int);
-                offsets[DOT_POSITIONS] = sizeof(void*);
-                offsets[DOT_FLAGS] = sizeof(void*);
-                offsets[DOT_CONNECTION_A] = sizeof(void*);
-                offsets[DOT_CONNECTION_B] = sizeof(void*);
-                offsets[DECORATIONS] = sizeof(void*);
-                offsets[DECORATION_FLAGS] = sizeof(void*);
-                offsets[DECORATION_COLORS] = sizeof(void*);
-                offsets[NUM_DECORATIONS] = sizeof(int);
-                offsets[REFLECTION_DATA] = sizeof(void*);
-                offsets[GRID_SIZE_X] = sizeof(int);
-                offsets[GRID_SIZE_Y] = sizeof(int);
-                offsets[STYLE_FLAGS] = sizeof(int);
-                offsets[SEQUENCE_LEN] = sizeof(int);
-                offsets[SEQUENCE] = sizeof(void*);
-                offsets[DOT_SEQUENCE_LEN] = sizeof(int);
-                offsets[DOT_SEQUENCE] = sizeof(void*);
-                offsets[DOT_SEQUENCE_LEN_REFLECTION] = sizeof(int);
-                offsets[DOT_SEQUENCE_REFLECTION] = sizeof(void*);
-                offsets[PANEL_TARGET] = sizeof(void*);
-                offsets[SPECULAR_TEXTURE] = sizeof(void*);
-        }
-
-        for (auto const& [offset, size] : offsets) {
-                std::vector<byte> panel1data = _memory->ReadEntityData<byte>(panel1, offset, size);
-                std::vector<byte> panel2data = _memory->ReadEntityData<byte>(panel2, offset, size);
-                _memory->WriteEntityData<byte>(panel2, offset, panel1data);
-                _memory->WriteEntityData<byte>(panel1, offset, panel2data);
-        }
+    std::map<int, int> offsets;
+
+    if (flags & SWAP::TARGETS) {
+        offsets[TARGET] = sizeof(int);
+    }
+    if (flags & SWAP::AUDIO_NAMES) {
+        offsets[AUDIO_LOG_NAME] = sizeof(void*);
+    }
+    if (flags & SWAP::COLORS) {
+        offsets[PATH_COLOR] = 16;
+        offsets[REFLECTION_PATH_COLOR] = 16;
+        offsets[DOT_COLOR] = 16;
+        offsets[ACTIVE_COLOR] = 16;
+        offsets[BACKGROUND_REGION_COLOR] = 12; // Not copying alpha to preserve transparency.
+        offsets[SUCCESS_COLOR_A] = 16;
+        offsets[SUCCESS_COLOR_B] = 16;
+        offsets[STROBE_COLOR_A] = 16;
+        offsets[STROBE_COLOR_B] = 16;
+        offsets[ERROR_COLOR] = 16;
+        offsets[PATTERN_POINT_COLOR] = 16;
+        offsets[PATTERN_POINT_COLOR_A] = 16;
+        offsets[PATTERN_POINT_COLOR_B] = 16;
+        offsets[SYMBOL_A] = 16;
+        offsets[SYMBOL_B] = 16;
+        offsets[SYMBOL_C] = 16;
+        offsets[SYMBOL_D] = 16;
+        offsets[SYMBOL_E] = 16;
+        offsets[PUSH_SYMBOL_COLORS] = sizeof(int);
+        offsets[OUTER_BACKGROUND] = 16;
+        offsets[OUTER_BACKGROUND_MODE] = sizeof(int);
+        // These two control the "burn intensity", but I can't swap out burn marks in new ver, so they should probably stay tied to each frame.
+        // offsets[SPECULAR_ADD] = sizeof(float);
+        // offsets[SPECULAR_POWER] = sizeof(int);
+        offsets[NUM_COLORED_REGIONS] = sizeof(int);
+        offsets[COLORED_REGIONS] = sizeof(void*);
+    }
+    if (flags & SWAP::LINES) {
+        offsets[TRACED_EDGES] = 16;
+        offsets[AUDIO_PREFIX] = sizeof(void*);
+//        offsets[IS_CYLINDER] = sizeof(int);
+//        offsets[CYLINDER_Z0] = sizeof(float);
+//        offsets[CYLINDER_Z1] = sizeof(float);
+//        offsets[CYLINDER_RADIUS] = sizeof(float);
+        offsets[PATH_WIDTH_SCALE] = sizeof(float);
+        offsets[STARTPOINT_SCALE] = sizeof(float);
+        offsets[NUM_DOTS] = sizeof(int);
+        offsets[NUM_CONNECTIONS] = sizeof(int);
+        offsets[DOT_POSITIONS] = sizeof(void*);
+        offsets[DOT_FLAGS] = sizeof(void*);
+        offsets[DOT_CONNECTION_A] = sizeof(void*);
+        offsets[DOT_CONNECTION_B] = sizeof(void*);
+        offsets[DECORATIONS] = sizeof(void*);
+        offsets[DECORATION_FLAGS] = sizeof(void*);
+        offsets[DECORATION_COLORS] = sizeof(void*);
+        offsets[NUM_DECORATIONS] = sizeof(int);
+        offsets[REFLECTION_DATA] = sizeof(void*);
+        offsets[GRID_SIZE_X] = sizeof(int);
+        offsets[GRID_SIZE_Y] = sizeof(int);
+        offsets[STYLE_FLAGS] = sizeof(int);
+        offsets[SEQUENCE_LEN] = sizeof(int);
+        offsets[SEQUENCE] = sizeof(void*);
+        offsets[DOT_SEQUENCE_LEN] = sizeof(int);
+        offsets[DOT_SEQUENCE] = sizeof(void*);
+        offsets[DOT_SEQUENCE_LEN_REFLECTION] = sizeof(int);
+        offsets[DOT_SEQUENCE_REFLECTION] = sizeof(void*);
+        offsets[PANEL_TARGET] = sizeof(void*);
+        offsets[SPECULAR_TEXTURE] = sizeof(void*);
+    }
+
+    for (auto const& [offset, size] : offsets) {
+        std::vector<byte> panel1data = _memory->ReadEntityData<byte>(panel1, offset, size);
+        std::vector<byte> panel2data = _memory->ReadEntityData<byte>(panel2, offset, size);
+        _memory->WriteEntityData<byte>(panel2, offset, panel1data);
+        _memory->WriteEntityData<byte>(panel1, offset, panel2data);
+    }
 }
 
 void Randomizer::ReassignTargets(const std::vector<int>& panels, const std::vector<int>& order, std::vector<int> targets) {
-        if (targets.empty()) {
-                // This list is offset by 1, so the target of the Nth panel is in position N (aka the N+1th element)
-                // The first panel may not have a wire to power it, so we use the panel ID itself.
-                targets = {panels[0] + 1};
-                for (const int panel : panels) {
-                        int target = _memory->ReadEntityData<int>(panel, TARGET, 1)[0];
-                        targets.push_back(target);
-                }
-        }
-
-        for (size_t i=0; i<order.size() - 1; i++) {
-                // Set the target of order[i] to order[i+1], using the "real" target as determined above.
-                const int panelTarget = targets[order[i+1]];
-                _memory->WriteEntityData<int>(panels[order[i]], TARGET, {panelTarget});
-        }
+    if (targets.empty()) {
+        // This list is offset by 1, so the target of the Nth panel is in position N (aka the N+1th element)
+        // The first panel may not have a wire to power it, so we use the panel ID itself.
+        targets = {panels[0] + 1};
+        for (const int panel : panels) {
+            int target = _memory->ReadEntityData<int>(panel, TARGET, 1)[0];
+            targets.push_back(target);
+        }
+    }
+
+    for (size_t i=0; i<order.size() - 1; i++) {
+        // Set the target of order[i] to order[i+1], using the "real" target as determined above.
+        const int panelTarget = targets[order[i+1]];
+        _memory->WriteEntityData<int>(panels[order[i]], TARGET, {panelTarget});
+    }
 }
 
 void Randomizer::ReassignNames(const std::vector<int>& panels, const std::vector<int>& order) {
-        std::vector<int64_t> names;
-        for (const int panel : panels) {
-                names.push_back(_memory->ReadEntityData<int64_t>(panel, AUDIO_LOG_NAME, 1)[0]);
-        }
-
-        for (int i=0; i<panels.size(); i++) {
-                _memory->WriteEntityData<int64_t>(panels[i], AUDIO_LOG_NAME, {names[order[i]]});
-        }
+    std::vector<int64_t> names;
+    for (const int panel : panels) {
+        names.push_back(_memory->ReadEntityData<int64_t>(panel, AUDIO_LOG_NAME, 1)[0]);
+    }
+
+    for (int i=0; i<panels.size(); i++) {
+        _memory->WriteEntityData<int64_t>(panels[i], AUDIO_LOG_NAME, {names[order[i]]});
+    }
 }
@@ -5,45 +5,45 @@
 class Randomizer {
 public:
     Randomizer(const std::shared_ptr<Memory>& memory);
-        void Randomize();
-        void RandomizeChallenge();
+    void Randomize();
+    void RandomizeChallenge();
 
-        void AdjustSpeed();
-        void RandomizeLasers();
-        void PreventSnipes();
+    void AdjustSpeed();
+    void RandomizeLasers();
+    void PreventSnipes();
 
-        enum SWAP {
-                NONE = 0,
-                TARGETS = 1,
-                LINES = 2,
-                AUDIO_NAMES = 4,
-                COLORS = 8,
-        };
+    enum SWAP {
+        NONE = 0,
+        TARGETS = 1,
+        LINES = 2,
+        AUDIO_NAMES = 4,
+        COLORS = 8,
+    };
 
 private:
-        int _lastRandomizedFrame = 1 << 30;
-        void RandomizeTutorial();
-        void RandomizeSymmetry();
-        void RandomizeDesert();
-        void RandomizeQuarry();
-        void RandomizeTreehouse();
-        void RandomizeKeep();
-        void RandomizeShadows();
-        void RandomizeTown();
-        void RandomizeMonastery();
-        void RandomizeBunker();
-        void RandomizeJungle();
-        void RandomizeSwamp();
-        void RandomizeMountain();
-        void RandomizeAudioLogs();
+    int _lastRandomizedFrame = 1 << 30;
+    void RandomizeTutorial();
+    void RandomizeSymmetry();
+    void RandomizeDesert();
+    void RandomizeQuarry();
+    void RandomizeTreehouse();
+    void RandomizeKeep();
+    void RandomizeShadows();
+    void RandomizeTown();
+    void RandomizeMonastery();
+    void RandomizeBunker();
+    void RandomizeJungle();
+    void RandomizeSwamp();
+    void RandomizeMountain();
+    void RandomizeAudioLogs();
 
-        void Randomize(std::vector<int>& panels, int flags);
-        void RandomizeRange(std::vector<int> &panels, int flags, size_t startIndex, size_t endIndex);
-        void SwapPanels(int panel1, int panel2, int flags);
-        void ReassignTargets(const std::vector<int>& panels, const std::vector<int>& order, std::vector<int> targets = {});
-        void ReassignNames(const std::vector<int>& panels, const std::vector<int>& order);
+    void Randomize(std::vector<int>& panels, int flags);
+    void RandomizeRange(std::vector<int> &panels, int flags, size_t startIndex, size_t endIndex);
+    void SwapPanels(int panel1, int panel2, int flags);
+    void ReassignTargets(const std::vector<int>& panels, const std::vector<int>& order, std::vector<int> targets = {});
+    void ReassignNames(const std::vector<int>& panels, const std::vector<int>& order);
 
-        std::shared_ptr<Memory> _memory;
+    std::shared_ptr<Memory> _memory;
 
-        friend class SwapTests_Shipwreck_Test;
+    friend class SwapTests_Shipwreck_Test;
 };