Code is no longer dependent on the SMW rom.

- You now need to run python3 assets/restool.py to extract assets

.gitignore

@@ -9,4 +9,8 @@
 /smw.sfc
 SDL2.dll
 /smw.exe
-/glsl-shaders/
+/glsl-shaders/
+/dis/
+/work
+smw_assets.dat
+__pycache__

README.md

@@ -8,8 +8,9 @@ You must self-build for now. Easy method on Windows (no installs, terminal, or b
 (1) Click the green button "Code > Download ZIP" on the github page and extract the ZIP<br>
 (2) Place the USA rom named smw.sfc in that folder (crc32=b1ed489)<br>
 (3) Download [TCC](https://github.com/FitzRoyX/tinycc/releases/download/tcc_20230519/tcc_20230519.zip) and [SDL2](https://github.com/libsdl-org/SDL/releases/download/release-2.26.5/SDL2-devel-2.26.5-VC.zip) and extract each ZIP into the "third-party" subfolder<br>
-(4) Double-click run_with_tcc.bat in the main dir. This will create smw.exe and run it.<br>
+(4) run `python3 assets/restool.py`.
-(5) Configure with smw.ini<br>
+(5) Double-click run_with_tcc.bat in the main dir. This will create smw.exe and run it.<br>
+(6) Configure with smw.ini<br>
 
 For other platforms and compilers, see: https://github.com/snesrev/smw/blob/main/BUILDING.md
 

assets/compile_resources.py

@@ -0,0 +1,347 @@
+import sys, array, hashlib, struct, argparse, os
+import util
+from util import cache
+
+def flatten(xss):
+    return [x for xs in xss for x in xs]
+  
+def invert_dict(xs):
+  return {s:i for i,s in xs.items()}
+
+assets = {}
+
+def add_asset_uint8(name, data):
+  assert name not in assets
+  assets[name] = ('uint8', bytes(array.array('B', data)))
+
+def add_asset_uint16(name, data):
+  assert name not in assets
+  assets[name] = ('uint16', bytes(array.array('H', data)))
+
+def add_asset_int8(name, data):
+  assert name not in assets
+  assets[name] = ('int8', bytes(array.array('b', data)))
+
+def add_asset_int16(name, data):
+  assert name not in assets
+  assets[name] = ('int16', bytes(array.array('h', data)))
+
+def add_asset_packed(name, data):
+  assert name not in assets
+  assets[name] = ('packed', pack_arrays(data))
+
+# Pack arrays and determine automatically the index size
+def pack_arrays(arr):
+  if len(arr) == 0:
+    return b''
+  backmap, fstmap = {}, []
+  all_offs, offs = [], 0
+  saved = 0
+  for i, v in enumerate(arr):
+    v = bytes(v)
+    k = backmap.get(v)
+    if k == None:
+      k = len(all_offs)
+      backmap[v] = k
+      offs += len(v)
+      all_offs.append(offs)
+    else:
+      saved += len(v)
+    fstmap.append(k)
+  assert len(arr) <= 4096
+  del all_offs[-1]
+  flags = len(arr) - 1
+  if len(all_offs) == 0 or all_offs[-1] < 65536:
+    r = [struct.pack('H', i) for i in all_offs] + list(backmap.keys())
+    flags |= 0x8000
+  else:
+    r = [struct.pack('I', i) for i in all_offs] + list(backmap.keys())
+  if len(backmap) != len(arr):
+    if len(all_offs) <= 255:
+      r.append(array.array('B', fstmap).tobytes())  
+    else:
+      r.append(array.array('H', fstmap).tobytes())  
+    r.append(struct.pack('H', len(all_offs)))
+    flags |= 0x4000
+  r.append(struct.pack('H', flags))
+  return b''.join(r)
+
+def get_stripe_len(ea):
+  ea_org = ea
+  while True:
+    b = util.get_byte(ea)
+    if b & 0x80: 
+      return ea + 1 - ea_org
+    p1 = util.get_byte(ea + 1)
+    p2 = util.get_byte(ea + 2)
+    p3 = util.get_byte(ea + 3)
+    ea += 4
+    if p2 & 0x40:
+      ea += 2
+    else:
+      ll = ((p2 << 8 | p3) & 0x3fff) + 1
+      ea += ll
+@cache
+def unpack_rle(ea):
+  ea_org = ea
+  r = bytearray()
+  while util.get_word(ea) != 0xffff:
+    x = util.get_byte(ea); ea += 1 
+    if x & 0x80:
+      y = util.get_byte(ea); ea += 1 
+      for i in range((x & 0x7f) + 1):
+        r.append(y)
+    else:
+      for i in range((x & 0x7f) + 1):
+        y = util.get_byte(ea); ea += 1 
+        r.append(y)
+  return bytes(r), ea + 2 - ea_org
+
+@cache
+def calc_level_len(ea):
+  ea_org = ea
+  ea += 5
+  while True:
+    b0 = util.get_byte(ea); ea += 1
+    if b0 == 0xff:
+      break
+    b1 = util.get_byte(ea); ea += 1
+    b2 = util.get_byte(ea); ea += 1
+
+    blocks_object_number = (b1 >> 4) | ((b0 & 0x60) >> 1)
+    blocks_size_or_type = b2
+
+    if blocks_object_number == 0 and blocks_size_or_type == 0:
+      ea += 1
+  return ea - ea_org
+
+
+def print_all(args):
+  r = []
+  lo, hi, bank = util.get_bytes(0xB992, 50), util.get_bytes(0xB9c4, 50), util.get_bytes(0xB9f6, 50)
+  for i in range(50):
+    p = bank[i] << 16 | hi[i] << 8 | lo[i]
+    data, comp_len = util.decomp(p, util.get_byte, return_length = True)
+    #print('%d: %d: %d' % (i, comp_len, len(data)))
+    r.append(data)
+  add_asset_packed('kGraphicsPtrs', r)
+
+  data, comp_len = util.decomp(0x88000, util.get_byte, return_length = True)
+  #print('%d: %d: %d' % (0x32, comp_len, len(data)))
+  add_asset_uint8('kGfx32', data)
+
+  data, comp_len = util.decomp(0x8bfc0, util.get_byte, return_length = True)
+  #print('%d: %d: %d' % (0x33, comp_len, len(data)))
+  add_asset_uint8('kGfx33', data)
+
+  r = [b'']
+  for i in range(1, 86):
+    p = util.get_24(0x84D0 + i * 3)
+    pl = get_stripe_len(p)
+    #if i == 1:
+      #print(util.get_bytes(p, 16))
+    r.append(util.get_bytes(p, pl))
+  add_asset_packed('kLoadStripeImagePtrs', r)
+
+  r = []
+  for i in range(45):
+    p = util.get_24(0x59000 + i * 3)
+    pl = get_stripe_len(p)
+    r.append(util.get_bytes(p, pl))
+  add_asset_packed('kLayer3ImagePtrs', r)
+
+  add_asset_uint8('kOverworldLayer2EventTilemap_Tiles', util.get_bytes(0xc8000, 3328))
+
+  add_asset_uint8('kSpcCreditsMusicBank', util.get_bytes(0x3e400, 6624))
+  add_asset_uint8('kSpcLevelMusicBank', util.get_bytes(0xEAED6, 16899))
+  add_asset_uint8('kSpcEngine', util.get_bytes(0xe8000, 6321) + b'\x00\x00')
+  add_asset_uint8('kSpcSamples', util.get_bytes(0xf8000, 28538))
+  add_asset_uint8('kSpcOverworldMusicBank', util.get_bytes(0xe98b1, 5667))
+
+  add_asset_uint16('kMap16Data_OverworldLayer1', util.get_words(0x05d000, 772))
+
+  add_asset_uint8('kkOverworldLayer2EventTilemap_Prop', util.get_bytes(0xc8d00, 1664))
+
+  add_asset_uint16('kMap16Data', util.get_words(0xd8000, (0xA100 - 0x8000) // 2))
+  add_asset_uint16('kMap16Data_Castle', util.get_words(0xdbc00, 712))
+  add_asset_uint16('kMap16Data_Rope', util.get_words(0xdc800, 712))
+  add_asset_uint16('kMap16Data_Underground', util.get_words(0xdd400, 712))
+  add_asset_uint16('kMap16Data_GhostHouse', util.get_words(0xde300, 712))
+
+  add_asset_uint8('kGameMode1B_EndingCinema_Tilemaps', util.get_bytes(0xC95C7, 1873))
+  add_asset_uint16('kGameMode1B_EndingCinema_RowPointers', util.get_words(0xC9D18, 202))
+
+  add_asset_uint8('kLevelInfo_05F000', util.get_bytes(0x5f000, 0x200))  
+  add_asset_uint8('kLevelInfo_05F200', util.get_bytes(0x5f200, 0x200))  
+  add_asset_uint8('kLevelInfo_05F400', util.get_bytes(0x5f400, 0x200))
+  add_asset_uint8('kLevelInfo_05F600', util.get_bytes(0x5f600, 0x200))
+  add_asset_uint8('kLevelInfo_05F800', util.get_bytes(0x5f800, 0x200))
+  add_asset_uint8('kLevelInfo_05FA00', util.get_bytes(0x5fa00, 0x200))
+  add_asset_uint8('kLevelInfo_05FC00', util.get_bytes(0x5fc00, 0x200))
+  add_asset_uint8('kLevelInfo_05FE00', util.get_bytes(0x5fe00, 0x200))
+
+  add_asset_uint8('kLoadLevel_DATA_05D608', util.get_bytes(0x5D608, 0x100))
+
+  add_asset_uint8('kDisplayMessage_DATA_05A5D9', util.get_bytes(0x5A5D9, 2854))
+
+  add_asset_uint8('kOverworldLightningAndRandomCloudSpawning', util.get_bytes(0x4F708, 128))
+
+  add_asset_uint16('kLevelNames', util.get_words(0x4A0FC, 256))
+
+  add_asset_uint8('kLoadOverworldLayer2AndEventsTilemaps_OverworldLayer2Tilemap', util.get_bytes(0x4A533, 6904))
+  add_asset_uint8('kLoadOverworldLayer2AndEventsTilemaps_OverworldLayer2Tilemap_Prop', util.get_bytes(0x4C02B , 5709))
+  add_asset_uint8('kLoadOverworldLayer1AndEvents_DATA_0CF7DF', util.get_bytes(0xCF7DF, 0x800))
+
+  add_asset_uint8('kLineGuideSpeedTableData', util.get_bytes(0x7F9DB, 536))
+
+  def add_packed_levels(name, addr, num, bank = None):
+    r = []
+    for i in range(num):
+      if bank == None:
+        ea = util.get_24(addr + i * 3)
+      else:
+        ea = util.get_word(addr + i * 2) | bank << 16
+      ln = calc_level_len(ea)
+      r.append(util.get_bytes(ea, ln))
+    add_asset_packed(name, r)
+
+  add_packed_levels('kLevelData_Layer1', 0x5E000, 0x200)
+  add_packed_levels('kEntranceData_Layer1', 0x5d766, 6)
+  add_packed_levels('kChoclateIsland2_Layer1', 0x5DB08, 9, bank = 6)
+  add_packed_levels('kRollCallData_Layer1', 0xCAD58, 13, bank = 0xc)
+
+
+  def add_packed_level_bg(name, addr, num, mode = None):
+    r = []
+    fls = []
+    for i in range(num):
+      if mode == None:
+        ea = util.get_24(addr + i * 3)
+      elif mode == 'choc':
+        ea = util.get_word(addr + i * 2) | 0xff0000
+      elif mode == 'end':
+        ea = util.get_word(addr + i * 2) | (0xff0000 if i != 12 else 0xc0000)
+      else:
+        assert 0
+
+      fl = 0
+      if (ea & 0xff0000) == 0xff0000:
+        ea = (ea & 0xffff) | 0xc0000
+        fl = ((ea & 0xffff) >= 0xE8FE) << 4 | 2
+      fls.append(fl)
+
+      if fl & 2:
+        packed, ln = unpack_rle(ea)
+      else:
+        ln = calc_level_len(ea)
+
+      r.append(util.get_bytes(ea, ln))
+    add_asset_packed(name, r)
+    add_asset_uint8(name + '_IsBg', fls)
+
+  add_packed_level_bg('kLevelData_Layer2', 0x5E600, 0x200)
+  add_packed_level_bg('kEntranceData_Layer2', 0x5d778, 6)
+  add_packed_level_bg('kChoclateIsland2_Layer2', 0x5DB2C, 9, mode = 'choc')
+  add_packed_level_bg('kRollCallData_Layer2', 0xCAD72, 13, mode = 'end')
+
+  add_packed_level_bg('kBufferCreditsBackgrounds_Layer2', 0xc93c1, 7, mode = 'choc')
+
+  def get_sprite_data_len(ea):
+    ea_org = ea
+    ea += 1
+    while util.get_byte(ea) != 0xff:
+      ea += 3
+    return ea + 1 - ea_org
+
+
+  def add_sprites():
+    r = []
+
+    def touch(ea):
+      lx = get_sprite_data_len(ea)
+      r.append(util.get_bytes(ea, lx))
+
+    for i in range(0x200):
+      touch(util.get_word(0x5ec00 + i * 2) | 0x70000)
+
+    touch(0x7c3ee)
+    for i in range(9):
+      touch(util.get_word(0x5DB1A + i * 2) | 0x70000)
+
+    add_asset_packed('kLoadLevelSpriteList', r)
+
+  add_sprites()
+
+  add_asset_uint16('kLoadLevel_SpriteDataPtrs', util.get_words(0x5EC00, 0x200))
+  add_asset_uint8('kFileSelectText_EraseFile', util.get_bytes(0x5B6FE, 203 + 204))
+  add_asset_uint8('kInitializeMode7TilemapsAndPalettes_TilemapData', util.get_bytes(0x3D9DE, 912))
+
+  add_asset_uint16('kLayer2EventData_TileEntries', util.get_words(0x4DD8D, 742))
+  add_asset_uint8('kUpdateLevelName_LevelNameStrings', util.get_bytes(0x49ac5, 460))  
+  
+  add_asset_uint8('kGameMode25_ShowEnemyRollcallScreen_TileData', util.get_bytes(0xCAF11, 1681))
+
+  add_asset_uint8('kRom', util.ROM.ROM if args.include_rom else b'')
+
+  #add_asset_uint16('', util.get_words(0x, ))
+  #add_asset_uint8('', util.get_bytes(0x, ))  
+
+
+
+def write_assets_to_file(print_header = False):
+  key_sig = b''
+  all_data = []
+  if print_header:
+    print('''#pragma once
+#include "types.h"
+
+enum {
+  kNumberOfAssets = %d
+};
+extern const uint8 *g_asset_ptrs[kNumberOfAssets];
+extern uint32 g_asset_sizes[kNumberOfAssets];
+extern MemBlk FindInAssetArray(int asset, int idx);
+''' % len(assets))
+
+  for i, (k, (tp, data)) in enumerate(assets.items()):
+    if print_header:
+      if tp == 'packed':
+        print('#define %s(idx) FindInAssetArray(%d, idx)' % (k, i))
+      else:
+        print('#define %s ((%s*)g_asset_ptrs[%d])' % (k, tp, i))
+        print('#define %s_SIZE (g_asset_sizes[%d])' % (k, i))
+    key_sig += k.encode('utf8') + b'\0'
+    all_data.append(data)
+
+  assets_sig = b'Smw_v0        \n\0' + hashlib.sha256(key_sig).digest()
+
+  if print_header:
+    print('#define kAssets_Sig %s' % ", ".join((str(a) for a in assets_sig)))
+
+  hdr = assets_sig + b'\x00' * 32 + struct.pack('II', len(all_data), len(key_sig))
+
+  encoded_sizes = array.array('I', [len(i) for i in all_data])
+
+  file_data = hdr + encoded_sizes + key_sig
+
+  for v in all_data:
+    while len(file_data) & 3:
+      file_data += b'\0'
+    file_data += v
+
+  open('smw_assets.dat', 'wb').write(file_data)
+
+def main(args):
+  print_all(args)
+  write_assets_to_file(args.print_assets_header)
+
+if __name__ == "__main__":
+  ROM = util.load_rom(sys.argv[1] if len(sys.argv) >= 2 else None)
+  class DefaultArgs:
+    print_assets_header = True
+    include_rom = True
+  main(DefaultArgs())
+else:
+  ROM = util.ROM
+
+

assets/restool.py

@@ -0,0 +1,24 @@
+import argparse
+import util
+import sys
+
+parser = argparse.ArgumentParser(description='Resource tool used to build smw_assets.dat', allow_abbrev=False)
+parser.add_argument('-r', '--rom', nargs='?', metavar='ROM')
+parser.add_argument('--extract-from-rom', '-e', action='store_true', help='Extract assets from the ROM')
+
+
+parser.add_argument('--no-include-rom', dest='include_rom', action='store_false', help='Don''t include the ROM in the assets file for verification')
+
+optional = parser.add_argument_group('Debug things')
+optional.add_argument('--print-assets-header', action='store_true')
+
+args = parser.parse_args()
+
+ROM = util.load_rom(args.rom)
+
+want_compile = True
+
+import compile_resources
+compile_resources.main(args)
+
+

assets/smw_assets.h

@@ -0,0 +1,114 @@
+#pragma once
+#include "src/types.h"
+
+enum {
+  kNumberOfAssets = 58
+};
+extern const uint8 *g_asset_ptrs[kNumberOfAssets];
+extern uint32 g_asset_sizes[kNumberOfAssets];
+extern MemBlk FindInAssetArray(int asset, int idx);
+
+#define kGraphicsPtrs(idx) FindInAssetArray(0, idx)
+#define kGfx32 ((uint8*)g_asset_ptrs[1])
+#define kGfx32_SIZE (g_asset_sizes[1])
+#define kGfx33 ((uint8*)g_asset_ptrs[2])
+#define kGfx33_SIZE (g_asset_sizes[2])
+#define kLoadStripeImagePtrs(idx) FindInAssetArray(3, idx)
+#define kLayer3ImagePtrs(idx) FindInAssetArray(4, idx)
+#define kOverworldLayer2EventTilemap_Tiles ((uint8*)g_asset_ptrs[5])
+#define kOverworldLayer2EventTilemap_Tiles_SIZE (g_asset_sizes[5])
+#define kSpcCreditsMusicBank ((uint8*)g_asset_ptrs[6])
+#define kSpcCreditsMusicBank_SIZE (g_asset_sizes[6])
+#define kSpcLevelMusicBank ((uint8*)g_asset_ptrs[7])
+#define kSpcLevelMusicBank_SIZE (g_asset_sizes[7])
+#define kSpcEngine ((uint8*)g_asset_ptrs[8])
+#define kSpcEngine_SIZE (g_asset_sizes[8])
+#define kSpcSamples ((uint8*)g_asset_ptrs[9])
+#define kSpcSamples_SIZE (g_asset_sizes[9])
+#define kSpcOverworldMusicBank ((uint8*)g_asset_ptrs[10])
+#define kSpcOverworldMusicBank_SIZE (g_asset_sizes[10])
+#define kMap16Data_OverworldLayer1 ((uint16*)g_asset_ptrs[11])
+#define kMap16Data_OverworldLayer1_SIZE (g_asset_sizes[11])
+#define kkOverworldLayer2EventTilemap_Prop ((uint8*)g_asset_ptrs[12])
+#define kkOverworldLayer2EventTilemap_Prop_SIZE (g_asset_sizes[12])
+#define kMap16Data ((uint16*)g_asset_ptrs[13])
+#define kMap16Data_SIZE (g_asset_sizes[13])
+#define kMap16Data_Castle ((uint16*)g_asset_ptrs[14])
+#define kMap16Data_Castle_SIZE (g_asset_sizes[14])
+#define kMap16Data_Rope ((uint16*)g_asset_ptrs[15])
+#define kMap16Data_Rope_SIZE (g_asset_sizes[15])
+#define kMap16Data_Underground ((uint16*)g_asset_ptrs[16])
+#define kMap16Data_Underground_SIZE (g_asset_sizes[16])
+#define kMap16Data_GhostHouse ((uint16*)g_asset_ptrs[17])
+#define kMap16Data_GhostHouse_SIZE (g_asset_sizes[17])
+#define kGameMode1B_EndingCinema_Tilemaps ((uint8*)g_asset_ptrs[18])
+#define kGameMode1B_EndingCinema_Tilemaps_SIZE (g_asset_sizes[18])
+#define kGameMode1B_EndingCinema_RowPointers ((uint16*)g_asset_ptrs[19])
+#define kGameMode1B_EndingCinema_RowPointers_SIZE (g_asset_sizes[19])
+#define kLevelInfo_05F000 ((uint8*)g_asset_ptrs[20])
+#define kLevelInfo_05F000_SIZE (g_asset_sizes[20])
+#define kLevelInfo_05F200 ((uint8*)g_asset_ptrs[21])
+#define kLevelInfo_05F200_SIZE (g_asset_sizes[21])
+#define kLevelInfo_05F400 ((uint8*)g_asset_ptrs[22])
+#define kLevelInfo_05F400_SIZE (g_asset_sizes[22])
+#define kLevelInfo_05F600 ((uint8*)g_asset_ptrs[23])
+#define kLevelInfo_05F600_SIZE (g_asset_sizes[23])
+#define kLevelInfo_05F800 ((uint8*)g_asset_ptrs[24])
+#define kLevelInfo_05F800_SIZE (g_asset_sizes[24])
+#define kLevelInfo_05FA00 ((uint8*)g_asset_ptrs[25])
+#define kLevelInfo_05FA00_SIZE (g_asset_sizes[25])
+#define kLevelInfo_05FC00 ((uint8*)g_asset_ptrs[26])
+#define kLevelInfo_05FC00_SIZE (g_asset_sizes[26])
+#define kLevelInfo_05FE00 ((uint8*)g_asset_ptrs[27])
+#define kLevelInfo_05FE00_SIZE (g_asset_sizes[27])
+#define kLoadLevel_DATA_05D608 ((uint8*)g_asset_ptrs[28])
+#define kLoadLevel_DATA_05D608_SIZE (g_asset_sizes[28])
+#define kDisplayMessage_DATA_05A5D9 ((uint8*)g_asset_ptrs[29])
+#define kDisplayMessage_DATA_05A5D9_SIZE (g_asset_sizes[29])
+#define kOverworldLightningAndRandomCloudSpawning ((uint8*)g_asset_ptrs[30])
+#define kOverworldLightningAndRandomCloudSpawning_SIZE (g_asset_sizes[30])
+#define kLevelNames ((uint16*)g_asset_ptrs[31])
+#define kLevelNames_SIZE (g_asset_sizes[31])
+#define kLoadOverworldLayer2AndEventsTilemaps_OverworldLayer2Tilemap ((uint8*)g_asset_ptrs[32])
+#define kLoadOverworldLayer2AndEventsTilemaps_OverworldLayer2Tilemap_SIZE (g_asset_sizes[32])
+#define kLoadOverworldLayer2AndEventsTilemaps_OverworldLayer2Tilemap_Prop ((uint8*)g_asset_ptrs[33])
+#define kLoadOverworldLayer2AndEventsTilemaps_OverworldLayer2Tilemap_Prop_SIZE (g_asset_sizes[33])
+#define kLoadOverworldLayer1AndEvents_DATA_0CF7DF ((uint8*)g_asset_ptrs[34])
+#define kLoadOverworldLayer1AndEvents_DATA_0CF7DF_SIZE (g_asset_sizes[34])
+#define kLineGuideSpeedTableData ((uint8*)g_asset_ptrs[35])
+#define kLineGuideSpeedTableData_SIZE (g_asset_sizes[35])
+#define kLevelData_Layer1(idx) FindInAssetArray(36, idx)
+#define kEntranceData_Layer1(idx) FindInAssetArray(37, idx)
+#define kChoclateIsland2_Layer1(idx) FindInAssetArray(38, idx)
+#define kRollCallData_Layer1(idx) FindInAssetArray(39, idx)
+#define kLevelData_Layer2(idx) FindInAssetArray(40, idx)
+#define kLevelData_Layer2_IsBg ((uint8*)g_asset_ptrs[41])
+#define kLevelData_Layer2_IsBg_SIZE (g_asset_sizes[41])
+#define kEntranceData_Layer2(idx) FindInAssetArray(42, idx)
+#define kEntranceData_Layer2_IsBg ((uint8*)g_asset_ptrs[43])
+#define kEntranceData_Layer2_IsBg_SIZE (g_asset_sizes[43])
+#define kChoclateIsland2_Layer2(idx) FindInAssetArray(44, idx)
+#define kChoclateIsland2_Layer2_IsBg ((uint8*)g_asset_ptrs[45])
+#define kChoclateIsland2_Layer2_IsBg_SIZE (g_asset_sizes[45])
+#define kRollCallData_Layer2(idx) FindInAssetArray(46, idx)
+#define kRollCallData_Layer2_IsBg ((uint8*)g_asset_ptrs[47])
+#define kRollCallData_Layer2_IsBg_SIZE (g_asset_sizes[47])
+#define kBufferCreditsBackgrounds_Layer2(idx) FindInAssetArray(48, idx)
+#define kBufferCreditsBackgrounds_Layer2_IsBg ((uint8*)g_asset_ptrs[49])
+#define kBufferCreditsBackgrounds_Layer2_IsBg_SIZE (g_asset_sizes[49])
+#define kLoadLevelSpriteList(idx) FindInAssetArray(50, idx)
+#define kLoadLevel_SpriteDataPtrs ((uint16*)g_asset_ptrs[51])
+#define kLoadLevel_SpriteDataPtrs_SIZE (g_asset_sizes[51])
+#define kFileSelectText_EraseFile ((uint8*)g_asset_ptrs[52])
+#define kFileSelectText_EraseFile_SIZE (g_asset_sizes[52])
+#define kInitializeMode7TilemapsAndPalettes_TilemapData ((uint8*)g_asset_ptrs[53])
+#define kInitializeMode7TilemapsAndPalettes_TilemapData_SIZE (g_asset_sizes[53])
+#define kLayer2EventData_TileEntries ((uint16*)g_asset_ptrs[54])
+#define kLayer2EventData_TileEntries_SIZE (g_asset_sizes[54])
+#define kUpdateLevelName_LevelNameStrings ((uint8*)g_asset_ptrs[55])
+#define kUpdateLevelName_LevelNameStrings_SIZE (g_asset_sizes[55])
+#define kGameMode25_ShowEnemyRollcallScreen_TileData ((uint8*)g_asset_ptrs[56])
+#define kGameMode25_ShowEnemyRollcallScreen_TileData_SIZE (g_asset_sizes[56])
+#define kRom ((uint8*)g_asset_ptrs[57])
+#define kRom_SIZE (g_asset_sizes[57])
+#define kAssets_Sig 83, 109, 119, 95, 118, 48, 32, 32, 32, 32, 32, 32, 32, 32, 10, 0, 52, 78, 183, 252, 40, 131, 208, 13, 64, 107, 152, 161, 6, 99, 150, 130, 181, 105, 242, 158, 255, 50, 227, 158, 57, 108, 112, 255, 9, 165, 191, 187

assets/util.py

@@ -0,0 +1,320 @@
+import array
+import sys
+import hashlib
+import os
+from functools import lru_cache
+
+def cache(user_function):
+  'Simple lightweight unbounded cache.  Sometimes called "memoize".'
+  return lru_cache(maxsize=None)(user_function)
+
+COMMON_ROM_NAMES = ['smw.sfc', '../smw.sfc']
+DEFAULT_ROM_DIRECTORY = os.path.dirname(__file__)
+
+SMW_SHA1_US = '6B47BB75D16514B6A476AA0C73A683A2A4C18765'
+SMW_SHA1 = {
+   SMW_SHA1_US : ('us', 'Super Mario World (USA)'),
+}
+
+def load_rom(filename, support_multilanguage = False):
+  global ROM
+  ROM = LoadedRom(filename, support_multilanguage)
+  return ROM
+
+def get_byte(addr):
+  return ROM.get_byte(addr)
+
+def get_24(addr):
+  return ROM.get_24(addr)
+
+@cache
+def get_bytes(addr, n):
+  return ROM.get_bytes(addr, n)
+
+@cache
+def get_words(addr, n):
+  return ROM.get_words(addr, n)
+
+def get_int8(ea):
+  b = get_byte(ea)
+  if b & 0x80: b -= 256
+  return b
+
+def get_int16(ea):
+  b = get_word(ea)
+  if b & 0x8000: b -= 65536
+  return b
+
+def get_word(addr):
+  return ROM.get_word(addr)
+
+
+class LoadedRom:
+  def __init__(self, path = None, support_multilanguage = False):
+    rom_path = self.__get_rom_path(path)
+    self.ROM = open(rom_path, 'rb').read()
+
+    # Remove the SMC header?
+    if (len(self.ROM) & 0xfffff) == 0x200:
+      self.ROM = self.ROM[0x200:]
+
+    hash = hashlib.sha1(self.ROM).hexdigest().upper()
+    entry = SMW_SHA1.get(hash)
+    self.language = entry[0] if entry != None else None
+
+    if support_multilanguage:
+      if self.language == None:
+        msg = f"\n\nROM with hash {hash} not supported.\n\nYou need one of the following ROMs to extract the resources:\n"
+        for k, v in SMW_SHA1.items():
+          msg += '%5s: %s: %s\n' % (v[0], k, v[1])
+        raise Exception(msg)
+      print('Identified ROM as: %s - "%s"' % entry)
+    else:
+      if self.language != 'us':
+        raise Exception(f"\n\nROM with hash {hash} not supported.\n\nExpected {SMW_SHA1_US}.\nPlease verify your ROM is \"Super Mario World\"");
+
+  def get_byte(self, ea):
+    assert (ea & 0x8000)
+    ea = ((ea >> 16) & 0x7f) * 0x8000 + (ea & 0x7fff)
+    return self.ROM[ea]
+
+  def get_word(self, ea):
+    return self.get_byte(ea) + self.get_byte(ea + 1) * 256
+
+  def get_24(self, ea):
+    return self.get_byte(ea) + self.get_byte(ea + 1) * 256 + self.get_byte(ea + 2) * 65536
+
+  def get_bytes(self, addr, n):
+    r = bytearray()
+    for i in range(n):
+      r.append(self.get_byte(addr))
+      addr += 1
+      if (addr & 0x8000) == 0:
+        addr += 0x8000
+    return r
+
+  def get_words(self, addr, n):
+    r = []
+    for i in range(n):
+      r.append(self.get_word(addr))
+      addr += 2
+      if (addr & 0x8000) == 0:
+        addr += 0x8000
+    return r
+
+  def __get_rom_path(self, path = None):
+    # Check default locations when no path is given by user.
+    if path is None:
+      for rom_name in COMMON_ROM_NAMES:
+        rom_path = os.path.join(DEFAULT_ROM_DIRECTORY, rom_name)
+        if os.path.isfile(rom_path):
+          return rom_path
+      raise Exception(f"Could not find any ROMs ({', '.join(COMMON_ROM_NAMES)}) at the default location {DEFAULT_ROM_DIRECTORY}.") 
+
+    rom_path = os.path.join(DEFAULT_ROM_DIRECTORY, path)
+    if os.path.isfile(rom_path):
+      return rom_path
+    raise Exception(f"No ROM found at provided path {rom_path}.")
+
+
+
+def split_list(l, n):
+  return [l[i:i+n] for i in range(0, len(l), n)]
+
+def to_hex(v):
+  return '%#x' % v if v < -9 or v >9 else '%d'%v
+
+
+def print_int_array(name, r, tname, decimal, split_length = 16, file = sys.stdout):
+  rlen = len(r)
+  rr = split_list(r, split_length )
+  if decimal != None:
+    if decimal:
+      rr = [['%d' % s for s in t] for t in rr]
+    else:
+      rr = [[to_hex(s) for s in t] for t in rr]
+
+  def pad_all_columns(rrs):
+    colsiz = [max((0 if j >= len(r) else len(r[j])) for r in rrs) for j in range(len(rrs[0]))]
+    def pad(c, i):
+      return (' ' * (i - len(c))) + c
+    return [[pad(c, colsiz[i]) for (i, c) in enumerate(r)] for r in rrs]
+
+  if len(rr) == 1:
+    print('static const %s %s[%d] = {%s};' % (tname, name, rlen, ", ".join(rr[0])), file = file)
+  else:
+    print('static const %s %s[%d] = {' % (tname, name, rlen), file = file)
+    for t in pad_all_columns(rr):
+      print("  " + "".join([(a + ', ') for a in t]), file = file)
+    print('};', file = file)
+
+
+
+class Reader:
+  def __init__(self, ea, rb):
+    self.ea, self.rb = ea, rb
+  def next(self):
+    r = self.rb(self.ea)
+    self.ea += 1
+    if (self.ea & 0xffff) == 0:
+      self.ea += 0x8000
+    return r
+
+def decomp(ea, rb, offset_is_be = True, return_length = False):
+  result = bytearray()
+  reader = Reader(ea, rb)
+  while True:
+    b = reader.next()
+    if b == 0xff:
+      if return_length:
+        return result, (reader.ea - ea) & 0x7fff
+      else:
+        return result
+    if (b & 0xe0) != 0xe0:
+      lx = b & 0x1f
+      cmd = b & 0xe0
+    else:
+      cmd = (b << 3) & 0xe0
+      lx = ((b & 3) << 8) | reader.next()
+    lx += 1
+    if cmd == 0x00: # 000 - literal
+#      print('literal %d' % lx)
+      while lx:
+        result.append(reader.next())
+        lx -= 1
+    elif cmd & 0x80: # 1xx - copy
+#      print('copy %d' % lx)
+      offs = reader.next() << 8
+      offs |= reader.next()
+      if not offset_is_be: offs = ((offs >> 8) | (offs << 8)) & 0xffff
+      while lx:
+        result.append(result[offs])
+        offs += 1
+        lx -= 1
+    elif (cmd & 0x40) == 0: # 00x - memset
+#      print('memset %d' % lx)
+      b = reader.next()
+      while lx:
+        result.append(b)
+        lx -= 1
+    elif (cmd & 0x20) == 0: # 010 - memset16
+#      print('memsetw %d' % lx)
+      b1, b2 = reader.next(), reader.next()
+      while lx:
+        result.append(b1)
+        if lx==1: break
+        result.append(b2)
+        lx -= 2
+    else: # 011 - incr
+#      print('incr %d' % lx)
+      b = reader.next()
+      while lx:
+        result.append(b)
+        b = (b + 1) & 0xff
+        lx -= 1
+
+
+def decode_brr(get_byte, olds = (0, 0)):
+  ea=0
+  r = []
+  old , older = olds
+  while True:
+    cmd = get_byte(ea)
+    
+    shift = cmd >> 4
+    filter = (cmd >> 2) & 3
+    #print("shift=%d, filter=%d" % (shift, filter))
+    for i in range(16):
+      t = (get_byte(ea+1+i//2) >> (0 if i & 1 else 4)) & 0xf
+      s = (t & 7) - (t & 8)
+      if shift <= 12:
+        s = ((s << shift) >> 1)
+      else:
+        s = (s >> 3) << 12 # -2048 or 0
+
+      if filter == 1:
+        s += old*1+((-old*1) >> 4)
+      elif filter == 2:
+        s += old*2 + ((-old*3) >> 5)  - older + ((older*1) >> 4)
+      elif filter == 3:
+        s += old*2 + ((-old*13) >> 6) - older + ((older*3) >> 4)
+      # saturate to 16 bits
+      if s < -0x8000: s = -0x8000
+      elif s >= 0x7fff: s = 0x7fff
+      # wrap to 15 bits
+      s = (s & 0x3fff) - (s & 0x4000)
+
+      older, old = old, s
+      #print('%d: 0x%x -> %d (shift %d, filter %d)' % (i, t, s*2, shift, filter))
+      r.append(s*2)
+    ea += 9
+    if cmd & 1:
+      break
+  return array.array('h', r)
+
+kBrrFilters = [
+  lambda old, older: 0,
+  lambda old, older: old*1+((-old*1) >> 4),
+  lambda old, older: old*2 + ((-old*3) >> 5)  - older + ((older*1) >> 4),
+  lambda old, older: old*2 + ((-old*13) >> 6) - older + ((older*3) >> 4)
+]
+
+def brr_get_one(old, rs, r):
+  s = (rs << r) >> 1 if r <= 12 else (rs >> 3) << 12
+  s += old
+  s = -0x8000 if s < -0x8000 else 0x7fff if s > 0x7fff else s
+  return (s & 0x3fff) - (s & 0x4000) # wrap to 15 bits
+
+def encode_brr_generic(data, brr_repeat, olds = (0, 0), lossless=True):  
+  assert len(data) % 16 == 0
+  loop_enabled, loop_offset = 1 if brr_repeat != 0 else 0, 0
+  result = []
+  blk_data = [0] * 16
+  best_data = [0] * 9
+  p = 0
+  best_old, best_older = olds
+  while p < len(data):
+#    print(p)
+    best_err = 1 << 60
+    startold, startolder = best_old, best_older
+
+    if all(data[p + i] == 0 for i in range(16)):
+      result.extend((loop_enabled * 2, 0, 0, 0, 0, 0, 0, 0, 0))
+      p += 16
+      continue
+    for filter in range(4):
+      if filter != 0 and (p == 0 or p == loop_offset):
+        continue
+      for r in range(12, 0, -1):
+        blk_err = 0
+        old, older = startold, startolder
+        for i in range(16):
+          s = kBrrFilters[filter](old, older)
+          xs = data[p + i] >> 1 
+          best_e = 1<<60
+          for j in (0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, -6, 7, -7, -8):
+            s0 = brr_get_one(s, j, r)
+            e = (xs - s0) * (xs - s0)
+            if e < best_e:
+              best_e, best_j, best_s0 = e, j, s0
+              if e == 0:
+                #print(j)
+                break
+          if best_e != 0 and lossless:
+            break
+          blk_err += best_e
+          blk_data[i] = best_j & 0xf
+          older, old = old, best_s0
+        else:
+          if blk_err < best_err:
+            best_err = blk_err
+            best_old, best_older = old, older
+            best_data[0] = r << 4 | filter << 2 | loop_enabled << 1
+            for i in range(8):
+              best_data[i + 1] = blk_data[i * 2] << 4 | blk_data[i * 2 + 1]
+    result.extend(best_data)
+    if lossless: assert best_err==0
+    p += 16
+#  result[-9] |= 1
+  return result
+

smb1/smb1_00.c

@@ -1623,17 +1623,17 @@ void UploadStripeImage() {
   WriteReg(A1B1, 0);
   R6_ = 0;
   v0 = 0;
-  for (i = *IndirPtr((LongPtr *)&R0_, 0); i >= 0; i = *IndirPtr((LongPtr *)&R0_, v0)) {
+  for (i = *IndirPtr(*(LongPtr *)&R0_, 0); i >= 0; i = *IndirPtr(*(LongPtr *)&R0_, v0)) {
     R4_ = i;
     v2 = v0 + 1;
-    R3_ = *IndirPtr((LongPtr *)&R0_, v2++);
+    R3_ = *IndirPtr(*(LongPtr *)&R0_, v2++);
-    v3 = *IndirPtr((LongPtr *)&R0_, v2) & 0x80;
+    v3 = *IndirPtr(*(LongPtr *)&R0_, v2) & 0x80;
     R7_ = 4 * v3 + __CFSHL__(v3, 1);
-    R5_ = *IndirPtr((LongPtr *)&R0_, v2) & 0x40;
+    R5_ = *IndirPtr(*(LongPtr *)&R0_, v2) & 0x40;
     WriteReg(DMAP1, (R5_ >> 3) | 1);
     WriteReg(BBAD1, 0x18u);
     WriteRegWord(VMADDL, *(uint16 *)&R3_);
-    v4 = IndirPtr((LongPtr *)&R0_, v2);
+    v4 = IndirPtr(*(LongPtr *)&R0_, v2);
     LOBYTE(v5) = HIBYTE(*(uint16 *)v4);
     HIBYTE(v5) = *(uint16 *)v4;
     v6 = (v5 & 0x3FFF) + 1;
@@ -2406,7 +2406,7 @@ void ProcessAreaData() {
       *(uint16 *)&object_index = i;
       behind_area_parser_flag = 0;
       v1 = area_data_offset;
-      v2 = *IndirPtr(&area_data_ptr, area_data_offset);
+      v2 = *IndirPtr(area_data_ptr, area_data_offset);
       if (v2 == 0xFD)
         goto LABEL_20;
       if ((v2 & 0xF) == 15)
@@ -2418,19 +2418,19 @@ LABEL_20:
       }
       if (level_3_byte_object_flag)
         ++v1;
-      if (__CFSHL__(*IndirPtr(&area_data_ptr, v1 + 1), 1) && !area_object_page_sel) {
+      if (__CFSHL__(*IndirPtr(area_data_ptr, v1 + 1), 1) && !area_object_page_sel) {
         ++area_object_page_sel;
         ++area_object_page_loc;
       }
       v1 = area_data_offset;
-      v3 = *IndirPtr(&area_data_ptr, area_data_offset) & 0xF;
+      v3 = *IndirPtr(area_data_ptr, area_data_offset) & 0xF;
       if (v3 == 13) {
-        v4 = IndirPtr(&area_data_ptr, v1 + 1);
+        v4 = IndirPtr(area_data_ptr, v1 + 1);
         v1 = area_data_offset;
         if ((*v4 & 0x40) == 0 && !area_object_page_sel) {
           if (level_3_byte_object_flag)
             v1 = area_data_offset + 1;
-          area_object_page_loc = *IndirPtr(&area_data_ptr, v1 + 1) & 0x1F;
+          area_object_page_loc = *IndirPtr(area_data_ptr, v1 + 1) & 0x1F;
           ++area_object_page_sel;
           goto LABEL_22;
         }
@@ -2487,7 +2487,7 @@ void DecodeAreaData(uint8 k, uint16 j) {
   tempF6 = 0;
   level_3_byte_object_flag = 0;
   v3 = 16;
-  v4 = IndirPtr(&area_data_ptr, j);
+  v4 = IndirPtr(area_data_ptr, j);
   if (*v4 == 0xFD)
     return;
   v5 = *v4 & 0xF;
@@ -2506,9 +2506,9 @@ void DecodeAreaData(uint8 k, uint16 j) {
       if (tempF6)
         *(uint16 *)&j = j + 1;
       v8 = j + 1;
-      if ((*IndirPtr(&area_data_ptr, v8) & 0x40) == 0)
+      if ((*IndirPtr(area_data_ptr, v8) & 0x40) == 0)
         return;
-      v9 = *IndirPtr(&area_data_ptr, v8) & 0x7F;
+      v9 = *IndirPtr(area_data_ptr, v8) & 0x7F;
       if (v9 == 75)
         ++loop_command;
       v7 = v9 & 0x3F;
@@ -2517,20 +2517,20 @@ void DecodeAreaData(uint8 k, uint16 j) {
     if (v5 >= 0xCu) {
       if (tempF6)
         *(uint16 *)&j = j + 1;
-      v13 = *IndirPtr(&area_data_ptr, j + 1) & 0x70;
+      v13 = *IndirPtr(area_data_ptr, j + 1) & 0x70;
     } else {
       if (tempF6)
         *(uint16 *)&j = j + 1;
       v10 = j + 1;
-      v11 = IndirPtr(&area_data_ptr, v10);
+      v11 = IndirPtr(area_data_ptr, v10);
       v12 = *v11 & 0x70;
       if (!v12) {
         R7_ = 22;
-        v7 = *IndirPtr(&area_data_ptr, v10) & 0xF;
+        v7 = *IndirPtr(area_data_ptr, v10) & 0xF;
         goto LABEL_32;
       }
       R0_ = *v11 & 0x70;
-      if (v12 == 112 && (*IndirPtr(&area_data_ptr, v10) & 8) != 0)
+      if (v12 == 112 && (*IndirPtr(area_data_ptr, v10) & 8) != 0)
         R0_ = 0;
       v13 = R0_;
     }
@@ -2554,7 +2554,7 @@ LABEL_43:
     return;
   }
   if (area_object_page_loc != column_pos_hi) {
-    if ((*IndirPtr(&area_data_ptr, area_data_offset) & 0xF) != 14 || !backloading_flag)
+    if ((*IndirPtr(area_data_ptr, area_data_offset) & 0xF) != 14 || !backloading_flag)
       return;
     goto LABEL_40;
   }
@@ -2565,7 +2565,7 @@ LABEL_43:
     object_index_upper_empty = 0;
     return;
   }
-  if ((uint8)(*IndirPtr(&area_data_ptr, area_data_offset) & 0xF0) >> 4 == current_column_pos_lo) {
+  if ((uint8)(*IndirPtr(area_data_ptr, area_data_offset) & 0xF0) >> 4 == current_column_pos_lo) {
 LABEL_40:
     area_obj_offset_buffer[(uint8)(2 * v6) >> 1] = area_data_offset;
     if (tempF6)
@@ -2589,7 +2589,7 @@ void ExtObj2E_AlterAreaAttributes(uint8 k) {
   uint8 v1;  // al
   uint8 v2;  // [rsp+47h] [rbp-1h]
 
-  v2 = *IndirPtr(&area_data_ptr, area_obj_offset_buffer[(uint16)(2 * k) >> 1] + 1);
+  v2 = *IndirPtr(area_data_ptr, area_obj_offset_buffer[(uint16)(2 * k) >> 1] + 1);
   if ((v2 & 0x40) != 0) {
     v1 = v2 & 7;
     if ((v2 & 7u) >= 4) {
@@ -3114,8 +3114,8 @@ uint8 GetLrgObjAttrib(uint8 k) {
   uint16 v1;  // di
 
   v1 = area_obj_offset_buffer[(uint16)(2 * k) >> 1];
-  R7_ = *IndirPtr(&area_data_ptr, v1) & 0xF;
+  R7_ = *IndirPtr(area_data_ptr, v1) & 0xF;
-  return *IndirPtr(&area_data_ptr, v1 + 1) & 0xF;
+  return *IndirPtr(area_data_ptr, v1 + 1) & 0xF;
 }
 
 uint8 GetAreaObjXPosition() {
@@ -5160,24 +5160,24 @@ LABEL_31:
         return;
       }
       v2 = enemy_data_offset2;
-      v3 = IndirPtr(&enemy_data_ptr, enemy_data_offset2);
+      v3 = IndirPtr(enemy_data_ptr, enemy_data_offset2);
       if (*v3 == 0xFF)
         goto LABEL_59;
-      if ((*v3 & 0xF) != 14 && k >= 8u && (*IndirPtr(&enemy_data_ptr, (uint8)(v2 + 1)) & 0x3F) != 46)
+      if ((*v3 & 0xF) != 14 && k >= 8u && (*IndirPtr(enemy_data_ptr, (uint8)(v2 + 1)) & 0x3F) != 46)
         return;
       uint16 t;
       t = PAIR16(screen_right_xpos_hi, screen_right_xpos) + 48;
       R7_ = t & 0xF0;
       R6_ = t >> 8;
       v4 = enemy_data_offset2 + 1;
-      if (__CFSHL__(*IndirPtr(&enemy_data_ptr, (uint8)(enemy_data_offset2 + 1)), 1) && !enemy_object_page_sel) {
+      if (__CFSHL__(*IndirPtr(enemy_data_ptr, (uint8)(enemy_data_offset2 + 1)), 1) && !enemy_object_page_sel) {
         ++enemy_object_page_sel;
         ++enemy_object_page_loc;
       }
       v5 = v4 - 1;
-      if ((*IndirPtr(&enemy_data_ptr, v5) & 0xF) != 15 || enemy_object_page_sel) {
+      if ((*IndirPtr(enemy_data_ptr, v5) & 0xF) != 15 || enemy_object_page_sel) {
         obj_xpos_hi.enemy[k] = enemy_object_page_loc;
-        v6 = *IndirPtr(&enemy_data_ptr, v5) & 0xF0;
+        v6 = *IndirPtr(enemy_data_ptr, v5) & 0xF0;
         obj_xpos_lo.enemy[k] = v6;
         if (obj_xpos_hi.enemy[k] >= ((v6 < screen_right_xpos) + screen_right_xpos_hi)) {
           if (R6_ < ((R7_ < obj_xpos_lo.enemy[k]) + obj_xpos_hi.enemy[k])) {
@@ -5196,14 +5196,14 @@ LABEL_59:
             }
           } else {
             obj_ypos_hi.enemy[k] = 1;
-            v7 = 16 * *IndirPtr(&enemy_data_ptr, v5);
+            v7 = 16 * *IndirPtr(enemy_data_ptr, v5);
             obj_ypos_lo.enemy[k] = v7;
             if (v7 == 0xE0)
               goto LABEL_66;
             v8 = v5 + 1;
-            if ((*IndirPtr(&enemy_data_ptr, v8) & 0x40) != 0 && !secondary_hard_mode)
+            if ((*IndirPtr(enemy_data_ptr, v8) & 0x40) != 0 && !secondary_hard_mode)
               goto LABEL_71;
-            v9 = IndirPtr(&enemy_data_ptr, v8);
+            v9 = IndirPtr(enemy_data_ptr, v8);
             v10 = *v9 & 0x3F;
             if (v10 < 0x37u || (*v9 & 0x3F) == 63) {
               if (v10 == 6 && primary_hard_mode)
@@ -5220,17 +5220,17 @@ LABEL_59:
             }
           }
         } else {
-          if ((*IndirPtr(&enemy_data_ptr, v5) & 0xF) != 14) {
+          if ((*IndirPtr(enemy_data_ptr, v5) & 0xF) != 14) {
-            if ((*IndirPtr(&enemy_data_ptr, enemy_data_offset2) & 0xF) == 14)
+            if ((*IndirPtr(enemy_data_ptr, enemy_data_offset2) & 0xF) == 14)
               goto LABEL_70;
             goto LABEL_71;
           }
 LABEL_66:
           v12 = v5 + 2;
-          if (*IndirPtr(&enemy_data_ptr, v12) >> 5 == world_number) {
+          if (*IndirPtr(enemy_data_ptr, v12) >> 5 == world_number) {
             v13 = v12 - 1;
-            area_pointer = *IndirPtr(&enemy_data_ptr, v13);
+            area_pointer = *IndirPtr(enemy_data_ptr, v13);
-            entrance_page = *IndirPtr(&enemy_data_ptr, (uint8)(v13 + 1)) & 0x1F;
+            entrance_page = *IndirPtr(enemy_data_ptr, (uint8)(v13 + 1)) & 0x1F;
           }
 LABEL_70:
           ++enemy_data_offset2;
@@ -5241,7 +5241,7 @@ LABEL_71:
         }
         return;
       }
-      enemy_object_page_loc = *IndirPtr(&enemy_data_ptr, (uint8)(v5 + 1)) & 0x3F;
+      enemy_object_page_loc = *IndirPtr(enemy_data_ptr, (uint8)(v5 + 1)) & 0x3F;
       ++enemy_data_offset2;
       ++enemy_data_offset2;
       ++enemy_object_page_sel;

smb1/smb1_01.c

@@ -646,7 +646,7 @@ void SpawnCastleTilesWithPriority() {
   v0 = *(uint16 *)&vram_buffer1_offset;
   v1 = 0;
   do {
-    v2 = IndirPtr((LongPtr *)&tempF3, v1);
+    v2 = IndirPtr(*(LongPtr *)&tempF3, v1);
     v3 = *(uint16 *)v2;
     *(uint16 *)&vram_buffer1[v0 + 1] = *(uint16 *)v2;
     v1 += 2;
@@ -765,7 +765,7 @@ void DecodeAreaData_Sub2_New(uint16 j) {
   tempF3 = area_data_ptr.addr;
   tempF4 = area_data_ptr.addr >> 8;
   tempF5 = area_data_ptr.bank;
-  v1 = *IndirPtr((LongPtr *)&tempF3, (j + 2)) & 0x7F;
+  v1 = *IndirPtr(*(LongPtr *)&tempF3, (j + 2)) & 0x7F;
   R0_ = *((uint8 *)kDATA_048E43 + v1);
   R1_ = *((uint8 *)kDATA_048E43 + v1 + 1);
   v2 = object_index;
@@ -1014,8 +1014,8 @@ uint8 CODE_0491C0(uint8 k) {
   uint16 v1;  // di
 
   v1 = area_obj_offset_buffer[(uint16)(2 * k) >> 1] + 1;
-  R7_ = *IndirPtr((LongPtr *)&tempF3, v1) >> 4;
+  R7_ = *IndirPtr(*(LongPtr *)&tempF3, v1) >> 4;
-  return *IndirPtr((LongPtr *)&tempF3, v1) & 0xF;
+  return *IndirPtr(*(LongPtr *)&tempF3, v1) & 0xF;
 }
 
 uint8 CODE_0491DD() {
@@ -1385,7 +1385,7 @@ PairU16 CODE_049724(uint8 k, uint8 j) {
   *(uint16 *)&R4_ = 1;
   *(uint16 *)&R0_ = 16;
   do {
-    palette_mirror[k >> 1] = *(uint16 *)IndirPtr((LongPtr *)&R2_, j);
+    palette_mirror[k >> 1] = *(uint16 *)IndirPtr(*(LongPtr *)&R2_, j);
     j += 2;
     k += 2;
     --*(uint16 *)&R0_;
@@ -1429,7 +1429,7 @@ void CODE_04973C() {
     tempF7 = *((uint8 *)kDATA_04B683 + (uint16)(*(uint16 *)&tempF8 + 1)) & 0x3F;
     while (1) {
       uint16 t = g_ram[0xf3] | g_ram[0xf4] << 8;
-      IndirWriteByte((LongPtr *)&tempF3, v2, tempF7);
+      IndirWriteByte(*(LongPtr *)&tempF3, v2, tempF7);
       if (!tempF6 || (v2 & 0xF0) == 0xD0)
         break;
       LOBYTE(v1) = v2 + 16;
@@ -1633,7 +1633,7 @@ LABEL_8:
   LOBYTE(area_data_ptr.addr) = kAreaDataAddrLow[v2];
   HIBYTE(area_data_ptr.addr) = kAreaDataAddrHigh[v2];
   area_data_ptr.bank = 1;
-  v7 = *IndirPtr(&area_data_ptr, 0);
+  v7 = *IndirPtr(area_data_ptr, 0);
   v3 = v7 & 7;
   if ((v7 & 7u) >= 4) {
     background_color_ctrl = v7 & 4;
@@ -1642,7 +1642,7 @@ LABEL_8:
   foreground_scenery = v3;
   player_entrance_ctrl = (uint8)(v7 & 0x38) >> 3;
   game_timer_setting = 2 * (4 * (v7 & 0xC0) + __CFSHL__(v7 & 0xC0, 1)) + __CFSHL__(2 * (v7 & 0xC0), 1);
-  v8 = *IndirPtr(&area_data_ptr, 1u);
+  v8 = *IndirPtr(area_data_ptr, 1u);
   terrain_control = v8 & 0xF;
   v4 = (uint8)(v8 & 0x30) >> 4;
   if (v4 == 1)

smb1/smb1_02.c

@@ -920,10 +920,10 @@ void SetupLayer2BgB() {
     v0 = *(uint16 *)&tempEB + 16;
   do {
     v1 = 4 * (*(uint16 *)&tempEF - 16);
-    layer2_bgdata[v0 + 32] = *IndirPtr(&tempD8, v1++);
+    layer2_bgdata[v0 + 32] = *IndirPtr(tempD8, v1++);
-    layer2_bgdata[v0 + 33] = *IndirPtr(&tempD8, v1++);
+    layer2_bgdata[v0 + 33] = *IndirPtr(tempD8, v1++);
-    layer2_bgdata[v0 + 48] = *IndirPtr(&tempD8, v1);
+    layer2_bgdata[v0 + 48] = *IndirPtr(tempD8, v1);
-    layer2_bgdata[v0 + 49] = *IndirPtr(&tempD8, v1 + 1);
+    layer2_bgdata[v0 + 49] = *IndirPtr(tempD8, v1 + 1);
     v0 += 2;
     --*(uint16 *)&tempF1;
   } while (*(int16 *)&tempF1 >= 0);
@@ -1112,12 +1112,12 @@ void GenerateLayer2Map16() {
     v3 = *(uint16 *)&tempE4;
     v4 = 8 * (uint8)v2;
     v5 = *(uint16 *)&tempE4 >> 1;
-    layer2_map16_table[v5] = *(uint16 *)IndirPtr((LongPtr *)&R0_, v4);
+    layer2_map16_table[v5] = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v4);
     v4 += 2;
-    layer2_map16_table[v5 + 1] = *(uint16 *)IndirPtr((LongPtr *)&R0_, v4);
+    layer2_map16_table[v5 + 1] = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v4);
     v4 += 2;
-    layer2_map16_table[v5 + 32] = *(uint16 *)IndirPtr((LongPtr *)&R0_, v4);
+    layer2_map16_table[v5 + 32] = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v4);
-    layer2_map16_table[v5 + 33] = *(uint16 *)IndirPtr((LongPtr *)&R0_, v4 + 2);
+    layer2_map16_table[v5 + 33] = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v4 + 2);
     v1 = v6 + 1;
     if ((v1 & 0xF) == 0) v3 += 64;
     v0 = v3 + 4;

smb1/smb1_08.c

@@ -59,10 +59,10 @@ void HandleSPCUploads_Main() {
   LOBYTE(v1) = -52;
   while (1) {
     v13 = v1;
-    v9 = IndirPtr((LongPtr *)&R0_, v0);
+    v9 = IndirPtr(*(LongPtr *)&R0_, v0);
     v10 = v0 + 2;
     v4 = *(uint16 *)v9;
-    v11 = *(uint16 *)IndirPtr((LongPtr *)&R0_, v10);
+    v11 = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v10);
     v12 = v10 + 2;
     WriteRegWord(APUI02, v11);
     WriteReg(APUI01, v4 != 0);
@@ -71,14 +71,14 @@ void HandleSPCUploads_Main() {
       ;
     if (Unreachable())
       break;
-    v2 = IndirPtr((LongPtr *)&R0_, v12);
+    v2 = IndirPtr(*(LongPtr *)&R0_, v12);
     v0 = v12 + 1;
     HIBYTE(v1) = *v2;
     for (LOBYTE(v1) = 0;; LOBYTE(v1) = v1 + 1) {
       WriteRegWord(APUI00, v1);
       if (!--v4)
         break;
-      v3 = IndirPtr((LongPtr *)&R0_, v0++);
+      v3 = IndirPtr(*(LongPtr *)&R0_, v0++);
       HIBYTE(v1) = *v3;
       while ((uint8)v1 != ReadReg(APUI00))
         ;

smbll/smbll_00.c

@@ -1594,17 +1594,17 @@ void Smbll_UploadStripeImage() {
 
   R6_ = 0;
   v0 = 0;
-  for (i = *IndirPtr((LongPtr *)&R0_, 0); i >= 0; i = *IndirPtr((LongPtr *)&R0_, v0)) {
+  for (i = *IndirPtr(*(LongPtr *)&R0_, 0); i >= 0; i = *IndirPtr(*(LongPtr *)&R0_, v0)) {
     R4_ = i;
     v2 = v0 + 1;
-    R3_ = *IndirPtr((LongPtr *)&R0_, v2++);
+    R3_ = *IndirPtr(*(LongPtr *)&R0_, v2++);
-    v3 = *IndirPtr((LongPtr *)&R0_, v2) & 0x80;
+    v3 = *IndirPtr(*(LongPtr *)&R0_, v2) & 0x80;
     R7_ = 4 * v3 + __CFSHL__(v3, 1);
-    R5_ = *IndirPtr((LongPtr *)&R0_, v2) & 0x40;
+    R5_ = *IndirPtr(*(LongPtr *)&R0_, v2) & 0x40;
     WriteReg(DMAP1, (R5_ >> 3) | 1);
     WriteReg(BBAD1, 0x18u);
     WriteRegWord(VMADDL, *(uint16 *)&R3_);
-    v4 = IndirPtr((LongPtr *)&R0_, v2);
+    v4 = IndirPtr(*(LongPtr *)&R0_, v2);
     LOBYTE(v5) = HIBYTE(*(uint16 *)v4);
     HIBYTE(v5) = *(uint16 *)v4;
     v6 = (v5 & 0x3FFF) + 1;
@@ -2420,7 +2420,7 @@ void Smbll_ProcessAreaData() {
       *(uint16 *)&object_index = i;
       behind_area_parser_flag = 0;
       v1 = area_data_offset;
-      v2 = *IndirPtr(&area_data_ptr, area_data_offset);
+      v2 = *IndirPtr(area_data_ptr, area_data_offset);
       if (v2 == 0xFD)
         goto LABEL_20;
       if ((v2 & 0xF) == 15)
@@ -2432,19 +2432,19 @@ LABEL_20:
       }
       if (level_3_byte_object_flag)
         ++v1;
-      if (__CFSHL__(*IndirPtr(&area_data_ptr, v1 + 1), 1) && !area_object_page_sel) {
+      if (__CFSHL__(*IndirPtr(area_data_ptr, v1 + 1), 1) && !area_object_page_sel) {
         ++area_object_page_sel;
         ++area_object_page_loc;
       }
       v1 = area_data_offset;
-      v3 = *IndirPtr(&area_data_ptr, area_data_offset) & 0xF;
+      v3 = *IndirPtr(area_data_ptr, area_data_offset) & 0xF;
       if (v3 == 13) {
-        v4 = IndirPtr(&area_data_ptr, v1 + 1);
+        v4 = IndirPtr(area_data_ptr, v1 + 1);
         v1 = area_data_offset;
         if ((*v4 & 0x40) == 0 && !area_object_page_sel) {
           if (level_3_byte_object_flag)
             v1 = area_data_offset + 1;
-          area_object_page_loc = *IndirPtr(&area_data_ptr, v1 + 1) & 0x1F;
+          area_object_page_loc = *IndirPtr(area_data_ptr, v1 + 1) & 0x1F;
           ++area_object_page_sel;
           goto LABEL_22;
         }
@@ -2500,7 +2500,7 @@ void Smbll_DecodeAreaData(uint8 k, uint16 j) {
   tempF6 = 0;
   level_3_byte_object_flag = 0;
   v3 = 16;
-  v4 = IndirPtr(&area_data_ptr, j);
+  v4 = IndirPtr(area_data_ptr, j);
   if (*v4 == 0xFD)
     return;
   v5 = *v4 & 0xF;
@@ -2519,9 +2519,9 @@ void Smbll_DecodeAreaData(uint8 k, uint16 j) {
       if (tempF6)
         *(uint16 *)&j = j + 1;
       v8 = j + 1;
-      if ((*IndirPtr(&area_data_ptr, v8) & 0x40) == 0)
+      if ((*IndirPtr(area_data_ptr, v8) & 0x40) == 0)
         return;
-      v9 = *IndirPtr(&area_data_ptr, v8) & 0x7F;
+      v9 = *IndirPtr(area_data_ptr, v8) & 0x7F;
       if (v9 == 75)
         ++loop_command;
       v7 = v9 & 0x3F;
@@ -2530,20 +2530,20 @@ void Smbll_DecodeAreaData(uint8 k, uint16 j) {
     if (v5 >= 0xCu) {
       if (tempF6)
         *(uint16 *)&j = j + 1;
-      v13 = *IndirPtr(&area_data_ptr, j + 1) & 0x70;
+      v13 = *IndirPtr(area_data_ptr, j + 1) & 0x70;
     } else {
       if (tempF6)
         *(uint16 *)&j = j + 1;
       v10 = j + 1;
-      v11 = IndirPtr(&area_data_ptr, v10);
+      v11 = IndirPtr(area_data_ptr, v10);
       v12 = *v11 & 0x70;
       if (!v12) {
         R7_ = 24;
-        v7 = *IndirPtr(&area_data_ptr, v10) & 0xF;
+        v7 = *IndirPtr(area_data_ptr, v10) & 0xF;
         goto LABEL_32;
       }
       R0_ = *v11 & 0x70;
-      if (v12 == 112 && (*IndirPtr(&area_data_ptr, v10) & 8) != 0)
+      if (v12 == 112 && (*IndirPtr(area_data_ptr, v10) & 8) != 0)
         R0_ = 0;
       v13 = R0_;
     }
@@ -2567,7 +2567,7 @@ LABEL_43:
     return;
   }
   if (area_object_page_loc != column_pos_hi) {
-    if ((*IndirPtr(&area_data_ptr, area_data_offset) & 0xF) != 14 || !backloading_flag)
+    if ((*IndirPtr(area_data_ptr, area_data_offset) & 0xF) != 14 || !backloading_flag)
       return;
     goto LABEL_40;
   }
@@ -2578,7 +2578,7 @@ LABEL_43:
     object_index_upper_empty = 0;
     return;
   }
-  if ((uint8)(*IndirPtr(&area_data_ptr, area_data_offset) & 0xF0) >> 4 == current_column_pos_lo) {
+  if ((uint8)(*IndirPtr(area_data_ptr, area_data_offset) & 0xF0) >> 4 == current_column_pos_lo) {
 LABEL_40:
     area_obj_offset_buffer[(uint16)(2 * v6) >> 1] = area_data_offset;
     if (tempF6)
@@ -2609,7 +2609,7 @@ void Smbll_ExtObj2E_AlterAreaAttributes(uint8 k) {
   uint8 v1;  // al
   uint8 v2;  // [rsp+47h] [rbp-1h]
 
-  v2 = *IndirPtr(&area_data_ptr, area_obj_offset_buffer[(uint16)(2 * k) >> 1] + 1);
+  v2 = *IndirPtr(area_data_ptr, area_obj_offset_buffer[(uint16)(2 * k) >> 1] + 1);
   if ((v2 & 0x40) != 0) {
     v1 = v2 & 7;
     if ((v2 & 7u) >= 4) {
@@ -3160,8 +3160,8 @@ uint8 Smbll_GetLrgObjAttrib(uint8 k) {
   uint16 v1;  // di
 
   v1 = area_obj_offset_buffer[(uint16)(2 * k) >> 1];
-  R7_ = *IndirPtr(&area_data_ptr, v1) & 0xF;
+  R7_ = *IndirPtr(area_data_ptr, v1) & 0xF;
-  return *IndirPtr(&area_data_ptr, v1 + 1) & 0xF;
+  return *IndirPtr(area_data_ptr, v1 + 1) & 0xF;
 }
 
 uint8 Smbll_GetAreaObjXPosition() {
@@ -5288,34 +5288,34 @@ void Smbll_EnemiesAndLoopsCore(uint8 k) {
           return;
         }
         v2 = enemy_data_offset2;
-        v3 = IndirPtr(&enemy_data_ptr, enemy_data_offset2);
+        v3 = IndirPtr(enemy_data_ptr, enemy_data_offset2);
         if (*v3 == 0xFF)
           goto LABEL_56;
-        if ((*v3 & 0xF) != 14 && k >= 5u && (*IndirPtr(&enemy_data_ptr, (uint8)(v2 + 1)) & 0x3F) != 46)
+        if ((*v3 & 0xF) != 14 && k >= 5u && (*IndirPtr(enemy_data_ptr, (uint8)(v2 + 1)) & 0x3F) != 46)
           return;
         uint16 t;
         t = PAIR16(screen_right_xpos_hi, screen_right_xpos) + 48;
         R7_ = t & 0xF0;
         R6_ = t >> 8;
         v4 = enemy_data_offset2 + 1;
-        if (__CFSHL__(*IndirPtr(&enemy_data_ptr, (uint8)(enemy_data_offset2 + 1)), 1) && !enemy_object_page_sel) {
+        if (__CFSHL__(*IndirPtr(enemy_data_ptr, (uint8)(enemy_data_offset2 + 1)), 1) && !enemy_object_page_sel) {
           ++enemy_object_page_sel;
           ++enemy_object_page_loc;
         }
         v5 = v4 - 1;
-        if ((*IndirPtr(&enemy_data_ptr, v5) & 0xF) != 15 || enemy_object_page_sel)
+        if ((*IndirPtr(enemy_data_ptr, v5) & 0xF) != 15 || enemy_object_page_sel)
           break;
-        enemy_object_page_loc = *IndirPtr(&enemy_data_ptr, (uint8)(v5 + 1)) & 0x3F;
+        enemy_object_page_loc = *IndirPtr(enemy_data_ptr, (uint8)(v5 + 1)) & 0x3F;
         ++enemy_data_offset2;
         ++enemy_data_offset2;
         ++enemy_object_page_sel;
       }
       obj_xpos_hi.enemy[k] = enemy_object_page_loc;
-      v6 = *IndirPtr(&enemy_data_ptr, v5) & 0xF0;
+      v6 = *IndirPtr(enemy_data_ptr, v5) & 0xF0;
       obj_xpos_lo.enemy[k] = v6;
       if (obj_xpos_hi.enemy[k] < ((v6 < screen_right_xpos) + screen_right_xpos_hi)) {
-        if ((*IndirPtr(&enemy_data_ptr, v5) & 0xF) != 14) {
+        if ((*IndirPtr(enemy_data_ptr, v5) & 0xF) != 14) {
-          if ((*IndirPtr(&enemy_data_ptr, enemy_data_offset2) & 0xF) != 14) {
+          if ((*IndirPtr(enemy_data_ptr, enemy_data_offset2) & 0xF) != 14) {
 LABEL_69:
             ++enemy_data_offset2;
             ++enemy_data_offset2;
@@ -5328,10 +5328,10 @@ LABEL_68:
         }
 LABEL_63:
         v12 = v5 + 2;
-        if (world_number == 8 || (Smbll_sub_C462(*IndirPtr(&enemy_data_ptr, v12)) == world_number)) {
+        if (world_number == 8 || (Smbll_sub_C462(*IndirPtr(enemy_data_ptr, v12)) == world_number)) {
           v14 = v12 - 1;
-          area_pointer = *IndirPtr(&enemy_data_ptr, v14);
+          area_pointer = *IndirPtr(enemy_data_ptr, v14);
-          entrance_page = *IndirPtr(&enemy_data_ptr, (uint8)(v14 + 1)) & 0x1F;
+          entrance_page = *IndirPtr(enemy_data_ptr, (uint8)(v14 + 1)) & 0x1F;
         }
         goto LABEL_68;
       }
@@ -5351,14 +5351,14 @@ LABEL_56:
         }
       } else {
         obj_ypos_hi.enemy[k] = 1;
-        v7 = 16 * *IndirPtr(&enemy_data_ptr, v5);
+        v7 = 16 * *IndirPtr(enemy_data_ptr, v5);
         obj_ypos_lo.enemy[k] = v7;
         if (v7 == 0xE0)
           goto LABEL_63;
         v8 = v5 + 1;
-        if ((*IndirPtr(&enemy_data_ptr, v8) & 0x40) != 0 && !secondary_hard_mode)
+        if ((*IndirPtr(enemy_data_ptr, v8) & 0x40) != 0 && !secondary_hard_mode)
           goto LABEL_69;
-        v9 = IndirPtr(&enemy_data_ptr, v8);
+        v9 = IndirPtr(enemy_data_ptr, v8);
         v10 = *v9 & 0x3F;
         if (v10 >= 0x37u && (*v9 & 0x3F) != 63) {
           Smbll_HandleGroupEnemies(v10);

smbll/smbll_01.c

@@ -401,7 +401,7 @@ void Smbll_SpawnCastleTilesWithPriority() {
   v0 = *(uint16 *)vram_buffer1;
   v1 = 0;
   do {
-    v2 = IndirPtr((LongPtr *)&tempF3, v1);
+    v2 = IndirPtr(*(LongPtr *)&tempF3, v1);
     v3 = *(uint16 *)v2;
     *(uint16 *)&vram_buffer1[v0 + 2] = *(uint16 *)v2;
     v1 += 2;
@@ -544,7 +544,7 @@ void Smbll_DecodeAreaData_Sub2_New(uint16 j) {
   tempF4 = HIBYTE(addr);
   tempF3 = addr;
   tempF5 = area_data_ptr.bank;
-  v3 = IndirPtr((LongPtr *)&tempF3, j + 2);
+  v3 = IndirPtr(*(LongPtr *)&tempF3, j + 2);
   v4 = *v3 & 0x7F;
   v5 = (int)(uint8)v4 >> 1;
   R0_ = *((uint8 *)koff_188C1 + (*v3 & 0x7F));
@@ -848,8 +848,8 @@ uint8 Smbll_CODE_0491C0(uint8 k) {
   uint16 v1;  // di
 
   v1 = area_obj_offset_buffer[(uint16)(2 * k) >> 1] + 1;
-  R7_ = *IndirPtr((LongPtr *)&tempF3, v1) >> 4;
+  R7_ = *IndirPtr(*(LongPtr *)&tempF3, v1) >> 4;
-  return *IndirPtr((LongPtr *)&tempF3, v1) & 0xF;
+  return *IndirPtr(*(LongPtr *)&tempF3, v1) & 0xF;
 }
 
 uint8 Smbll_CODE_0491DD() {
@@ -1199,7 +1199,7 @@ PairU16 Smbll_CODE_049724(uint8 k, uint8 j) {
   *(uint16 *)&R4_ = 1;
   *(uint16 *)&R0_ = 16;
   do {
-    palette_mirror[k >> 1] = *(uint16 *)IndirPtr((LongPtr *)&R2_, j);
+    palette_mirror[k >> 1] = *(uint16 *)IndirPtr(*(LongPtr *)&R2_, j);
     j += 2;
     k += 2;
     --*(uint16 *)&R0_;
@@ -1242,7 +1242,7 @@ void Smbll_CODE_04973C() {
     *(uint16 *)&tempF6 = v3;
     tempF7 = *((uint8 *)kword_1B4BA + (uint16)(*(uint16 *)&tempF8 + 1)) & 0x3F;
     while (1) {
-      IndirWriteByte((LongPtr *)&tempF3, v2, tempF7);
+      IndirWriteByte(*(LongPtr *)&tempF3, v2, tempF7);
       if (!tempF6 || (v2 & 0xF0) == 0xD0)
         break;
       LOBYTE(v1) = v2 + 16;
@@ -1451,7 +1451,7 @@ void Smbll_GetAreaDataAddrs() {
   LOBYTE(area_data_ptr.addr) = kbyte_1C582[area_data_addr_index];
   HIBYTE(area_data_ptr.addr) = kbyte_1C5C9[area_data_addr_index];
   area_data_ptr.bank = 1;
-  v7 = *IndirPtr(&area_data_ptr, 0);
+  v7 = *IndirPtr(area_data_ptr, 0);
   v4 = v7 & 7;
   if ((v7 & 7u) >= 4) {
     background_color_ctrl = v7 & 7;
@@ -1460,7 +1460,7 @@ void Smbll_GetAreaDataAddrs() {
   foreground_scenery = v4;
   player_entrance_ctrl = (uint8)(v7 & 0x38) >> 3;
   game_timer_setting = 2 * (4 * (v7 & 0xC0) + __CFSHL__(v7 & 0xC0, 1)) + __CFSHL__(2 * (v7 & 0xC0), 1);
-  v8 = *IndirPtr(&area_data_ptr, 1u);
+  v8 = *IndirPtr(area_data_ptr, 1u);
   terrain_control = v8 & 0xF;
   background_scenery = (uint8)(v8 & 0x30) >> 4;
   v5 = 2 * (4 * (v8 & 0xC0) + __CFSHL__(v8 & 0xC0, 1)) + __CFSHL__(2 * (v8 & 0xC0), 1);

smbll/smbll_02.c

@@ -903,10 +903,10 @@ void Smbll_SetupLayer2BgB() {
     v0 = *(uint16 *)&tempEB + 16;
   do {
     v1 = 4 * (*(uint16 *)&tempEF - 16);
-    layer2_bgdata[v0 + 32] = *IndirPtr(&tempD8, v1++);
+    layer2_bgdata[v0 + 32] = *IndirPtr(tempD8, v1++);
-    layer2_bgdata[v0 + 33] = *IndirPtr(&tempD8, v1++);
+    layer2_bgdata[v0 + 33] = *IndirPtr(tempD8, v1++);
-    layer2_bgdata[v0 + 48] = *IndirPtr(&tempD8, v1);
+    layer2_bgdata[v0 + 48] = *IndirPtr(tempD8, v1);
-    layer2_bgdata[v0 + 49] = *IndirPtr(&tempD8, v1 + 1);
+    layer2_bgdata[v0 + 49] = *IndirPtr(tempD8, v1 + 1);
     v0 += 2;
     --*(uint16 *)&tempF1;
   } while (*(int16 *)&tempF1 >= 0);
@@ -1103,12 +1103,12 @@ void Smbll_GenerateLayer2Map16() {
     v3 = *(uint16 *)&tempE4;
     v4 = 8 * (uint8)v2;
     v5 = *(uint16 *)&tempE4 >> 1;
-    layer2_map16_table[v5] = *(uint16 *)IndirPtr((LongPtr *)&R0_, v4);
+    layer2_map16_table[v5] = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v4);
     v4 += 2;
-    layer2_map16_table[v5 + 1] = *(uint16 *)IndirPtr((LongPtr *)&R0_, v4);
+    layer2_map16_table[v5 + 1] = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v4);
     v4 += 2;
-    layer2_map16_table[v5 + 32] = *(uint16 *)IndirPtr((LongPtr *)&R0_, v4);
+    layer2_map16_table[v5 + 32] = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v4);
-    layer2_map16_table[v5 + 33] = *(uint16 *)IndirPtr((LongPtr *)&R0_, v4 + 2);
+    layer2_map16_table[v5 + 33] = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v4 + 2);
     v1 = v6 + 1;
     if ((((uint8)v6 + 1) & 0xF) == 0)
       v3 += 64;

smbll/smbll_08.c

@@ -58,10 +58,10 @@ void Smbll_HandleSPCUploads_Main() {
   LOBYTE(v1) = -52;
   while (1) {
     v13 = v1;
-    v9 = IndirPtr((LongPtr *)&R0_, v0);
+    v9 = IndirPtr(*(LongPtr *)&R0_, v0);
     v10 = v0 + 2;
     v4 = *(uint16 *)v9;
-    v11 = *(uint16 *)IndirPtr((LongPtr *)&R0_, v10);
+    v11 = *(uint16 *)IndirPtr(*(LongPtr *)&R0_, v10);
     v12 = v10 + 2;
     WriteRegWord(APUI02, v11);
     WriteReg(APUI01, v4 != 0);
@@ -70,14 +70,14 @@ void Smbll_HandleSPCUploads_Main() {
       ;
     if (Unreachable())
       break;
-    v2 = IndirPtr((LongPtr *)&R0_, v12);
+    v2 = IndirPtr(*(LongPtr *)&R0_, v12);
     v0 = v12 + 1;
     HIBYTE(v1) = *v2;
     for (LOBYTE(v1) = 0;; LOBYTE(v1) = v1 + 1) {
       WriteRegWord(APUI00, v1);
       if (!--v4)
         break;
-      v3 = IndirPtr((LongPtr *)&R0_, v0++);
+      v3 = IndirPtr(*(LongPtr *)&R0_, v0++);
       HIBYTE(v1) = *v3;
       while ((uint8)v1 != ReadReg(APUI00))
         ;

src/common_cpu_infra.c

@@ -18,7 +18,7 @@ Cpu *g_cpu;
 bool g_calling_asm_from_c;
 int g_calling_asm_from_c_ret;
 bool g_fail;
-bool g_use_my_apu_code = false;
+bool g_use_my_apu_code = true;
 extern bool g_other_image;
 const RtlGameInfo *g_rtl_game_info;
 
@@ -211,17 +211,17 @@ static void MakeSnapshot(Snapshot *s) {
   s->vTimer = g_snes->vTimer;
   memcpy(s->ram, g_snes->ram, 0x20000);
   memcpy(s->sram, g_snes->cart->ram, g_snes->cart->ramSize);
-  memcpy(s->vram, g_snes->ppu->vram, sizeof(uint16) * 0x8000);
+  memcpy(s->vram, g_ppu->vram, sizeof(uint16) * 0x8000);
-  memcpy(s->oam, g_snes->ppu->oam, sizeof(uint16) * 0x120);
+  memcpy(s->oam, g_ppu->oam, sizeof(uint16) * 0x120);
-  memcpy(s->cgram, g_snes->ppu->cgram, sizeof(uint16) * 0x100);
+  memcpy(s->cgram, g_ppu->cgram, sizeof(uint16) * 0x100);
 }
 
 static void MakeMySnapshot(Snapshot *s) {
   memcpy(s->ram, g_snes->ram, 0x20000);
   memcpy(s->sram, g_snes->cart->ram, g_snes->cart->ramSize);
-  memcpy(s->vram, g_snes->ppu->vram, sizeof(uint16) * 0x8000);
+  memcpy(s->vram, g_ppu->vram, sizeof(uint16) * 0x8000);
-  memcpy(s->oam, g_snes->ppu->oam, sizeof(uint16) * 0x120);
+  memcpy(s->oam, g_ppu->oam, sizeof(uint16) * 0x120);
-  memcpy(s->cgram, g_snes->ppu->cgram, sizeof(uint16) * 0x100);
+  memcpy(s->cgram, g_ppu->cgram, sizeof(uint16) * 0x100);
 }
 
 static void RestoreSnapshot(Snapshot *s) {
@@ -233,66 +233,66 @@ static void RestoreSnapshot(Snapshot *s) {
   cpu_setFlags(c, s->flags);
   memcpy(g_snes->ram, s->ram, 0x20000);
   memcpy(g_snes->cart->ram, s->sram, g_snes->cart->ramSize);
-  memcpy(g_snes->ppu->vram, s->vram, sizeof(uint16) * 0x8000);
+  memcpy(g_ppu->vram, s->vram, sizeof(uint16) * 0x8000);
-  memcpy(g_snes->ppu->oam, s->oam, sizeof(uint16) * 0x120);
+  memcpy(g_ppu->oam, s->oam, sizeof(uint16) * 0x120);
-  memcpy(g_snes->ppu->cgram, s->cgram, sizeof(uint16) * 0x100);
+  memcpy(g_ppu->cgram, s->cgram, sizeof(uint16) * 0x100);
-}
-
-static bool loadRom(const char *name, Snes *snes) {
-  size_t length = 0;
-  uint8_t *file = NULL;
-  file = ReadWholeFile(name, &length);
-  if (file == NULL) {
-    fprintf(stderr, "Failed to read file: %s\n", name);
-    return false;
-  }
-  bool result = snes_loadRom(snes, file, (int)length);
-  free(file);
-  return result;
 }
 
 static void FixupCarry(uint32 addr) {
   *SnesRomPtr(addr) = 0;
 }
   
-Snes *SnesInit(const char *filename) {
+Snes *SnesInit(const uint8 *data, int data_size) {
-  g_snes = snes_init(g_ram);
+  g_my_ppu = ppu_init();
+  ppu_reset(g_my_ppu);
 
+  g_snes = snes_init(g_ram);
   g_cpu = g_snes->cpu;
+  g_dma = g_snes->dma;
   g_use_my_apu_code = (g_runmode != RM_THEIRS);
 
-  bool loaded = loadRom(filename, g_snes);
+  RtlSetupEmuCallbacks(NULL, &RtlRunFrameCompare, NULL);
-  if (!loaded) {
+
-    return NULL;
+  if (data_size != 0) {
+    bool loaded = snes_loadRom(g_snes, data, data_size);
+    if (!loaded) {
+      return NULL;
+    }
+    g_rom = g_snes->cart->rom;
+
+    if (memcmp(g_rom + 0x7fc0, "Super Mario Bros. LL ", 21) == 0) {
+      g_rtl_game_info = &kSmbllGameInfo;
+    } else if (memcmp(g_rom + 0x7fc0, "Super Mario Bros. 1  ", 21) == 0) {
+      g_rtl_game_info = &kSmb1GameInfo;
+    } else {
+      g_rtl_game_info = &kSmwGameInfo;
+    }
+
+    for (size_t i = 0; i != g_rtl_game_info->patch_carrys_count; i++) {
+      uint8 t = *SnesRomPtr(g_rtl_game_info->patch_carrys[i]);
+      if (t) {
+        kPatchedCarrysOrg[i] = t;
+        FixupCarry(g_rtl_game_info->patch_carrys[i]);
+      } else {
+        printf("0x%x double patched!\n", g_rtl_game_info->patch_carrys[i]);
+      }
+    }
+    PatchBugs(1, 0);
+  } else {
+    g_runmode = RM_MINE;
+    g_snes->cart->ramSize = 2048;
+    g_snes->cart->ram = calloc(1, 2048);
+    g_rtl_game_info = &kSmwGameInfo;
+
+    ppu_reset(g_snes->ppu);
+    dma_reset(g_snes->dma);
   }
 
   g_sram = g_snes->cart->ram;
   g_sram_size = g_snes->cart->ramSize;
-  g_rom = g_snes->cart->rom;
-
-  RtlSetupEmuCallbacks(NULL, &RtlRunFrameCompare, NULL);
-
-  if (memcmp(g_rom + 0x7fc0, "Super Mario Bros. LL ", 21) == 0) {
-    g_rtl_game_info = &kSmbllGameInfo;
-  } else if (memcmp(g_rom + 0x7fc0, "Super Mario Bros. 1  ", 21) == 0) {
-    g_rtl_game_info = &kSmb1GameInfo;
-  } else {
-    g_rtl_game_info = &kSmwGameInfo;
-  }
-
   game_id = g_rtl_game_info->game_id;
   g_rtl_game_info->initialize();
 
-  for (size_t i = 0; i != g_rtl_game_info->patch_carrys_count; i++) {
-    uint8 t = *SnesRomPtr(g_rtl_game_info->patch_carrys[i]);
-    if (t) {
-      kPatchedCarrysOrg[i] = t;
-      FixupCarry(g_rtl_game_info->patch_carrys[i]);
-    } else {
-      printf("0x%x double patched!\n", g_rtl_game_info->patch_carrys[i]);
-    }
-  }
-  PatchBugs(1, 0);
   return g_snes;
 }
 
@@ -306,7 +306,7 @@ void SaveBugSnapshot() {
 }
 
 void RunOneFrameOfGame_Both(void) {
-  g_snes->ppu = g_snes->snes_ppu;
+  g_ppu = g_snes->ppu;
   MakeSnapshot(&g_snapshot_before);
 
   // Run orig version then snapshot
@@ -317,7 +317,7 @@ again_theirs:
 
   // Run my version and snapshot
 //again_mine:
-  g_snes->ppu = g_snes->my_ppu;
+  g_ppu = g_my_ppu;
   RestoreSnapshot(&g_snapshot_before);
 
   g_snes->runningWhichVersion = 2;
@@ -335,7 +335,7 @@ again_theirs:
 
     printf("Verify failure!\n");
 
-    g_snes->ppu = g_snes->snes_ppu;
+    g_ppu = g_snes->ppu;
     RestoreSnapshot(&g_snapshot_before);
 
     if (g_debug_flag)
@@ -346,10 +346,10 @@ again_theirs:
     goto getout;
   }
 
-  g_snes->ppu = g_snes->snes_ppu;
+  g_ppu = g_snes->ppu;
   RestoreSnapshot(&g_snapshot_theirs);
 getout:
-  g_snes->ppu = g_other_image ? g_snes->my_ppu : g_snes->snes_ppu;
+  g_ppu = g_other_image ? g_my_ppu : g_snes->ppu;
   g_snes->runningWhichVersion = 0;
 
   if (g_got_mismatch_count)
@@ -362,12 +362,12 @@ static void RtlRunFrameCompare(uint16 input, int run_what) {
   g_use_my_apu_code = (g_runmode != RM_THEIRS);
 
   if (g_runmode == RM_THEIRS) {
-    g_snes->ppu = g_snes->snes_ppu;
+    g_ppu = g_snes->ppu;
     g_snes->runningWhichVersion = 1;
     g_rtl_game_info->run_frame_emulated();
     g_snes->runningWhichVersion = 0;
   } else if (g_runmode == RM_MINE) {
-    g_snes->ppu = g_snes->snes_ppu;
+    g_ppu = g_my_ppu;
     g_snes->runningWhichVersion = 2;
     g_rtl_game_info->run_frame();
     g_snes->runningWhichVersion = 0;

src/common_cpu_infra.h

@@ -12,7 +12,7 @@ extern bool g_fail;
 
 typedef struct Snes Snes;
 
-Snes *SnesInit(const char *filename);
+Snes *SnesInit(const uint8 *data, int data_size);
 bool FixBugHook(uint32 addr);
 uint8_t *SnesRomPtr(uint32 v);
 

src/common_rtl.c

@@ -22,6 +22,8 @@ bool g_is_uploading_apu;
 bool g_did_finish_level_hook;
 uint8 game_id;
 bool g_playback_mode;
+Ppu *g_ppu, *g_my_ppu;
+Dma *g_dma;
 
 static uint8 *g_rtl_memory_ptr;
 static RunFrameFunc *g_rtl_runframe;
@@ -74,10 +76,10 @@ void loadFunc(SaveLoadInfo *sli, void *data, size_t data_size) {
   memcpy(data, st->p, data_size);
   st->p += data_size;
 }
+
 static void LoadSnesState(SaveLoadInfo *sli) {
   // Do the actual loading
   snes_saveload(g_snes, sli);
-  g_snes->cpu->e = false;
   RtlSynchronizeWholeState();
 }
 
@@ -163,6 +165,7 @@ void ReadFromFile(FILE *f, void *data, size_t n) {
 void RtlReset(int mode) {
   snes_frame_counter = 0;
   snes_reset(g_snes, true);
+  ppu_reset(g_my_ppu);
   if (!(mode & 1))
     memset(g_sram, 0, g_sram_size);
 
@@ -432,8 +435,6 @@ bool RtlRunFrame(int inputs) {
         StateRecorder_RecordPatchByte(&state_recorder, kSmwRam_APUI02, &apui02, 1);
       }
     }
-
-
   }
 
   g_rtl_runframe(inputs, 0);
@@ -456,13 +457,9 @@ void RtlSaveSnapshot(const char *filename, bool saving_with_bug) {
 static void RtlLoadFromFile(FILE *f, bool replay) {
   RtlApuLock();
 
-  Ppu *ppu = g_snes->ppu;
-  g_snes->ppu = g_snes->snes_ppu;
-
   StateRecorder_Load(&state_recorder, f, replay);
-  ppu_copy(g_snes->my_ppu, g_snes->ppu);
+  ppu_copy(g_my_ppu, g_snes->ppu);
 
-  g_snes->ppu = ppu;
   RtlApuUnlock();
   RtlSynchronizeWholeState();
 }
@@ -472,7 +469,7 @@ static const char *const kBugSaves[] = {
 };
 
 
-static int g_playback_ctr = ( 89 - 1) * 2; // 49
+static int g_playback_ctr = ( 1) * 2 - 1; // 36
 void SmwLoadNextPlaybackSnapshot() {
   char name[128];
   for (int i = 0; i < 100; i++) {
@@ -531,8 +528,8 @@ void mov24(struct LongPtr *a, uint32 d) {
   a->bank = d >> 16;
 }
 
-uint32 Load24(const LongPtr *src) {
+uint32 Load24(LongPtr src) {
-  return *(uint32 *)src & 0xffffff;
+  return *(uint32 *)&src & 0xffffff;
 }
 
 bool Unreachable(void) {
@@ -543,7 +540,7 @@ bool Unreachable(void) {
 }
 
 uint8 *RomPtr(uint32_t addr) {
-  if (!(addr & 0x8000)) {
+  if (!(addr & 0x8000) || addr >= 0x7e0000) {
     printf("RomPtr - Invalid access 0x%x!\n", addr);
     if (!g_fail) {
       g_fail = true;
@@ -592,8 +589,8 @@ void WriteRegWord(uint16 reg, uint16 value) {
   WriteReg(reg + 1, value >> 8);
 }
 
-uint8 *IndirPtr(LongPtr *ptr, uint16 offs) {
+uint8 *IndirPtr(LongPtr ptr, uint16 offs) {
-  uint32 a = (*(uint32 *)ptr & 0xffffff) + offs;
+  uint32 a = (*(uint32 *)&ptr & 0xffffff) + offs;
   if ((a >> 16) >= 0x7e && (a >> 16) <= 0x7f || (a & 0xffff) < 0x2000) {
     return &g_ram[a & 0x1ffff];
   } else {
@@ -601,12 +598,7 @@ uint8 *IndirPtr(LongPtr *ptr, uint16 offs) {
   }
 }
 
-void IndirWriteWord(LongPtr *ptr, uint16 offs, uint16 value) {
+void IndirWriteByte(LongPtr ptr, uint16 offs, uint8 value) {
-  uint8 *p = IndirPtr(ptr, offs);
-  WORD(*p) = value;
-}
-
-void IndirWriteByte(LongPtr *ptr, uint16 offs, uint8 value) {
   uint8 *p = IndirPtr(ptr, offs);
   p[0] = value;
 }
@@ -818,36 +810,36 @@ void RtlWriteSram(void) {
 
 void SmwCopyToVram(uint16 vram_addr, const uint8 *src, int n) {
   for (size_t i = 0; i < (n >> 1); i++)
-    g_snes->ppu->vram[vram_addr + i] = WORD(src[i * 2]);
+    g_ppu->vram[vram_addr + i] = WORD(src[i * 2]);
 }
 
 void SmwCopyToVramPitch32(uint16 vram_addr, const uint8 *src, int n) {
   for (size_t i = 0; i < (n >> 1); i++)
-    g_snes->ppu->vram[vram_addr + i * 32] = WORD(src[i * 2]);
+    g_ppu->vram[vram_addr + i * 32] = WORD(src[i * 2]);
 }
 
 void SmwCopyToVramLow(uint16 vram_addr, const uint8 *src, int n) {
   for (size_t i = 0; i < n; i++)
-    g_snes->ppu->vram[vram_addr + i] = (g_snes->ppu->vram[vram_addr + i] & 0xff00) | src[i];
+    g_ppu->vram[vram_addr + i] = (g_ppu->vram[vram_addr + i] & 0xff00) | src[i];
 }
 
 void RtlUpdatePalette(const uint16 *src, int dst, int n) {
   for(int i = 0; i < n; i++)
-    g_snes->ppu->cgram[dst + i] = src[i];
+    g_ppu->cgram[dst + i] = src[i];
 }
 
 void SmwClearVram(uint16 vram_addr, uint16 value, int n) {
   for (int i = 0; i < n; i++)
-    g_snes->ppu->vram[vram_addr + i] = value;
+    g_ppu->vram[vram_addr + i] = value;
 }
 
 uint16 *RtlGetVramAddr() {
-  return g_snes->ppu->vram;
+  return g_ppu->vram;
 }
 
 void RtlPpuWrite(uint16 addr, uint8 value) {
   assert((addr & 0xff00) == 0x2100);
-  ppu_write(g_snes->ppu, addr, value);
+  ppu_write(g_ppu, addr, value);
 }
 
 void RtlPpuWriteTwice(uint16 addr, uint16 value) {
@@ -856,7 +848,7 @@ void RtlPpuWriteTwice(uint16 addr, uint16 value) {
 }
 
 void RtlHdmaSetup(uint8 which, uint8 transfer_unit, uint8 reg, uint32 addr, uint8 indirect_bank) {
-  Dma *dma = g_snes->dma;
+  Dma *dma = g_dma;
   dma_write(dma, DMAP0 + which * 16, transfer_unit);
   dma_write(dma, BBAD0 + which * 16, reg);
   dma_write(dma, A1T0L + which * 16, addr);
@@ -944,7 +936,7 @@ void LoadStripeImage_UploadToVRAM(const uint8 *pp) {  // 00871e
     uint8 vmain = __CFSHL__(pp[2], 1);
     uint8 fixed_addr = (uint8)(pp[2] & 0x40) >> 3;
     uint16 num = (swap16(WORD(pp[2])) & 0x3FFF) + 1;
-    uint16 *dst = g_snes->ppu->vram + vram_addr;
+    uint16 *dst = g_ppu->vram + vram_addr;
     pp += 4;
     
     if (fixed_addr) {

src/common_rtl.h

@@ -26,17 +26,21 @@ typedef struct SimpleHdma {
   uint8 indir_bank;
 } SimpleHdma;
 
+
+typedef struct Dma Dma;
 typedef struct DmaChannel DmaChannel;
+typedef struct Ppu Ppu;
 
 void SimpleHdma_Init(SimpleHdma *c, DmaChannel *dc);
 void SimpleHdma_DoLine(SimpleHdma *c);
 void RtlHdmaSetup(uint8 which, uint8 transfer_unit, uint8 reg, uint32 addr, uint8 indirect_bank);
 
-
 extern uint8 g_ram[0x20000];
 extern uint8 *g_sram;
 extern int g_sram_size;
 extern const uint8 *g_rom;
+extern Ppu *g_ppu, *g_my_ppu;
+extern Dma *g_dma;
 
 #define GET_BYTE(p) (*(uint8*)(p))
 
@@ -49,7 +53,7 @@ typedef struct SpcPlayer SpcPlayer;
 extern SpcPlayer *g_spc_player;
 
 void mov24(LongPtr *dst, uint32 src);
-uint32 Load24(const LongPtr *src);
+uint32 Load24(LongPtr src);
 void MemCpy(void *dst, const void *src, int size);
 bool Unreachable();
 
@@ -65,6 +69,7 @@ static inline const uint8 *RomFixedPtr(uint32_t addr) { return &g_rom[(((addr >>
 #define GET_BYTE(p) (*(uint8*)(p))
 
 uint8 *RomPtr(uint32_t addr);
+
 static inline uint8 *RomPtr_RAM(uint16_t addr) { assert(addr < 0x2000); return g_ram + addr; }
 static inline const uint8 *RomPtr_00(uint16_t addr) { return RomPtr(0x000000 | addr); }
 static inline const uint8 *RomPtr_01(uint16_t addr) { return RomPtr(0x010000 | addr); }
@@ -93,9 +98,8 @@ void WriteReg(uint16 reg, uint8 value);
 void WriteRegWord(uint16 reg, uint16 value);
 uint16 ReadRegWord(uint16 reg);
 uint8 ReadReg(uint16 reg);
-uint8_t *IndirPtr(LongPtr *ptr, uint16 offs);
+uint8_t *IndirPtr(LongPtr ptr, uint16 offs);
-void IndirWriteWord(LongPtr *ptr, uint16 offs, uint16 value);
+void IndirWriteByte(LongPtr ptr, uint16 offs, uint8 value);
-void IndirWriteByte(LongPtr *ptr, uint16 offs, uint8 value);
 
 
 typedef void RunFrameFunc(uint16 input, int run_what);

src/consts.h

@@ -1,75 +1,33 @@
 #include "types.h"
-#define kLoadStripeImage_StripeImagePtrs ((LongPtr*)RomFixedPtr(0x84D0))
-#define kChangeNetDoorTiles_DATA_00C32E ((LongPtr*)RomFixedPtr(0xC32E))
-#define kManipulateMode7Image_DATA_008B57 ((uint16*)RomFixedPtr(0x8B57))
-#define kUpdatePaletteFromIndexedTable_DATA_00A47F ((uint8*)RomFixedPtr(0xA47F))
-
-#define kLevelTileAnimations_FrameData ((uint16*)RomFixedPtr(0x5B999))
-
-#define kPlayerGFXRt_XDisp ((uint16*)RomFixedPtr(0xDD4E))
-#define kPlayerGFXRt_YDisp ((uint16*)RomFixedPtr(0xDE32))
-
-#define kPlayerState0C_CastleDestructionMoves_CastleDestructionMovementData ((uint8*)RomFixedPtr(0xC5E8))
 
+extern const uint16 kLevelTileAnimations_FrameData[208];
 extern const uint8 kSlopeDataTables_SlopeType[33];
+extern const uint8 kSlopeDataTables_ShapeOfSlope[512];
 
 extern const uint8 kLevelDataLayoutTables_EightBitLo_Horizontal[32];
 extern const uint8 kLevelDataLayoutTables_EightBitLo_Vertical[28];
 extern const uint8 kLevelDataLayoutTables_EightBitHi_Horizontal[32];
 extern const uint8 kLevelDataLayoutTables_EightBitHi_Vertical[28];
 
-extern const uint16 kGlobalPalettes_BowserLightningFlash[11];
 extern const uint16 kGlobalPalettes_Bowser[56];
+extern const uint16 kGlobalPalettes_Background[];
 
 extern const uint8 kGameModeXX_FadeInOrOut_DATA_009F2F[2];
 extern const uint8 kGameModeXX_FadeInOrOut_DATA_009F31[2];
 extern const uint8 kGameModeXX_FadeInOrOut_DATA_009F33[2];
 
-extern const uint16 kLevelDataLayoutTables_LoTablePtrs[2];
-extern const uint16 kLevelDataLayoutTables_HiTablePtrs[2];
-
 extern const uint16 kGlobalPalettes_Sky[8];
 extern const uint8 kGameMode19_Cutscene_SkyColorSetting[8];
 
 extern const uint8 kGenericSpriteToSpawnTable[19];
 extern const uint16 kSpr01F_MagiKoopa_MagiKoopaFadePalettes[64];
 
-#define kDrawOverworldPlayer_PlayerRidingYoshiTilesAndProp ((uint8*)RomFixedPtr(0x489DE))
-
 extern const uint8 kOverworldLightningAndRandomCloudSpawning_DATA_04F700[8];
 extern const uint8 kOverworldLightningAndRandomCloudSpawning_DATA_04F6F8[8];
-#define kDrawOverworldPlayer_PlayerTilesAndProp ((uint16*)RomFixedPtr(0x487CB))
-#define kLevelNames ((uint16*)RomFixedPtr(0x4A0FC))
-
-#define kHandleOverworldPathExits_DATA_049964 ((OwExits*)RomFixedPtr(0x49964))
-#define kHandleOverworldPathExits_DATA_0499AA ((OwExits*)RomFixedPtr(0x499AA))
-#define kOverworldLightningAndRandomCloudSpawning ((uint8*)RomFixedPtr(0x4F708))
-
-#define kInitializeLevelLayer3_Layer3ImagePtrs ((LongPtr*)RomFixedPtr(0x59000))
 
 extern const uint8 kBitTable_Bank05[8];
-#define kDisplayMessage_DATA_05A5D9 ((uint8*)RomFixedPtr(0x5A5D9))
-#define kLevelTileAnimations_DATA_05B93B ((LevelTileAnimations*)RomFixedPtr(0x5B93B))
-#define kSpecifySublevelToLoad_DATA_05D608 ((uint8*)RomFixedPtr(0x5D608))
-#define kSpecifySublevelToLoad_LevelEntranceLayer1 ((LongPtr*)RomFixedPtr(0x5D766))
-#define kSpecifySublevelToLoad_LevelEntranceLayer2 ((LongPtr*)RomFixedPtr(0x5D778))
-
-#define kSpecifySublevelToLoad_Layer1DataPtrs ((LongPtr*)RomFixedPtr(0x5E000))
-#define kSpecifySublevelToLoad_Layer2DataPtrs ((LongPtr*)RomFixedPtr(0x5E600))
-#define kSpecifySublevelToLoad_SpriteDataPtrs ((uint16*)RomFixedPtr(0x5EC00))
-#define kSpecifySublevelToLoad_DATA_05F000 ((uint8*)RomFixedPtr(0x5F000))
-#define kSpecifySublevelToLoad_DATA_05F200 ((uint8*)RomFixedPtr(0x5F200))
-#define kSpecifySublevelToLoad_DATA_05F400 ((uint8*)RomFixedPtr(0x5F400))
-#define kSpecifySublevelToLoad_DATA_05F600 ((uint8*)RomFixedPtr(0x5F600))
-#define kSpecifySublevelToLoad_DATA_05F800 ((uint8*)RomFixedPtr(0x5F800))
-#define kSpecifySublevelToLoad_DATA_05FA00 ((uint8*)RomFixedPtr(0x5FA00))
-#define kSpecifySublevelToLoad_DATA_05FC00 ((uint8*)RomFixedPtr(0x5FC00))
-#define kSpecifySublevelToLoad_DATA_05FE00 ((uint8*)RomFixedPtr(0x5FE00))
 
 extern const uint8 kInitializeNormalSpriteRAMTables_Sprite190FVals[201];
+extern const uint16 kCircleCoordinates[256];
 
-#define kCircleCoordinates ((uint16*)RomFixedPtr(0x7F7DB))
-#define kOverworldLayer2EventTilemap_Tiles ((uint8*)RomFixedPtr(0xC8000))
-#define kGameMode1B_EndingCinema_Tilemaps ((uint8*)RomFixedPtr(0xC95C7))
-#define kGameMode1B_EndingCinema_RowPointers ((uint16*)RomFixedPtr(0xC9D18))
 

src/funcs.h

@@ -5,7 +5,7 @@ typedef struct CollInfo {
 } CollInfo;
 
 typedef struct HdmaPtrs {
-  uint16 r4, r6;
+  const uint8 *r4, *r6;
 } HdmaPtrs;
 
 typedef struct PairU8 {
@@ -26,6 +26,10 @@ typedef struct CheckPlatformCollRet {
   bool out_of_bounds;
 } CheckPlatformCollRet;
 
+const uint16 *GetLayerLayoutPtr(int layer, int top);
+const uint16 *GetPlayerPalette();
+const uint16 *GetMap16RomAddr(uint8 bank, uint16_t addr);
+
 // Bank 0
 PairU16 BufferFileSelectText_009DB5(uint8 k);
 PairU16 GetPlayerLevelCollisionMap16ID_Entry2(uint8 k);
@@ -36,7 +40,6 @@ PairU16 OwPrompt03_OverworldLifeExchanger_00974C(uint8 a);
 uint8 CheckWaterSlope(uint8 a);
 uint8 CheckWhatSlopeSpriteIsOn(uint8 a, uint8 r10, uint8 r12, uint8 *r8_slope_type);
 uint8 GameMode07_TitleScreenDemo_009CBE(void);
-uint8 GraphicsDecompressionRoutines_ReadByte(void);
 uint8 HandleMenuCursor_Main_ReturnsTwice(uint8 j);
 uint16 ManipulateMode7Image_008B2B(uint16 k, uint8 r0);
 uint8 ModifyMap16IDForSpecialBlocks(uint8 a);
@@ -52,7 +55,7 @@ void BufferLoadingLetterTiles(void);
 void BufferPalettesRoutines_IggyLarryPlatform(void);
 void BufferPalettesRoutines_Levels(void);
 void BufferPalettesRoutines_LoadColorInVerticalStrip(uint16 k, uint16 r4);
-void BufferPalettesRoutines_LoadColors(uint16 r0, uint16 r4, uint16 r6, uint16 r8);
+void BufferPalettesRoutines_LoadColors(const uint16 *r0, uint16 r4, uint16 r6, uint16 r8);
 void BufferPalettesRoutines_Overworld(void);
 void BufferPalettesRoutines_Overworld(void);
 void BufferPalettesRoutines_ReznorAndMode7KoopaBosses(void);
@@ -145,7 +148,7 @@ void GenericPage01Tile_00C0FB(GenTileArgs *gta, uint16 j);
 void GenericPage01Tile(GenTileArgs *gta);
 void GenericPage01Tile_Return00C1AB(void);
 void GenericPage01Tile_SetItemMemory(GenTileArgs *gta);
-void GraphicsDecompressTo(uint8 *pdst);
+void GraphicsDecompressTo(const uint8 *src, uint8 *pdst);
 void GraphicsDecompressionRoutines_DecompressGFX32And33(void);
 const uint8 *GraphicsDecompress(uint8 j);
 void HandleMenuCursor_009E82(uint8 j);
@@ -1160,15 +1163,15 @@ void Spr09F_BanzaiBill_Draw(uint8 k);
 void Spr09F_BanzaiBill_Sub(uint8 k);
 PointU8 Spr0A3_GreyChainedPlatform_02D813(uint8 k);
 PointU8 Spr0A3_GreyChainedPlatform_02D848(uint8 k);
-void Spr0DE_Load5Eeries(uint8 k, uint16 r0w, uint8 r2, uint8 r3);
+void Spr0DE_Load5Eeries(uint8 k, uint16 r0w, uint8 r2, const uint8 *edata);
-void Spr0E0_Load3Platforms(uint16 r0w, uint8 r2, uint8 r3);
+void Spr0E0_Load3Platforms(uint16 r0w, uint8 r2, const uint8 *edata);
-void Spr0E1_LoadBooCeiling(uint8 k, uint8 a, uint16 r0w, uint8 r2, uint8 r3);
+void Spr0E1_LoadBooCeiling(uint8 k, uint8 a, uint16 r0w, uint8 r2, const uint8 *edata);
 void SprXXX_Dolphins(uint8 k);
 void SprXXX_Dolphins_Draw(uint8 k);
 void SprXXX_JumpingPiranhaPlant_02E17F(uint8 k);
 void SprXXX_JumpingPiranhaPlant_02E1C0(uint8 k, uint8 a);
 void Spr04F_JumpingPiranhaPlant(uint8 k);
-void SprXXX_LoadShooter(uint8 k, uint8 j, uint8 a, uint16 r0w);
+void SprXXX_LoadShooter(uint8 k, uint8 a, uint16 r0w, const uint8 *edata);
 void SprXXX_SuperKoopas_02EB3D(uint8 k, uint8 j);
 void SprXXX_SuperKoopas_02EBB5(uint8 k, uint8 r0);
 void SprXXX_SuperKoopas_02EBCA(uint8 k);
@@ -1610,9 +1613,9 @@ void ScrollLayer3(void);
 void ScrollSecondInteractiveLayer(void);
 void ScrollSecondInteractiveLayer(void);
 void ShowCourseClearText(void);
-void SpecifySublevelToLoad_05DBAC(void);
+void LoadLevel_05DBAC(void);
-void SpecifySublevelToLoad_HandleChocolateIsland2Gimmick(void);
+void LoadLevel_HandleChocolateIsland2Gimmick(void);
-void SpecifySublevelToLoad(void);
+void LoadLevel(void);
 void Spr0E7_SpecialAutoScroll_Layer2(void);
 void Spr0E7_SpecialAutoScroll(void);
 void Spr0E9_Layer2Smash(void);

src/main.c

@@ -13,6 +13,8 @@
 #include <unistd.h>
 #endif
 
+#include "assets/smw_assets.h"
+
 #include "snes/ppu.h"
 
 #include "types.h"
@@ -22,11 +24,15 @@
 #include "util.h"
 #include "smw_spc_player.h"
 
+#include "snes/snes.h"
 #ifdef __SWITCH__
 #include "switch_impl.h"
 #endif
 
+#include "assets/smw_assets.h"
+
 static void SDLCALL AudioCallback(void *userdata, Uint8 *stream, int len);
+static void LoadAssets();
 static void SwitchDirectory();
 static void RenderNumber(uint8 *dst, size_t pitch, int n, uint8 big);
 static void OpenOneGamepad(int i);
@@ -41,7 +47,7 @@ void OpenGLRenderer_Create(struct RendererFuncs *funcs);
 bool g_debug_flag;
 bool g_want_dump_memmap_flags;
 bool g_new_ppu = true;
-bool g_other_image = false;
+bool g_other_image = true;
 struct SpcPlayer *g_spc_player;
 static uint32_t button_state;
 
@@ -165,7 +171,7 @@ void RtlDrawPpuFrame(uint8 *pixel_buffer, size_t pitch, uint32 render_flags) {
 }
 
 static void DrawPpuFrameWithPerf(void) {
-  int render_scale = PpuGetCurrentRenderScale(g_snes->ppu, g_ppu_render_flags);
+  int render_scale = PpuGetCurrentRenderScale(g_ppu, g_ppu_render_flags);
   uint8 *pixel_buffer = 0;
   int pitch = 0;
 
@@ -332,6 +338,8 @@ int main(int argc, char** argv) {
   }
   ParseConfigFile(config_file);
 
+  LoadAssets();
+
   g_snes_width = (g_config.extended_aspect_ratio * 2 + 256);
   g_snes_height = 224;// (g_config.extend_y ? 240 : 224);
   g_ppu_render_flags = g_config.new_renderer * kPpuRenderFlags_NewRenderer |
@@ -376,18 +384,24 @@ int main(int argc, char** argv) {
     g_renderer_funcs = kSdlRendererFuncs;
   }
 
-  // init snes, load rom
+  if (argv[0]) {
-  const char* filename = argv[0] ? argv[0] : "smw.sfc";
+    size_t size;
-  Snes *snes = SnesInit(filename);
+    kRom = ReadWholeFile(argv[0], &size);
+    kRom_SIZE = (uint32)size;
+    if (!kRom)
+      goto error_reading;
+  }
 
-  if(snes == NULL) {
+  Snes *snes = SnesInit(kRom, kRom_SIZE);
-  #ifdef __SWITCH__
+  if (snes == NULL) {
+error_reading:;
+#ifdef __SWITCH__
     ThrowMissingROM();
-  #else
+#else
     char buf[256];
-    snprintf(buf, sizeof(buf), "unable to load rom: %s", filename);
+    snprintf(buf, sizeof(buf), "unable to load rom");
     Die(buf);
-  #endif
+#endif
     return 1;
   }
 
@@ -431,8 +445,8 @@ int main(int argc, char** argv) {
     g_audiobuffer = (uint8 *)calloc(g_frames_per_block * have.channels * sizeof(int16), 1);
   }
 
-  PpuBeginDrawing(snes->snes_ppu, g_pixels, 256 * 4, 0);
+  PpuBeginDrawing(g_snes->ppu, g_pixels, 256 * 4, 0);
-  PpuBeginDrawing(snes->my_ppu, g_my_pixels, 256 * 4, 0);
+  PpuBeginDrawing(g_my_ppu, g_my_pixels, 256 * 4, 0);
 
   if (g_config.save_playthrough)
     MkDir("playthrough");
@@ -809,6 +823,40 @@ static void HandleGamepadAxisInput(int gamepad_id, int axis, int value) {
   }
 }
 
+const uint8 *g_asset_ptrs[kNumberOfAssets];
+uint32 g_asset_sizes[kNumberOfAssets];
+
+static void LoadAssets() {
+  size_t length = 0;
+  uint8 *data = ReadWholeFile("assets/smw_assets.dat", &length);
+  if (!data)
+    data = ReadWholeFile("smw_assets.dat", &length);
+  if (!data) Die("Failed to read smw_assets.dat. Please see the README for information about how you get this file.");
+
+  static const char kAssetsSig[] = { kAssets_Sig };
+
+  if (length < 16 + 32 + 32 + 8 + kNumberOfAssets * 4 ||
+    memcmp(data, kAssetsSig, 48) != 0 ||
+    *(uint32*)(data + 80) != kNumberOfAssets)
+    Die("Invalid assets file");
+
+  uint32 offset = 88 + kNumberOfAssets * 4 + *(uint32 *)(data + 84);
+
+  for (size_t i = 0; i < kNumberOfAssets; i++) {
+    uint32 size = *(uint32 *)(data + 88 + i * 4);
+    offset = (offset + 3) & ~3;
+    if ((uint64)offset + size > length)
+      Die("Assets file corruption");
+    g_asset_sizes[i] = size;
+    g_asset_ptrs[i] = data + offset;
+    offset += size;
+  }
+}
+
+MemBlk FindInAssetArray(int asset, int idx) {
+  return FindIndexInMemblk((MemBlk) { g_asset_ptrs[asset], g_asset_sizes[asset] }, idx);
+}
+
 // Go some steps up and find smw.ini
 static void SwitchDirectory(void) {
   char buf[4096];

src/smw_00.c

@@ -2,6 +2,7 @@
 #include "funcs.h"
 #include "smw_rtl.h"
 #include "variables.h"
+#include "assets/smw_assets.h"
 
 static FuncV *const kInitAndMainLoop_GameModePtrs[42] = {
     &GameMode00_LoadNintendoPresents,
@@ -107,6 +108,7 @@ static const uint8 kUploadLevelLayer1And2Tilemaps_PARAMS_008A40[7] = { 0x1, 0x18
 static const uint8 kUploadLevelLayer1And2Tilemaps_PARAMS_008A47[5] = { 0x1, 0x18, 0xa8, 0x1d, 0x0,  };
 static const uint16 kManipulateMode7Image_DATA_008AB4[4] = { 0x0, 0xfe, 0x0, 0xfe,  };
 static const uint16 kManipulateMode7Image_DATA_008ABC[4] = { 0x0, 0x2, 0x0, 0x2,  };
+static const uint16 kManipulateMode7Image_DATA_008B57[149] = { 0x0, 0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x19, 0x1c, 0x1f, 0x22, 0x25, 0x28, 0x2b, 0x2e, 0x31, 0x35, 0x38, 0x3b, 0x3e, 0x41, 0x44, 0x47, 0x4a, 0x4d, 0x50, 0x53, 0x56, 0x59, 0x5c, 0x5f, 0x61, 0x64, 0x67, 0x6a, 0x6d, 0x70, 0x73, 0x75, 0x78, 0x7b, 0x7e, 0x80, 0x83, 0x86, 0x88, 0x8b, 0x8e, 0x90, 0x93, 0x95, 0x98, 0x9b, 0x9d, 0x9f, 0xa2, 0xa4, 0xa7, 0xa9, 0xab, 0xae, 0xb0, 0xb2, 0xb5, 0xb7, 0xb9, 0xbb, 0xbd, 0xbf, 0xc1, 0xc3, 0xc5, 0xc7, 0xc9, 0xcb, 0xcd, 0xcf, 0xd1, 0xd3, 0xd4, 0xd6, 0xd8, 0xd9, 0xdb, 0xdd, 0xde, 0xe0, 0xe1, 0xe3, 0xe4, 0xe6, 0xe7, 0xe8, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf1, 0xf2, 0xf3, 0xf4, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x100, 0x3cb7, 0xbcb7, 0x3cb8, 0x3cb9, 0x3cba, 0x3cbb, 0x3cba, 0xbcba, 0x3cbc, 0x3cbd, 0x3cbe, 0x3cbf, 0x3cc0, 0xbcb7, 0x3cc1, 0x3cb9, 0x3cc2, 0xbcc2, 0x3cb7, 0xfcc0,  };
 static const uint8 kStatusBarTilemap_SecondRow[118] = { 0x30, 0x28, 0x31, 0x28, 0x32, 0x28, 0x33, 0x28, 0x34, 0x28, 0xfc, 0x38, 0xfc, 0x3c, 0xfc, 0x3c, 0xfc, 0x3c, 0xfc, 0x3c, 0xfc, 0x38, 0xfc, 0x38, 0x4a, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0x4a, 0x78, 0xfc, 0x38, 0x3d, 0x3c, 0x3e, 0x3c, 0x3f, 0x3c, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0x2e, 0x3c, 0x26, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0x0, 0x38, 0x26, 0x38, 0xfc, 0x38, 0x0, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0x64, 0x28, 0x26, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0x4a, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0x4a, 0x78, 0xfc, 0x38, 0xfe, 0x3c, 0xfe, 0x3c, 0x0, 0x3c, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0x0, 0x38, 0x3a, 0xb8, 0x3b, 0xb8, 0x3b, 0xb8, 0x3a, 0xf8,  };
 static const uint8 kInitializeStatusBarTilemap_PARAMS_008D90[7] = { 0x1, 0x18, 0x81, 0x8c, 0x0, 0x8, 0x0,  };
 static const uint8 kInitializeStatusBarTilemap_PARAMS_008D97[7] = { 0x1, 0x18, 0x89, 0x8c, 0x0, 0x38, 0x0,  };
@@ -166,7 +168,6 @@ static const uint8 kUploadGraphicsFiles_FGAndBGGFXList[104] = { 0x14, 0x17, 0x19
 static const uint8 kUploadGraphicsFiles_DATA_00A9D2[4] = { 0x78, 0x70, 0x68, 0x60,  };
 static const uint8 kUploadGraphicsFiles_DATA_00A9D6[4] = { 0x18, 0x10, 0x8, 0x0,  };
 static const uint8 kBufferPalettesRoutines_DATA_00ABD3[12] = { 0x0, 0x18, 0x30, 0x48, 0x60, 0x78, 0x90, 0xa8, 0x0, 0x14, 0x28, 0x3c,  };
-static const uint16 kBufferPalettesRoutines_DATA_00ABDF[7] = { 0x0, 0x38, 0x70, 0xa8, 0xe0, 0x118, 0x150,  };
 static const uint8 kBufferPalettesRoutines_DATA_00AD1E[7] = { 0x1, 0x0, 0x3, 0x4, 0x3, 0x5, 0x2,  };
 static const uint8 kUpdatePaletteFromIndexedTable_DATA_00AE41[3] = { 0x0, 0x5, 0xa,  };
 static const uint8 kUpdatePaletteFromIndexedTable_DATA_00AE44[3] = { 0x20, 0x40, 0x80,  };
@@ -178,7 +179,6 @@ static const uint16 kHandlePaletteFades_DATA_00AEF7[16] = { 0x8000, 0x4000, 0x20
 const uint16 kGlobalPalettes_Sky[8] = { 0x5b9f, 0x6ffb, 0x5d80, 0x0, 0x1d22, 0x24c3, 0x7393, 0x7fff,  };
 static const uint16 kGlobalPalettes_BowserEnd[6] = { 0x0, 0x63fb, 0x30c, 0x20b, 0x1535, 0x1a5f,  };
 static const uint16 kGlobalPalettes_B3CC[6] = { 0x0, 0x3434, 0x443a, 0x659f, 0x116, 0x27f,  };
-const uint16 kGlobalPalettes_BowserLightningFlash[11] = { 0x0, 0x2ce7, 0x3d6b, 0x4def, 0x5e73, 0x6ef7, 0x7fff,0x7393,     0, 0x3FF,0x573B  };
 static const uint16 kGlobalPalettes_Flashing[16] = { 0x2df, 0x35f, 0x27ff, 0x5fff, 0x73ff, 0x5fff, 0x27ff, 0x35f, 0x1bf, 0x1f, 0x1b, 0x18, 0x18, 0x1b, 0x1f, 0x1bf,  };
 static const uint16 kGlobalPalettes_Layer3Smasher[4] = { 0x7393, 0x0, 0xd71, 0x1e9b,  };
 const uint16 kGlobalPalettes_Bowser[56] = { 0x7fff, 0x18c0, 0x63fb, 0x30c, 0x20b, 0x1535, 0x1a5f, 0x779b, 0x1860, 0x5b97, 0x2a8, 0x1a7, 0xcd1, 0x11fb, 0x6f37, 0x1800, 0x5333, 0x245, 0x143, 0x46e, 0x997, 0x66d3, 0x1000, 0x4acf, 0x1e1, 0xe0, 0xa, 0x133, 0x5e6f, 0x0, 0x426b, 0x180, 0x80, 0x6, 0xcf, 0x560b, 0x0, 0x3a07, 0x120, 0x20, 0x2, 0x6b, 0x4da7, 0x0, 0x31a3, 0xc0, 0x0, 0x0, 0x7, 0x4543, 0x0, 0x2940, 0x60, 0x0, 0x0, 0x3,  };
@@ -186,10 +186,6 @@ static const uint16 kGlobalPalettes_EndingLuigi[6] = { 0x44c4, 0x320, 0x4adf, 0x
 static const uint16 kGlobalPalettes_EndingMario[6] = { 0x44c4, 0x391f, 0x4adf, 0x2874, 0x13f, 0x4e08,  };
 static const uint16 kGlobalPalettes_EndingToadstool[6] = { 0x28d2, 0x551e, 0x635f, 0x7b1f, 0x1fb, 0x2de,  };
 
-static const uint32 kGraphicsPtrs[50] = {
-  0x8d9f9, 0x8e231, 0x8ecbb, 0x8f552, 0x8ff7d, 0x98963, 0x9936c, 0x99d10, 0x9a657, 0x9afa1, 0x9ba15, 0x9c39c, 0x9cd63, 0x9d5d2, 0x9ddcb, 0x9e6e5, 0x9ef1e, 0x9f7af, 0x9ffbd, 0xa8910, 0xa9348, 0xa9ae8, 0xaa374, 0xaa9b4, 0xab2ad, 0xabbe4, 0xac380, 0xacc66, 0xad47e, 0xadc88, 0xae67f, 0xaee43, 0xaf6a1, 0xaff65, 0xb88cd, 0xb91ca, 0xb9ae5, 0xba3b5, 0xbae21, 0xbb744, 0xbc06c, 0xbc6a3, 0xbcb7b, 0xbd0f0, 0xbd7b9, 0xbe006, 0xbe936, 0xbf185, 0xbf3bb, 0xbf800
-};
-
 const uint8 kLevelDataLayoutTables_EightBitLo_Horizontal[32] = { 0x0, 0xb0, 0x60, 0x10, 0xc0, 0x70, 0x20, 0xd0, 0x80, 0x30, 0xe0, 0x90, 0x40, 0xf0, 0xa0, 0x50, 
 0x0, 0xb0, 0x60, 0x10, 0xc0, 0x70, 0x20, 0xd0, 0x80, 0x30, 0xe0, 0x90, 0x40, 0xf0, 0xa0, 0x50,};
 const uint8 kLevelDataLayoutTables_EightBitLo_Vertical[28] = { 
@@ -200,8 +196,6 @@ const uint8 kLevelDataLayoutTables_EightBitHi_Horizontal[32] = { 0xc8, 0xc9, 0xc
 0xe3, 0xe4, 0xe6, 0xe8, 0xe9, 0xeb, 0xed, 0xee, 0xf0, 0xf2, 0xf3, 0xf5, 0xf7, 0xf8, 0xfa, 0xfc,};
 const uint8 kLevelDataLayoutTables_EightBitHi_Vertical[28] = { 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde, 0xe0, 0xe2,
 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,};
-const uint16 kLevelDataLayoutTables_LoTablePtrs[2] = { 0xbda8, 0xbde8,  };
-const uint16 kLevelDataLayoutTables_HiTablePtrs[2] = { 0xbe28, 0xbe68,  };
 static const uint16 kSetItemMemoryBit_DATA_00BFFF[3] = { 0x0, 0x80, 0x100,  };
 static const uint8 kSetItemMemoryBit_DATA_00C005[8] = { 0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1,  };
 static const uint8 kGenericPage00Tile_Map16Page00TileLo[9] = { 0x25, 0x25, 0x25, 0x6, 0x49, 0x48, 0x2b, 0xa2, 0xc6,  };
@@ -210,6 +204,7 @@ static const uint8 kGameMode14_InLevel_DATA_00C470[4] = { 0x90, 0x0, 0x90, 0x0,
 static const uint8 kGameMode14_InLevel_DATA_00C474[4] = { 0x4, 0xfc, 0x4, 0xfc,  };
 static const uint8 kGameMode14_InLevel_DATA_00C478[6] = { 0x30, 0x33, 0x33, 0x30, 0x1, 0x0,  };
 static const uint8 kPlayerState0C_CastleDestructionMoves_DATA_00C5E1[8] = { 0x10, 0x30, 0x31, 0x32, 0x33, 0x34, 0xe, 0x26};
+static const uint8 kPlayerState0C_CastleDestructionMoves_CastleDestructionMovementData[247] = { 0x26, 0x11, 0x2, 0x48, 0x0, 0x60, 0x1, 0x9, 0x80, 0x8, 0x0, 0x20, 0x4, 0x60, 0x0, 0x1, 0xff, 0x1, 0x2, 0x48, 0x0, 0x60, 0x41, 0x2c, 0xc1, 0x4, 0x27, 0x4, 0x2f, 0x8, 0x25, 0x1, 0x2f, 0x4, 0x27, 0x4, 0x0, 0x8, 0x41, 0x1b, 0xc1, 0x4, 0x27, 0x4, 0x2f, 0x8, 0x25, 0x1, 0x2f, 0x4, 0x27, 0x4, 0x0, 0x4, 0x1, 0x8, 0x20, 0x1, 0x1, 0x10, 0x0, 0x8, 0x41, 0x12, 0x81, 0xa, 0x0, 0x40, 0x82, 0x10, 0x2, 0x20, 0x0, 0x30, 0x1, 0x1, 0x0, 0x50, 0x22, 0x1, 0xff, 0x1, 0x2, 0x48, 0x0, 0x60, 0x1, 0x9, 0x80, 0x8, 0x0, 0x20, 0x4, 0x60, 0x0, 0x20, 0x10, 0x20, 0x1, 0x58, 0x0, 0x2c, 0x31, 0x1, 0x3a, 0x10, 0x31, 0x1, 0x3a, 0x10, 0x31, 0x1, 0x3a, 0x20, 0x28, 0xa0, 0x28, 0x40, 0x29, 0x4, 0x28, 0x4, 0x29, 0x4, 0x28, 0x4, 0x29, 0x4, 0x28, 0x40, 0x22, 0x1, 0xff, 0x1, 0x2, 0x48, 0x0, 0x60, 0x1, 0x9, 0x80, 0x8, 0x0, 0x20, 0x4, 0x60, 0x10, 0x20, 0x31, 0x1, 0x18, 0x60, 0x31, 0x1, 0x3b, 0x80, 0x31, 0x1, 0x3c, 0x40, 0xff, 0x1, 0x2, 0x48, 0x0, 0x60, 0x2, 0x30, 0x1, 0x84, 0x0, 0x20, 0x23, 0x1, 0x1, 0x16, 0x2, 0x20, 0x20, 0x1, 0x1, 0x20, 0x2, 0x20, 0x1, 0x2, 0x0, 0x80, 0xff, 0x1, 0x2, 0x48, 0x0, 0x60, 0x2, 0x28, 0x1, 0x83, 0x0, 0x28, 0x24, 0x1, 0x2, 0x1, 0x0, 0xff, 0x0, 0x40, 0x20, 0x1, 0x0, 0x40, 0x2, 0x60, 0x0, 0x30, 0xff, 0x1, 0x2, 0x48, 0x0, 0x60, 0x1, 0x4e, 0x0, 0x40, 0x26, 0x1, 0x0, 0x1e, 0x20, 0x1, 0x0, 0x20, 0x8, 0x10, 0x20, 0x1, 0x2d, 0x18, 0x0, 0xa0, 0x20, 0x1, 0x2e, 0x1, 0xff,  };
 static const uint8 kPlayerState0C_CastleDestructionMoves_DATA_00C5E9[16] = { 0x11, 0x2, 0x48, 0x0, 0x60, 0x1, 0x9, 0x80, 0x8, 0x0, 0x20, 0x4, 0x60, 0x0, 0x1, 0xff,  };
 static const uint8 kPlayerState0C_CastleDestructionMoves_UNK_00C6DF[8] = { 0x1, 0x0, 0x10, 0xa0, 0x84, 0x50, 0xbc, 0xd8,  };
 static const uint16 kPlayerState08_WarpToYoshiWingsBonus_DATA_00C7F9[2] = { 0xffc0, 0xa0,  };
@@ -261,6 +256,8 @@ static const uint8 kSetPlayerPose_WalkingPoseCount[4] = { 0x1, 0x2, 0x2, 0x2,  }
 static const uint8 kSetPlayerPose_AnimationSpeedTable[112] = { 0xa, 0x8, 0x6, 0x4, 0x3, 0x2, 0x1, 0x1, 0xa, 0x8, 0x6, 0x4, 0x3, 0x2, 0x1, 0x1, 0xa, 0x8, 0x6, 0x4, 0x3, 0x2, 0x1, 0x1, 0x8, 0x6, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x8, 0x6, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x5, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x5, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x5, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x5, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x5, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x5, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x4, 0x3, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2,  };
 static const uint8 kPlayerGFXRt_PlayerXYDispIndexIndex[70] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x4, 0x4, 0x4, 0xe, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x0, 0x0, 0x0, 0x0, 0xc, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0,  };
 static const uint8 kPlayerGFXRt_PlayerXYDispIndex[28] = { 0x0, 0x8, 0x10, 0x14, 0x18, 0x1e, 0x24, 0x24, 0x28, 0x30, 0x38, 0x3e, 0x44, 0x4a, 0x50, 0x54, 0x58, 0x58, 0x5c, 0x60, 0x64, 0x68, 0x6c, 0x70, 0x74, 0x78, 0x7c, 0x80,  };
+static const uint16 kPlayerGFXRt_XDisp[114] = { 0x0, 0x0, 0x10, 0x10, 0x0, 0x0, 0xfff8, 0xfff8, 0xe, 0x6, 0xfff2, 0xfffa, 0x17, 0x7, 0xf, 0xffea, 0xfffa, 0xfffa, 0x0, 0x0, 0x0, 0x0, 0x10, 0x10, 0x0, 0x0, 0xfff8, 0xfff8, 0x0, 0xfff8, 0x8, 0x0, 0x8, 0xfff8, 0x0, 0x0, 0xfff8, 0x0, 0x0, 0x10, 0x2, 0x0, 0xfffe, 0x0, 0x0, 0x0, 0xfffc, 0x5, 0x4, 0xfffb, 0xfffb, 0x6, 0x5, 0xfffa, 0xfff9, 0x9, 0x7, 0xfff7, 0xfffd, 0xfffd, 0x3, 0x3, 0xffff, 0x7, 0x1, 0xfff9, 0xa, 0xfff6, 0x8, 0xfff8, 0x8, 0xfff8, 0x0, 0x4, 0xfffc, 0xfffe, 0x2, 0xb, 0xfff5, 0x14, 0xffec, 0xe, 0xfff3, 0x8, 0xfff8, 0xc, 0x14, 0xfffd, 0xfff4, 0xfff4, 0xb, 0xb, 0x3, 0x13, 0xfff5, 0x5, 0xfff5, 0x9, 0x1, 0x1, 0xfff7, 0x7, 0x7, 0x5, 0xd, 0xd, 0xfffb, 0xfffb, 0xfffb, 0xffff, 0xf, 0x1, 0xfff9, 0x0,  };
+static const uint16 kPlayerGFXRt_YDisp[114] = { 0x1, 0x11, 0x11, 0x19, 0x1, 0x11, 0x11, 0x19, 0xc, 0x14, 0xc, 0x14, 0x18, 0x18, 0x28, 0x18, 0x18, 0x28, 0x6, 0x16, 0x1, 0x11, 0x9, 0x11, 0x1, 0x11, 0x9, 0x11, 0x1, 0x11, 0x11, 0x1, 0x11, 0x11, 0x1, 0x11, 0x11, 0x1, 0x11, 0x11, 0x1, 0x11, 0x1, 0x11, 0x11, 0x5, 0x4, 0x14, 0x4, 0x14, 0xc, 0x14, 0xc, 0x14, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0, 0x10, 0x0, 0x10, 0x0, 0x10, 0x0, 0xb, 0xb, 0x11, 0x11, 0xffff, 0xffff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x15, 0x15, 0x25, 0x25, 0x4, 0x4, 0x4, 0x14, 0x14, 0x4, 0x14, 0x14, 0x4, 0x4, 0x14, 0x4, 0x4, 0x14, 0x0, 0x8, 0x0, 0x0, 0x8, 0x0, 0x0, 0x10, 0x18, 0x0, 0x10, 0x18, 0x0, 0x10, 0x0, 0x10, 0xfff8,  };
 static const uint8 kPlayerGFXRt_PowerupTilesetIndex[4] = { 0x0, 0x46, 0x83, 0x46,  };
 static const uint8 kPlayerGFXRt_Tiles[50] = { 0x0, 0x2, 0x80, 0x80, 0x0, 0x2, 0xc, 0x80, 0x0, 0x2, 0x1a, 0x1b, 0x0, 0x2, 0xd, 0x80, 0x0, 0x2, 0x22, 0x23, 0x0, 0x2, 0x32, 0x33, 0x0, 0x2, 0xa, 0xb, 0x0, 0x2, 0x30, 0x31, 0x0, 0x2, 0x20, 0x21, 0x0, 0x2, 0x7e, 0x80, 0x0, 0x2, 0x2, 0x80, 0x4, 0x7f, 0x4a, 0x5b, 0x4B, 0x5A };
 static const uint8 kPlayerGFXRt_TilesIndex[192] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xc, 0xc, 0x0, 0x0, 0x10, 0x10, 0x14, 0x14, 0x18, 0x18, 0x0, 0x0, 0x1c, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x24, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x4, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0xc, 0xc, 0xc, 0x0, 0x0, 0x10, 0x10, 0x14, 0x14, 0x18, 0x18, 0x0, 0x0, 0x1c, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x24, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,  };
@@ -283,7 +280,7 @@ static const uint8 kSlopeDataTables_Player_StationaryYSpeed[33] = { 0x10, 0x10,
 static const uint8 kSlopeDataTables_Player_TowardsPeakYSpeed[33] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xec, 0xec, 0xee, 0xee, 0xda, 0xda, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xda, 0xda, 0xda, 0xda, 0x0, 0x0, 0x0, 0x0, 0x0,  };
 static const uint8 kSlopeDataTables_Player_SnapToSlopeDistance[33] = { 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x9, 0x9, 0x9, 0x9, 0xb, 0xb, 0xb, 0xb, 0xb, 0xb, 0xb, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0xb, 0xb, 0xb, 0x14, 0x14, 0x14, 0x14, 0x6,  };
 const uint8 kSlopeDataTables_SlopeType[33] = { 0xff, 0xff, 0xff, 0xff, 0x1, 0x1, 0x1, 0x1, 0xfe, 0xfe, 0x2, 0x2, 0xfd, 0x3, 0xfd, 0x3, 0xfd, 0x3, 0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0xf8, 0xf8, 0xfc, 0xfc, 0x4, 0x4, 0x0,  };
-static const uint8 kSlopeDataTables_ShapeOfSlope[512] = { 0xf, 0xf, 0xf, 0xf, 0xe, 0xe, 0xe, 0xe, 0xd, 0xd, 0xd, 0xd, 0xc, 0xc, 0xc, 0xc, 0xb, 0xb, 0xb, 0xb, 0xa, 0xa, 0xa, 0xa, 0x9, 0x9, 0x9, 0x9, 0x8, 0x8, 0x8, 0x8, 0x7, 0x7, 0x7, 0x7, 0x6, 0x6, 0x6, 0x6, 0x5, 0x5, 0x5, 0x5, 0x4, 0x4, 0x4, 0x4, 0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3, 0x4, 0x4, 0x4, 0x4, 0x5, 0x5, 0x5, 0x5, 0x6, 0x6, 0x6, 0x6, 0x7, 0x7, 0x7, 0x7, 0x8, 0x8, 0x8, 0x8, 0x9, 0x9, 0x9, 0x9, 0xa, 0xa, 0xa, 0xa, 0xb, 0xb, 0xb, 0xb, 0xc, 0xc, 0xc, 0xc, 0xd, 0xd, 0xd, 0xd, 0xe, 0xe, 0xe, 0xe, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xe, 0xe, 0xd, 0xd, 0xc, 0xc, 0xb, 0xb, 0xa, 0xa, 0x9, 0x9, 0x8, 0x8, 0x7, 0x7, 0x6, 0x6, 0x5, 0x5, 0x4, 0x4, 0x3, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7, 0x8, 0x8, 0x9, 0x9, 0xa, 0xa, 0xb, 0xb, 0xc, 0xc, 0xd, 0xd, 0xe, 0xe, 0xf, 0xf, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x8, 0x6, 0x4, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x4, 0x6, 0x8, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2, 0x0, 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2, 0x0, 0xfe, 0xfc, 0xfa, 0xf8, 0xf6, 0xf4, 0xf2, 0xf0, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe,  };
+const uint8 kSlopeDataTables_ShapeOfSlope[512] = { 0xf, 0xf, 0xf, 0xf, 0xe, 0xe, 0xe, 0xe, 0xd, 0xd, 0xd, 0xd, 0xc, 0xc, 0xc, 0xc, 0xb, 0xb, 0xb, 0xb, 0xa, 0xa, 0xa, 0xa, 0x9, 0x9, 0x9, 0x9, 0x8, 0x8, 0x8, 0x8, 0x7, 0x7, 0x7, 0x7, 0x6, 0x6, 0x6, 0x6, 0x5, 0x5, 0x5, 0x5, 0x4, 0x4, 0x4, 0x4, 0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3, 0x4, 0x4, 0x4, 0x4, 0x5, 0x5, 0x5, 0x5, 0x6, 0x6, 0x6, 0x6, 0x7, 0x7, 0x7, 0x7, 0x8, 0x8, 0x8, 0x8, 0x9, 0x9, 0x9, 0x9, 0xa, 0xa, 0xa, 0xa, 0xb, 0xb, 0xb, 0xb, 0xc, 0xc, 0xc, 0xc, 0xd, 0xd, 0xd, 0xd, 0xe, 0xe, 0xe, 0xe, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xe, 0xe, 0xd, 0xd, 0xc, 0xc, 0xb, 0xb, 0xa, 0xa, 0x9, 0x9, 0x8, 0x8, 0x7, 0x7, 0x6, 0x6, 0x5, 0x5, 0x4, 0x4, 0x3, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7, 0x8, 0x8, 0x9, 0x9, 0xa, 0xa, 0xb, 0xb, 0xc, 0xc, 0xd, 0xd, 0xe, 0xe, 0xf, 0xf, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x8, 0x6, 0x4, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x4, 0x6, 0x8, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2, 0x0, 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2, 0x0, 0xfe, 0xfc, 0xfa, 0xf8, 0xf6, 0xf4, 0xf2, 0xf0, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe,  };
 static const uint16 kGetPlayerLevelCollisionMap16ID_DATA_00E832[54] = { 0x8, 0xe, 0xe, 0x8, 0x5, 0xb, 0x8, 0x2, 0x2, 0x8, 0xb, 0x5, 0x8, 0xe, 0xe, 0x8, 0x5, 0xb, 0x8, 0x2, 0x2, 0x8, 0xb, 0x5, 0x8, 0xe, 0xe, 0x8, 0x5, 0xb, 0x8, 0x2, 0x2, 0x8, 0xb, 0x5, 0x8, 0xe, 0xe, 0x8, 0x5, 0xb, 0x8, 0x2, 0x2, 0x8, 0xb, 0x5, 0x10, 0x20, 0x7, 0x0, 0xfff0, 0x8, };
 // todo: buffer read overflow
 static const uint16 kGetPlayerLevelCollisionMap16ID_DATA_00E89C[54] = { 0x18, 0x1a, 0x16, 0x10, 0x20, 0x20, 0x18, 0x1a, 0x16, 0x10, 0x20, 0x20, 0x12, 0x1a, 0xf, 0x8, 0x20, 0x20, 0x12, 0x1a, 0xf, 0x8, 0x20, 0x20, 0x1d, 0x28, 0x19, 0x13, 0x30, 0x30, 0x1d, 0x28, 0x19, 0x13, 0x30, 0x30, 0x1a, 0x28, 0x16, 0x10, 0x30, 0x30, 0x1a, 0x28, 0x16, 0x10, 0x30, 0x30, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,};
@@ -327,6 +324,16 @@ static const uint8 kSpawnPlayerFireball_xlo[6] = { 0x0, 0x8, 0xf8, 0x10, 0xf8, 0
 static const uint8 kSpawnPlayerFireball_xhi[6] = { 0x0, 0x0, 0xff, 0x0, 0xff, 0x0,  };
 static const uint8 kSpawnPlayerFireball_ylo[6] = { 0x8, 0x8, 0xc, 0xc, 0x14, 0x14,  };
 
+static const uint8 kUpdateHDMAWindowBuffer_CircleHDMAData[] = {
+  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf3, 0xf3, 0xf2, 0xf1, 0xf1, 0xf0, 0xef, 0xee, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe9, 0xe8, 0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xdf, 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xd8, 0xd7, 0xd6, 0xd5, 0xd3, 0xd2, 0xd0, 0xcf, 0xcd, 0xcc, 0xca, 0xc9, 0xc7, 0xc6, 0xc4, 0xc2, 0xc1, 0xbf, 0xbd, 0xbb, 0xb9, 0xb7, 0xb6, 0xb4, 0xb1, 0xaf, 0xad, 0xab, 0xa9, 0xa7, 0xa4, 0xa2, 0x9f, 0x9d, 0x9a, 0x97, 0x95, 0x92, 0x8f, 0x8c, 0x89, 0x86, 0x82, 0x7f, 0x7b, 0x78, 0x74, 0x70, 0x6c, 0x67, 0x63, 0x5e, 0x59, 0x53, 0x4d, 0x46, 0x3f, 0x37, 0x2d, 0x1f, 0x00
+};
+
+static const uint8 kUpdateHDMAWindowBuffer_KeyholeHDMAData[] = {
+  0x54, 0x53, 0x52, 0x52, 0x51, 0x50, 0x50, 0x4f, 0x4e, 0x4e, 0x4d, 0x4c, 0x4c, 0x4b, 0x4a, 0x4a, 0x4b, 0x48, 0x48, 0x47, 0x46, 0x46, 0x45, 0x44, 0x44, 0x43, 0x42, 0x42, 0x41, 0x40, 0x40, 0x3f, 0x3e, 0x3e, 0x3d, 0x3c, 0x3c, 0x3b, 0x3a, 0x3a, 0x39, 0x38, 0x38, 0x37, 0x36, 0x36, 0x35, 0x34, 0x34, 0x33, 0x32, 0x32, 0x31, 0x33, 0x35, 0x38, 0x3a, 0x3c, 0x3e, 0x3f, 0x41, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4e, 0x4f, 0x50, 0x50, 0x51, 0x51, 0x52, 0x52, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4e, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x48, 0x47, 0x45, 0x44, 0x43, 0x41, 0x3f, 0x3e, 0x3c, 0x3a, 0x38, 0x35, 0x33, 0x30, 0x2d, 0x2a, 0x26, 0x23, 0x1e, 0x18, 0x11, 0x00
+};
+
+
+
 void SmwVectorReset() {
 //  xWriteReg(NMITIMEN, 0);
 //  xWriteReg(HDMAEN, 0);
@@ -368,7 +375,7 @@ void ResetSpritesFunc(int wh) {
 }
 
 void HandleSPCUploads_UploadSPCEngine() {  // 0080e8
-  HandleSPCUploads_UploadDataToSPC(RomPtr(0xe8000));
+  HandleSPCUploads_UploadDataToSPC(kSpcEngine);
 }
 
 void HandleSPCUploads_UploadDataToSPC(const uint8 *p) {  // 0080f7
@@ -377,11 +384,11 @@ void HandleSPCUploads_UploadDataToSPC(const uint8 *p) {  // 0080f7
 }
 
 void HandleSPCUploads_UploadSamples() {  // 0080fd
-  HandleSPCUploads_StrtSPCMscUpld(RomPtr(0xf8000));
+  HandleSPCUploads_StrtSPCMscUpld(kSpcSamples);
 }
 
 void HandleSPCUploads_UploadOverworldMusicBank() {  // 00810e
-  HandleSPCUploads_StrtSPCMscUpld(RomPtr(0xe98b1));
+  HandleSPCUploads_StrtSPCMscUpld(kSpcOverworldMusicBank);
 }
 
 void HandleSPCUploads_StrtSPCMscUpld(const uint8 *p) {  // 00811d
@@ -396,12 +403,12 @@ void HandleSPCUploads_StrtSPCMscUpld(const uint8 *p) {  // 00811d
 void HandleSPCUploads_008134() {  // 008134
   if (flag_active_bonus_game || misc_intro_level_flag == 0xE9 ||
       !(flag_show_player_start | (uint8)(counter_sublevels_entered | misc_intro_level_flag))) {
-    HandleSPCUploads_StrtSPCMscUpld(RomPtr(0xeaed6));
+    HandleSPCUploads_StrtSPCMscUpld(kSpcLevelMusicBank);
   }
 }
 
 void HandleSPCUploads_UploadCreditsMusicBank() {  // 008159
-  HandleSPCUploads_StrtSPCMscUpld(RomPtr(0x3e400));
+  HandleSPCUploads_StrtSPCMscUpld(kSpcCreditsMusicBank);
 }
 
 void SmwVectorNMI() {
@@ -578,9 +585,10 @@ void CompressOamEntExt() {  // 008494
 }
 
 void LoadStripeImage() {  // 0085d2
-//  printf("M: upl stripe %d\n", graphics_stripe_image_to_upload);
+  if (graphics_stripe_image_to_upload)
-  LongPtr p0 = *(LongPtr *)((uint8 *)&kLoadStripeImage_StripeImagePtrs[0].addr + graphics_stripe_image_to_upload);
+    graphics_stripe_image_to_upload += 0;
-  LoadStripeImage_UploadToVRAM(IndirPtr(&p0, 0));
+  const uint8 *p = (graphics_stripe_image_to_upload == 0) ? stripe_image_upload_data : kLoadStripeImagePtrs(graphics_stripe_image_to_upload / 3).ptr;
+  LoadStripeImage_UploadToVRAM(p);
   if (!graphics_stripe_image_to_upload) {
     LOBYTE(stripe_image_upload) = graphics_stripe_image_to_upload;
     HIBYTE(stripe_image_upload) = graphics_stripe_image_to_upload;
@@ -722,11 +730,14 @@ uint16 ManipulateMode7Image_008B2B(uint16 k, uint8 r0) {  // 008b2b
   return v2 >> 5;
 }
 
+static const uint8 kStatusBarTilemap_TopRow[8] = { 0x3A,0x38,0x3B,0x38,0x3B,0x38,0x3A,0x78 };
+static const uint8 kStatusBarTilemap_SomeRow[8] = { 0x3A,0xB8,0x3B,0xB8,0x3B,0xB8,0x3A,0xF8 };
+
 void InitializeStatusBarTilemap() {  // 008cff
-  SmwCopyToVram(0x502e, RomPtr_00(0x8c81), 8);
+  SmwCopyToVram(0x502e, kStatusBarTilemap_TopRow, 8);
-  SmwCopyToVram(0x5042, RomPtr_00(0x8c89), 0x38);
+  SmwCopyToVram(0x5042, kStatusBarTilemap_SecondRow, 0x38);
-  SmwCopyToVram(0x5063, RomPtr_00(0x8cc1), 0x36);
+  SmwCopyToVram(0x5063, kStatusBarTilemap_SecondRow + 0x38, 0x36);
-  SmwCopyToVram(0x508e, RomPtr_00(0x8cf7), 8);
+  SmwCopyToVram(0x508e, kStatusBarTilemap_SomeRow, 8);
   int8 v4 = 54;
   uint8 v5 = 108;
   do {
@@ -1320,7 +1331,7 @@ void GameMode11_LoadSublevel_0096D5() {  // 0096d5
   flag_disable_layer3_scroll = 0;
   pointer_current_overworld_process = 0;
   timer_wait_before_score_tally = 80;
-  SpecifySublevelToLoad();
+  LoadLevel();
   for (uint8 i = 7; (i & 0x80) == 0; --i)
     LOBYTE(get_PointU16(misc_layer1_pos, i)->x) = *((uint8 *)&mirror_current_layer1_xpos + i);
   HandleSPCUploads_008134();
@@ -1474,6 +1485,8 @@ void GameMode14_InLevel_InMode7Level() {  // 00987d
   }
 }
 
+const uint16 kLevelTileAnimations_FrameData[208] = { 0x9500, 0x9700, 0x9900, 0x9b00, 0x9580, 0x9780, 0x9980, 0x9b80, 0x9600, 0x9600, 0x9600, 0x9600, 0x9d80, 0x9f80, 0xa180, 0xa380, 0x9600, 0x9800, 0x9a00, 0x9c00, 0x6d80, 0x6f80, 0x7c00, 0x7c80, 0xac20, 0xac20, 0xac20, 0xac20, 0xac20, 0xac20, 0xac20, 0xac20, 0x9380, 0x9380, 0x9380, 0x9380, 0xa400, 0xa480, 0xa400, 0xa480, 0xac20, 0xac20, 0xac20, 0xac20, 0xac00, 0xac00, 0xac00, 0xac00, 0x9100, 0x9100, 0x9100, 0x9100, 0x9680, 0x9880, 0x9a80, 0x9c80, 0x9d00, 0x9f00, 0xa100, 0xa300, 0x8e80, 0x9080, 0x9280, 0x9480, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9d00, 0x9f00, 0xa100, 0xa300, 0x8e80, 0x9080, 0x9280, 0x9480, 0x7d00, 0x7f00, 0x8100, 0x8300, 0x8300, 0x8100, 0x7f00, 0x7d00, 0x9e00, 0xa000, 0xa200, 0xa000, 0x9d00, 0x9f00, 0xa100, 0xa300, 0xa500, 0xa700, 0xa900, 0xab00, 0xa580, 0xa780, 0xa980, 0xab80, 0xab80, 0xa980, 0xa780, 0xa580, 0x9500, 0x9500, 0x9500, 0x9500, 0x9e80, 0xa080, 0xa280, 0xa080, 0x7d80, 0x7f80, 0x8180, 0x8380, 0x7e00, 0x8000, 0x8200, 0x8400, 0x7e80, 0x8080, 0x8280, 0x8480, 0x8380, 0x8180, 0x7f80, 0x7d80, 0x9500, 0x9500, 0x9500, 0x9500, 0xa680, 0xa880, 0xaa80, 0xa880, 0x8e00, 0x9000, 0x9200, 0x9400, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9e80, 0xa080, 0xa280, 0xa080, 0xa600, 0xa800, 0xaa00, 0xa800, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9500, 0x9180, 0x9180, 0x9180, 0x9180, 0x9680, 0x9880, 0x9a80, 0x9c80, 0x9680, 0x9880, 0x9a80, 0x9c80, 0x9680, 0x9880, 0x9a80, 0x9c80, 0x9500, 0x9700, 0x9900, 0x9b00, 0xac80, 0xac80, 0xac80, 0xac80, 0x9300, 0x9300, 0x9300, 0x9300, 0x9380, 0x9380, 0x9380, 0x9380,  };
+
 void UploadMode7KoopaBossesAndLavaAnimation() {  // 0098a9
   int8 v0 = misc_nmito_use_flag & 1;
   if (!(misc_nmito_use_flag & 1)) {
@@ -1863,7 +1876,6 @@ void BufferFileSelectText() {  // 009d38
   BufferFileSelectText_Entry3(0xCB, 0);
 }
 
-#define kFileSelectText_EraseFile ((uint8*)RomFixedPtr(0x5B6FE))
 
 void BufferFileSelectText_Entry3(uint8 k, uint8 r5) {  // 009d3c
   uint16 kk = k;
@@ -1873,7 +1885,7 @@ void BufferFileSelectText_Entry3(uint8 k, uint8 r5) {  // 009d3c
     stripe_image_upload_data[i] = kFileSelectText_EraseFile[kk];
     kk = kk + 1;
   }
-  uint8 r0 = -124;
+  uint8 r0 = 0x84;
   uint8 v3 = 2;
   do {
     int8 v4 = r5 & 1;
@@ -1887,13 +1899,13 @@ void BufferFileSelectText_Entry3(uint8 k, uint8 r5) {  // 009d3c
           v7 = v8.first;
           second = v8.second;
         } else {
-          second = -121;
+          second = 0x87;
-          v7 = -120;
+          v7 = 0x88;
         }
         uint8 v9 = r0;
         stripe_image_upload_data[r0 + 4] = v7;
         if (!second)
-          second = -4;
+          second = 0xfc;
         stripe_image_upload_data[v9 + 2] = second;
         stripe_image_upload_data[v9 + 3] = 56;
         stripe_image_upload_data[v9 + 5] = 56;
@@ -2076,6 +2088,9 @@ void GameMode28_ShowTheEnd() {  // 009f7c
   }
 }
 
+const uint8 *GetLayer3ImagePtr(int i) {
+  return kLayer3ImagePtrs(i).ptr;
+}
 
 void InitializeLevelLayer3() {  // 009fb8
   uint8 v4;
@@ -2112,7 +2127,7 @@ LABEL_15:
 LABEL_16:
   if (misc_level_layer3_settings) {
     uint8 v6 = r0 + misc_level_layer3_settings - 1;
-    LoadStripeImage_UploadToVRAM(IndirPtr(&kInitializeLevelLayer3_Layer3ImagePtrs[v6], 0));
+    LoadStripeImage_UploadToVRAM(GetLayer3ImagePtr(v6));
   }
 }
 
@@ -2300,9 +2315,17 @@ void UpdateCurrentPlayerPositionRAM() {  // 00a2f3
   player_current_ypos = player_ypos;
 }
 
+static const uint16 kPlayerPalettes[] = {
+  0x635f, 0x581d, 0x0a, 0x391f, 0x44c4, 0x4e08, 0x6770, 0x30b6, 0x35df, 0x3ff, 0x4f3f, 0x581d, 0x1140, 0x3fe0, 0x3c07, 0x7cae, 0x7db3, 0x2f00, 0x165f, 0x3ff, 0x635f, 0x581d, 0x2529, 0x7fff, 0x08, 0x17, 0x1f, 0x577b, 0xddf, 0x3ff, 0x3b1f, 0x581d, 0x2529, 0x7fff, 0x1140, 0x1e0, 0x2e0, 0x577b, 0xddf, 0x3ff
+};
+
+const uint16 *GetPlayerPalette() {
+  return kPlayerPalettes + ((pointer_player_palette - 0xb2c8) >> 1);
+}
+
 void UploadPlayerGFX() {  // 00a300
   if (player_number_of_tiles_to_update) {
-    RtlUpdatePalette((uint16*)RomPtr_00(pointer_player_palette), 0x86, 10);
+    RtlUpdatePalette(GetPlayerPalette(), 0x86, 10);
   }
   SmwCopyToVram(0x67f0, g_ram + (graphics_dynamic_sprite_tile7 ? graphics_dynamic_sprite_tile7 : 0x2000), 0x20);
 
@@ -2358,17 +2381,15 @@ void RestoreSP1AfterMarioStart() {  // 00a436
   }
 }
 
-void UpdatePaletteFromIndexedTable() {  // 00a488
+static const uint16 kUpdatePaletteFromIndexedTable_DATA_00A47F[3] = {
-  uint16 v1;
+  0x682, 0x0905, 0x0703
+};
 
+void UpdatePaletteFromIndexedTable() {  // 00a488
   if (palettes_palette_upload_table_index == 0xff)
     return;
 
-  uint16 v0 = kUpdatePaletteFromIndexedTable_DATA_00A47F[palettes_palette_upload_table_index + 2];
+  const uint8 *p = g_ram + kUpdatePaletteFromIndexedTable_DATA_00A47F[palettes_palette_upload_table_index / 3];
-  LongPtr p0 = { .bank = v0, .addr = 0 };
-  v1 = WORD(kUpdatePaletteFromIndexedTable_DATA_00A47F[palettes_palette_upload_table_index]);
-  uint16 v2 = v1;
-  uint8 *p = IndirPtr(&p0, v2);
   int n;
   while ((n = p[0]) != 0) {
     RtlUpdatePalette((uint16 *)(p + 2), p[1], n >> 1);
@@ -2462,7 +2483,7 @@ LABEL_6:
                                           blocks_give_life_in_bonus_flags_row1;
   uint8 v1 = 35;
   do
-    *(&ptr_hi_map16_data.bank + v1--) = 0;
+    g_ram[0x70 + v1--] = 0;
   while (v1);
   uint8 v2 = 55;
   do
@@ -2751,20 +2772,64 @@ void ConvertGFX27IntoNormallFormat(uint16 *dst) {  // 00ab42
   } while (--v11);
 }
 
+static const uint16 kGlobalPalettes_Layer3[] = {
+  0x7393, 0x0, 0xcfb, 0x2feb, 0x7393, 0x0, 0x7fdd, 0x2d7f,
+  0x7393, 0x0, 0x7aab, 0x7fff, 0x7393, 0x0, 0x1e9b, 0x3b7f,
+};
+
+static const uint16 kGlobalPalettes_Objects[] = {
+  0x39ce, 0x00, 0x6318, 0x7f34, 0x7f95, 0x7ff8, 0x00, 0x32b7, 0x67fb, 0x200, 0x320, 0x3e0, 0x00, 0xd71, 0x7c3f, 0x1e9b, 0x137f, 0x3ff, 0x00, 0x2817, 0x401f, 0x4529, 0x59ad, 0x6610, 0x00, 0xd71, 0x1e9b, 0x3b7f, 0x7fff, 0x7fff, 0x00, 0x39ce, 0x5294, 0x6318, 0x739c, 0x2c5f, 0x00, 0x1ff, 0x31f, 0x3ff, 0xb7, 0x23f, 0x00, 0x6d08, 0x6dad, 0x7e31, 0xb7, 0x23f, 0x00, 0x11, 0x17, 0x1f, 0xb7, 0x23f, 0x00, 0x1e0, 0x2e0, 0x3e0, 0xb7, 0x23f
+};
+
+static const uint16 kGlobalPalettes_YoshiBerry[] = {
+  0x7FFF,     0, 0x320,  0x16,  0x1F, 0x17F, 0x29F,
+  0x7FFF,     0, 0x320,0x347D,0x551E,0x65FF,0x7B1F,
+  0x7FFF,     0, 0x320, 0x380,0x1FF1, 0x3F9,0x4FFF,
+};
+
+const uint16 kGlobalPalettes_Background[] = {
+  0x3a49, 0x428b, 0x4acd, 0x530f, 0x5b51, 0x6393, 0x7fff, 0x0, 0x7f20, 0x7f80, 0x7fe0, 0x7fe0,
+  0x3942, 0x5208, 0x6ace, 0x6312, 0x6b55, 0x7398, 0x3942, 0x5208, 0x6ace, 0x3942, 0x5208, 0x6ace,
+  0x4ed6, 0x5718, 0x5f5a, 0x679c, 0x6fde, 0x77ff, 0x7fff, 0x0, 0x7f20, 0x7f80, 0x7fe0, 0x7fe0,
+  0x20a3, 0x3148, 0x3dac, 0x39ce, 0x3e32, 0x4ab6, 0x20a2, 0x2d25, 0x3568, 0x358a, 0x24e4, 0x4a52,
+  0x50c8, 0x59cc, 0x526d, 0x58eb, 0x654c, 0x5ad0, 0x5d80, 0x7f39, 0x7e93, 0x65a8, 0x5648, 0x5728,
+  0x1462, 0x3546, 0x45a9, 0x520d, 0x62b1, 0x7b77, 0x0, 0x7b1e, 0x7b9f, 0x7f99, 0x7ff6, 0x7ffc,
+  0x0, 0x24c5, 0x2d49, 0x2dad, 0x2253, 0x3f18, 0x1060, 0x1881, 0x1ca3, 0x1ce4, 0x2909, 0x254b,
+  0x960, 0x1a4, 0x1e8, 0x22c, 0x291, 0x2f5, 0x7fff, 0x0, 0x7ee0, 0x7f20, 0x7f80, 0x7fe0,
+};
+
+static const uint16 kGlobalPalettes_Sprites[] = {
+  0x0, 0x24c5, 0x2d49, 0x2dad, 0x2253, 0x3f18, 0x2523, 0x35c4, 0x3e25, 0x4686, 0x4ee7, 0x401f,
+  0x0, 0x41c6, 0x7354, 0x7ffa, 0x7ffd, 0x6d08, 0x0, 0x3434, 0x443a, 0x659f, 0x116, 0x27f,
+  0x0, 0x24c5, 0x2d49, 0x2dad, 0x2253, 0x3f18, 0x0, 0x2dae, 0x3e32, 0x4ab6, 0x52f9, 0x2cf3,
+  0x0, 0x516b, 0x4e6d, 0x4fb3, 0x30bf, 0x371d, 0x2e32, 0x4a0d, 0x1088, 0x214a, 0x296d, 0x3dcf,
+  0x0, 0x2940, 0x3de0, 0x5280, 0xb7, 0x23f, 0x0, 0x39ce, 0x5294, 0x6318, 0xb7, 0x23f,
+  0x0, 0x7e70, 0x7ed3, 0x7f36, 0x7f99, 0x401f, 0x0, 0x39ce, 0x5294, 0x6318, 0x739c, 0x2c5f,
+  0x0, 0x4edf, 0x5ade, 0x66bd, 0x727c, 0x401f, 0x0, 0x7ff5, 0x7ff7, 0x7ff9, 0x7ffc, 0x7fff,
+};
+
+static const uint16 kGlobalPalettes_Foreground[] = {
+  0x0, 0xdaf, 0x2e79, 0x25e0, 0x2b1c, 0x320, 0x0, 0x2d6b, 0x3def, 0x4e73, 0x6318, 0x739c,
+  0x0, 0xe9, 0x220d, 0x58e, 0x1a33, 0x32b7, 0x0, 0x2de0, 0x52e0, 0x157f, 0x325f, 0x4b3f,
+  0x0, 0x59c8, 0x72ce, 0x39cb, 0x3e30, 0x4ab3, 0x0, 0x16, 0x1b, 0x15f, 0x21f, 0x31f,
+  0x0, 0x49ec, 0x524f, 0x5ab2, 0x6715, 0x7fdb, 0x0, 0x16, 0x1b, 0x15f, 0x21f, 0x31f,
+  0x0, 0x8c9, 0x194e, 0x29d3, 0x3e78, 0x531d, 0x0, 0x14c8, 0x1d09, 0x296c, 0x35cf, 0x4232,
+  0x55ef, 0x6eb5, 0x76f7, 0x7f39, 0x7f7b, 0x7fbd, 0x0, 0x2cc9, 0x414e, 0x55d3, 0x6e78, 0x7f1d,
+  0x0, 0x1e9, 0x2ac, 0x32f, 0x399, 0x53fe, 0x0, 0x0, 0x0, 0x3c8f, 0x61d8, 0x7e7f,
+  0x0, 0x24c5, 0x2d49, 0x2dad, 0x2253, 0x3f18, 0x0, 0x16, 0x1b, 0x15f, 0x21f, 0x31f,
+};
+
 void BufferPalettesRoutines_Levels() {  // 00abed
   BufferPalettesRoutines_LoadColorInVerticalStrip(2, 0x7fdd);
   BufferPalettesRoutines_LoadColorInVerticalStrip(0x102, 0x7FFF);
-  BufferPalettesRoutines_LoadColors(0xb170, 16, 7, 1);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_Layer3, 16, 7, 1);
-  BufferPalettesRoutines_LoadColors(0xb250, 132, 5, 9);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_Objects, 132, 5, 9);
   palettes_background_color = kGlobalPalettes_Sky[misc_background_color_setting & 0xF];
-  uint16 r0w = kBufferPalettesRoutines_DATA_00ABD3[misc_fgpalette_setting & 0xF] + 0xb190;
+  BufferPalettesRoutines_LoadColors((kBufferPalettesRoutines_DATA_00ABD3[misc_fgpalette_setting & 0xF] >> 1) + kGlobalPalettes_Foreground, 68, 5, 1);
-  BufferPalettesRoutines_LoadColors(r0w, 68, 5, 1);
+  BufferPalettesRoutines_LoadColors((kBufferPalettesRoutines_DATA_00ABD3[misc_sprite_palette_setting & 0xF] >> 1) + kGlobalPalettes_Sprites, 452, 5, 1);
-  r0w = kBufferPalettesRoutines_DATA_00ABD3[misc_sprite_palette_setting & 0xF] + 0xb318;
+  BufferPalettesRoutines_LoadColors((kBufferPalettesRoutines_DATA_00ABD3[misc_bgpalette_setting & 0xF] >> 1) + kGlobalPalettes_Background, 4, 5, 1);
-  BufferPalettesRoutines_LoadColors(r0w, 452, 5, 1);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_YoshiBerry, 82, 6, 2);
-  r0w = kBufferPalettesRoutines_DATA_00ABD3[misc_bgpalette_setting & 0xF] + 0xb0b0;
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_YoshiBerry, 306, 6, 2);
-  BufferPalettesRoutines_LoadColors(r0w, 4, 5, 1);
-  BufferPalettesRoutines_LoadColors(0xb674, 82, 6, 2);
-  BufferPalettesRoutines_LoadColors(0xb674, 306, 6, 2);
 }
 
 void BufferPalettesRoutines_LoadColorInVerticalStrip(uint16 k, uint16 r4) {  // 00aced
@@ -2774,41 +2839,89 @@ void BufferPalettesRoutines_LoadColorInVerticalStrip(uint16 k, uint16 r4) {  //
   }
 }
 
-void BufferPalettesRoutines_LoadColors(uint16 r0, uint16 r4, uint16 r6, uint16 r8) {  // 00acff
+void BufferPalettesRoutines_LoadColors(const uint16 *r0, uint16 r4, uint16 r6, uint16 r8) {  // 00acff
   do {
     uint16 v0 = r4;
     int16 v1 = r6;
     do {
-      palettes_palette_mirror[v0 >> 1] = *(uint16 *)RomPtr_00(r0);
+      palettes_palette_mirror[v0 >> 1] = *r0++;
-      r0 += 2;
       v0 += 2;
     } while (--v1 >= 0);
     r4 += 32;
   } while ((--r8 & 0x8000) == 0);
 }
 
+static const uint16 kGlobalPalettes_OW_Objects[] = {
+  0x0, 0x2ce7, 0x3d6b, 0x4def, 0x5e73, 0x6ef7, 0x7fff,
+  0x7ff1, 0x1bf, 0x7e00, 0x3bf, 0x3e0, 0x7ffc, 0x7fff,
+  0x0, 0x194f, 0x3e78, 0x573e, 0x7e20, 0x7ee0, 0x7fe0,
+  0x0, 0x5231, 0x66f6, 0x7b9c, 0x1685, 0x2f4b, 0x47f1,
+  0x0, 0x194f, 0x3e78, 0x573e, 0x3ff, 0x7bde, 0x7c1f,
+  0x0, 0x194f, 0x3e78, 0x573e, 0x2d7f, 0x2f4b, 0x47f1,
+};
+
+static const uint16 GlobalPalettes_OW_Sprites[] = {
+  0x7fff, 0x0, 0xd71, 0x37f, 0x4fff, 0x4f3f, 0x7fe0,
+  0x7fff, 0x0, 0x1e0, 0x7dad, 0x380, 0xb7, 0x23f,
+  0x7fff, 0x0, 0x16, 0x1f, 0x6d08, 0x2ddd, 0x635f,
+  0x7fff, 0x0, 0x280, 0x3e0, 0x6d08, 0x261a, 0x573b,
+  0x7fff, 0x0, 0x7ee0, 0x7f20, 0x7f80, 0x7fe0, 0x7fe0,
+  0x7fff, 0x0, 0x7ee0, 0x7f20, 0x7f80, 0x7fe0, 0x7fe0,
+  0x0, 0x1b, 0x462d, 0x5ef3, 0x1685, 0x2f4b, 0x47f1,
+  0x0, 0x2ce7, 0x3d6b, 0x4def, 0x5e73, 0x6ef7, 0x7fff,
+};
+
+static const uint16 kGlobalPalettes_B5EC[] = {
+  0x7393, 0x0, 0x3ff, 0x573b, 0x7393, 0x3e75, 0x3212, 0x25af, 0x7393, 0x573b, 0x7fff, 0x0, 0x7393, 0x0, 0x573b, 0x7e6c,
+};
+
+static const uint16 kGlobalPalettes_OW_Areas[][28] = {
+  {0x0, 0x1228, 0x12a8, 0x1348, 0x327b, 0x5bbf, 0x7d60, 0x0, 0x7bde, 0x1348, 0x7d60, 0x327b, 0x37bf, 0x2d7f, 0x0, 0x3268, 0x32e8, 0x1348, 0x5eff, 0x6f7f, 0x7d60, 0x0, 0x7bde, 0x573b, 0x7ea0, 0x1f6, 0x12a8, 0x1348,},
+  {0x0, 0x1228, 0x12a8, 0x1348, 0x327b, 0x5bbf, 0x7e28, 0x0, 0x7bde, 0x1348, 0x7e28, 0x327b, 0x37bf, 0x3ff, 0x0, 0x3212, 0x3e75, 0x573b, 0x327b, 0x5bbf, 0x7e28, 0x0, 0x7bde, 0x573b, 0x7e28, 0x327b, 0x38c4, 0x1348,},
+  {0x2cc7, 0x69f0, 0x66b2, 0x67d5, 0x6634, 0x53de, 0x7fff, 0x2cc7, 0x4560, 0x6680, 0x7ff7, 0x31f, 0x37f, 0x47ff, 0x412c, 0x69f0, 0x66b2, 0x67d5, 0x1f, 0x7fff, 0x2cc7, 0x2cc7, 0x69f0, 0x66b2, 0x67d5, 0x412c, 0x3ad5, 0x5b9c,},
+  {0x0, 0x49ec, 0x562e, 0x62f1, 0x3126, 0x5bbf, 0x0, 0x0, 0x7bde, 0x5795, 0x7e28, 0x3126, 0x37bf, 0x2d7f, 0x0, 0x3126, 0x3d89, 0x49ec, 0x3126, 0x5bbf, 0x7e28, 0x0, 0x7bde, 0x573b, 0x32c6, 0x3126, 0x37f, 0x37f,},
+  {0x0, 0x1a05, 0xac5, 0x22ef, 0x1a75, 0x4359, 0x7d60, 0x0, 0x7739, 0x22ef, 0x7d60, 0x1e18, 0x375c, 0x7e09, 0x0, 0x3660, 0x4b20, 0x22ef, 0x4e5a, 0x533a, 0x7d60, 0x0, 0x327b, 0x22ef, 0x2119, 0x1f6, 0x2de6, 0x36a8,},
+  {0x2cc7, 0x69f0, 0x0, 0x0, 0x6634, 0x7ff9, 0x7fff, 0x0, 0x4560, 0x6680, 0x7ff7, 0x31f, 0x37f, 0x47ff, 0x412c, 0x69f0, 0x66b2, 0x67d5, 0x1f, 0x7fff, 0x2cc7, 0x2cc7, 0x69f0, 0x66b2, 0x67d5, 0x412c, 0x3ad5, 0x5b9c,},
+};
+
+static const uint16 kGlobalPalettes_OW_AreasPassed[][28] = {
+  {0x0, 0x1533, 0x25b7, 0x363b, 0x25af, 0x5bbf, 0x5ac6, 0x0, 0x7bde, 0x363b, 0x5ac6, 0x25af, 0x37bf, 0x2d7f, 0x0, 0x1533, 0x25b7, 0x363b, 0x5eff, 0x6f7f, 0x5ac6, 0x0, 0x7bde, 0x573b, 0x5ac6, 0x25af, 0x12a8, 0x1348,},
+  {0x0, 0x25b7, 0x363b, 0x46bf, 0x25af, 0x5b5f, 0x5ac6, 0x0, 0x7bde, 0x46bf, 0x5ac6, 0x25af, 0x37bf, 0x3ff, 0x0, 0x1685, 0x2f4b, 0x47f1, 0x25af, 0x5b5f, 0x5ac6, 0x0, 0x7bde, 0x573b, 0x5ac6, 0x25af, 0x38c4, 0x1348,},
+  {0x1ce7, 0x19f3, 0x32b9, 0x4b7f, 0x7610, 0x2eb9, 0x7fff, 0x1ce7, 0x4560, 0x6680, 0x7ff7, 0x31f, 0x37f, 0x47ff, 0x1ce7, 0x19f3, 0x32b9, 0x4b7f, 0x1f, 0x7fff, 0x1ce7, 0x1ce7, 0x19f3, 0x32b9, 0x4b7f, 0x58c6, 0x3ad5, 0x5b9c,},
+  {0x0, 0x1d6d, 0x29d0, 0x3633, 0x2d6b, 0x4ef9, 0x0, 0x0, 0x7bde, 0x3633, 0x3082, 0x2d6b, 0x37bf, 0x2d7f, 0x0, 0xa7, 0x152b, 0x218e, 0x2d6b, 0x4ef9, 0x3082, 0x0, 0x7bde, 0x4ef9, 0x3082, 0x2d6b, 0x3082, 0x1348,},
+  {0x0, 0x2171, 0x31f5, 0x3279, 0x41f6, 0x573b, 0x7d60, 0x0, 0x7739, 0x3279, 0x7d60, 0x1e18, 0x375c, 0x7e09, 0x0, 0x3660, 0x4b20, 0x22ef, 0x527a, 0x533a, 0x7d60, 0x0, 0x218e, 0x3279, 0x2119, 0x3e75, 0x1135, 0x1d98,},
+  {0x2cc7, 0x69f0, 0x0, 0x0, 0x6634, 0x7ff9, 0x7fff, 0x0, 0x4560, 0x6680, 0x7ff7, 0x31f, 0x37f, 0x47ff, 0x412c, 0x69f0, 0x66b2, 0x67d5, 0x1f, 0x7fff, 0x2cc7, 0x2cc7, 0x69f0, 0x66b2, 0x67d5, 0x412c, 0x3ad5, 0x5b9c,},
+};
+
+
 void BufferPalettesRoutines_Overworld() {  // 00ad25
-  uint16 v0 = 0xb3d8;
+  int tt = kBufferPalettesRoutines_DATA_00AD1E[(misc_level_tileset_setting & 0xF) - 1];
+  const uint16 *v0 = kGlobalPalettes_OW_Areas[tt];
   if (*(int16 *)&ow_level_tile_settings[72] < 0)
-    v0 = 0xb732;
+    v0 = kGlobalPalettes_OW_AreasPassed[tt];
-  uint16 r0w = v0 + kBufferPalettesRoutines_DATA_00ABDF
+  BufferPalettesRoutines_LoadColors(v0, 130, 6, 3);
-                  [(uint16)(2 * kBufferPalettesRoutines_DATA_00AD1E[(uint16)((misc_level_tileset_setting & 0xF) - 1)]) >> 1];
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_OW_Objects, 82, 6, 5);
-  BufferPalettesRoutines_LoadColors(r0w, 130, 6, 3);
+  BufferPalettesRoutines_LoadColors(GlobalPalettes_OW_Sprites, 258, 6, 7);
-  BufferPalettesRoutines_LoadColors(0xb528, 82, 6, 5);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_B5EC, 16, 7, 1);
-  BufferPalettesRoutines_LoadColors(0xb57c, 258, 6, 7);
-  BufferPalettesRoutines_LoadColors(0xb5ec, 16, 7, 1);
 }
 
+static const uint16 kGlobalPalettes_TS_Layer3[] = {0x437F,     0,0x7F60,0x173F,0x437F,     0,0x1CFF, 0x320};
+static const uint16 kGlobalPalettes_DATA_00B63C[] = {0x437F,     0, 0x320,0x7F60,0x437F,0x5BBF,0x327B, 0x8E7};
+
 void BufferPalettesRoutines_TitleScreen() {  // 00ada6
-  BufferPalettesRoutines_LoadColors(0xb63c, 16, 7, 0);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_DATA_00B63C, 16, 7, 0);
-  BufferPalettesRoutines_LoadColors(0xb62c, 48, 7, 0);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_TS_Layer3, 48, 7, 0);
 }
 
+static const uint16 kGlobalPalettes_IggyLarryPlatform[] = {
+  0x0, 0x1ce0, 0x3de8, 0x5ef0, 0x7ff8, 0x7fff, 0x1685, 0x2f4b,
+};
+
 void BufferPalettesRoutines_IggyLarryPlatform() {  // 00add9
   BufferPalettesRoutines_Levels();
   palettes_background_color = 23;
-  BufferPalettesRoutines_LoadColors(0xb170, 16, 7, 1);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_Layer3, 16, 7, 1);
-  BufferPalettesRoutines_LoadColors(0xb65c, 0, 7, 0);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_IggyLarryPlatform, 0, 7, 0);
 }
 
 void BufferPalettesRoutines_ReznorAndMode7KoopaBosses() {  // 00ae15
@@ -2816,7 +2929,7 @@ void BufferPalettesRoutines_ReznorAndMode7KoopaBosses() {  // 00ae15
   misc_fgpalette_setting = 7;
   BufferPalettesRoutines_Levels();
   palettes_background_color = 23;
-  BufferPalettesRoutines_LoadColors(0xb5f4, 24, 3, 0);
+  BufferPalettesRoutines_LoadColors(kGlobalPalettes_B5EC + 4, 24, 3, 0);
 }
 
 void UpdatePaletteFromIndexedTable_00AE47() {  // 00ae47
@@ -2873,7 +2986,7 @@ void HandlePaletteFades_00AF35(bool run_code_at_end) {  // 00af35
     palettes_palette_upload_table_index = 3;
 
     if (run_code_at_end) {
-      const uint8 *p0 = RomPtr_00(pointer_player_palette);
+      const uint8 *p0 = (const uint8 *)GetPlayerPalette();
       for (uint16 i = 20; (i & 0x8000) == 0; i -= 2)
         palettes_copy_of_palette_mirror[(i >> 1) + 134] = WORD(p0[i]);
       palettes_copy_of_palette_mirror[128] = 0x81ee;
@@ -2938,8 +3051,7 @@ void PlayerState00_00B03E() {  // 00b03e
 }
 
 void GraphicsDecompressionRoutines_DecompressGFX32And33() {  // 00b888
-  decomp_src = (LongPtr){ .bank = 8, .addr = 0xbfc0 };
+  memcpy(g_ram + 0x2000, kGfx33, kGfx33_SIZE);
-  GraphicsDecompressTo(g_ram + 0x2000);
   uint8 *t8d = g_ram + 0xacfe;
   int16 v0 = 0x23ff;
 LABEL_2:;
@@ -2959,115 +3071,82 @@ LABEL_2:;
     if (!--v2)
       goto LABEL_2;
   }
-  decomp_src.addr = 0x8000;
+  memcpy(g_ram + 0x2000, kGfx32, kGfx32_SIZE);
-  GraphicsDecompressTo(g_ram + 0x2000);
 }
 
-void GraphicsDecompressTo(uint8 *pdst) {  // 00b8de
+void GraphicsDecompressTo(const uint8 *src, uint8 *pdst) {  // 00b8de
-  int16 v3;
+  uint8 cmd;
-  uint16 v17;
-  int8 v20;
-
   uint16 v0 = 0;
   while (1) {
-    uint8 tag = GraphicsDecompressionRoutines_ReadByte();
+    uint8 tag = *src++;
     if (tag == 0xFF)
       break;
-    int8 v2 = tag & 0xE0;
+    uint8 v2 = tag & 0xE0;
-    if (v2 == -32) {
+    int len;
-      v20 = (8 * tag) & 0xE0;
+    if (v2 == 0xe0) {
-      HIBYTE(v3) = tag & 3;
+      cmd = (8 * tag) & 0xE0;
-      LOBYTE(v3) = GraphicsDecompressionRoutines_ReadByte();
+      len = ((tag & 3) << 8 | *src++) + 1;
     } else {
-      v20 = v2;
+      cmd = v2;
-      v3 = tag & 0x1F;
+      len = (tag & 0x1F) + 1;
     }
-    uint16 len = v3 + 1;
+    if (cmd) {
-    if (v20) {
+      if (cmd & 0x80) {
-      if (v20 < 0) {
+        uint16 v18 = src[0] << 8 | src[1];
-        HIBYTE(v17) = GraphicsDecompressionRoutines_ReadByte();
+        src += 2;
-        LOBYTE(v17) = GraphicsDecompressionRoutines_ReadByte();
-        uint16 v18 = v17;
         do {
           pdst[v0++] = pdst[v18];
           ++v18;
-          --len;
+        } while (--len);
-        } while (len);
+      } else if ((cmd & 0x40) != 0) {
-      } else if ((v20 & 0x40) != 0) {
+        if ((cmd & 0x20) != 0) {
-        if (((2 * v20) & 0x40) != 0) {
+          uint8 v4 = *src++;
-          uint8 v4 = GraphicsDecompressionRoutines_ReadByte();
-          int16 v5 = len;
           do {
             pdst[v0++] = v4++;
-            --v5;
+          } while (--len);
-          } while (v5);
         } else {
-          uint8 v9 = GraphicsDecompressionRoutines_ReadByte();
+          uint8 v9 = *src++;
-          uint8 v10 = GraphicsDecompressionRoutines_ReadByte();
+          uint8 v10 = *src++;
-          int16 v11 = len;
           do {
-            uint8 v14 = v10;
+            pdst[v0++] = v9;
-            uint8 v12 = v9;
+            if (len <= 1)
-            uint8 v13 = v14;
-            pdst[v0++] = v12;
-            int16 v15 = v11 - 1;
-            if (!v15)
               break;
-            uint8 v16 = v12;
-            v10 = v13;
-            v9 = v16;
             pdst[v0++] = v10;
-            v11 = v15 - 1;
+          } while (len -= 2);
-          } while (v11);
         }
       } else {
-        uint8 v7 = GraphicsDecompressionRoutines_ReadByte();
+        uint8 v7 = *src++;
-        int16 v8 = len;
         do {
           pdst[v0++] = v7;
-          --v8;
+        } while (--len);
-        } while (v8);
       }
     } else {
       do {
-        uint8 v6 = GraphicsDecompressionRoutines_ReadByte();
+        uint8 v6 = *src++;
         pdst[v0++] = v6;
-        --len;
+      } while (--len);
-      } while (len);
     }
   }
 }
 
-uint8 GraphicsDecompressionRoutines_ReadByte() {  // 00b983
-  uint8 result = *IndirPtr(&decomp_src, 0);
-  int16 v1 = decomp_src.addr + 1;
-  if (decomp_src.addr == 0xFFFF) {
-    v1 = 0x8000;
-    decomp_src.bank++;
-  }
-  decomp_src.addr = v1;
-  return result;
-}
-
 const uint8 *GraphicsDecompress(uint8 j) {  // 00ba28
-  uint32 p = kGraphicsPtrs[j];
+  MemBlk blk = kGraphicsPtrs(j);
-  decomp_src = (LongPtr) {
+  memcpy(g_ram + 0xad00, blk.ptr, blk.size);
-    .bank = p >> 16,
+//  GraphicsDecompressTo(p, g_ram + 0xad00);
-    .addr = p & 0xffff,
-  };
-  GraphicsDecompressTo(g_ram + 0xad00);
   return g_ram + 0xad00;
 }
 
-void GenerateTile() {  // 00beb0
+uint8 *GetPtrToLevelDataLayout() {
-  uint16 v0;
+  const uint16 *rp = GetLayerLayoutPtr(misc_current_layer_being_processed, misc_level_mode_setting);
+  return g_ram + rp[HIBYTE(blocks_xpos)];
+}
 
+void GenerateTile() {  // 00beb0
   if (blocks_map16_to_generate) {
     GenTileArgs gta;
 
     gta.r12 = blocks_xpos;
     gta.r14 = blocks_ypos;
-    HIBYTE(v0) = 0;
     uint8 r9 = misc_level_layout_flags;
     if ((uint8)misc_current_layer_being_processed)
       r9 >>= 1;
@@ -3079,11 +3158,8 @@ void GenerateTile() {  // 00beb0
       v1 = gta.r12;
     }
     if (v1 < 0x200) {
-      uint16 *p0 = (uint16 *)RomPtr(kLevelDataLayoutTables_LoTablePtrs[misc_current_layer_being_processed]);
+      ptr_lo_map16_data = NULL;
-      const uint8 *rp = RomPtr(p0[misc_level_mode_setting]);
+      gta.ptr_lo_map16_data = GetPtrToLevelDataLayout();
-      ptr_hi_map16_data.addr = ptr_lo_map16_data.addr = *(uint16*)(rp + 3 * HIBYTE(blocks_xpos));
-      ptr_lo_map16_data.bank = 126;
-      ptr_hi_map16_data.bank = 127;
       // @25: Write to 0x6 = 0x25: 0xbf67: r18=0x4100: r20=0xc19e: a = 0x25, x = 0x0, y = 0xd, c = 0, r4 = 24, r5 = 40, r6 = 25, r9=1, blocks_ypos = 482/15e
       uint8 v3, v4;
       if ((r9 & 1) != 0) {
@@ -3143,10 +3219,10 @@ void sub_C074(GenTileArgs *gta) {  // 00c074
 void sub_C077(GenTileArgs *gta) {  // 00c077
   uint16 v0 = blocks_ypos & 0x1F0 | ((uint8)blocks_xpos >> 4);
   uint16 v1 = blocks_map16_to_generate;
-  uint8 *v2 = IndirPtr(&ptr_hi_map16_data, v0);
+  uint8 *v2 = gta->ptr_lo_map16_data + v0;
-  *v2 &= 0xFE;
+  v2[0x10000] &= ~1;
   uint8 v3 = kGenericPage00Tile_Map16Page00TileLo[v1];
-  SetMap16LowByte(v0, v3);
+  v2[0] = v3;
   GenericPage01Tile_00C0FB(gta, 2 * v3);
 }
 
@@ -3158,10 +3234,10 @@ void GenericPage01Tile_SetItemMemory(GenTileArgs *gta) {  // 00c0c1
 void GenericPage01Tile(GenTileArgs *gta) {  // 00c0c4
   uint16 v0 = blocks_ypos & 0x1F0 | ((uint8)blocks_xpos >> 4);
   uint16 v1 = (uint8)(blocks_map16_to_generate - 9);
-  uint8 *v2 = IndirPtr(&ptr_hi_map16_data, v0);
+  uint8 *v2 = gta->ptr_lo_map16_data + v0;
-  *v2 |= 1;
+  v2[0x10000] |= 1;
   uint8 v3 = kGenericPage01Tile_Map16Page01TileLo[v1];
-  SetMap16LowByte(v0, v3);
+  v2[0] = v3;
   GenericPage01Tile_00C0FB(gta, 2 * (v3 | 0x100));
 }
 
@@ -3193,11 +3269,11 @@ LABEL_15:;
     stripe_image_upload_data[v5 + 3] = 3;
     stripe_image_upload_data[v5 + 11] = 3;
     stripe_image_upload_data[v5 + 16] = -1;
-    const uint8 *rp = RomPtr(0xd0000 + pointer_map16_tiles[j >> 1]);
+    const uint16 *rp = GetMap16RomAddr(13, pointer_map16_tiles[j >> 1]);
-    *(uint16 *)&stripe_image_upload_data[v5 + 4] = WORD(rp[0]);
+    *(uint16 *)&stripe_image_upload_data[v5 + 4] = rp[0];
-    *(uint16 *)&stripe_image_upload_data[v5 + 12] = WORD(rp[2]);
+    *(uint16 *)&stripe_image_upload_data[v5 + 12] = rp[1];
-    *(uint16 *)&stripe_image_upload_data[v5 + 6] = WORD(rp[4]);
+    *(uint16 *)&stripe_image_upload_data[v5 + 6] = rp[2];
-    *(uint16 *)&stripe_image_upload_data[v5 + 14] = WORD(rp[6]);
+    *(uint16 *)&stripe_image_upload_data[v5 + 14] = rp[3];
     stripe_image_upload = v5 + 16;
     return;
   }
@@ -3216,8 +3292,7 @@ LABEL_15:;
 void EraseYoshiCoin(GenTileArgs *gta) {  // 00c1ac
   SetItemMemoryBit();
   uint16 v0 = blocks_ypos & 0x1F0 | ((uint8)blocks_xpos >> 4);
-  SetMap16LowByte(v0, 0x25);
+  gta->ptr_lo_map16_data[v0] = gta->ptr_lo_map16_data[v0 + 16] = 0x25;
-  SetMap16LowByte(v0 + 16, 0x25);
   uint16 r0w = *(uint16 *)&misc_level_layout_flags;
   if (misc_current_layer_being_processed)
     r0w >>= 1;
@@ -3247,17 +3322,17 @@ LABEL_14:;
     stripe_image_upload_data[v4 + 15] = 7;
     stripe_image_upload_data[v4 + 24] = -1;
     g_ram[6] = 13;
-    const uint8 *rp = RomPtr(0xd0000 + pointer_map16_tiles[37]);
+    const uint16 *rp = GetMap16RomAddr(13, pointer_map16_tiles[37]);
-    int16 v9 = *(uint16 *)(rp + 0);
+    uint16 v9 = rp[0];
     *(uint16 *)&stripe_image_upload_data[v4 + 4] = v9;
     *(uint16 *)&stripe_image_upload_data[v4 + 8] = v9;
-    int16 v11 = *(uint16 *)(rp + 2);
+    uint16 v11 = rp[1];
     *(uint16 *)&stripe_image_upload_data[v4 + 16] = v11;
     *(uint16 *)&stripe_image_upload_data[v4 + 20] = v11;
-    int16 v13 = *(uint16 *)(rp + 4);
+    uint16 v13 = rp[2];
     *(uint16 *)&stripe_image_upload_data[v4 + 6] = v13;
     *(uint16 *)&stripe_image_upload_data[v4 + 10] = v13;
-    int16 v15 = *(uint16 *)(rp + 6);
+    uint16 v15 = rp[3];
     *(uint16 *)&stripe_image_upload_data[v4 + 18] = v15;
     *(uint16 *)&stripe_image_upload_data[v4 + 22] = v15;
     stripe_image_upload = v4 + 24;
@@ -3275,10 +3350,13 @@ LABEL_14:;
     goto LABEL_14;
 }
 
+static const uint16 kChangeNetDoorTiles_Open[72] = { 0x9c99, 0x1c8b, 0x1c8b, 0x1c8b, 0x1c8b, 0xdc99, 0x1c9b, 0x1cf8, 0x1cf8, 0x1cf8, 0x1cf8, 0x5c9b, 0x1c9b, 0x1cf8, 0x1cf8, 0x1cf8, 0x1cf8, 0x5c9b, 0x1c9b, 0x1cf8, 0x1cf8, 0x1cf8, 0x1cf8, 0x5c9b, 0x1c9b, 0x1cf8, 0x1cf8, 0x1cf8, 0x1cf8, 0x5c9b, 0x1c99, 0x9c8b, 0x9c8b, 0x9c8b, 0x9c8b, 0x5c99,  };
+static const uint16 kChangeNetDoorTiles_Closed[72] = { 0x9cba, 0x1cab, 0x1cab, 0x1cab, 0x1cab, 0xdcba, 0x1caa, 0x1c82, 0x1c82, 0x1c82, 0x1c82, 0x5caa, 0x1caa, 0x1c82, 0x1c82, 0x1c82, 0x1c82, 0x5caa, 0x1caa, 0x1c82, 0x1c82, 0x1c82, 0x1c82, 0x5caa, 0x1caa, 0x1c82, 0x1c82, 0x1c82, 0x1c82, 0x5caa, 0x1cba, 0x9cab, 0x9cab, 0x9cab, 0x9cab, 0x5cba,  };
+
 void ChangeNetDoorTiles(GenTileArgs *gta) {  // 00c334
   ++gta->r7;
   AddHiLo(&gta->r6, &gta->r7, 32);
-  const uint8 *p2 = IndirPtr(&kChangeNetDoorTiles_DATA_00C32E[blocks_map16_to_generate - 25], 0);
+  const uint8 *p2 = (uint8*)((blocks_map16_to_generate == 25) ? kChangeNetDoorTiles_Open : kChangeNetDoorTiles_Closed);
   uint16 v1 = stripe_image_upload;
   for (int16 i = 5; i >= 0; --i) {
     stripe_image_upload_data[v1] = gta->r6;
@@ -3306,11 +3384,11 @@ void ChangeNetDoorTiles(GenTileArgs *gta) {  // 00c334
 void EraseLargeSwitch(GenTileArgs *gta) {  // 00c3d1
   uint16 v0 = blocks_ypos & 0x1F0 | ((uint8)blocks_xpos >> 4);
   uint16 v1 = stripe_image_upload;
-  SetMap16LowByte(v0++, 0x25);
+  uint8 *p = gta->ptr_lo_map16_data;
-  SetMap16LowByte(v0, 0x25);
+  p[v0] = 0x25;
-  v0 += 16;
+  p[v0 + 1] = 0x25;
-  SetMap16LowByte(v0, 0x25);
+  p[v0 + 16] = 0x25;
-  SetMap16LowByte(v0 - 1, 0x25);
+  p[v0 + 17] = 0x25;
   for (int16 i = 3; i >= 0; --i) {
     stripe_image_upload_data[v1] = gta->r6;
     stripe_image_upload_data[v1 + 1] = gta->r7;
@@ -3353,7 +3431,7 @@ void GameMode14_InLevel_00C47E() {  // 00c47e
       mirror_color_math_initial_settings = 18;
       uint8 r0 = player_on_tilting_platform_xpos - mirror_current_layer1_xpos + 4;
       uint8 r1 = player_on_tilting_platform_ypos - mirror_current_layer1_ypos + 16;
-      UpdateHDMAWindowBuffer_KeyholeEntry((HdmaPtrs) {.r4 = 0xcb93, .r6 = 0}, r0, r1);
+      UpdateHDMAWindowBuffer_KeyholeEntry((HdmaPtrs) {.r4 = kUpdateHDMAWindowBuffer_KeyholeHDMAData, .r6 = 0}, r0, r1);
     }
   }
 LABEL_11:
@@ -3752,7 +3830,7 @@ void PlayerState00_00CA44() {  // 00ca44
 }
 
 HdmaPtrs UpdateHDMAWindowBuffer_SetCircleHDMAPointer() {  // 00ca61
-  return (HdmaPtrs) { .r4 = 0xcb12, .r6 = 0xcb12 };
+  return (HdmaPtrs) { .r4 = kUpdateHDMAWindowBuffer_CircleHDMAData, .r6 = kUpdateHDMAWindowBuffer_CircleHDMAData };
 }
 
 void UpdateHDMAWindowBuffer_IrisInOnPlayerEntry(uint8 a, HdmaPtrs hptr) {  // 00ca6d
@@ -3790,7 +3868,7 @@ void UpdateHDMAWindowBuffer_KeyholeEntry(HdmaPtrs hptr, uint8 r0, uint8 r1) {  /
       misc_hdmawindow_effect_table[v2] = r0 >= pair.first ? r0 - pair.first : 0;
     }
     if (v1 < 0x1E0) {
-      if (hptr.r6 >= 256) {
+      if (hptr.r6) {
         misc_hdmawindow_effect_table[v1 + 1] = r0 + pair.second < 255 ? r0 + pair.second : 255;
         misc_hdmawindow_effect_table[v1] = r0 >= pair.second ? r0 - pair.second : 0;
       } else {
@@ -3809,9 +3887,9 @@ LABEL_21:
 
 PairU8 UpdateHDMAWindowBuffer_00CC14(uint16 j, HdmaPtrs hptr, uint8 r1) {  // 00cc14
   uint16 v1 = SnesDivide(r1 << 8, timer_hdmawindow_scaling_factor) >> 1;
-  uint8 t = hptr.r6 ? RomPtr_00(hptr.r6)[v1] : 0;
+  uint8 t = hptr.r6 ? hptr.r6[v1] : 0;
   uint8 r3 = (t * timer_hdmawindow_scaling_factor) >> 8;
-  const uint8 *v3 = RomPtr_00(hptr.r4);
+  const uint8 *v3 = hptr.r4;
   uint8 result = (v3[v1] * timer_hdmawindow_scaling_factor) >> 8;
   uint8 r2 = result;
   return (PairU8) { .first = r2, .second = r3 };
@@ -5245,6 +5323,17 @@ void RunPlayerBlockCode_00EB73() {  // 00eb73
   player_wall_walk_status = 0;
 }
 
+static const uint8 kSlopeSteepness_e55e[106] = { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 14, 15, 16, 17, 3, 3, 4, 4, 9, 9, 10, 10, 12, 12, 13, 13, 18, 19, 20, 21, 22, 23, 28, 29, 30, 31, 24, 25, 26, 27, 8, 9, 10, 11, 12, 13,  };
+static const uint8 kSlopeSteepness_e5c8[106] = { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 14, 15, 16, 17, 3, 3, 4, 4, 9, 9, 10, 10, 12, 12, 13, 13, 12, 13, 13, 12, 22, 23, 28, 29, 30, 31, 24, 25, 26, 27, 8, 9, 10, 11, 12, 13,  };
+
+const uint8 *GetSlopeSteepness() {
+  switch (ptr_slope_steepness.addr) {
+  case 0xe55e: return kSlopeSteepness_e55e;
+  case 0xe5c8: return kSlopeSteepness_e5c8;
+  }
+  return Unreachable(), NULL;
+}
+
 void RunPlayerBlockCode_EB77() {  // 00eb77
   unsigned int v3;
   unsigned int v10;
@@ -5371,7 +5460,8 @@ LABEL_45:;
       }
       player_vdir_push_out_of_block -= (LOBYTE(pair.second) < 0xD8) + 15;
     }
-    v13 = 16 * *IndirPtr(&ptr_slope_steepness, (uint8)(v11 - 110));
+    const uint8 *slope_steepness = GetSlopeSteepness();
+    v13 = 16 * slope_steepness[(uint8)(v11 - 110)];
     LOBYTE(v13) = player_xpos_in_block | v13;
     v14 = kSlopeDataTables_ShapeOfSlope[v13];
     if (v14 >= 0)
@@ -5456,7 +5546,8 @@ LABEL_99:
   }
   if ((misc_level_tileset_setting == 3 || misc_level_tileset_setting == 14) && v19 >= 0xD2)
     goto LABEL_95;
-  uint8 k = *IndirPtr(&ptr_slope_steepness, (uint8)(v19 - 110));
+  const uint8 *slope_steepness = GetSlopeSteepness();
+  uint8 k = slope_steepness[(uint8)(v19 - 110)];
   uint8 v22 = player_ypos_in_block - kSlopeDataTables_ShapeOfSlope[player_xpos_in_block | 16 * k];
   if ((v22 & 0x80) != 0)
     ++player_on_ground_flag;
@@ -6297,12 +6388,12 @@ void PlayerState00_00F9C9(uint16 temp14b4, uint16 temp14b6, PointU16 pt) {  // 0
 
 uint8 CheckWhatSlopeSpriteIsOn(uint8 a, uint8 r10, uint8 r12, uint8 *slope_type) {  // 00fa19
   R5_slopeptr.addr = 0xe632;
-  R5_slopeptr.bank = 0;
+  const uint8 *slope_steepness = GetSlopeSteepness();
-  uint8 r8 = *IndirPtr(&ptr_slope_steepness, (uint8)(a - 110));
+  uint8 r8 = slope_steepness[(uint8)(a - 110)];
   *slope_type = r8;
   uint8 r1 = 16 * r8;
   if (__CFSHL__(8 * r8, 1))
-    ++g_ram[6];
+    R5_slopeptr.addr = 0xe732;
   return r1 | r10 & 0xF;
 }
 

src/smw_01.c

@@ -2,6 +2,7 @@
 #include "funcs.h"
 #include "smw_rtl.h"
 #include "variables.h"
+#include "assets/smw_assets.h"
 
 void (*kUnk_18137[13])(uint8) = {
     &SprStatus00_EmptySlot,   &SprStatus01_Init,         &SprStatus02_Dead,
@@ -1963,6 +1964,10 @@ void HandleNormalSpriteLevelColl_0192C9(uint8 k) {  // 0192c9
   }
 }
 
+uint8 GetCurrentSlope(int i) {
+  return (kSlopeDataTables_ShapeOfSlope + R5_slopeptr.addr - 0xE632)[i];
+}
+
 void HandleNormalSpriteLevelColl_01933B(uint8 k, uint8 a, uint8 r10, uint8 r12, uint8 r15) {  // 01933b
   if (a < 0x11) {
     if ((r12 & 0xF) >= 5)
@@ -1972,10 +1977,10 @@ void HandleNormalSpriteLevelColl_01933B(uint8 k, uint8 a, uint8 r10, uint8 r12,
       goto LABEL_18;
     uint8 r8_slope_type;
     uint8 v2 = CheckWhatSlopeSpriteIsOn(a, r10, r12, &r8_slope_type);
-    uint8 *v3 = IndirPtr(&R5_slopeptr, v2);
+    uint8 v3 = GetCurrentSlope(v2);
-    if (*v3 == 16)
+    if (v3 == 16)
       return;
-    if (*v3 >= 0x10) {
+    if (v3 >= 0x10) {
 LABEL_18:
       if ((r12 & 0xF) < 5) {
         uint8 v6 = spr_current_status[k];
@@ -1987,9 +1992,9 @@ LABEL_18:
       return;
     }
     uint8 v4 = r12 & 0xf;
-    if (v4 < 0xC && v4 < *v3)
+    if (v4 < 0xC && v4 < v3)
       return;
-    sprites_distance_to_snap_down_to_nearest_tile = *v3;
+    sprites_distance_to_snap_down_to_nearest_tile = v3;
     uint8 v5 = kSlopeDataTables_SlopeType[r8_slope_type];
     spr_slope_surface_its_on[k] = v5;
     if (v5 == 4 || v5 == 0xFC) {
@@ -6700,9 +6705,10 @@ void SprXXX_LineGuided_State01_OnLineGuide(uint8 k) {  // 01d768
 }
 
 void SprXXX_LineGuided_01D7B0(uint8 k, uint8 j) {  // 01d7b0
-  uint16 t = PAIR16(spr_table1528[k], spr_table151c[k]);
+  uint16 t = PAIR16(spr_table1528[k], spr_table151c[k]) - 0xF9DB;
-  uint8 r6 = RomPtr_07(t)[j] & 0xF;
+  uint8 tt = kLineGuideSpeedTableData[t + j];
-  uint8 r7 = RomPtr_07(t)[j] >> 4;
+  uint8 r6 = tt & 0xF;
+  uint8 r7 = tt >> 4;
   spr_ypos_lo[k] = r7 + (spr_ypos_lo[k] & 0xF0);
   spr_xpos_lo[k] = r6 + (spr_xpos_lo[k] & 0xF0);
 }

src/smw_02.c

@@ -2958,10 +2958,10 @@ uint8 HandleExtendedSpriteLevelColl_02A611(uint8 k, uint8 r15, ExtCollOut *out)
   uint8 r8_slope_type;
   uint8 v13 = CheckWhatSlopeSpriteIsOn(blocks_currently_processed_map16_tile_lo, blocks_xpos, blocks_ypos, &r8_slope_type);
   uint8 v14 = blocks_ypos & 0xf;
-  uint8 *rr = IndirPtr(&R5_slopeptr, v13);
+  uint8 rr = GetCurrentSlope(v13);
-  if (v14 < 0xC && v14 < *rr)
+  if (v14 < 0xC && v14 < rr)
     return 0;
-  sprites_distance_to_snap_down_to_nearest_tile = *rr;
+  sprites_distance_to_snap_down_to_nearest_tile = rr;
   out->r11 = kSlopeDataTables_SlopeType[r8_slope_type];
   return 1;
 }
@@ -3002,55 +3002,50 @@ void ParseLevelSpriteList_Entry2() {  // 02a802
 }
 
 void ParseLevelSpriteList_LoadSpriteLoopStrt(uint8 k, uint8 j, uint16 r0w) {  // 02a82e
-  uint8 *psld = IndirPtr(&ptr_sprite_list_data, 0);
+  const uint8 *p = GetSpriteListPtr();
-  uint8 r2, r3;
+  uint8 r2;
   while (1) {
 //    printf("M: Load sprites offs %d: 0x%x\n", j, r0w);
-    uint8 *v2 = &psld[j];
+    const uint8 *v2 = &p[j];
     if (*v2 == 0xFF)
       break;
     r2 = (8 * *v2) & 0x10;
-    uint8 v3 = j + 1;
+    uint8 v4 = r2 | p[j + 1] & 0xF;
-    uint8 v4 = r2 | psld[v3] & 0xF;
     bool v5 = v4 < (r0w >> 8);
     int8 v6 = v4 - (r0w >> 8);
     if (v5)
       goto LABEL_3;
     if (v6)
       return;
-    if ((psld[v3] & 0xF0) != (uint8)r0w || sprites_load_status[k]) {
+    if ((p[j + 1] & 0xF0) != (uint8)r0w || sprites_load_status[k]) {
 LABEL_3:
-      j = v3 + 2;
+      j += 3;
       ++k;
     } else {
       r2 = k;
       ++sprites_load_status[k];
-      uint8 v7 = v3 + 1;
+      uint8 v8 = p[j + 2];
-      uint8 v8 = psld[v7];
       uint8 v9;
       uint8 r5 = v8;
-      v3 = v7 - 1;
       if (v8 >= 0xE7) {
         if (!*(uint16 *)l1_l2_scroll_spr_spriteid) {
           l1_l2_scroll_spr_spriteid[0] = r5 + 25;
-          l1_l2_scroll_spr_scroll_type_index[0] = psld[(uint8)(v3 - 1)] >> 2;
+          l1_l2_scroll_spr_scroll_type_index[0] = p[j] >> 2;
           InitializeScrollSprites();
         }
         goto LABEL_3;
       }
       if (v8 == 0xDE) {
-        r3 = v3 - 1;
+        Spr0DE_Load5Eeries(k, r0w, r2, p + j);
-        Spr0DE_Load5Eeries(k, r0w, r2, r3);
         goto LABEL_3;
       }
       if (v8 == 0xE0) {
-        r3 = v3 - 1;
+        Spr0E0_Load3Platforms(r0w, r2, p + j);
-        Spr0E0_Load3Platforms(r0w, r2, r3);
         goto LABEL_3;
       }
       if (v8 < 0xCB) {
         if (v8 >= 0xC9) {
-          SprXXX_LoadShooter(k, v3, v8, r0w);
+          SprXXX_LoadShooter(k, v8, r0w, p + j);
           goto LABEL_3;
         }
         v9 = 1;
@@ -3061,14 +3056,12 @@ LABEL_3:
           goto LABEL_3;
         }
         if (v8 >= 0xE1) {
-          r3 = v3 - 1;
+          Spr0E1_LoadBooCeiling(k, v8, r0w, r2, p + j);
-          Spr0E1_LoadBooCeiling(k, v8, r0w, r2, r3);
           goto LABEL_3;
         }
         v9 = 9;
       }
       uint8 r4 = v9;
-      r3 = v3 - 1;
       uint8 v10 = kParseLevelSpriteList_SpriteSlotMax[sprites_sprite_memory_setting];
       uint8 r6 = kParseLevelSpriteList_SpriteSlotStart[sprites_sprite_memory_setting];
       if (r5 == kParseLevelSpriteList_ReservedSprite1[sprites_sprite_memory_setting]) {
@@ -3095,16 +3088,14 @@ LABEL_38:
           break;
         }
       }
-      uint8 v11 = r3;
+      const uint8 *v12 = &p[j];
-      uint8 *v12 = &psld[r3];
       if (misc_level_layout_flags & 1) {
         SetSprXYPos(v10, *v12 & 0xF0 | (*v12 & 0xD) << 8, r0w);
       } else {
         SetSprXYPos(v10, r0w, *v12 & 0xF0 | (*v12 & 0xD) << 8);
       }
-      uint8 v14 = v11 + 2;
       spr_current_status[v10] = r4;
-      uint8 v15 = psld[v14];
+      uint8 v15 = p[j + 2];
       if (r4 >= 9)
         v15 += 42;
       if ((ow_level_tile_settings[73] & 0x80) != 0) {
@@ -3125,7 +3116,7 @@ LABEL_38:
       }
       spr_xoffscreen_flag[v10] = 1;
       spr_decrementing_table1fe2[v10] = 4;
-      j = v14 + 1;
+      j += 3;
       k = r2 + 1;
     }
   }
@@ -3149,7 +3140,7 @@ uint8 FindFreeNormalSpriteSlot_02A9E6(uint8 r14) {  // 02a9ef
   return result;
 }
 
-void Spr0E1_LoadBooCeiling(uint8 k, uint8 a, uint16 r0w, uint8 r2, uint8 r3) {  // 02aac0
+void Spr0E1_LoadBooCeiling(uint8 k, uint8 a, uint16 r0w, uint8 r2, const uint8 *edata) {  // 02aac0
   flag_run_cluster_sprites = 1;
   switch (a) {
   case 0xE4:
@@ -3160,9 +3151,8 @@ void Spr0E1_LoadBooCeiling(uint8 k, uint8 a, uint16 r0w, uint8 r2, uint8 r3) {
       uint8 r = GetRand();
       SetHiLo(&cluster_spr_xpos_hi[i], &cluster_spr_xpos_lo[i], mirror_current_layer1_xpos + r);
       cluster_spr_table0f4a[i] = cluster_spr_xpos_lo[i];
-      uint8 *v14 = IndirPtr(&ptr_sprite_list_data, r3);
+      cluster_spr_ypos_lo[i] = *edata & 0xF0;
-      cluster_spr_ypos_lo[i] = *v14 & 0xF0;
+      cluster_spr_ypos_hi[i] = *edata & 1;
-      cluster_spr_ypos_hi[i] = *v14 & 1;
     }
     break;
   case 0xE6:
@@ -3203,9 +3193,8 @@ void Spr0E1_LoadBooCeiling(uint8 k, uint8 a, uint16 r0w, uint8 r2, uint8 r3) {
             cluster_spr_table0f4a[n] = r15;
             r15 = 0;
             if (v9) {
-              uint8 *v10 = IndirPtr(&ptr_sprite_list_data, r3);
               uint8 v11 = cluster_spr04_boo_ring_index;
-              uint8 v18 = *v10;
+              uint8 v18 = *edata;
               *(&cluster_spr04_boo_ring1_center_ypos_lo + v11) = v18 & 0xF0;
               *(&cluster_spr04_boo_ring1_center_ypos_hi + v11) = v18 & 1;
               *(&cluster_spr04_boo_ring1_center_xpos_lo + v11) = r0w;
@@ -3236,9 +3225,8 @@ void Spr0E1_LoadBooCeiling(uint8 k, uint8 a, uint16 r0w, uint8 r2, uint8 r3) {
   }
 }
 
-void SprXXX_LoadShooter(uint8 k, uint8 j, uint8 a, uint16 r0w) {  // 02ab78
+void SprXXX_LoadShooter(uint8 k, uint8 a, uint16 r0w, const uint8 *edata) {  // 02ab78
   uint8 r2 = k;
-  uint8 r3 = j - 1;
   uint8 r4 = a;
   uint8 v3 = 7;
   while (shooter_spr_spriteid[v3]) {
@@ -3250,24 +3238,21 @@ void SprXXX_LoadShooter(uint8 k, uint8 j, uint8 a, uint16 r0w) {  // 02ab78
       break;
     }
   }
-  uint8 v4 = r3;
   shooter_spr_spriteid[v3] = r4 + 56;
-  uint8 *v5 = IndirPtr(&ptr_sprite_list_data, v4);
 
   if (misc_level_layout_flags & 1) {  
-    uint8 v7 = *v5;
+    uint8 v7 = *edata;
-    shooter_spr_xpos_lo[v3] = *v5 & 0xF0;
+    shooter_spr_xpos_lo[v3] = v7 & 0xF0;
     shooter_spr_xpos_hi[v3] = v7 & 1;
     SetHiLo(&shooter_spr_ypos_hi[v3], &shooter_spr_ypos_lo[v3], r0w);
   } else {
-    uint8 v8 = *v5;
+    uint8 v8 = *edata;
-    shooter_spr_ypos_lo[v3] = *v5 & 0xF0;
+    shooter_spr_ypos_lo[v3] = v8 & 0xF0;
     shooter_spr_ypos_hi[v3] = v8 & 1;
     SetHiLo(&shooter_spr_xpos_hi[v3], &shooter_spr_xpos_lo[v3], r0w);
   }
   shooter_spr_unused_level_list_index[v3] = r2;
   shooter_spr_shoot_timer[v3] = 16;
-  ParseLevelSpriteList_LoadSpriteLoopStrt(r2 + 1, v4 + 3, r0w);
 }
 
 void InitializeAllSpritesOnLevelLoad() {  // 02abf2
@@ -3456,8 +3441,8 @@ LABEL_15:;
   }
 }
 
-void Spr0E0_Load3Platforms(uint16 r0w, uint8 r2, uint8 r3) {  // 02af33
+void Spr0E0_Load3Platforms(uint16 r0w, uint8 r2, const uint8 *edata) {  // 02af33
-  uint8 v3 = *IndirPtr(&ptr_sprite_list_data, r3);
+  uint8 v3 = *edata;
   uint16 ypos = PAIR16(v3 & 1, v3 & 0xF0);
   uint8 r4 = 2;
   do {
@@ -3477,8 +3462,8 @@ void Spr0E0_Load3Platforms(uint16 r0w, uint8 r2, uint8 r3) {  // 02af33
   } while ((--r4 & 0x80) == 0);
 }
 
-void Spr0DE_Load5Eeries(uint8 k, uint16 r0w, uint8 r2, uint8 r3) {  // 02af9d
+void Spr0DE_Load5Eeries(uint8 k, uint16 r0w, uint8 r2, const uint8 *edata) {  // 02af9d
-  uint8 v5 = *IndirPtr(&ptr_sprite_list_data, r3);
+  uint8 v5 = *edata;
   uint16 ypos = PAIR16(v5 & 1, v5 & 0xF0);
   uint8 r4 = 4;
   do {
@@ -7304,9 +7289,10 @@ void Spr06A_CoinGameCloud_02EF67(uint8 k) {  // 02ef67
 
 void Spr086_Wiggler_Init(uint8 k) {  // 02eff2
   Spr086_Wiggler_Init_GetWigglerSegmentPosIndex(k);
+  uint8 *v2 = g_ram + 0x10000 + spr86_wiggler_segment_pos_ptr.addr;
   for (int i = 126; i >= 0; i -= 2) {
-    IndirWriteByte(&spr86_wiggler_segment_pos_ptr, i, spr_xpos_lo[k]);
+    v2[i] = spr_xpos_lo[k];
-    IndirWriteByte(&spr86_wiggler_segment_pos_ptr, i + 1, spr_ypos_lo[k]);
+    v2[i + 1] = spr_ypos_lo[k];
   }
   spr_table157c[k] = CheckPlayerPositionRelativeToSprite_Bank23_X(k);
 }
@@ -7378,10 +7364,9 @@ void Spr086_Wiggler(uint8 k) {  // 02f035
     uint8 v8 = kSpr086_Wiggler_DATA_02F103[v7];
     if (r8)
       v8 = (v8 >> 1) & 0xFE;
-    uint8 *v9 = IndirPtr(&spr86_wiggler_segment_pos_ptr, v8);
+    uint8 *v9 = g_ram + 0x10000 + spr86_wiggler_segment_pos_ptr.addr + v8;
-    get_OamEnt(oam_buf, v24)[64].xpos = *v9 - mirror_current_layer1_xpos;
+    get_OamEnt(oam_buf, v24)[64].xpos = v9[0] - mirror_current_layer1_xpos;
-    int8 v10 = *IndirPtr(&spr86_wiggler_segment_pos_ptr, (uint8)(v8 + 1)) - mirror_current_layer1_ypos -
+    int8 v10 = v9[1] - mirror_current_layer1_ypos - kSpr086_Wiggler_WigglerYDisp[r6];
-               kSpr086_Wiggler_WigglerYDisp[r6];
     OamEnt *oam = get_OamEnt(oam_buf, v24);
     oam[64].ypos = v10;
     uint8 v12 = -116;
@@ -7467,8 +7452,8 @@ void Spr086_Wiggler(uint8 k) {  // 02f035
 void Spr086_Wiggler_02F0DB(uint8 k) {  // 02f0db
   uint8 *v2 = g_ram + 0x10000 + spr86_wiggler_segment_pos_ptr.addr;
   memmove(v2 + 2, v2, 0x7E);
-  IndirWriteByte(&spr86_wiggler_segment_pos_ptr, 0, spr_xpos_lo[k]);
+  v2[0] = spr_xpos_lo[k];
-  IndirWriteByte(&spr86_wiggler_segment_pos_ptr, 1, spr_ypos_lo[k]);
+  v2[1] = spr_ypos_lo[k];
 }
 
 void Spr086_Wiggler_02F2D7(uint8 k) {  // 02f2d7

src/smw_03.c

@@ -2,6 +2,7 @@
 #include "funcs.h"
 #include "smw_rtl.h"
 #include "variables.h"
+#include "assets/smw_assets.h"
 
 static FuncU8 *const kSpr0C5_BigBooBoss_BigBooBossPtrs[7] = {
     &Spr0C5_BigBooBoss_StoppedBeforeFadeIn,
@@ -348,12 +349,9 @@ static const uint8 kSpr029_KoopaKid_WendyLemmy_LemmyTileSize[138] = { 0x2, 0x2,
 static const uint8 kSpr029_KoopaKid_WendyLemmy_WendyTileSize[138] = { 0x2, 0x2, 0x2, 0x2, 0x2, 0x4, 0x2, 0x2, 0x2, 0x2, 0x2, 0x4, 0x2, 0x2, 0x0, 0x4, 0x4, 0x4, 0x2, 0x2, 0x0, 0x0, 0x4, 0x4, 0x2, 0x2, 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, 0x2, 0x4, 0x4, 0x4, 0x2, 0x2, 0x0, 0x4, 0x4, 0x4, 0x2, 0x2, 0x0, 0x4, 0x4, 0x4, 0x2, 0x2, 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, 0x2, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, 0x4, 0x4, 0x4, 0x4, 0x2, 0x2, 0x4, 0x4, 0x4, 0x4, 0x2, 0x2, 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, 0x2, 0x4, 0x4, 0x4, 0x2, 0x2, 0x2, 0x4, 0x4, 0x4, 0x2, 0x2, 0x2, 0x4, 0x4, 0x4, 0x2, 0x2, 0x2, 0x0, 0x0, 0x4, 0x2, 0x2, 0x2, 0x4, 0x4, 0x4, 0x2, 0x2, 0x2, 0x4, 0x4, 0x4, 0x2, 0x2, 0x2, 0x4, 0x4, 0x4,  };
 static const uint8 kSpr029_KoopaKid_WendyLemmy_NumberOfTilesToDrawForLemmy[23] = { 0x4, 0x4, 0x2, 0x3, 0x4, 0x2, 0x2, 0x2, 0x3, 0x3, 0x5, 0x4, 0x1, 0x1, 0x4, 0x4, 0x2, 0x2, 0x2, 0x4, 0x2, 0x2, 0x2,  };
 static const uint8 kSpr029_KoopaKid_WendyLemmy_NumberOfTilesToDrawForWendy[23] = { 0x4, 0x4, 0x2, 0x3, 0x4, 0x2, 0x2, 0x2, 0x4, 0x4, 0x5, 0x4, 0x1, 0x1, 0x4, 0x4, 0x2, 0x2, 0x2, 0x4, 0x2, 0x2, 0x2,  };
-#define kSpr07C_PrincessPeach_MessageData ((uint16*)RomFixedPtr(0x3D524))
 static const uint8 kSpr0A9_Reznor_DATA_03D700[12] = { 0xb0, 0xa0, 0x90, 0x80, 0x70, 0x60, 0x50, 0x40, 0x30, 0x20, 0x10, 0x0,  };
+static const uint8 kGameMode12_PrepareLevel_IggyPlatformTiles[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 23, 24, 23, 24, 23, 24, 23, 24, 25, 26, 0, 0, 0, 0, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 5, 18, 0, 0, 0, 0, 0, 7, 4, 3, 4, 3, 4, 3, 4, 3, 8, 0, 0, 0, 0, 0, 0, 9, 10, 4, 3, 4, 3, 4, 3, 11, 12, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 3, 4, 3, 15, 16, 0, 0, 0, 0, 0, 0, 0, 0, 17, 2, 3, 4, 3, 4, 5, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 4, 3, 4, 3, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 10, 4, 3, 11, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 3, 4, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  };
 static const uint16 kGameMode12_PrepareLevel_DATA_03D8EC[54] = { 0xffff, 0xffff, 0xffff, 0x3424, 0xb25, 0x3626, 0x1b0e, 0x1c0c, 0x1d0d, 0x1e0e, 0x3929, 0x3a2a, 0x3b2b, 0x3826, 0x3020, 0x3121, 0x3727, 0x3828, 0xffff, 0x3222, 0x330e, 0x1c0c, 0x1d0d, 0x3c0e, 0x3d2d, 0xffff, 0x1707, 0x230e, 0x40e, 0x1c0c, 0x1d0d, 0x90e, 0x2c0e, 0x1a0a, 0xffff, 0x3424, 0x3b2b, 0xffff, 0x1707, 0x180e, 0x190e, 0x1a0a, 0x1202, 0x1303, 0x803, 0x503, 0x503, 0x1403, 0x1503, 0x503, 0x503, 0x803, 0x603, 0x1f0f,  };
-#define kInitializeMode7TilemapsAndPalettes_TilemapData ((uint8*)RomFixedPtr(0x3D9DE))
-static const uint8 kInitializeMode7TilemapsAndPalettes_PalPtrLo[5] = { 0xbc, 0xa4, 0x98, 0x78, 0x6c,  };
-static const uint8 kInitializeMode7TilemapsAndPalettes_PalPtrHi[5] = { 0xb2, 0xb2, 0xb2, 0xb3, 0xb3,  };
 static const uint8 kInitializeMode7TilemapsAndPalettes_GFXFile[5] = { 0xb, 0xb, 0xb, 0x21, 0x0,  };
 static const uint8 kInitializeMode7TilemapsAndPalettes_DATA_03DE4E[64] = { 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x3f,  };
 static const uint16 kUpdateMode7SpriteAnimations_DATA_03DEBB[2] = { 0x100, 0x110,  };
@@ -4281,6 +4279,8 @@ void Spr029_KoopaKid_WendyLemmy_Draw(uint8 k) {  // 03d484
   }
 }
 
+static const uint16 kSpr07C_PrincessPeach_MessageData[168] = { 0x2018, 0xea1, 0x2020, 0xe88, 0x2028, 0xeab, 0x2030, 0xe99, 0x2038, 0xea8, 0x2040, 0xebf, 0x2048, 0xeac, 0x2058, 0xe88, 0x2060, 0xe8b, 0x2068, 0xeaf, 0x2070, 0xe8c, 0x2078, 0xe9e, 0x2080, 0xead, 0x2088, 0xeae, 0x2090, 0xeab, 0x2098, 0xe8c, 0x20a8, 0xe99, 0x20b0, 0xeac, 0x20c0, 0xea8, 0x20c8, 0xeaf, 0x20d0, 0xe8c, 0x20d8, 0xeab, 0x20e0, 0xebd, 0x3018, 0xea1, 0x3020, 0xe88, 0x3028, 0xeab, 0x3030, 0xe99, 0x3038, 0xea8, 0x3040, 0xebe, 0x3048, 0xead, 0x3050, 0xe98, 0x3058, 0xe8c, 0x3068, 0xea0, 0x3070, 0xeab, 0x3078, 0xe99, 0x3080, 0xe9e, 0x3088, 0xe8a, 0x3090, 0xe8c, 0x3098, 0xeac, 0x30a0, 0xeac, 0x30a8, 0xebe, 0x30b0, 0xeb0, 0x30b8, 0xea8, 0x30c0, 0xeac, 0x30c8, 0xe98, 0x30d0, 0xe99, 0x30d8, 0xebe, 0x4018, 0xe88, 0x4020, 0xe9e, 0x4028, 0xe8b, 0x4038, 0xe98, 0x4040, 0xe99, 0x4048, 0xeac, 0x4058, 0xe8d, 0x4060, 0xeab, 0x4068, 0xe99, 0x4070, 0xe8c, 0x4078, 0xe9e, 0x4080, 0xe8b, 0x4088, 0xeac, 0x4098, 0xe88, 0x40a0, 0xeab, 0x40a8, 0xe8c, 0x40b8, 0xe8e, 0x40c0, 0xea8, 0x40c8, 0xe99, 0x40d0, 0xe9e, 0x40d8, 0xe8e, 0x5018, 0xead, 0x5020, 0xea8, 0x5030, 0xead, 0x5038, 0xe88, 0x5040, 0xe9b, 0x5048, 0xe8c, 0x5058, 0xe88, 0x5068, 0xeaf, 0x5070, 0xe88, 0x5078, 0xe8a, 0x5080, 0xe88, 0x5088, 0xead, 0x5090, 0xe99, 0x5098, 0xea8, 0x50a0, 0xe9e, 0x50a8, 0xebd,  };
+
 void Spr07C_PrincessPeach_DisplayPeachRescueMessage() {  // 03d674
   if (spr7c_princess_peach_current_letter) {
     int16 v0 = spr7c_princess_peach_current_letter - 1;
@@ -4362,7 +4362,7 @@ void GameMode12_PrepareLevel_UploadTiltingPlatformTilemap() {  // 03d958
   for (int i = 0; i < 0x4000; i++)
     LOBYTE(dst[i]) = 0xff;
   if ((misc_nmito_use_flag & 0x40) == 0) {
-    GameMode12_PrepareLevel_03D991(RomPtr(0x3d7ec), 0x810);
+    GameMode12_PrepareLevel_03D991(kGameMode12_PrepareLevel_IggyPlatformTiles, 0x810);
   }
 }
 
@@ -4392,6 +4392,14 @@ void GameMode12_PrepareLevel_03D991(const uint8 *p5, uint16 r0w) {  // 03d991
   } while (v0);
 }
 
+static const uint16 kInitializeMode7TilemapsAndPalettes_Pals[5][6] = {
+  {0x0, 0x1e0, 0x2e0, 0x3e0, 0xb7, 0x23f},
+  {0x0, 0x6d08, 0x6dad, 0x7e31, 0xb7, 0x23f},
+  {0x0, 0x1ff, 0x31f, 0x3ff, 0xb7, 0x23f},
+  {0x0, 0x2940, 0x3de0, 0x5280, 0xb7, 0x23f},
+  {0x2e32, 0x4a0d, 0x1088, 0x214a, 0x296d, 0x3dcf},
+};
+
 void InitializeMode7TilemapsAndPalettes(uint8 k) {  // 03dd7d
   misc_currently_active_boss = spr_table00c2[k];
   if (misc_currently_active_boss == 4) {
@@ -4402,9 +4410,7 @@ void InitializeMode7TilemapsAndPalettes(uint8 k) {  // 03dd7d
   misc_screens_in_lvl = -1;
   camera_last_screen_horiz = 0;
   uint8 v1 = kInitializeMode7TilemapsAndPalettes_GFXFile[misc_currently_active_boss];
-  uint16 r0w = kInitializeMode7TilemapsAndPalettes_PalPtrLo[misc_currently_active_boss] |
+  const uint8 *p0 = (const uint8 *)kInitializeMode7TilemapsAndPalettes_Pals[misc_currently_active_boss];
-      kInitializeMode7TilemapsAndPalettes_PalPtrHi[misc_currently_active_boss] << 8;
-  const uint8 *p0 = RomPtr_00(r0w);
   for (uint8 i = 11; (i & 0x80) == 0; --i)
     *((uint8 *)&palettes_palette_mirror[2] + i) = p0[i];
   uint16 *dst = RtlGetVramAddr();
@@ -4578,6 +4584,8 @@ void UpdateMode7SpriteAnimations_03DFAE(uint8 j, uint16 a) {  // 03dfae
   *(uint16 *)((int8 *)&mirror_m7_xpos + j) = *(uint16 *)((int8 *)&mirror_current_layer1_xpos + j) + kUpdateMode7SpriteAnimations_DATA_03DEBB[j >> 1] - a;
 }
 
+static const uint16 kGlobalPalettes_BowserLightningFlash[11] = { 0x0, 0x2ce7, 0x3d6b, 0x4def, 0x5e73, 0x6ef7, 0x7fff,0x7393,     0, 0x3FF,0x573B  };
+
 void Spr0A0_ActivateBowserBattle_UpdatePaletteAndLightningAnimation() {  // 03dfcc
   unsigned int v1;
   uint16 v4;

src/smw_04.c

@@ -2,7 +2,7 @@
 #include "funcs.h"
 #include "smw_rtl.h"
 #include "variables.h"
-
+#include "assets/smw_assets.h"
 
 void (*kHandleCurrentOverworldProcess_PtrsLong04857D[13])(void) = {
     &OwProcess00_OverworldEntryInitialization,
@@ -50,8 +50,6 @@ void (*kProcessOverworldSprites_OverworldSpritePtrs[11])(uint8 k) = {
     &OWSpr0A_Boo,
 };
 
-#define kLayer2EventData_TileEntries ((uint16*)RomFixedPtr(0x4DD8D))
-#define kLoadOverworldSprites_SpriteSlotData ((SpriteSlotData*)RomFixedPtr(0x4F625))
 
 static const uint16 kOwTileAnimations_WaterTileNumbers[3] = { 0xb480, 0xb498, 0xb4b0,  };
 static const uint16 kOwTileAnimations_TileNumbers[64] = { 0xb300, 0xb318, 0xb330, 0xb348, 0xb360, 0xb378, 0xb390, 0xb3a8, 0xb3c0, 0xb3d8, 0xb3f0, 0xb408, 0xb420, 0xb438, 0xb450, 0xb468, 0xb480, 0xb498, 0xb4b0, 0xb4c8, 0xb4e0, 0xb4f8, 0xb510, 0xb528, 0xb540, 0xb558, 0xb570, 0xb588, 0xb5a0, 0xb5b8, 0xb5d0, 0xb5e8, 0xb600, 0xb618, 0xb630, 0xb648, 0xb660, 0xb678, 0xb690, 0xb6a8, 0xb6c0, 0xb6d8, 0xb6f0, 0xb708, 0xb720, 0xb738, 0xb750, 0xb768, 0xb780, 0xb798, 0xb7b0, 0xb7c8, 0xb7e0, 0xb7f8, 0xb810, 0xb828, 0xb840, 0xb858, 0xb870, 0xb888, 0xb8a0, 0xb8b8, 0xb8d0, 0xb8e8,  };
@@ -62,7 +60,9 @@ static const uint16 kHandleOverworldStarPipeWarp_DATA_048431[27] = { 0x11, 0xa,
 static const uint16 kHandleOverworldStarPipeWarp_DATA_048467[27] = { 0x7, 0x3, 0x10, 0xe, 0x17, 0x18, 0x12, 0x14, 0xb, 0x3, 0x1, 0x9, 0x9, 0x1d, 0xe, 0x18, 0xf, 0x16, 0x10, 0x18, 0x2, 0x1d, 0x18, 0x13, 0x11, 0x3, 0x7,  };
 static const uint16 kHandleOverworldStarPipeWarp_DATA_04849D[27] = { 0x4a8, 0x438, 0x908, 0x928, 0x9c8, 0x948, 0xd28, 0x118, 0xa8, 0x98, 0xb8, 0x128, 0xa8, 0x78, 0xd28, 0x408, 0xd78, 0x108, 0xdc8, 0x148, 0xdc8, 0x948, 0xb18, 0xd78, 0x268, 0xdc8, 0xd28,  };
 static const uint16 kHandleOverworldStarPipeWarp_DATA_0484D3[27] = { 0x148, 0xb8, 0x38, 0x18, 0x98, 0x98, 0x1d8, 0x78, 0x38, 0x108, 0xe8, 0x178, 0x188, 0x128, 0x188, 0xe8, 0x168, 0xf8, 0x188, 0x108, 0x1d8, 0x38, 0x138, 0x188, 0x78, 0x1d8, 0x1d8,  };
+static const uint16 kDrawOverworldPlayer_PlayerTilesAndProp[192] = { 0x240e, 0x240f, 0x241e, 0x241f, 0x2420, 0x2421, 0x2430, 0x2431, 0x240e, 0x240f, 0x241e, 0x241f, 0x2420, 0x2421, 0x6431, 0x6430, 0x240a, 0x240b, 0x241a, 0x241b, 0x240c, 0x240d, 0x241c, 0x241d, 0x240a, 0x240b, 0x241a, 0x241b, 0x240c, 0x240d, 0x641d, 0x641c, 0x2408, 0x2409, 0x2418, 0x2419, 0x2406, 0x2407, 0x2416, 0x2417, 0x2408, 0x2409, 0x2418, 0x2419, 0x2406, 0x2407, 0x2416, 0x2417, 0x6409, 0x6408, 0x6419, 0x6418, 0x6407, 0x6406, 0x6417, 0x6416, 0x6409, 0x6408, 0x6419, 0x6418, 0x6407, 0x6406, 0x6417, 0x6416, 0x240e, 0x240f, 0x2438, 0x6438, 0x2420, 0x2421, 0x2439, 0x6439, 0x240e, 0x240f, 0x2438, 0x6438, 0x2420, 0x2421, 0x2439, 0x6439, 0x240a, 0x240b, 0x2438, 0x6438, 0x240c, 0x240d, 0x2439, 0x6439, 0x240a, 0x240b, 0x2438, 0x6438, 0x240c, 0x240d, 0x2439, 0x6439, 0x2408, 0x2409, 0x2438, 0x6438, 0x2406, 0x2407, 0x2439, 0x6439, 0x2408, 0x2409, 0x2438, 0x6438, 0x2406, 0x2407, 0x2439, 0x6439, 0x6409, 0x6408, 0x2438, 0x6438, 0x6407, 0x6406, 0x2439, 0x6439, 0x6409, 0x6408, 0x2438, 0x6438, 0x6407, 0x6406, 0x2439, 0x6439, 0x2424, 0x2425, 0x2434, 0x2435, 0x2424, 0x2425, 0x2434, 0x2435, 0x2424, 0x2425, 0x2434, 0x2435, 0x2424, 0x2425, 0x2434, 0x2435, 0x2424, 0x2425, 0x2438, 0x6438, 0x2424, 0x2425, 0x2438, 0x6438, 0x2424, 0x2425, 0x2438, 0x6438, 0x2424, 0x2425, 0x2438, 0x6438, 0x2446, 0x2447, 0x2456, 0x2457, 0x6447, 0x6446, 0x6457, 0x6456, 0x2446, 0x2447, 0x2456, 0x2457, 0x6447, 0x6446, 0x6457, 0x6456, 0x2446, 0x2447, 0x2456, 0x2457, 0x6447, 0x6446, 0x6457, 0x6456, 0x2446, 0x2447, 0x2456, 0x2457, 0x6447, 0x6446, 0x6457, 0x6456,  };
 static const uint8 kDrawOverworldPlayer_StarWarpAnimationOffset[4] = { 0x20, 0x60, 0x0, 0x40,  };
+static const uint8 kDrawOverworldPlayer_PlayerRidingYoshiTilesAndProp[384] = { 0x66, 0x24, 0x67, 0x24, 0x76, 0x24, 0x77, 0x24, 0x2f, 0x62, 0x2e, 0x62, 0x3f, 0x62, 0x3e, 0x62, 0x66, 0x24, 0x67, 0x24, 0x76, 0x24, 0x77, 0x24, 0x2e, 0x22, 0x2f, 0x22, 0x3e, 0x22, 0x3f, 0x22, 0x2f, 0x62, 0x2e, 0x62, 0x3f, 0x62, 0x3e, 0x62, 0xa, 0x24, 0xb, 0x24, 0x1a, 0x24, 0x1b, 0x24, 0x2e, 0x22, 0x2f, 0x22, 0x3e, 0x22, 0x3f, 0x22, 0xa, 0x24, 0xb, 0x24, 0x1a, 0x24, 0x1b, 0x24, 0x64, 0x24, 0x65, 0x24, 0x74, 0x24, 0x75, 0x24, 0x40, 0x22, 0x41, 0x22, 0x50, 0x22, 0x51, 0x22, 0x64, 0x24, 0x65, 0x24, 0x74, 0x24, 0x75, 0x24, 0x42, 0x22, 0x43, 0x24, 0x52, 0x24, 0x53, 0x24, 0x65, 0x64, 0x64, 0x64, 0x75, 0x64, 0x74, 0x64, 0x41, 0x62, 0x40, 0x62, 0x51, 0x62, 0x50, 0x62, 0x65, 0x64, 0x64, 0x64, 0x75, 0x64, 0x74, 0x64, 0x43, 0x62, 0x42, 0x62, 0x53, 0x62, 0x52, 0x62, 0x38, 0x24, 0x38, 0x64, 0x66, 0x24, 0x67, 0x24, 0x76, 0x24, 0x77, 0x24, 0xff, 0xff, 0xff, 0xff, 0x39, 0x24, 0x39, 0x64, 0x66, 0x24, 0x67, 0x24, 0x76, 0x24, 0x77, 0x24, 0xff, 0xff, 0xff, 0xff, 0x38, 0x24, 0x38, 0x64, 0x2f, 0x62, 0x2e, 0x62, 0xa, 0x24, 0xb, 0x24, 0x1a, 0x24, 0x1b, 0x24, 0x39, 0x24, 0x39, 0x24, 0x2e, 0x22, 0x2f, 0x22, 0xa, 0x24, 0xb, 0x24, 0x1a, 0x24, 0x1b, 0x24, 0x38, 0x24, 0x38, 0x64, 0x64, 0x24, 0x65, 0x24, 0x74, 0x24, 0x75, 0x24, 0x40, 0x22, 0x41, 0x22, 0x39, 0x24, 0x39, 0x64, 0x64, 0x24, 0x65, 0x24, 0x74, 0x24, 0x75, 0x24, 0x42, 0x22, 0x42, 0x22, 0x38, 0x24, 0x38, 0x64, 0x65, 0x64, 0x64, 0x64, 0x75, 0x64, 0x74, 0x64, 0x41, 0x62, 0x40, 0x62, 0x39, 0x24, 0x39, 0x64, 0x65, 0x64, 0x64, 0x64, 0x75, 0x64, 0x74, 0x64, 0x43, 0x62, 0x42, 0x62, 0x2f, 0x62, 0x2e, 0x62, 0x3f, 0x62, 0x3e, 0x62, 0x24, 0x24, 0x25, 0x24, 0x34, 0x24, 0x35, 0x24, 0x2e, 0x22, 0x2f, 0x22, 0x3e, 0x22, 0x3f, 0x22, 0x24, 0x24, 0x25, 0x24, 0x34, 0x24, 0x35, 0x24, 0x38, 0x24, 0x38, 0x64, 0x2f, 0x62, 0x2e, 0x62, 0x24, 0x24, 0x25, 0x24, 0x34, 0x24, 0x35, 0x24, 0x39, 0x24, 0x39, 0x64, 0x2e, 0x22, 0x2f, 0x22, 0x24, 0x24, 0x25, 0x24, 0x34, 0x24, 0x35, 0x24, 0x66, 0x24, 0x67, 0x24, 0x76, 0x24, 0x77, 0x24, 0x2f, 0x62, 0x2e, 0x62, 0x3f, 0x62, 0x3e, 0x62, 0x66, 0x24, 0x67, 0x24, 0x76, 0x24, 0x77, 0x24, 0x2e, 0x22, 0x2f, 0x22, 0x3e, 0x22, 0x3f, 0x22, 0x66, 0x24, 0x67, 0x24, 0x76, 0x24, 0x77, 0x24, 0x2f, 0x62, 0x2e, 0x62, 0x3f, 0x62, 0x3e, 0x62, 0x66, 0x24, 0x67, 0x24, 0x76, 0x24, 0x77, 0x24, 0x2e, 0x22, 0x2f, 0x22, 0x3e, 0x22, 0x3f, 0x22,  };
 static const uint8 kDrawOverworldPlayer_PlayerAndYoshiXDisp[192] = { 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x7, 0xf, 0x7, 0xf, 0x0, 0x8, 0x0, 0x8, 0x7, 0xf, 0x7, 0xf, 0x0, 0x8, 0x0, 0x8, 0xf9, 0x1, 0xf9, 0x1, 0x0, 0x8, 0x0, 0x8, 0xf9, 0x1, 0xf9, 0x1, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x7, 0xf, 0x7, 0xf, 0x0, 0x8, 0x0, 0x8, 0x7, 0xf, 0x7, 0xf, 0x0, 0x8, 0x0, 0x8, 0xf9, 0x1, 0xf9, 0x1, 0x0, 0x8, 0x0, 0x8, 0xf9, 0x1, 0xf9, 0x1, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8, 0x0, 0x8,  };
 static const uint8 kDrawOverworldPlayer_PlayerAndYoshiYDisp[192] = { 0xfb, 0xfb, 0x3, 0x3, 0x0, 0x0, 0x8, 0x8, 0xfa, 0xfa, 0x2, 0x2, 0x0, 0x0, 0x8, 0x8, 0x0, 0x0, 0x8, 0x8, 0xf8, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0xf9, 0xf9, 0x1, 0x1, 0xfc, 0xfc, 0x4, 0x4, 0x0, 0x0, 0x8, 0x8, 0xfb, 0xfb, 0x3, 0x3, 0x0, 0x0, 0x8, 0x8, 0xfc, 0xfc, 0x4, 0x4, 0x0, 0x0, 0x8, 0x8, 0xfb, 0xfb, 0x3, 0x3, 0x0, 0x0, 0x8, 0x8, 0x8, 0x8, 0xfb, 0xfb, 0x3, 0x3, 0x0, 0x0, 0x8, 0x8, 0xfa, 0xfa, 0x2, 0x2, 0x0, 0x0, 0x8, 0x8, 0x0, 0x0, 0xf8, 0xf8, 0x0, 0x0, 0x8, 0x8, 0x0, 0x0, 0xf9, 0xf9, 0x1, 0x1, 0x8, 0x8, 0xfc, 0xfc, 0x4, 0x4, 0x0, 0x0, 0x8, 0x8, 0xfb, 0xfb, 0x3, 0x3, 0x0, 0x0, 0x8, 0x8, 0xfc, 0xfc, 0x4, 0x4, 0x0, 0x0, 0x8, 0x8, 0xfb, 0xfb, 0x3, 0x3, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0xf8, 0xf8, 0x0, 0x0, 0x0, 0x0, 0x8, 0x8, 0xf8, 0xf8, 0x0, 0x0, 0x8, 0x8, 0x0, 0x0, 0xf8, 0xf8, 0x0, 0x0, 0x8, 0x8, 0x0, 0x0, 0xf8, 0xf8, 0x0, 0x0, 0xfb, 0xfb, 0x3, 0x3, 0x0, 0x0, 0x8, 0x8, 0xfa, 0xfa, 0x2, 0x2, 0x0, 0x0, 0x8, 0x8, 0xfb, 0xfb, 0x3, 0x3, 0x0, 0x0, 0x8, 0x8, 0xfa, 0xfa, 0x2, 0x2, 0x0, 0x0, 0x8, 0x8,  };
 static const uint16 kDrawOverworldPlayer_YoshiPalette[4] = { 0x0, 0x200, 0x400, 0x600,  };
@@ -1257,6 +1257,40 @@ void UnlockOverworldPathBasedOnExit() {  // 049903
   }
 }
 
+static const OwExits kHandleOverworldPathExits_DATA_049964[] = {
+  {0x0140, 0x0028, 0},
+  {0x0150, 0x0058, 0},
+  {0x0010, 0x0048, 1},
+  {0x0010, 0x0098, 1},
+  {0x00a0, 0x00d8, 0},
+  {0x0140, 0x0058, 2},
+  {0x0090, 0x01e8, 4},
+  {0x0160, 0x00e8, 0},
+  {0x00a0, 0x01c8, 0},
+  {0x0160, 0x0088, 3},
+  {0x0108, 0x0190, 0},
+  {0x01e8, 0x0010, 3},
+  {0x0110, 0x01c8, 0},
+  {0x01f0, 0x0088, 3},
+};
+
+static const OwExits kHandleOverworldPathExits_DATA_0499AA[] = {
+  {0x0000, 0x0048, 1},
+  {0x0000, 0x0098, 1},
+  {0x0150, 0x0028, 0},
+  {0x0160, 0x0058, 0},
+  {0x0150, 0x0058, 2},
+  {0x0090, 0x00d8, 0},
+  {0x0150, 0x00e8, 0},
+  {0x00a0, 0x01e8, 4},
+  {0x0150, 0x0088, 3},
+  {0x00b0, 0x01c8, 0},
+  {0x01e8, 0x0000, 3},
+  {0x0108, 0x01a0, 0},
+  {0x0200, 0x0088, 3},
+  {0x0100, 0x01c8, 0},
+};
+
 void HandleOverworldPathExits() {  // 049a24
   PointU16 *pt;
   ow_currently_loaded_submap = ow_players_map[(uint8)(player_current_characterx4 >> 2)];
@@ -1297,7 +1331,22 @@ void HandleOverworldPathExits_SetLayerPositions() {  // 049a93
   }
 }
 
-#define kUpdateLevelName_LevelNameStrings ((uint8*)RomFixedPtr(0x49AC5))
+
+static const SpriteSlotData kLoadOverworldSprites_SpriteSlotData[] = {
+  {0, 0x100, 0xe0},
+  {0, 0x100, 0x60},
+  {6, 0x170, 0x20},
+  {7, 0x38, 0x18a},
+  {0, 0x58, 0x7a},
+  {8, 0x188, 0x18},
+  {9, 0x148, 0xfffc},
+  {0, 0x80, 0x100},
+  {0, 0x50, 0x140},
+  {3, 0x0, 0x0},
+  {10, 0x40, 0x98},
+  {10, 0x60, 0xf8},
+  {10, 0x140, 0x158},
+};
 
 void UpdateLevelName(uint16 r0w) {  // 049d07
   uint16 v0 = stripe_image_upload;
@@ -1613,15 +1662,15 @@ void LoadOverworldLayer1AndEvents() {  // 04dc09
     r0w += 8;
   }
   uint8 *v3 = g_ram + 0xC800;
-  const uint8 *v4 = RomPtr_0C(0xF7DF);
+  const uint8 *v4 = kLoadOverworldLayer1AndEvents_DATA_0CF7DF;
   MemCpy(v3, v4, 0x800);
   LoadOverworldLayer1AndEvents_04D7F2();
 }
 
 void LoadOverworldLayer2AndEventsTilemaps_Sub() {  // 04dc6a
   LoadOverworldLayer2AndEventsTilemaps_04DD40();
-  BufferOverworldLayer2Tilemap(0, 0, 0x4000, RomPtr_04(0xa533));
+  BufferOverworldLayer2Tilemap(0, 0, 0x4000, kLoadOverworldLayer2AndEventsTilemaps_OverworldLayer2Tilemap);
-  BufferOverworldLayer2Tilemap(1, 0, 0x4000, RomPtr_04(0xc02b));
+  BufferOverworldLayer2Tilemap(1, 0, 0x4000, kLoadOverworldLayer2AndEventsTilemaps_OverworldLayer2Tilemap_Prop);
   uint8 r15 = 0;
   do {
     LoadOverworldLayer2AndEventsTilemaps_04E453(r15);
@@ -1630,7 +1679,7 @@ void LoadOverworldLayer2AndEventsTilemaps_Sub() {  // 04dc6a
 }
 
 void SubmapSwitchProcess01_UpdateLayer1() {  // 04dcb6
-  const uint8 *p0 = RomPtr(0x05d000);
+  const uint8 *p0 = (const uint8 *)kMap16Data_OverworldLayer1;
   uint16 r0w = (ow_submap_switch_process - 1) << 8;
   if (ow_players_map[(uint8)(player_current_characterx4 >> 2)])
     r0w += 4 << 8;
@@ -1652,7 +1701,7 @@ void SubmapSwitchProcess01_UpdateLayer1() {  // 04dcb6
 }
 
 void LoadOverworldLayer2AndEventsTilemaps_04DD40() {  // 04dd40
-  LoadOverworldLayer2AndEventsTilemaps_04DD57(0, 0, RomPtr(0xc8d00));
+  LoadOverworldLayer2AndEventsTilemaps_04DD57(0, 0, kkOverworldLayer2EventTilemap_Prop);
 }
 
 void LoadOverworldLayer2AndEventsTilemaps_04DD57(uint16 k, uint16 j, const uint8 *p2) {  // 04dd57
@@ -1694,7 +1743,7 @@ void BufferEventTileToLayer2Tilemap() {  // 04e496
 
 void BufferEventTileToLayer2Tilemap_Entry2(uint16 k, uint16 j, uint16 r4) {  // 04e4a9
   const uint8 *r6 = g_ram + 0x10000;
-  const uint8 *r9 = RomPtr(0xc8000);
+  const uint8 *r9 = kOverworldLayer2EventTilemap_Tiles;
   if (j < 0x900)
     BufferEventTileToLayer2Tilemap_Buffer6x6Tile(k, j, r4, r6, r9);
   else
@@ -2128,10 +2177,9 @@ PointU8 GetXAndYDispOfCurrentEventTileSprite() {  // 04ec67
 }
 
 void OwEventProcess05_GetLayer1Tile() {  // 04ec78
-  LongPtr r13 = LONGPTR(0x7ec800);
-
   uint16 v0 = 21;
-  uint8 v1 = *IndirPtr(&r13, kChangingLayer1OverworldTiles_Layer1TileLocation[ow_current_event_number]);
+  uint16 tt = kChangingLayer1OverworldTiles_Layer1TileLocation[ow_current_event_number];
+  uint8 v1 = g_ram[0xc800 + tt];
   while (v1 != kChangingLayer1OverworldTiles_TilesThatChange[v0]) {
     if ((--v0 & 0x8000) != 0) {
       pointer_overworld_event_process = 7;
@@ -2140,13 +2188,13 @@ void OwEventProcess05_GetLayer1Tile() {  // 04ec78
   }
   io_sound_ch3 = 1;
   ++pointer_overworld_event_process;
-  ow_on_screen_xpos_of_current_event_tile =
+  ow_on_screen_xpos_of_current_event_tile = tt * 16;
-      16 * *((uint8 *)kChangingLayer1OverworldTiles_Layer1TileLocation + (uint8)(2 * ow_current_event_number));
+  ow_on_screen_ypos_of_current_event_tile = tt & 0xf0;
-  ow_on_screen_ypos_of_current_event_tile =
-      *((uint8 *)kChangingLayer1OverworldTiles_Layer1TileLocation + (uint8)(2 * ow_current_event_number)) & 0xF0;
   timer_destroy_tile_event_unknown = 28;
 }
 
+static const uint8 kOverworldEventProcess01_DestroyTileAnimation_DATA_04ECD3[176] = { 134, 153, 134, 25, 134, 217, 134, 89, 150, 153, 150, 25, 150, 217, 150, 89, 134, 157, 134, 29, 134, 221, 134, 93, 150, 157, 150, 29, 150, 221, 150, 93, 134, 153, 134, 25, 134, 217, 134, 89, 150, 153, 150, 25, 150, 217, 150, 89, 134, 157, 134, 29, 134, 221, 134, 93, 150, 157, 150, 29, 150, 221, 150, 93, 136, 21, 152, 21, 137, 21, 153, 21, 164, 17, 180, 17, 165, 17, 181, 17, 34, 17, 144, 17, 34, 17, 145, 17, 194, 17, 210, 17, 195, 17, 211, 17, 166, 17, 182, 17, 167, 17, 183, 17, 130, 25, 146, 25, 131, 25, 147, 25, 200, 25, 248, 25, 201, 25, 249, 25, 128, 28, 144, 28, 129, 28, 144, 92, 128, 20, 144, 20, 129, 20, 144, 84, 162, 17, 178, 17, 163, 17, 179, 17, 130, 29, 146, 29, 131, 29, 147, 29, 134, 153, 134, 25, 134, 217, 134, 89, 134, 153, 134, 25, 134, 217, 134, 89, 168, 17, 184, 17, 169, 17, 185, 17,  };
+
 void OwEventProcess01_DestroyTileAnimation_04ED83() {  // 04ed83
   uint16 v0 = 21;
   uint8 v1 = g_ram[0xc800 + kChangingLayer1OverworldTiles_Layer1TileLocation[ow_current_event_number]];
@@ -2159,7 +2207,7 @@ void OwEventProcess01_DestroyTileAnimation_04ED83() {  // 04ed83
   int v2 = ow_current_event_number;
   uint16 r0w = kOwEventProcess01_DestroyTileAnimation_DATA_04D93D[v2];
   blocks_map16_table_lo[kChangingLayer1OverworldTiles_Layer1TileLocation[v2]] = kChangingLayer1OverworldTiles_TilesToBecome[v0];
-  OwEventProcess01_DestroyTileAnimation_04EDE6(stripe_image_upload, 8 * v0, r0w, RomPtr(0x4ecd3));
+  OwEventProcess01_DestroyTileAnimation_04EDE6(stripe_image_upload, 8 * v0, r0w, kOverworldEventProcess01_DestroyTileAnimation_DATA_04ECD3);
 }
 
 void OwEventProcess01_DestroyTileAnimation_04EDE6(uint16 k, uint16 j, uint16 r0w, const uint8 *p) {  // 04ede6
@@ -2194,9 +2242,11 @@ void OwEventProcess04_FadeInLayer2Tile_04EE30() {  // 04ee30
   stripe_image_upload = v0;
 }
 
+static const uint8 kOverworldEventProcess01_DestroyTileAnimation_DATA_04EE7A[48] = { 34, 1, 130, 28, 34, 1, 131, 28, 34, 1, 130, 20, 34, 1, 131, 20, 234, 1, 234, 1, 234, 193, 234, 193, 234, 1, 234, 1, 234, 193, 234, 193, 34, 1, 34, 1, 34, 1, 34, 1, 138, 21, 154, 21, 139, 21, 155, 21,  };
+
 void OwEventProcess01_DestroyTileAnimation_04EEAA() {  // 04eeaa
   uint16 v2;
-  const uint8 *p = RomPtr(0x4ee7a);
+  const uint8 *p = kOverworldEventProcess01_DestroyTileAnimation_DATA_04EE7A;
 
   uint16 r0w = kOwEventProcess01_DestroyTileAnimation_DATA_04E587[(uint16)(2 * ow_destroy_tile_event_vramindex) >> 1];
   uint16 v0 = stripe_image_upload;

src/smw_05.c

@@ -2,7 +2,8 @@
 #include "funcs.h"
 #include "smw_rtl.h"
 #include "variables.h"
-
+#include "assets/smw_assets.h"
+#include "snes/snes.h"
 void (*kBufferScrollingTiles_Layer1_Main_PtrsLong058823[32])(void) = {
     &BufferScrollingTiles_Layer1,
     &BufferScrollingTiles_Layer1,
@@ -204,6 +205,7 @@ void (*kProcessLevelEndRoutines_Ptrs05CC0E[4])(void) = {
     &GiveTimeBonusAndBonusStars_Return,
 };
 
+static const uint8 kInitializeMap16Pointers_DATA_0581BB[64] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfe, 0x0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x0, 0x0, 0x3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,  };
 static const uint16 kInitializeMap16Pointers_TilesetMap16Ptrs[15] = { 0x8b70, 0xbc00, 0xc800, 0xd400, 0xe300, 0xe300, 0xc800, 0x8b70, 0xc800, 0xd400, 0xd400, 0xd400, 0x8b70, 0xe300, 0xd400,  };
 static const uint8 kLoadLevelHeader_VerticalTable[32] = { 0x0, 0x0, 0x80, 0x1, 0x81, 0x2, 0x82, 0x3, 0x83, 0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80,  };
 static const uint8 kLoadLevelHeader_LevMainScrnTbl[32] = { 0x15, 0x15, 0x17, 0x15, 0x15, 0x15, 0x17, 0x15, 0x17, 0x15, 0x15, 0x15, 0x15, 0x15, 0x4, 0x4, 0x15, 0x17, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x1, 0x2,  };
@@ -296,42 +298,33 @@ static const uint8 kCalculateTimeBonusDigits_DATA_05CE42[10] = { 0x0, 0xa, 0x14,
 static const uint8 kNoBonusStarsText_Stars[32] = { 0x51, 0xb1, 0x0, 0x9, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0xfc, 0x38, 0x0, 0x38, 0x51, 0xf3, 0x0, 0x3, 0xfc, 0x38, 0xfc, 0x38, 0x52, 0x13, 0x0, 0x3, 0xfc, 0x38, 0xfc, 0x38, 0xff, 10 };
 static const uint8 kGiveTimeBonusAndBonusStars_DATA_05CEC2[4] = { 0xa, 0x0, 0x64, 0x0,  };
 static const uint8 kGiveTimeBonusAndBonusStars_DATA_05CEC6[4] = { 0x1, 0x0, 0xa, 0x0,  };
-static const uint8 kSpecifySublevelToLoad_DATA_05D708[4] = { 0x0, 0x60, 0xc0, 0x0,  };
+static const uint8 kLoadLevel_DATA_05D708[4] = { 0x0, 0x60, 0xc0, 0x0,  };
-static const uint8 kSpecifySublevelToLoad_DATA_05D70C[4] = { 0x60, 0x90, 0xc0, 0x0,  };
+static const uint8 kLoadLevel_DATA_05D70C[4] = { 0x60, 0x90, 0xc0, 0x0,  };
-static const uint8 kSpecifySublevelToLoad_L2VertScrollSettings[8] = { 0x3, 0x1, 0x1, 0x0, 0x0, 0x2, 0x2, 0x1,  };
+static const uint8 kLoadLevel_L2VertScrollSettings[8] = { 0x3, 0x1, 0x1, 0x0, 0x0, 0x2, 0x2, 0x1,  };
-static const uint8 kSpecifySublevelToLoad_L2HorzScrollSettings[8] = { 0x2, 0x2, 0x1, 0x0, 0x1, 0x2, 0x1, 0x0,  };
+static const uint8 kLoadLevel_L2HorzScrollSettings[8] = { 0x2, 0x2, 0x1, 0x0, 0x1, 0x2, 0x1, 0x0,  };
-static const uint8 kSpecifySublevelToLoad_DATA_05D730[16] = { 0x0, 0x30, 0x60, 0x80, 0xa0, 0xb0, 0xc0, 0xe0, 0x10, 0x30, 0x50, 0x60, 0x70, 0x90, 0x0, 0x0,  };
+static const uint8 kLoadLevel_DATA_05D730[16] = { 0x0, 0x30, 0x60, 0x80, 0xa0, 0xb0, 0xc0, 0xe0, 0x10, 0x30, 0x50, 0x60, 0x70, 0x90, 0x0, 0x0,  };
-static const uint8 kSpecifySublevelToLoad_DATA_05D740[16] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,  };
+static const uint8 kLoadLevel_DATA_05D740[16] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,  };
-static const uint8 kSpecifySublevelToLoad_DATA_05D750[8] = { 0x10, 0x80, 0x0, 0xe0, 0x10, 0x70, 0x0, 0xe0,  };
+static const uint8 kLoadLevel_DATA_05D750[8] = { 0x10, 0x80, 0x0, 0xe0, 0x10, 0x70, 0x0, 0xe0,  };
-static const uint8 kSpecifySublevelToLoad_DATA_05D758[8] = { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1,  };
+static const uint8 kLoadLevel_DATA_05D758[8] = { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1,  };
-static const uint8 kSpecifySublevelToLoad_LevelEntranceTileset[6] = { 0x5, 0x1, 0x2, 0x6, 0x8, 0x1,  };
+static const uint8 kLoadLevel_LevelEntranceTileset[6] = { 0x5, 0x1, 0x2, 0x6, 0x8, 0x1,  };
-static const uint8 kSpecifySublevelToLoad_LevelEntranceLayer3[6] = { 0x3, 0x0, 0x0, 0x0, 0x0, 0x0,  };
+static const uint8 kLoadLevel_LevelEntranceLayer3[6] = { 0x3, 0x0, 0x0, 0x0, 0x0, 0x0,  };
-static const uint8 kSpecifySublevelToLoad_LevelEntranceYPos[6] = { 0x70, 0x70, 0x60, 0x70, 0x70, 0x70,  };
+static const uint8 kLoadLevel_LevelEntranceYPos[6] = { 0x70, 0x70, 0x60, 0x70, 0x70, 0x70,  };
-static const uint16 kSpecifySublevelToLoad_Layer1Ptrs[9] = { 0xec24, 0xec7e, 0xec7e, 0xe985, 0xe9fb, 0xeab0, 0xeb0b, 0xeb72, 0xebbe,  };
+static const uint16 kChoclateIsland2_SpritePtrs[9] = { 0xd899, 0xd8a1, 0xd8a1, 0xd7e5, 0xd7ea, 0xd825, 0xd84b, 0xd86e, 0xd888,  };
-static const uint16 kSpecifySublevelToLoad_SpritePtrs[9] = { 0xd899, 0xd8a1, 0xd8a1, 0xd7e5, 0xd7ea, 0xd825, 0xd84b, 0xd86e, 0xd888,  };
+static const uint8 kLoadLevel_BonusLevelSublevelsLo[3] = { 0x0, 0xc8, 0x0,  };
-static const uint16 kSpecifySublevelToLoad_Layer2Ptrs[9] = { 0xdf59, 0xdf59, 0xdf59, 0xdf59, 0xdf59, 0xdf59, 0xdf59, 0xdf59, 0xdf59,  };
-static const uint8 kSpecifySublevelToLoad_BonusLevelSublevelsLo[3] = { 0x0, 0xc8, 0x0,  };
 static const uint8 kLoadOverworldLifeCounter_DATA_05DBC9[9] = { 0x50, 0x88, 0x0, 0x3, 0xfe, 0x38, 0xfe, 0x38, 0xff,  };
 
-static const uint16 kLevelDataLayoutTables_Layer1LoPtrs[32] = { 0xbad8, 0xbad8, 0xbad8, 0xbb38, 0xbb38, 0xbb92, 0xbb92, 0xbbec, 0xbbec, 0x0, 0xbbec, 0x0, 0xbad8, 0xbbec, 0xbad8, 0xbad8, 0x0, 0xbad8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbad8, 0xbad8,  };
-static const uint16 kLevelDataLayoutTables_Layer2LoPtrs[32] = { 0xbb08, 0xbb08, 0xbb08, 0xbb62, 0xbb62, 0xbbc2, 0xbbc2, 0xbc16, 0xbc16, 0x0, 0xbc16, 0x0, 0xbb08, 0xbc16, 0xbb08, 0xbb08, 0x0, 0xbb08, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbb08, 0xbb08,  };
-static const uint16 kLevelDataLayoutTables_Layer1HiPtrs[32] = { 0xbc40, 0xbc40, 0xbc40, 0xbca0, 0xbca0, 0xbcfa, 0xbcfa, 0xbd54, 0xbd54, 0x0, 0xbd54, 0x0, 0xbc40, 0xbd54, 0xbc40, 0xbc40, 0x0, 0xbc40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbc40, 0xbc40,  };
-static const uint16 kLevelDataLayoutTables_Layer2HiPtrs[32] = { 0xbc70, 0xbc70, 0xbc70, 0xbcca, 0xbcca, 0xbd2a, 0xbd2a, 0xbd7e, 0xbd7e, 0x0, 0xbd7e, 0x0, 0xbc70, 0xbd7e, 0xbc70, 0xbc70, 0x0, 0xbc70, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbc70, 0xbc70,  };
-
-
 void LoadSublevel() {  // 05801e
   for (uint16 i = 0; i != 512; ++i) {
     blocks_layer2_tiles_lo[i] = 37;
     blocks_layer2_tiles_lo[i + 512] = 37;
   }
   blocks_screen_to_place_current_object = 0;
-  if (ptr_layer2_data.bank == 0xFF) {
+  if (ptr_layer2_is_bg & 2) {
-    bool v1 = ptr_layer2_data.addr >= 0xE8FE;
+    uint8 v1 = ptr_layer2_is_bg >> 4;
     for (uint16 j = 0; j != 512; ++j) {
       blocks_layer2_tiles_hi[j] = v1;
       blocks_layer2_tiles_hi[j + 512] = v1;
     }
-    ptr_layer2_data.bank = 12;
     unusedram_copy_of_level_tileset_setting = 0;
     misc_level_tileset_setting = 0;
     BufferBGTilemap(g_ram + 0xb900);
@@ -383,14 +376,11 @@ void InitializeLevelLayer1And2Tilemaps() {  // 05809e
 }
 
 void BufferBGTilemap(uint8 *r13) {  // 058126
-  uint8 *p = IndirPtr(&ptr_layer2_data, 0);
+  const uint8 *p = ptr_layer2_data; 
   uint16 R3 = 0;
   uint16 R5_W = 0;
   do {
-    int16 v0 = R3;
+    uint8 r7 = p[R3++];
-    uint8 r7 = p[R3];
-    uint16 v1 = v0 + 1;
-    R3 = v1;
     if ((r7 & 0x80) == 0) {
       do {
         uint8 v5 = p[R3++];
@@ -398,16 +388,13 @@ void BufferBGTilemap(uint8 *r13) {  // 058126
       } while ((--r7 & 0x80) == 0);
     } else {
       r7 &= ~0x80;
-      uint8 v2 = p[v1];
+      uint8 v2 = p[R3++];
-      R3 = v1 + 1;
-      uint16 v3 = R5_W;
       do {
-        r13[v3++] = v2;
+        r13[R5_W++] = v2;
       } while ((--r7 & 0x80) == 0);
-      R5_W = v3;
     }
   } while (p[R3] != 0xFF || p[R3 + 1] != 0xFF);
-  uint16 R0_W = 0x9100;
+  uint16 R0_W = 0x9100;  // kMap16Data_Backgrounds
   for (uint16 i = 0; i != 0x400; i += 2) {
     pointer_map16_tiles[i >> 1] = R0_W;
     R0_W += 8;
@@ -420,15 +407,15 @@ void InitializeMap16Pointers() {  // 0581fb
   blocks_highest_number_solid_map16_tile_for_sprites = -54;
   ptr_slope_steepness.addr = 0xe55e;
   uint16 R0_W = kInitializeMap16Pointers_TilesetMap16Ptrs[misc_level_tileset_setting];
-  uint16 R2_W = 0x8000;
+  uint16 R2_W = 0x8000;  // bank 0xD
-  LongPtr r13 = LONGPTR(0x581bb);
+  const uint8 *r13 = kInitializeMap16Pointers_DATA_0581BB;
 //  R4_W = 0;
 //  R9_ = 0;
   uint8 r11 = 0;
   uint16 v0 = 0;
   uint16 v1 = 0;
   do {
-    uint16 r12 = *IndirPtr(&r13, v0);
+    uint16 r12 = r13[v0];
     do {
       bool v2 = __CFSHL__(r12, 1);
       r12 *= 2;
@@ -452,16 +439,14 @@ void InitializeMap16Pointers() {  // 0581fb
     uint16 v3 = 904;
     R0_W = 0x8a70;
     for (int16 i = 3; i >= 0; --i) {
-      uint16 v5 = R0_W;
       pointer_map16_tiles[v3 >> 1] = R0_W;
-      R0_W = v5 + 8;
+      R0_W = R0_W + 8;
       v3 += 2;
     }
     uint16 v6 = 984;
     for (int16 j = 3; j >= 0; --j) {
-      uint16 v8 = R0_W;
       pointer_map16_tiles[v6 >> 1] = R0_W;
-      R0_W = v8 + 8;
+      R0_W = R0_W + 8;
       v6 += 2;
     }
   }
@@ -531,12 +516,13 @@ uint16 InitializeLevelData_Hi(uint16 k, uint8 a) {  // 05833a
   return k + 1;
 }
 
+extern Snes *g_snes;
 void BeginLoadingLevelData() {  // 0583ac
   LOBYTE(misc_current_layer_being_processed) = 0;
   LoadLevelHeader();
   InitializeMap16Pointers();
   while (misc_level_mode_setting != 9 && misc_level_mode_setting != 11 && misc_level_mode_setting != 16) {
-    if (*IndirPtr(&ptr_layer1_data, 0) != 0xFF)
+    if (*ptr_layer1_data != 0xFF)
       LoadLevelDataObject();
     if (misc_level_mode_setting == 0 || misc_level_mode_setting == 10 || misc_level_mode_setting == 12 ||
         misc_level_mode_setting == 13 || misc_level_mode_setting == 14 || misc_level_mode_setting == 17 || misc_level_mode_setting == 30) 
@@ -544,15 +530,14 @@ void BeginLoadingLevelData() {  // 0583ac
     LOBYTE(misc_current_layer_being_processed) = misc_current_layer_being_processed + 1;
     if ((uint8)misc_current_layer_being_processed == 2)
       break;
-    ptr_layer1_data.addr = ptr_layer2_data.addr + 5;
+    ptr_layer1_data = ptr_layer2_data + 5;
-    ptr_layer1_data.bank = ptr_layer2_data.bank;
     blocks_screen_to_place_current_object = 0;
   }
   LOBYTE(misc_current_layer_being_processed) = 0;
 }
 
 void LoadLevelHeader() {  // 0584e3
-  uint8 *hdr = IndirPtr(&ptr_layer1_data, 0);
+  const uint8 *hdr = ptr_layer1_data;
   uint8 v0 = hdr[0];
   misc_screens_in_lvl = (v0 & 0x1F) + 1;
   misc_bgpalette_setting = v0 >> 5;
@@ -599,55 +584,49 @@ void LoadLevelHeader() {  // 0584e3
     v5 = 0;
   }
   flag_layer1_vert_scroll_level_setting = v5;
-  ptr_layer1_data.addr += 5;
+  ptr_layer1_data += 5;
 }
 
 void LoadLevelDataObject() {  // 0585ff
+  const uint8 *hdr;
   do {
-    uint8 *hdr = IndirPtr(&ptr_layer1_data, 0);
+    hdr = ptr_layer1_data;
-    uint8 r10 = hdr[0];
+    uint8 b0 = hdr[0];
-    uint8 r11 = hdr[1];
+    uint8 b1 = hdr[1];
     blocks_size_or_type = hdr[2];
-    ptr_layer1_data.addr += 3;
+    ptr_layer1_data += 3;
 
-    blocks_object_number = (r11 >> 4) | ((uint8)(r10 & 0x60) >> 1);
+    blocks_object_number = (b1 >> 4) | ((b0 & 0x60) >> 1);
     int8 v1 = misc_level_layout_flags;
     if ((uint8)misc_current_layer_being_processed)
       v1 = misc_level_layout_flags >> 1;
     if ((v1 & 1) != 0) {
       if (__PAIR16__(blocks_object_number, blocks_size_or_type) >= 2) {
-        uint8 r0 = r10 & 0xF;
+        uint8 r0 = b0 & 0xF;
-        r10 = r11 & 0xF | r10 & 0xF0;
+        b0 = b1 & 0xF | b0 & 0xF0;
-        r11 = r0 | r11 & 0xF0;
+        b1 = r0 | b1 & 0xF0;
       }
     }
-    blocks_sub_scr_pos = 16 * (r10 & 0xF);
+    blocks_sub_scr_pos = 16 * (b0 & 0xF);
-    blocks_sub_scr_pos |= r11 & 0xF;
+    blocks_sub_scr_pos |= b1 & 0xF;
     int v2 = misc_current_layer_being_processed;
-    uint8 v3 = 2 * (misc_level_mode_setting & 0x1F);
+    uint8 v3 = misc_level_mode_setting & 0x1F;
 
-    const uint8 *r3 = RomPtr_00(kLevelDataLayoutTables_LoTablePtrs[v2]);
+    const uint16 *r0 = GetLayerLayoutPtr(v2, v3);
-    const uint8 *r6 = RomPtr_00(kLevelDataLayoutTables_HiTablePtrs[v2]);
 
-    const uint8 *r0 = RomPtr_00(WORD(r3[v3]));
+    blocks_screen_to_place_current_object += (b0 & 0x80) != 0;
-    const uint8 *r13 = RomPtr_00(WORD(r6[v3]));
-
-    blocks_screen_to_place_current_object += __CFSHL__(r10 & 0x80, 1);
     blocks_screen_to_place_next_object = blocks_screen_to_place_current_object;
-    uint8 v4 = 3 * blocks_screen_to_place_current_object;
+    ptr_lo_map16_data = g_ram + r0[blocks_screen_to_place_current_object];
-    ptr_lo_map16_data = *(LongPtr *)(r0 + v4);
+    if ((b0 & 0x10) != 0) {
-    ptr_hi_map16_data = *(LongPtr *)(r13 + v4);
+      ptr_lo_map16_data += 256;
-    if ((r10 & 0x10) != 0) {
-      ++HIBYTE(ptr_lo_map16_data);
-      ++HIBYTE(ptr_hi_map16_data);
     }
-    loadlvl_R10 = r10;
+    loadlvl_R10 = b0;
-    loadlvl_R11 = r11;
+    loadlvl_R11 = b1;
     if (blocks_object_number)
       ProcessStandardAndTilesetSpecificObjects();
     else
       ProcessExtendedObjects();
-  } while (*IndirPtr(&ptr_layer1_data, 0) != 0xFF);
+  } while (*ptr_layer1_data != 0xff);
 }
 
 void CheckIfLevelTilemapsNeedScrollUpdate() {  // 0586f1
@@ -731,10 +710,118 @@ void BufferScrollingTiles_Layer2_Init() {  // 058955
   kBufferScrollingTiles_Layer2_Init_PtrsLong05895E[misc_level_mode_setting]();
 }
 
+static const uint16 kLevelDataLayout_StdHoriz[] = {
+  0xc800, 0xc9b0, 0xcb60, 0xcd10, 0xcec0, 0xd070, 0xd220, 0xd3d0, 0xd580, 0xd730, 0xd8e0, 0xda90, 0xdc40, 0xddf0, 0xdfa0, 0xe150,
+  0xe300, 0xe4b0, 0xe660, 0xe810, 0xe9c0, 0xeb70, 0xed20, 0xeed0, 0xf080, 0xf230, 0xf3e0, 0xf590, 0xf740, 0xf8f0, 0xfaa0, 0xfc50
+};
+
+static const uint16 kLevelDataLayout_VertL1HorizL2[] = {
+  0xc800, 0xca00, 0xcc00, 0xce00, 0xd000, 0xd200, 0xd400, 0xd600, 0xd800, 0xda00, 0xdc00, 0xde00, 0xe000, 0xe200,
+  0xe300, 0xe4b0, 0xe660, 0xe810, 0xe9c0, 0xeb70, 0xed20, 0xeed0, 0xf080, 0xf230, 0xf3e0, 0xf590, 0xf740, 0xf8f0, 0xfaa0, 0xfc50,
+};
+
+static const uint16 kLevelDataLayout_HorizL1VertL2[] = {
+  0xc800, 0xc9b0, 0xcb60, 0xcd10, 0xcec0, 0xd070, 0xd220, 0xd3d0, 0xd580, 0xd730, 0xd8e0, 0xda90, 0xdc40, 0xddf0, 0xdfa0, 0xe150,
+  0xe400, 0xe600, 0xe800, 0xea00, 0xec00, 0xee00, 0xf000, 0xf200, 0xf400, 0xf600, 0xf800, 0xfa00, 0xfc00, 0xfe00,
+};
+
+static const uint16 kLevelDataLayout_StdVert[] = {
+  0xc800, 0xca00, 0xcc00, 0xce00, 0xd000, 0xd200, 0xd400, 0xd600, 0xd800, 0xda00, 0xdc00, 0xde00, 0xe000, 0xe200,
+  0xe400, 0xe600, 0xe800, 0xea00, 0xec00, 0xee00, 0xf000, 0xf200, 0xf400, 0xf600, 0xf800, 0xfa00, 0xfc00, 0xfe00,
+};
+
+static const uint16 *const kLevelDataLayoutTables_Layer1LoPtrs[32] = {
+  kLevelDataLayout_StdHoriz,
+  kLevelDataLayout_StdHoriz,
+  kLevelDataLayout_StdHoriz,
+  kLevelDataLayout_VertL1HorizL2,
+  kLevelDataLayout_VertL1HorizL2,
+  kLevelDataLayout_HorizL1VertL2,
+  kLevelDataLayout_HorizL1VertL2,
+  kLevelDataLayout_StdVert,
+  kLevelDataLayout_StdVert,
+  0,
+  kLevelDataLayout_StdVert,
+  0,
+  kLevelDataLayout_StdHoriz,
+  kLevelDataLayout_StdVert,
+  kLevelDataLayout_StdHoriz,
+  kLevelDataLayout_StdHoriz,
+  0,
+  kLevelDataLayout_StdHoriz,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  kLevelDataLayout_StdHoriz,
+  kLevelDataLayout_StdHoriz,
+};
+
+static const uint16 *const kLevelDataLayoutTables_Layer2LoPtrs[32] = {
+  kLevelDataLayout_StdHoriz + 16,
+  kLevelDataLayout_StdHoriz + 16,
+  kLevelDataLayout_StdHoriz + 16,
+  kLevelDataLayout_VertL1HorizL2 + 14,
+  kLevelDataLayout_VertL1HorizL2 + 14,
+  kLevelDataLayout_HorizL1VertL2 + 16,
+  kLevelDataLayout_HorizL1VertL2 + 16,
+  kLevelDataLayout_StdVert + 14,
+  kLevelDataLayout_StdVert + 14,
+  0,
+  kLevelDataLayout_StdVert + 14,
+  0,
+  kLevelDataLayout_StdHoriz + 16,
+  kLevelDataLayout_StdVert + 14,
+  kLevelDataLayout_StdHoriz + 16,
+  kLevelDataLayout_StdHoriz + 16,
+  0,
+  kLevelDataLayout_StdHoriz + 16,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  kLevelDataLayout_StdHoriz + 16,
+  kLevelDataLayout_StdHoriz + 16,
+};
+
+const uint16 *GetLayerLayoutPtr(int layer, int top) {
+  return layer ? kLevelDataLayoutTables_Layer2LoPtrs[top] : kLevelDataLayoutTables_Layer1LoPtrs[top];
+}
+
+const uint16 *GetMap16RomAddr(uint8 bank, uint16_t addr) {
+  if (bank == 13) {
+    if (addr >= 0xe300)
+      return (uint16 *)((const uint8 *)kMap16Data_GhostHouse + addr - 0xe300);
+    else if (addr >= 0xd400)
+      return (uint16 *)((const uint8 *)kMap16Data_Underground + addr - 0xd400);
+    else if (addr >= 0xc800)
+      return (uint16 *)((const uint8 *)kMap16Data_Rope + addr - 0xc800);
+    else if (addr >= 0xbc00)
+      return (uint16 *)((const uint8 *)kMap16Data_Castle + addr - 0xbc00);
+    else
+      return (uint16 *)((const uint8 *)kMap16Data + addr - 0x8000);
+  }
+  assert(addr >= 0xd000 && addr < 0xd608);
+  return (uint16*)((const uint8 *)kMap16Data_OverworldLayer1 + addr - 0xd000);
+}
+
 void BufferScrollingTiles_Layer1() {  // 0589ce
-  const uint8 *r10 = RomPtr_00(kLevelDataLayoutTables_Layer1LoPtrs[misc_level_mode_setting]);
-  const uint8 *r13 = RomPtr_00(kLevelDataLayoutTables_Layer1HiPtrs[misc_level_mode_setting]);
-  
   uint16 v0 = camera_layer1_scrolling_direction;
   HIBYTE(blocks_layer1_vramupload_address) = 2 * (*((uint8 *)&camera_layer1_row_column_to_update_left_up + v0) & 0xF);
   int8 v1 = 32;
@@ -742,20 +829,19 @@ void BufferScrollingTiles_Layer1() {  // 0589ce
     v1 = 36;
   LOBYTE(blocks_layer1_vramupload_address) = v1;
   uint16 R0_W = (uint16)(*(uint16 *)((int8 *)&camera_layer1_row_column_to_update_left_up + v0) & 0x1F0) >> 4;
-  const uint8 *plo = IndirPtr((LongPtr *)(r10 + 3 * R0_W), 0);
+  const uint8 *plo = g_ram + kLevelDataLayoutTables_Layer1LoPtrs[misc_level_mode_setting][R0_W];
-  const uint8 *phi = IndirPtr((LongPtr *)(r13 + 3 * R0_W), 0);
   uint8 bank = sign8(misc_level_tileset_setting - 16) ? 13 : 5;
   uint16 r8 = *((uint8 *)&camera_layer1_row_column_to_update_left_up + v0) & 0xF;
   uint16 v4 = 0;
   do {
     uint16 v5 = r8;
-    R0_W = plo[v5] | phi[v5] << 8;
+    R0_W = plo[v5] | plo[v5 + 0x10000] << 8;
-    r10 = RomPtrWithBank(bank, pointer_map16_tiles[R0_W]);
+    const uint16 *r10t = GetMap16RomAddr(bank, pointer_map16_tiles[R0_W]);
     int v6 = v4 >> 1;
-    blocks_layer1_tiles_to_upload_buffer[v6] = *(uint16 *)(r10);
+    blocks_layer1_tiles_to_upload_buffer[v6] = r10t[0];
-    blocks_layer1_tiles_to_upload_buffer[v6 + 1] = *(uint16 *)(r10 + 2);
+    blocks_layer1_tiles_to_upload_buffer[v6 + 1] = r10t[1];
-    blocks_layer1_tiles_to_upload_buffer[v6 + 64] = *(uint16 *)(r10 + 4);
+    blocks_layer1_tiles_to_upload_buffer[v6 + 64] = r10t[2];
-    blocks_layer1_tiles_to_upload_buffer[v6 + 65] = *(uint16 *)(r10 + 6);
+    blocks_layer1_tiles_to_upload_buffer[v6 + 65] = r10t[3];
     v4 += 4;
     r8 += 16;
   } while (r8 < 0x1B0);
@@ -769,8 +855,7 @@ void BufferScrollingTiles_Layer1_VerticalLevel() {  // 058a9b
   int lvl_setting = misc_level_mode_setting;
   int max_n = (lvl_setting == 7 || lvl_setting == 8 || lvl_setting == 10 || lvl_setting == 13) ? 28 : 16;
 
-  const uint8 *r10 = RomPtr_00(kLevelDataLayoutTables_Layer1LoPtrs[lvl_setting]);
+  const uint16 *r10 = kLevelDataLayoutTables_Layer1LoPtrs[lvl_setting];
-  const uint8 *r13 = RomPtr_00(kLevelDataLayoutTables_Layer1HiPtrs[lvl_setting]);
 
   uint16 v0 = camera_layer1_scrolling_direction;
   uint8 v1 = 32;
@@ -779,24 +864,23 @@ void BufferScrollingTiles_Layer1_VerticalLevel() {  // 058a9b
   LOBYTE(blocks_layer1_vramupload_address) = v1 | (*((uint8 *)&camera_layer1_row_column_to_update_left_up + v0) >> 2) & 3;
   HIBYTE(blocks_layer1_vramupload_address) = (*((uint8 *)&camera_layer1_row_column_to_update_left_up + v0) & 3) << 6;
   uint16 R0_W = (uint16)(*(uint16 *)((int8 *)&camera_layer1_row_column_to_update_left_up + v0) & 0x1F0) >> 4;
-  uint16 v2 = (R0_W < max_n) ? 3 * R0_W : 0;
+  uint16 v2 = (R0_W < max_n) ? R0_W : 0;
-  const uint8 *plo = IndirPtr((LongPtr *)(r10 + v2), 0);
+  const uint8 *plo = g_ram + r10[v2];
-  const uint8 *phi = IndirPtr((LongPtr *)(r13 + v2), 0);
   uint8 bank = sign8(misc_level_tileset_setting - 16) ? 13 : 5;
   uint16 r8 = 16 * (*((uint8 *)&camera_layer1_row_column_to_update_left_up + v0) & 0xF);
   uint16 v4 = 0;
   do {
     uint16 v5 = r8;
-    R0_W = plo[r8] | phi[v5] << 8;
+    R0_W = plo[r8] | plo[v5 + 0x10000] << 8;
     
-    r10 = RomPtrWithBank(bank, pointer_map16_tiles[R0_W]);
+    const uint16 *r10p = GetMap16RomAddr(bank, pointer_map16_tiles[R0_W]);
     int v6 = v4 >> 1;
-    blocks_layer1_tiles_to_upload_buffer[v6] = WORD(r10[0]);
+    blocks_layer1_tiles_to_upload_buffer[v6] = r10p[0];
-    blocks_layer1_tiles_to_upload_buffer[v6 + 64] = WORD(r10[2]);
+    blocks_layer1_tiles_to_upload_buffer[v6 + 64] = r10p[1];
     uint16 v7 = v4 + 2;
     int v8 = v7 >> 1;
-    blocks_layer1_tiles_to_upload_buffer[v8] = WORD(r10[4]);
+    blocks_layer1_tiles_to_upload_buffer[v8] = r10p[2];
-    blocks_layer1_tiles_to_upload_buffer[v8 + 64] = WORD(r10[6]);
+    blocks_layer1_tiles_to_upload_buffer[v8 + 64] = r10p[3];
     v4 = v7 + 2;
     uint16 v9 = r8++;
     if ((r8 & 0xF) == 0)
@@ -810,8 +894,7 @@ void BufferScrollingTiles_Layer2() {  // 058b8d
     v1 = 0x1000;
   uint16 R3_W = v1;
 
-  const uint8 *r10 = RomPtr_00(kLevelDataLayoutTables_Layer2LoPtrs[misc_level_mode_setting]);
+  const uint16 *r10 = kLevelDataLayoutTables_Layer2LoPtrs[misc_level_mode_setting];
-  const uint8 *r13 = RomPtr_00(kLevelDataLayoutTables_Layer2HiPtrs[misc_level_mode_setting]);
   
   uint16 v0 = camera_layer2_scrolling_direction;
   HIBYTE(blocks_layer2_vramupload_address) = 2 * (*((uint8 *)&camera_layer2_row_column_to_update_left_up + v0) & 0xF);
@@ -820,22 +903,20 @@ void BufferScrollingTiles_Layer2() {  // 058b8d
     v2 = 52;
   LOBYTE(blocks_layer2_vramupload_address) = v2;
   uint16 R0_W = (uint16)(*(uint16 *)((int8 *)&camera_layer2_row_column_to_update_left_up + v0) & 0x1F0) >> 4;
-  uint16 v3 = 3 * R0_W;
+  const uint8 *plo = g_ram + r10[R0_W];
-  const uint8 *plo = IndirPtr((LongPtr *)(r10 + v3), 0);
-  const uint8 *phi = IndirPtr((LongPtr *)(r13 + v3), 0);
 
   uint8 bank = sign8(misc_level_tileset_setting - 16) ? 13 : 5;
   uint16 r8 = *((uint8 *)&camera_layer2_row_column_to_update_left_up + v0) & 0xF;
   uint16 v5 = 0;
   do {
     uint16 v6 = r8;
-    R0_W = plo[r8] | phi[v6] << 8;
+    R0_W = plo[r8] | plo[v6 + 0x10000] << 8;
-    r10 = RomPtrWithBank(bank, pointer_map16_tiles[R0_W]);
+    const uint16 *r10w = GetMap16RomAddr(bank, pointer_map16_tiles[R0_W]);
     int v7 = v5 >> 1;
-    blocks_layer2_tiles_to_upload_buffer[v7] = R3_W | WORD(r10[0]);
+    blocks_layer2_tiles_to_upload_buffer[v7] = R3_W | r10w[0];
-    blocks_layer2_tiles_to_upload_buffer[v7 + 1] = R3_W | WORD(r10[2]);
+    blocks_layer2_tiles_to_upload_buffer[v7 + 1] = R3_W | r10w[1];
-    blocks_layer2_tiles_to_upload_buffer[v7 + 64] = R3_W | WORD(r10[4]);
+    blocks_layer2_tiles_to_upload_buffer[v7 + 64] = R3_W | r10w[2];
-    blocks_layer2_tiles_to_upload_buffer[v7 + 65] = R3_W | WORD(r10[6]);
+    blocks_layer2_tiles_to_upload_buffer[v7 + 65] = R3_W | r10w[3];
     v5 += 4;
     r8 += 16;
   } while (r8 < 0x1B0);
@@ -854,8 +935,7 @@ void BufferScrollingTiles_Layer2_VerticalLevel() {  // 058c71
     v2 = 0x1000;
   uint16 R3_W = v2;
 
-  const uint8 *r10 = RomPtr_00(kLevelDataLayoutTables_Layer2LoPtrs[misc_level_mode_setting]);
+  const uint16 *r10 = kLevelDataLayoutTables_Layer2LoPtrs[misc_level_mode_setting];
-  const uint8 *r13 = RomPtr_00(kLevelDataLayoutTables_Layer2HiPtrs[misc_level_mode_setting]);
 
   uint16 v1 = camera_layer2_scrolling_direction;
   uint8 v3 = 48;
@@ -864,23 +944,22 @@ void BufferScrollingTiles_Layer2_VerticalLevel() {  // 058c71
   LOBYTE(blocks_layer2_vramupload_address) = v3 | (*((uint8 *)&camera_layer2_row_column_to_update_left_up + v1) >> 2) & 3;
   HIBYTE(blocks_layer2_vramupload_address) = (*((uint8 *)&camera_layer2_row_column_to_update_left_up + v1) & 3) << 6;
   uint16 R0_W = (uint16)(*(uint16 *)((int8 *)&camera_layer2_row_column_to_update_left_up + v1) & 0x1F0) >> 4;
-  uint16 v4 = (R0_W < max_n) ? 3 * R0_W : 0;
+  uint16 v4 = (R0_W < max_n) ? R0_W : 0;
-  const uint8 *plo = IndirPtr((LongPtr *)(r10 + v4), 0);
+  const uint8 *plo = g_ram + r10[v4];
-  const uint8 *phi = IndirPtr((LongPtr *)(r13 + v4), 0);
   uint8 bank = sign8(misc_level_tileset_setting - 16) ? 13 : 5;
   uint16 r8 = 16 * (*((uint8 *)&camera_layer2_row_column_to_update_left_up + v1) & 0xF);
   uint16 v6 = 0;
   do {
     uint16 v7 = r8;
-    R0_W = plo[r8] | phi[v7] << 8;
+    R0_W = plo[r8] | plo[r8 + 0x10000] << 8;
-    r10 = RomPtrWithBank(bank, pointer_map16_tiles[R0_W]);
+    const uint16 *r10w = GetMap16RomAddr(bank, pointer_map16_tiles[R0_W]);
     int v8 = v6 >> 1;
-    blocks_layer2_tiles_to_upload_buffer[v8] = R3_W | *(uint16 *)(r10);
+    blocks_layer2_tiles_to_upload_buffer[v8] = R3_W | r10w[0];
-    blocks_layer2_tiles_to_upload_buffer[v8 + 64] = R3_W | *(uint16 *)(r10 + 2);
+    blocks_layer2_tiles_to_upload_buffer[v8 + 64] = R3_W | r10w[1];
     uint16 v9 = v6 + 2;
     int v10 = v9 >> 1;
-    blocks_layer2_tiles_to_upload_buffer[v10] = R3_W | *(uint16 *)(r10 + 4);
+    blocks_layer2_tiles_to_upload_buffer[v10] = R3_W | r10w[2];
-    blocks_layer2_tiles_to_upload_buffer[v10 + 64] = R3_W | *(uint16 *)(r10 + 6);
+    blocks_layer2_tiles_to_upload_buffer[v10 + 64] = R3_W | r10w[3];
     v6 = v9 + 2;
     uint16 v11 = r8++;
     if ((r8 & 0xF) == 0)
@@ -900,7 +979,7 @@ void BufferScrollingTiles_Layer2_Background() {  // 058d7a
     plo += 432;
     phi += 432;
   }
-  const uint8 *r10 = RomPtr(0xd9100);
+  const uint8 *r10 = (const uint8 *)kMap16Data + 0x1100;  // kMap16Data_Backgrounds
   uint16 r8 = blocks_screen_to_place_current_object & 0xF;
   uint16 v1 = 0;
   do {
@@ -1087,12 +1166,23 @@ uint8 UnusedOverworldEventPassedCheck(uint8 j) {  // 05b363
   return kBitTable_Bank05[j & 7] & ow_event_flags[j >> 3];
 }
 
+static const kLevelTileAnimationsAddrs[] = {
+  0x600, 0x640, 0x680,
+  0x740, 0xEA0, 0x800,
+  0x500, 0x540, 0x580,
+  0x5C0, 0x780, 0x7C0,
+  0xDA0, 0x6C0, 0x700,
+  0x4C0, 0x440, 0x480,
+  0x400,     0,     0,
+  0,     0,     0
+};
+
 void HandleLevelTileAnimations() {  // 05bb39
   uint8 v0 = 3 * (counter_local_frames & 7);
   uint16 R0_W = (uint8)(counter_local_frames & 0x18) >> 2;
-  graphics_tile_anim_vramaddress3 = *(uint16 *)((char *)&kLevelTileAnimations_DATA_05B93B[0].field_0 + (2 * v0));
+  graphics_tile_anim_vramaddress3 = kLevelTileAnimationsAddrs[v0 + 0];
-  graphics_tile_anim_vramaddress2 = *(uint16 *)((char *)&kLevelTileAnimations_DATA_05B93B[0].field_2 + (2 * v0));
+  graphics_tile_anim_vramaddress2 = kLevelTileAnimationsAddrs[v0 + 1];
-  graphics_tile_anim_vramaddress1 = *(uint16 *)((char *)&kLevelTileAnimations_DATA_05B93B[0].field_4 + (2 * v0));
+  graphics_tile_anim_vramaddress1 = kLevelTileAnimationsAddrs[v0 + 2];
   uint8 v2 = 4;
   do {
     uint8 v4 = v2;
@@ -2209,18 +2299,66 @@ void GiveTimeBonusAndBonusStars_Return() {  // 05cfe9
   ;
 }
 
-void SpecifySublevelToLoad() {  // 05d796
+// If we don't use the exact right id for the sprite list the snapshot load will fail.
+#define E(a, b) (a) | (b) << 20
+static const uint32 kSpriteListPtrToIndex[] = {
+  E(0x7c340, 0x9b), E(0x7c345, 0x9a), E(0x7c34a, 0x99), E(0x7c34f, 0x98), E(0x7c354, 0x97), E(0x7c359, 0x96), E(0x7c367, 0x95), E(0x7c3db, 0x93), 
+  E(0x7c3e3, 0x94), E(0x7c3ee, 0xbd), E(0x7c3f0, 0xc6), E(0x7c3f5, 0xc4), E(0x7c407, 0x0), E(0x7c40c, 0xeb), E(0x7c414, 0xd5), E(0x7c422, 0x10d), 
+  E(0x7c427, 0xc7), E(0x7c441, 0xc5), E(0x7c446, 0x14), E(0x7c44b, 0xca), E(0x7c450, 0x11b), E(0x7c473, 0x1d8), E(0x7c478, 0x121), E(0x7c498, 0x1d7), 
+  E(0x7c49d, 0x8), E(0x7c4c0, 0xc9), E(0x7c4c5, 0x3), E(0x7c4ca, 0x105), E(0x7c532, 0x106), E(0x7c57f, 0x1ca), E(0x7c593, 0x103), E(0x7c5ef, 0x1fd), 
+  E(0x7c5f4, 0x102), E(0x7c659, 0x1ff), E(0x7c661, 0x1be), E(0x7c66f, 0x101), E(0x7c6bf, 0x1fc), E(0x7c6d0, 0x1f6), E(0x7c6d5, 0x15), E(0x7c749, 0xe3), 
+  E(0x7c751, 0x9), E(0x7c7a7, 0xe9), E(0x7c7b5, 0x4), E(0x7c7bd, 0xde), E(0x7c7cb, 0xfe), E(0x7c7d9, 0x5), E(0x7c844, 0x6), E(0x7c8cd, 0xd2), 
+  E(0x7c8ea, 0xc3), E(0x7c904, 0x7), E(0x7c915, 0xe8), E(0x7c926, 0xe7), E(0x7c943, 0xe5), E(0x7c948, 0xa), E(0x7c9aa, 0xc2), E(0x7c9ca, 0x13), 
+  E(0x7c9db, 0xed), E(0x7c9f2, 0xf1), E(0x7ca0c, 0xe4), E(0x7ca17, 0x10b), E(0x7ca6d, 0x1c6), E(0x7ca87, 0x11a), E(0x7cb01, 0x1ef), E(0x7cb2a, 0x118), 
+  E(0x7cbc5, 0x1c3), E(0x7cbdc, 0x107), E(0x7cc11, 0x1ea), E(0x7cc25, 0x10a), E(0x7ccba, 0x1c2), E(0x7ccd4, 0x119), E(0x7cd63, 0x1f5), E(0x7cd68, 0x11c), 
+  E(0x7cd94, 0x1f3), E(0x7cdc0, 0x1f2), E(0x7cdc8, 0x109), E(0x7ce0c, 0x1f1), E(0x7ce14, 0x1f0), E(0x7ce1c, 0x1), E(0x7ceba, 0xd8), E(0x7cebf, 0x2), 
+  E(0x7cf06, 0xb), E(0x7cf4d, 0xe0), E(0x7cfaf, 0xf), E(0x7d02f, 0xbf), E(0x7d043, 0x10), E(0x7d0cf, 0xc1), E(0x7d0d7, 0xe), E(0x7d0f4, 0xdc), 
+  E(0x7d111, 0xdb), E(0x7d152, 0xd9), E(0x7d157, 0x11), E(0x7d1f5, 0xc), E(0x7d25a, 0xd), E(0x7d304, 0xdd), E(0x7d30c, 0x11e), E(0x7d380, 0x120), 
+  E(0x7d445, 0x123), E(0x7d4c5, 0x1f8), E(0x7d4cd, 0x20), E(0x7d51d, 0xcc), E(0x7d522, 0x11d), E(0x7d56c, 0x1fa), E(0x7d577, 0x11f), E(0x7d5c7, 0x1df), 
+  E(0x7d5cf, 0x1c1), E(0x7d5f5, 0x122), E(0x7d648, 0x1f), E(0x7d668, 0xd6), E(0x7d6d9, 0x22), E(0x7d741, 0xbe), E(0x7d74c, 0x21), E(0x7d799, 0xfc), 
+  E(0x7d7bf, 0x24), E(0x7d7e5, 0xcf), E(0x7d7ea, 0x205), E(0x7d825, 0x206), E(0x7d84b, 0xce), E(0x7d86e, 0x208), E(0x7d888, 0x209), E(0x7d899, 0xcd), 
+  E(0x7d8a1, 0x202), E(0x7d8be, 0x23), E(0x7d956, 0xd7), E(0x7d95e, 0x1b), E(0x7d9b1, 0xef), E(0x7d9ef, 0x117), E(0x7da12, 0x1ed), E(0x7da44, 0x1ec), 
+  E(0x7da7f, 0x1c0), E(0x7da93, 0x1d), E(0x7dadd, 0xea), E(0x7db0f, 0x1c), E(0x7db95, 0xc0), E(0x7dbbb, 0x1a), E(0x7dbf9, 0xd4), E(0x7dc22, 0xd3), 
+  E(0x7dc2d, 0x18), E(0x7dc3b, 0xf8), E(0x7dc61, 0xf7), E(0x7dd14, 0x116), E(0x7dd76, 0x1e5), E(0x7dd7b, 0x115), E(0x7ddb3, 0x1e3), E(0x7ddb8, 0x1e2), 
+  E(0x7ddcf, 0xc8), E(0x7de01, 0x114), E(0x7de0f, 0x1dd), E(0x7de3b, 0x1db), E(0x7de4f, 0x113), E(0x7df08, 0x10f), E(0x7df94, 0x1bf), E(0x7dfb1, 0x110), 
+  E(0x7dfe0, 0x1fe), E(0x7e024, 0x1eb), E(0x7e032, 0x111), E(0x7e067, 0x1d4), E(0x7e08d, 0x1d3), E(0x7e0c5, 0x1d2), E(0x7e0e8, 0x1d1), E(0x7e114, 0x1cf), 
+  E(0x7e131, 0x1ce), E(0x7e160, 0x1cd), E(0x7e183, 0x1cc), E(0x7e19d, 0x10e), E(0x7e1c0, 0x1c7), E(0x7e1c5, 0x134), E(0x7e221, 0x130), E(0x7e29e, 0x132), 
+  E(0x7e2af, 0x135), E(0x7e335, 0x136), E(0x7e3dc, 0x12a), E(0x7e402, 0x1c4), E(0x7e428, 0x12b), E(0x7e466, 0x12c), E(0x7e4ec, 0x1c8), E(0x7e4f1, 0x12d), 
+  E(0x7e574, 0x128), E(0x7e5df, 0x127), E(0x7e650, 0x126), E(0x7e6f4, 0x125), E(0x7e759, 0x104), E(0x7e76d, 0x12), 
+};
+#undef E
+
+size_t FindWithBinarySearch(const uint32 *sorted_values, size_t values_size, uint32 value_to_find) {
+  size_t low = 0, high = values_size - 1;
+  while (low < high) {
+    size_t mid = (low + high) >> 1;
+    bool pred = (sorted_values[mid] & 0xfffff) < value_to_find;
+    low = pred ? mid + 1 : low;
+    high = pred ? high : mid;
+  }
+  if (low == high && (sorted_values[low] & 0xfffff) == value_to_find)
+    return sorted_values[low] >> 20;
+  return -1;
+}
+
+const uint8 *GetSpriteListPtr() {
+  uint32 v = Load24(ptr_sprite_list_data);
+  int idx = (int)FindWithBinarySearch(kSpriteListPtrToIndex, arraysize(kSpriteListPtrToIndex), v);
+  assert(idx != -1);
+  const uint8 *bb = kLoadLevelSpriteList(idx).ptr;
+  return bb;
+}
+
+void LoadLevel() {  // 05d796
   uint16 v1;
   int16 v5;
   uint16 v10;
   uint16 r14w;
-
   uint8 R1_ = 0;
 
-
   flag_override_no_yoshi_intro_for_midway_entrance = 0;
   if (in_yoshi_wings_bonus_area || flag_active_bonus_game)
-    SpecifySublevelToLoad_05DBAC();
+    LoadLevel_05DBAC();
   if (counter_sublevels_entered) {
     uint8 v0 = HIBYTE(player_xpos);
     if ((misc_level_layout_flags & 1) != 0)
@@ -2229,16 +2367,16 @@ void SpecifySublevelToLoad() {  // 05d796
    
     if (flag_use_secondary_entrance) {
       uint16 j = r14w;
-      r14w = (r14w & ~0xff) | kSpecifySublevelToLoad_DATA_05F800[j];
+      r14w = (r14w & ~0xff) | kLevelInfo_05F800[j];
-      uint8 r0 = kSpecifySublevelToLoad_DATA_05FA00[j];
+      uint8 r0 = kLevelInfo_05FA00[j];
-      LOBYTE(player_ypos) = kSpecifySublevelToLoad_DATA_05D730[r0 & 0xF];
+      LOBYTE(player_ypos) = kLoadLevel_DATA_05D730[r0 & 0xF];
-      HIBYTE(player_ypos) = kSpecifySublevelToLoad_DATA_05D740[r0 & 0xF];
+      HIBYTE(player_ypos) = kLoadLevel_DATA_05D740[r0 & 0xF];
-      LOBYTE(mirror_current_layer1_ypos) = kSpecifySublevelToLoad_DATA_05D708[(r0 & 0x30) >> 4];
+      LOBYTE(mirror_current_layer1_ypos) = kLoadLevel_DATA_05D708[(r0 & 0x30) >> 4];
-      LOBYTE(mirror_current_layer2_ypos) = kSpecifySublevelToLoad_DATA_05D70C[r0 >> 6];
+      LOBYTE(mirror_current_layer2_ypos) = kLoadLevel_DATA_05D70C[r0 >> 6];
-      R1_ = kSpecifySublevelToLoad_DATA_05FC00[j];
+      R1_ = kLevelInfo_05FC00[j];
-      LOBYTE(player_xpos) = kSpecifySublevelToLoad_DATA_05D750[R1_ >> 5];
+      LOBYTE(player_xpos) = kLoadLevel_DATA_05D750[R1_ >> 5];
-      HIBYTE(player_xpos) = kSpecifySublevelToLoad_DATA_05D758[R1_ >> 5];
+      HIBYTE(player_xpos) = kLoadLevel_DATA_05D758[R1_ >> 5];
-      misc_level_header_entrance_settings = kSpecifySublevelToLoad_DATA_05FE00[j] & 7;
+      misc_level_header_entrance_settings = kLevelInfo_05FE00[j] & 7;
     }
   } else {
     v1 = 0;
@@ -2261,45 +2399,46 @@ void SpecifySublevelToLoad() {  // 05d796
       v2 -= 36;
     r14w = (ow_players_map[(uint8)v1] != 0) << 8 | v2;
   }
-  ptr_layer1_data = kSpecifySublevelToLoad_Layer1DataPtrs[r14w];
+  ptr_layer1_data = kLevelData_Layer1(r14w).ptr;
-  ptr_layer2_data = kSpecifySublevelToLoad_Layer2DataPtrs[r14w];
+  ptr_layer2_data = kLevelData_Layer2(r14w).ptr;
+  ptr_layer2_is_bg = kLevelData_Layer2_IsBg[r14w];
+
   HIBYTE(v5) = 0;
-  ptr_sprite_list_data.addr = kSpecifySublevelToLoad_SpriteDataPtrs[r14w];
+  ptr_sprite_list_data = (LongPtr){ .bank = 7, .addr = kLoadLevel_SpriteDataPtrs[r14w] };
-  ptr_sprite_list_data.bank = 7;
+  uint8 sprite_hdr = *GetSpriteListPtr();
-  uint8 sprite_hdr = *IndirPtr(&ptr_sprite_list_data, 0);
   sprites_sprite_memory_setting = sprite_hdr & 0x3F;
   sprites_sprite_buoyancy_settings = sprite_hdr & 0xC0;
-  uint8 v6 = kSpecifySublevelToLoad_DATA_05F000[r14w] >> 4;
+  uint8 v6 = kLevelInfo_05F000[r14w] >> 4;
-  flag_layer2_horiz_scroll_level_setting = kSpecifySublevelToLoad_L2HorzScrollSettings[v6];
+  flag_layer2_horiz_scroll_level_setting = kLoadLevel_L2HorzScrollSettings[v6];
-  flag_layer2_vert_scroll_level_setting = kSpecifySublevelToLoad_L2VertScrollSettings[v6];
+  flag_layer2_vert_scroll_level_setting = kLoadLevel_L2VertScrollSettings[v6];
   flag_layer1_horiz_scroll_level_setting = 1;
-  misc_level_layer3_settings = (kSpecifySublevelToLoad_DATA_05F200[r14w] & 0xC0) >> 6;
+  misc_level_layer3_settings = (kLevelInfo_05F200[r14w] & 0xC0) >> 6;
   HIBYTE(mirror_current_layer1_ypos) = 0;
   HIBYTE(mirror_current_layer2_ypos) = 0;
-  flag_disable_no_yoshi_intro = kSpecifySublevelToLoad_DATA_05F600[r14w] & 0x80;
+  flag_disable_no_yoshi_intro = kLevelInfo_05F600[r14w] & 0x80;
-  misc_level_layout_flags = (uint8)(kSpecifySublevelToLoad_DATA_05F600[r14w] & 0x60) >> 5;
+  misc_level_layout_flags = (uint8)(kLevelInfo_05F600[r14w] & 0x60) >> 5;
   uint8 R2_ = 0;  // todo: what is R2 here?
   if (!flag_use_secondary_entrance) {
-    v10 = kSpecifySublevelToLoad_DATA_05F000[r14w] & 0xF;
+    v10 = kLevelInfo_05F000[r14w] & 0xF;
-    player_ypos = PAIR16(kSpecifySublevelToLoad_DATA_05D740[v10], kSpecifySublevelToLoad_DATA_05D730[v10]);
+    player_ypos = PAIR16(kLoadLevel_DATA_05D740[v10], kLoadLevel_DATA_05D730[v10]);
-    R2_ = kSpecifySublevelToLoad_DATA_05F200[r14w];
+    R2_ = kLevelInfo_05F200[r14w];
     v10 = R2_ & 7;
-    player_xpos = PAIR16(kSpecifySublevelToLoad_DATA_05D758[v10], kSpecifySublevelToLoad_DATA_05D750[v10]);
+    player_xpos = PAIR16(kLoadLevel_DATA_05D758[v10], kLoadLevel_DATA_05D750[v10]);
     misc_level_header_entrance_settings = (uint8)(R2_ & 0x38) >> 3;
-    R2_ = kSpecifySublevelToLoad_DATA_05F400[r14w];
+    R2_ = kLevelInfo_05F400[r14w];
     v10 = R2_ & 3;
-    mirror_current_layer2_ypos = kSpecifySublevelToLoad_DATA_05D70C[v10];
+    mirror_current_layer2_ypos = kLoadLevel_DATA_05D70C[v10];
     LOBYTE(v10) = (uint8)(R2_ & 0xC) >> 2;
-    mirror_current_layer1_ypos = kSpecifySublevelToLoad_DATA_05D708[v10];
+    mirror_current_layer1_ypos = kLoadLevel_DATA_05D708[v10];
-    R1_ = kSpecifySublevelToLoad_DATA_05F600[r14w];
+    R1_ = kLevelInfo_05F600[r14w];
   }
   if ((misc_level_layout_flags & 1) != 0) {
-    HIBYTE(player_ypos) = *IndirPtr(&ptr_layer1_data, 0) & 0x1F;
+    HIBYTE(player_ypos) = *ptr_layer1_data & 0x1F;
     camera_last_screen_vert = HIBYTE(player_ypos) + 1;
     flag_layer1_vert_scroll_level_setting = 1;
   }
   if (counter_sublevels_entered || (unusedram_disable_midpoint = R2_ >> 4, flag_got_midpoint = 0,
-                                    ow_current_event_number = kSpecifySublevelToLoad_DATA_05D608[*(uint16 *)&ow_level_number_lo],
+                                    ow_current_event_number = kLoadLevel_DATA_05D608[ow_level_number_lo],
                                     (ow_level_tile_settings[ow_level_number_lo] & 0x40) == 0)) {
     R1_ &= 0x1F;
     if ((misc_level_layout_flags & 1) != 0) {
@@ -2318,8 +2457,8 @@ void SpecifySublevelToLoad() {  // 05d796
   uint8 v11;
   if (ow_level_number_lo < 0x52) {
     v11 = 4;
-    uint8 v12 = *IndirPtr(&ptr_layer1_data, 4) & 0xF;
+    uint8 v12 = ptr_layer1_data[4] & 0xF;
-    while (v12 != kSpecifySublevelToLoad_LevelEntranceTileset[v11]) {
+    while (v12 != kLoadLevel_LevelEntranceTileset[v11]) {
       if ((--v11 & 0x80) != 0)
         goto LABEL_47;
     }
@@ -2332,35 +2471,34 @@ void SpecifySublevelToLoad() {  // 05d796
       v11 = 5;
     }
     if (!flag_override_no_yoshi_intro_for_midway_entrance) {
-      LOBYTE(player_ypos) = kSpecifySublevelToLoad_LevelEntranceYPos[v11];
+      LOBYTE(player_ypos) = kLoadLevel_LevelEntranceYPos[v11];
       HIBYTE(player_ypos) = 1;
       player_xpos = 48;
       LOBYTE(mirror_current_layer1_ypos) = -64;
       LOBYTE(mirror_current_layer2_ypos) = -64;
       misc_level_header_entrance_settings = 0;
-      ptr_sprite_list_data.addr = 0xc3ee;
+      ptr_sprite_list_data = (LongPtr){ .bank = 7, .addr = 0xc3ee };
-      ptr_sprite_list_data.bank = 7;
+      uint8 sprite_hdr = *GetSpriteListPtr();
-      uint8 sprite_hdr = *IndirPtr(&ptr_sprite_list_data, 0);
       sprites_sprite_memory_setting = sprite_hdr & 0x3F;
       sprites_sprite_buoyancy_settings = sprite_hdr & 0xC0;
       flag_layer2_horiz_scroll_level_setting = 0;
       flag_layer2_vert_scroll_level_setting = 0;
       flag_layer1_horiz_scroll_level_setting = 0;
       misc_level_layout_flags = 0;
-      misc_level_layer3_settings = kSpecifySublevelToLoad_LevelEntranceLayer3[v11];
+      misc_level_layer3_settings = kLoadLevel_LevelEntranceLayer3[v11];
-      ptr_layer1_data = kSpecifySublevelToLoad_LevelEntranceLayer1[v11];
+      ptr_layer1_data = kEntranceData_Layer1(v11).ptr;
-      ptr_layer2_data = kSpecifySublevelToLoad_LevelEntranceLayer2[v11];
+      ptr_layer2_data = kEntranceData_Layer2(v11).ptr;
+      ptr_layer2_is_bg = kEntranceData_Layer2_IsBg[v11];
     }
-    misc_level_tileset_setting = kSpecifySublevelToLoad_LevelEntranceTileset[v11];
+    misc_level_tileset_setting = kLoadLevel_LevelEntranceTileset[v11];
   }
 LABEL_47:
   if (counter_sublevels_entered && !flag_active_bonus_game && ow_level_number_lo == 36)
-    SpecifySublevelToLoad_HandleChocolateIsland2Gimmick();
+    LoadLevel_HandleChocolateIsland2Gimmick();
 }
 
-void SpecifySublevelToLoad_HandleChocolateIsland2Gimmick() {  // 05daef
+void LoadLevel_HandleChocolateIsland2Gimmick() {  // 05daef
-  int8 v0 = *IndirPtr(&ptr_layer1_data, 4) & 0xC0;
+  uint8 v1 = ptr_layer1_data[4] >> 6;
-  int8 v1 = 2 * (4 * v0 + __CFSHL__(v0, 1)) + __CFSHL__(2 * v0, 1);
   uint8 v2;
   if (v1) {
     if (v1 == 1) {
@@ -2386,22 +2524,23 @@ void SpecifySublevelToLoad_HandleChocolateIsland2Gimmick() {  // 05daef
   } else {
     v2 = (counter_yoshi_coins_to_display != 4) ? 2 : 0;
   }
+
   int v3 = v2 >> 1;
-  ptr_layer1_data.addr = kSpecifySublevelToLoad_Layer1Ptrs[v3];
+  ptr_layer1_data = kChoclateIsland2_Layer1(v3).ptr;
-  ptr_sprite_list_data.addr = kSpecifySublevelToLoad_SpritePtrs[v3];
+  ptr_sprite_list_data.addr = kChoclateIsland2_SpritePtrs[v3];
-  ptr_layer2_data.addr = kSpecifySublevelToLoad_Layer2Ptrs[v3];
+  ptr_layer2_data = kChoclateIsland2_Layer2(v3).ptr;
-
+  ptr_layer2_is_bg = kChoclateIsland2_Layer2_IsBg[v3];
-  uint8 sprite_hdr = *IndirPtr(&ptr_sprite_list_data, 0);
 
+  uint8 sprite_hdr = *GetSpriteListPtr();
   sprites_sprite_memory_setting = sprite_hdr & 0x7F;
   sprites_sprite_buoyancy_settings = sprite_hdr & 0x80;
 }
 
-void SpecifySublevelToLoad_05DBAC() {  // 05dbac
+void LoadLevel_05DBAC() {  // 05dbac
   uint8 v0 = HIBYTE(player_xpos);
   if ((misc_level_layout_flags & 1) != 0)
     v0 = HIBYTE(player_ypos);
-  misc_subscreen_exit_entrance_number_lo[v0] = kSpecifySublevelToLoad_BonusLevelSublevelsLo[in_yoshi_wings_bonus_area != 0];
+  misc_subscreen_exit_entrance_number_lo[v0] = kLoadLevel_BonusLevelSublevelsLo[in_yoshi_wings_bonus_area != 0];
   ++counter_sublevels_entered;
 }
 

src/smw_07.c

@@ -11,6 +11,7 @@ static const uint8 kInitializeNormalSpriteRAMTables_Sprite1686Vals[201] = { 0x0,
 const uint8 kInitializeNormalSpriteRAMTables_Sprite190FVals[201] = { 0x0, 0x0, 0x0, 0x0, 0xa0, 0xa0, 0xa0, 0xa0, 0xb0, 0xb0, 0xb0, 0xb0, 0xa0, 0x80, 0x44, 0x80, 0x80, 0x80, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x20, 0x0, 0x0, 0x0, 0x60, 0x20, 0x4, 0x4, 0x20, 0x20, 0x20, 0x20, 0x24, 0x4, 0x0, 0x44, 0x20, 0x4, 0x44, 0xc4, 0x0, 0xc4, 0x24, 0x24, 0x24, 0x4, 0x4, 0x46, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x0, 0xc4, 0x0, 0x0, 0x5, 0x5, 0x5, 0x4, 0x44, 0x48, 0x0, 0x0, 0x40, 0x40, 0x40, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x64, 0xc4, 0x64, 0x45, 0x65, 0x45, 0x65, 0x45, 0x45, 0x45, 0x45, 0x65, 0x65, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x5, 0x5, 0x44, 0x44, 0x44, 0x44, 0x46, 0x0, 0x0, 0x0, 0x10, 0x10, 0x10, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x42, 0x42, 0x40, 0x40, 0x40, 0xc0, 0x40, 0x40, 0x40, 0x40, 0x0, 0x0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x1, 0x0, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x0, 0x40, 0x40, 0x40, 0x0, 0x4, 0x4, 0x40, 0x40, 0x0, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x40, 0x40, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x41, 0x41, 0x40, 0x41, 0x40, 0x0, 0x0, 0x0, 0x20, 0x47, 0x45, 0x0, 0x0, 0x41, 0x41, 0xff, 0x40, 0x40,  };
 static const uint8 kSpawnSpinJumpStars_InitialXSpeed[4] = { 0xe0, 0x20, 0xe0, 0x20,  };
 static const uint8 kSpawnSpinJumpStars_InitialYSpeed[4] = { 0xf0, 0xf0, 0x10, 0x10,  };
+const uint16 kCircleCoordinates[256] = { 0x0, 0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x19, 0x1c, 0x1f, 0x22, 0x25, 0x28, 0x2b, 0x2e, 0x31, 0x35, 0x38, 0x3b, 0x3e, 0x41, 0x44, 0x47, 0x4a, 0x4d, 0x50, 0x53, 0x56, 0x59, 0x5c, 0x5f, 0x61, 0x64, 0x67, 0x6a, 0x6d, 0x70, 0x73, 0x75, 0x78, 0x7b, 0x7e, 0x80, 0x83, 0x86, 0x88, 0x8b, 0x8e, 0x90, 0x93, 0x95, 0x98, 0x9b, 0x9d, 0x9f, 0xa2, 0xa4, 0xa7, 0xa9, 0xab, 0xae, 0xb0, 0xb2, 0xb5, 0xb7, 0xb9, 0xbb, 0xbd, 0xbf, 0xc1, 0xc3, 0xc5, 0xc7, 0xc9, 0xcb, 0xcd, 0xcf, 0xd1, 0xd3, 0xd4, 0xd6, 0xd8, 0xd9, 0xdb, 0xdd, 0xde, 0xe0, 0xe1, 0xe3, 0xe4, 0xe6, 0xe7, 0xe8, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf1, 0xf2, 0xf3, 0xf4, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x100, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xf9, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf4, 0xf3, 0xf2, 0xf1, 0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe8, 0xe7, 0xe6, 0xe4, 0xe3, 0xe1, 0xe0, 0xde, 0xdd, 0xdb, 0xd9, 0xd8, 0xd6, 0xd4, 0xd3, 0xd1, 0xcf, 0xcd, 0xcb, 0xc9, 0xc7, 0xc5, 0xc3, 0xc1, 0xbf, 0xbd, 0xbb, 0xb9, 0xb7, 0xb5, 0xb2, 0xb0, 0xae, 0xab, 0xa9, 0xa7, 0xa4, 0xa2, 0x9f, 0x9d, 0x9b, 0x98, 0x95, 0x93, 0x90, 0x8e, 0x8b, 0x88, 0x86, 0x83, 0x80, 0x7e, 0x7b, 0x78, 0x75, 0x73, 0x70, 0x6d, 0x6a, 0x67, 0x64, 0x61, 0x5f, 0x5c, 0x59, 0x56, 0x53, 0x50, 0x4d, 0x4a, 0x47, 0x44, 0x41, 0x3e, 0x3b, 0x38, 0x35, 0x31, 0x2e, 0x2b, 0x28, 0x25, 0x22, 0x1f, 0x1c, 0x19, 0x15, 0x12, 0xf, 0xc, 0x9, 0x6, 0x3,  };
 
 void InitializeNormalSpriteRAMTables_ClearTables(uint8 k) {  // 07f722
   spr_table164a[k] = 0;

src/smw_0c.c

@@ -2,6 +2,7 @@
 #include "funcs.h"
 #include "smw_rtl.h"
 #include "variables.h"
+#include "assets/smw_assets.h"
 
 void (*kUnk_ca1de[5])(void) = {
     &sub_CA1ED,
@@ -70,7 +71,6 @@ void (*kGameMode19_Cutscene_Ptrs0CCA79[5])(void) = {
     &CheckIfPlayerCanEndCastleDestructionCutscene,
 };
 
-static const uint16 kBufferCreditsBackgrounds_Layer2Pointers[7] = { 0xf45a, 0xe7c0, 0xec82, 0xdd44, 0xd900, 0xdf59, 0xde54,  };
 static const uint16 kBufferCreditsBackgrounds_TilePageModifier[7] = { 0xffff, 0xfeff, 0xfeff, 0xfeff, 0xffff, 0xfeff, 0xfeff,  };
 static const uint8 kUpdateCreditsBackground_PARAMS_0C9559[7] = { 0x1, 0x18, 0x0, 0x40, 0x7f, 0x0, 0x4,  };
 static const uint8 kUpdateCreditsBackground_PARAMS_0C9560[7] = { 0x1, 0x18, 0x0, 0x44, 0x7f, 0x0, 0x4,  };
@@ -109,12 +109,8 @@ static const uint8 kCreditsFadeOut_DATA_0CAB1D[2] = { 0x0, 0xe0,  };
 static const uint8 kCreditsFadeOut_BGPaletteIndex[8] = { 0x0, 0x18, 0x30, 0x48, 0x60, 0x78, 0x90, 0xa8,  };
 static const uint8 kCreditsFadeOut_SkyColorSetting[7] = { 0x6, 0x0, 0x0, 0x2, 0x5, 0x6, 0x0,  };
 static const uint8 kCreditsFadeOut_BGPaletteSetting[7] = { 0x3, 0x3, 0x7, 0x0, 0x1, 0x2, 0x0,  };
-static const uint16 kGetLayer1And2PointersForEnemyRollcall_Layer1Ptrs[13] = { 0xac29, 0xac3e, 0xac53, 0xac77, 0xac9e, 0xacc8, 0xacda, 0xacef, 0xad04, 0xad1f, 0xad31, 0xad3d, 0xad52,  };
-static const uint16 kGetLayer1And2PointersForEnemyRollcall_Layer2Ptrs[13] = { 0xec82, 0xdd44, 0xdf59, 0xd900, 0xde54, 0xe8fe, 0xdab9, 0xef80, 0xf45a, 0xe103, 0xf45a, 0xe103, 0xad52,  };
 static const uint8 kInitializeEnemyRollcallLayerPositions_DATA_0CADB5[13] = { 0x28, 0x28, 0x44, 0x28, 0x38, 0x20, 0x28, 0x20, 0x8, 0x28, 0x7c, 0x68, 0x28,  };
 static const uint16 kInitializeEnemyRollcallLayerPositions_InitialLayer2YPos[13] = { 0x0, 0x88, 0xe0, 0xc0, 0xe8, 0x0, 0xa0, 0x50, 0xb0, 0xe0, 0x18, 0xe0, 0x0,  };
-static const uint16 kInitializeEnemyRollcallLayerPositions_SpecialWorldEnemyNamePtrs[13] = { 0xfe49, 0xfe4b, 0xfe5f, 0xfe71, 0xfe73, 0xfe8f, 0xfe91, 0xfe93, 0xfe95, 0xfe97, 0xfe99, 0xfe9b, 0xfe9d,  };
-#define kGameMode25_ShowEnemyRollcallScreen_TileData ((uint8*)RomFixedPtr(0xCAF11))
 static const uint16 kGameMode25_ShowEnemyRollcallScreen_EnemyRollcallSpriteDataPtrs[13] = { 0x2fc, 0x11c, 0x1c1, 0x222, 0x0, 0x45, 0x28b, 0x395, 0x9e, 0x42a, 0x493, 0xe7, 0x4fc,  };
 static const uint8 kDrawThankYouSpeechBubble_TileData[12] = { 0x20, 0x48, 0xa6, 0x18, 0x30, 0x48, 0xa8, 0x18, 0x28, 0x58, 0x8d, 0x8,  };
 static const uint8 kDrawCastleDestructionCastleDoor_Tiles[4] = { 0x86, 0x87, 0x96, 0x97,  };
@@ -184,14 +180,16 @@ void BufferCreditsBackgrounds() {  // 0c93dd
   *(uint16 *)&blocks_screen_to_place_current_object = 0;
   do {
     int v0 = blocks_screen_to_place_current_object;
-    uint16 ptr_layer2_data_addr = kBufferCreditsBackgrounds_Layer2Pointers[v0];
+    const uint8 *ptr_layer2_data_addr = kBufferCreditsBackgrounds_Layer2(v0).ptr;
-    uint16 modifier = kBufferCreditsBackgrounds_TilePageModifier[v0];
+    uint8 isbg = kBufferCreditsBackgrounds_Layer2_IsBg[v0];
-    bool v1 = ptr_layer2_data_addr >= 0xE8FE;
+    uint8 upper = isbg >> 4;
     for (uint16 i = 0; i != 512; ++i) {
-      blocks_layer2_tiles_hi[i] = v1;
+      blocks_layer2_tiles_hi[i] = upper;
-      blocks_layer2_tiles_hi[i + 512] = v1;
+      blocks_layer2_tiles_hi[i + 512] = upper;
     }
-    BufferCreditsBackgrounds_0C944C(0xb900, RomPtr_0C(ptr_layer2_data_addr));
+    BufferCreditsBackgrounds_0C944C(0xb900, ptr_layer2_data_addr);
+
+    uint16 modifier = kBufferCreditsBackgrounds_TilePageModifier[v0];
     BufferCreditsBackgrounds_0C94C0(modifier);
     ++*(uint16 *)&blocks_screen_to_place_current_object;
   } while (*(uint16 *)&blocks_screen_to_place_current_object != 7);
@@ -232,7 +230,7 @@ void BufferCreditsBackgrounds_0C944C(uint16 r13w, const uint8 *src) {  // 0c944c
       R5 = v3;
     }
   } while (src[R3] != 0xFF || src[R3 + 1] != 0xFF);
-  uint16 r0w = 0x9100;
+  uint16 r0w = 0x9100;  // kMap16Data_Backgrounds
   for (uint16 i = 0; i != 0x400; i += 2) {
     pointer_map16_tiles[i >> 1] = r0w;
     r0w += 8;
@@ -249,12 +247,12 @@ void BufferCreditsBackgrounds_0C94C0(uint16 mask) {  // 0c94c0
   while (1) {
     do {
       uint16 r2w = p_lo[r4w] | p_hi[r4w] << 8;
-      const uint8 *p2 = RomPtr_0D(pointer_map16_tiles[r2w]);
+      const uint16 *rp = GetMap16RomAddr(13, pointer_map16_tiles[r2w]);
       uint16 v2 = (4 * r0w) & 0x3F | (2 * ((4 * r0w) & 0xFFC0));
-      *(uint16 *)&ow_layer2_tiles[v2] = mask & WORD(p2[0]);
+      *(uint16 *)&ow_layer2_tiles[v2] = mask & rp[0];
-      *(uint16 *)&ow_layer2_tiles[v2 + 64] = mask & WORD(p2[2]);
+      *(uint16 *)&ow_layer2_tiles[v2 + 64] = mask & rp[1];
-      *(uint16 *)&ow_layer2_tiles[v2 + 2] = mask & WORD(p2[4]);
+      *(uint16 *)&ow_layer2_tiles[v2 + 2] = mask & rp[2];
-      *(uint16 *)&ow_layer2_tiles[v2 + 66] = mask & WORD(p2[6]);
+      *(uint16 *)&ow_layer2_tiles[v2 + 66] = mask & rp[3];
       ++r0w;
       ++r4w;
       --r8w;
@@ -987,8 +985,7 @@ void CreditsFadeOut_0CABB2() {  // 0cabb2
   palettes_dynamic_palette_cgramaddress = 2;
   palettes_dynamic_palette_colors[13] = 18;
   palettes_background_color = kGlobalPalettes_Sky[kCreditsFadeOut_SkyColorSetting[blocks_screen_to_place_current_object] & 0xF];
-  uint16 r0w = kCreditsFadeOut_BGPaletteIndex[kCreditsFadeOut_BGPaletteSetting[blocks_screen_to_place_current_object] & 0xF] + 0xb0b0;
+  const uint8 *p0 = (uint8*)(kGlobalPalettes_Background + (kCreditsFadeOut_BGPaletteSetting[blocks_screen_to_place_current_object] & 0xF) * 12);
-  const uint8 *p0 = RomPtr_00(r0w);
   uint16 r4w = 0;
   uint16 n = 1;
   uint16 v0;
@@ -1007,27 +1004,57 @@ void CreditsFadeOut_0CABB2() {  // 0cabb2
 
 void GetLayer1And2PointersForEnemyRollcall() {  // 0cad8c
   int v1 = ++counter_enemy_rollcall_screen;
-  ptr_layer2_data.bank = (counter_enemy_rollcall_screen == 12) ? 12 : 0xff;
+
-  ptr_layer2_data.addr = kGetLayer1And2PointersForEnemyRollcall_Layer2Ptrs[v1];
+  ptr_layer1_data = kRollCallData_Layer1(v1).ptr;
-  ptr_layer1_data.bank = 12;
+  ptr_layer2_data = kRollCallData_Layer2(v1).ptr;
-  ptr_layer1_data.addr = kGetLayer1And2PointersForEnemyRollcall_Layer1Ptrs[v1];
+  ptr_layer2_is_bg = kRollCallData_Layer2_IsBg[v1];
 }
 
+
+static const uint16 kCreditsEnemyNames_SpecialWorld[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Pumpkin[] = {0xc152, 0x0d00, 0x3819, 0x381e, 0x3816, 0x3819, 0x3814, 0x3812, 0x3817, 0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Pidget[] = {0x2d53, 0x0b00, 0x3819, 0x3812, 0x380d, 0x3810, 0x3812, 0x381d, 0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused2[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_MaskKoopa[] = {0x2e53, 0x1500, 0x3816, 0x380a, 0x381c, 0x3814, 0x00fc, 0x3814, 0x3818, 0x3818, 0x3819, 0x380a, 0x381c, 0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused3[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused4[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused5[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused6[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused7[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused8[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused9[] = {0xffff};
+static const uint16 kCreditsEnemyNames_SpecialWorld_Unused10[] = {0xffff};
+
+static const uint16 * const kInitializeEnemyRollcallLayerPositions_SpecialWorldEnemyNamePtrs[13] = {
+  kCreditsEnemyNames_SpecialWorld,
+  kCreditsEnemyNames_SpecialWorld_Pumpkin,
+  kCreditsEnemyNames_SpecialWorld_Pidget,
+  kCreditsEnemyNames_SpecialWorld_Unused2,
+  kCreditsEnemyNames_SpecialWorld_MaskKoopa,
+  kCreditsEnemyNames_SpecialWorld_Unused3,
+  kCreditsEnemyNames_SpecialWorld_Unused4,
+  kCreditsEnemyNames_SpecialWorld_Unused5,
+  kCreditsEnemyNames_SpecialWorld_Unused6,
+  kCreditsEnemyNames_SpecialWorld_Unused7,
+  kCreditsEnemyNames_SpecialWorld_Unused8,
+  kCreditsEnemyNames_SpecialWorld_Unused9,
+  kCreditsEnemyNames_SpecialWorld_Unused10,
+};
+
 void InitializeEnemyRollcallLayerPositions() {  // 0cadf6
   graphics_stripe_image_to_upload = 3 * counter_enemy_rollcall_screen - 40;
   uint8 v7 = counter_enemy_rollcall_screen;
   uint8 v6 = 2 * counter_enemy_rollcall_screen;
   LoadStripeImage();
   if ((ow_level_tile_settings[73] & 0x80) != 0) {
-    uint16 r0w = kInitializeEnemyRollcallLayerPositions_SpecialWorldEnemyNamePtrs[counter_enemy_rollcall_screen];
+    const uint16 *r0w = kInitializeEnemyRollcallLayerPositions_SpecialWorldEnemyNamePtrs[counter_enemy_rollcall_screen];
-    const uint8 *p0 = RomPtr_0D(r0w);
     uint8 v0 = 0;
     uint8 v1 = stripe_image_upload;
     uint16 v3;
     do {
-      const uint8 *v2 = &p0[v0];
+      const uint8 *v2 = (const uint8 *)&r0w[v0 >> 1];
       v3 = *(uint16 *)v2;
-      *(uint16 *)&stripe_image_upload_data[v1] = *(uint16 *)v2;
+      *(uint16 *)&stripe_image_upload_data[v1] = v3;
       v0 += 2;
       v1 += 2;
     } while (v3 != 0xffff);

src/smw_0d.c

@@ -643,8 +643,6 @@ static const uint8 kExtObj95_VerticalLevelVerySteepLeftSlope_TopTiles[2] = { 0xc
 static const uint8 kExtObj95_VerticalLevelVerySteepLeftSlope_MiddleTiles[2] = { 0xcb, 0xcd,  };
 static const uint8 kExtObj95_VerticalLevelVerySteepLeftSlope_BottomTiles[2] = { 0xf1, 0xf2,  };
 static const uint8 kBitTable_Bank0D[8] = { 0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1,  };
-static const uint8 kBank0DItemMemoryIndexes_Lo[3] = { 0x0, 0x80, 0x0,  };
-static const uint8 kBank0DItemMemoryIndexes_Hi[3] = { 0x0, 0x0, 0x1,  };
 static const uint8 kStdObjXX_Generic1RepeatedTileObject_Tiles[15] = { 0x2, 0x21, 0x23, 0x2a, 0x2b, 0x3f, 0x3, 0x13, 0x1e, 0x24, 0x2e, 0x2f, 0x30, 0x32, 0x65,  };
 static const uint8 kStdObj0F_VerticalPipes_TopLeftPipeEndTiles[5] = { 0x33, 0x37, 0x39, 0x0, 0x0,  };
 static const uint8 kStdObj0F_VerticalPipes_TopRightPipeEndTiles[5] = { 0x34, 0x38, 0x3a, 0x0, 0x0,  };
@@ -773,8 +771,7 @@ void ProcessGrasslandObjects() {  // 0da44b
 }
 
 void ExtObj00_ScreenExit(uint8 k) {  // 0da512
-  blocks_object_number = *IndirPtr(&ptr_layer1_data, 0);
+  blocks_object_number = *ptr_layer1_data++;
-  ptr_layer1_data.addr += 1;
   uint8 v2 = loadlvl_R10 & 0x1F;
   misc_subscreen_exit_entrance_number_lo[v2] = blocks_object_number;
   misc_subscreen_exit_properties[v2] = loadlvl_R11 & 1;
@@ -812,13 +809,13 @@ void ExtObjXX_Generic1TileObject_0DA57F(uint8 k, uint8 a) {  // 0da57f
   uint8 r12 = kExtObjXX_Generic1TileObject_Tiles[v5];
   if (v5 == 1 || v5 == 7 || v5 == 50 || v5 == 38 ||
       v5 == 27 && ((v6 = v4 & 0xF, (v4 & 0xF) == 1) || v6 == 4 || v6 == 7 || v6 == 10 || v6 == 13)) {
-    uint16 r8 = PAIR16(kBank0DItemMemoryIndexes_Hi[misc_item_memory_setting], kBank0DItemMemoryIndexes_Lo[misc_item_memory_setting]) + 0x19f8;
+    uint16 r8 = misc_item_memory_setting * 0x80 + 0x19f8;
     uint8 r14 = 4 * blocks_screen_to_place_next_object;
     if ((loadlvl_R10 & 0x10) != 0)
       r14 |= 2;
     if ((v4 & 8) != 0)
       r14 |= 1;
-    if (kBitTable_Bank0D[blocks_sub_scr_pos & 7] & RomPtr_RAM(r8)[r14]) {
+    if (kBitTable_Bank0D[blocks_sub_scr_pos & 7] & (g_ram + r8)[r14]) {
       if (v5 == 7)
         return;
       SetMap16HighByteForCurrentObject_Page01(v4);
@@ -861,11 +858,11 @@ void ExtObj46_MidwayBar(uint8 k) {  // 0da68e
 }
 
 void PreserveLevelDataPointerInObjects() {  // 0da6b1
-  lvlload_R4W = ptr_lo_map16_data.addr;
+  ptr_lo_map16_data_bak = ptr_lo_map16_data;
 }
 
 void RestoreLevelDataPointerInObjects() {  // 0da6ba
-  ptr_hi_map16_data.addr = ptr_lo_map16_data.addr = lvlload_R4W;
+  ptr_lo_map16_data = ptr_lo_map16_data_bak;
   blocks_screen_to_place_next_object = blocks_screen_to_place_current_object;
 }
 
@@ -922,7 +919,7 @@ uint8 ExtObjXX_LargeBush_HandleOverlappingBigBushTiles(uint8 j, uint8 a) {  // 0
     return HandleHorizontalSubScreenCrossingForCurrentObject_Entry2(j);
   } else {
     if (a >= 0x54) {
-      uint8 v2 = *IndirPtr(&ptr_lo_map16_data, j);
+      uint8 v2 = ptr_lo_map16_data[j];
       if (v2 != 37) {
         if (v2 != 73)
           ++a;
@@ -976,7 +973,7 @@ uint8 HandleVerticalSubScreenCrossingForCurrentObject_VerticalLevel() {  // 0da8
   uint16 t = blocks_sub_scr_pos + 16;
   blocks_sub_scr_pos = t;
   if (t >= 256)
-    HIBYTE(ptr_hi_map16_data) = (HIBYTE(ptr_lo_map16_data) += 2);
+    ptr_lo_map16_data += 0x200;
   return t;
 }
 
@@ -1016,13 +1013,13 @@ void StdObj05_Coins(uint8 k) {  // 0da8c3
   while (1) {
     if (k != 4)
       goto LABEL_9;
-    uint16 r8 = PAIR16(kBank0DItemMemoryIndexes_Hi[misc_item_memory_setting], kBank0DItemMemoryIndexes_Lo[misc_item_memory_setting]) + 0x19f8;
+    uint16 r8 = misc_item_memory_setting * 0x80 + 0x19f8;
     uint8 r14 = 4 * blocks_screen_to_place_next_object;
     if ((loadlvl_R10 & 0x10) != 0)
       r14 |= 2;
     if ((v1 & 8) != 0)
       r14 |= 1;
-    uint8 r15 = kBitTable_Bank0D[v1 & 7] & RomPtr_RAM(r8)[r14];
+    uint8 r15 = kBitTable_Bank0D[v1 & 7] & (g_ram + r8)[r14];
     k = 4;
     if (r15) {
       v1 = HandleHorizontalSubScreenCrossingForCurrentObject_Entry2(v1);
@@ -1052,8 +1049,7 @@ uint8 HandleHorizontalSubScreenCrossingForCurrentObject(uint8 j, uint8 a) {  //
 uint8 HandleHorizontalSubScreenCrossingForCurrentObject_Entry2(uint8 j) {  // 0da95d
   uint8 result = j + 1;
   if ((result & 0xF) == 0) {
-    ptr_lo_map16_data.addr += 0x1b0;
+    ptr_lo_map16_data += 0x1b0;
-    ptr_hi_map16_data.addr = ptr_lo_map16_data.addr;
     ++blocks_screen_to_place_next_object;
     result = blocks_sub_scr_pos & 0xF0;
   }
@@ -1068,9 +1064,8 @@ uint8 HandleVerticalSubScreenCrossingForCurrentObject_HorizontalLevel() {  // 0d
 }
 
 void HandleVerticalSubScreenCrossingForCurrentObject_HorizontalLevel_Entry2(uint8 cr) {  // 0da987
-  HIBYTE(ptr_lo_map16_data) += cr;
+  ptr_lo_map16_data += cr << 8;
-  HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
+  ptr_lo_map16_data_bak = ptr_lo_map16_data;
-  HIBYTE(lvlload_R4W) = HIBYTE(ptr_lo_map16_data);
 }
 
 uint8 GoDownLeftAndUpdateLevelDataPointerInObjects() {  // 0da992
@@ -1103,29 +1098,30 @@ uint8 GoDownRightAndUpdateLevelDataPointerInObjects() {  // 0da9b4
 }
 
 void GoBackOneScreenAndUpdateLevelDataPointerInObjects() {  // 0da9d6
-  ptr_lo_map16_data.addr -= 0x1b0;
+  ptr_lo_map16_data -= 0x1b0;
-  ptr_hi_map16_data.addr = ptr_lo_map16_data.addr;
+  ptr_lo_map16_data_bak = ptr_lo_map16_data;
-  lvlload_R4W = ptr_lo_map16_data.addr;
   --blocks_screen_to_place_next_object;
 }
 
 void GoForwardOneScreenAndUpdateLevelDataPointerInObjects() {  // 0da9ef
-  ptr_lo_map16_data.addr += 0x1b0;
+  ptr_lo_map16_data += 0x1b0;
-  ptr_hi_map16_data.addr = ptr_lo_map16_data.addr;
+  ptr_lo_map16_data_bak = ptr_lo_map16_data;
-  lvlload_R4W = ptr_lo_map16_data.addr;
   ++blocks_screen_to_place_next_object;
 }
 
 void SetMap16HighByteForCurrentObject_Page01(uint8 j) {  // 0daa08
-  IndirWriteByte(&ptr_hi_map16_data, j, 1);
+  uint8 *p = ptr_lo_map16_data + j;
+  p[0x10000] = 1;
 }
 
 void SetMap16HighByteForCurrentObject_Page00(uint8 j) {  // 0daa0d
-  IndirWriteByte(&ptr_hi_map16_data, j, 0);
+  uint8 *p = ptr_lo_map16_data + j;
+  p[0x10000] = 0;
 }
 
 void SetMap16LowByte(uint16 j, uint8 a) {
-  IndirWriteByte(&ptr_lo_map16_data, j, a);
+  uint8 *p = ptr_lo_map16_data + j;
+  *p = a;
 }
 
 void StdObj0F_VerticalPipes(uint8 k) {  // 0daa26
@@ -1281,7 +1277,7 @@ LABEL_6:
 
 uint8 FillInSlopeTileAir(uint8 j, uint8 a) {  // 0dabfd
   uint8 v2 = 2;
-  uint8 v3 = *IndirPtr(&ptr_lo_map16_data, j);
+  uint8 v3 = ptr_lo_map16_data[j];
   while (v3 != kFillInSlopeTileAir_DATA_0DABF7[v2]) {
     if ((--v2 & 0x80) != 0)
       return HandleHorizontalSubScreenCrossingForCurrentObject(j, a);
@@ -1602,9 +1598,8 @@ LABEL_3:
 }
 
 void StdObj12_Slopes_0DAFDF(uint8 cr) {  // 0dafdf
-  HIBYTE(ptr_lo_map16_data) -= !(cr & 1);
+  ptr_lo_map16_data -= !(cr & 1) * 256;
-  HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
+  ptr_lo_map16_data_bak = ptr_lo_map16_data;
-  HIBYTE(lvlload_R4W) = HIBYTE(ptr_lo_map16_data);
 }
 
 void StdObj12_Slopes_UpsideDownSteepRightSlope() {  // 0dafea
@@ -1671,7 +1666,7 @@ void StdObj13_GroundEdgesAndVine(uint8 k) {  // 0db075
 uint8 StdObj13_GroundEdgesAndVine_0DB114(uint8 k, uint8 j, uint8 a) {  // 0db114
   if (((int8)(k - 3) < 0 || (int8)(k - 9) < 0 || (int8)(k - 11) >= 0) && k != 2) {
     uint8 v3 = 17;
-    uint8 v4 = *IndirPtr(&ptr_lo_map16_data, j);
+    uint8 v4 = ptr_lo_map16_data[j];
     do {
       if (v4 == kStdObj13_GroundEdgesAndVine_DATA_0DB0F0[v3]) {
         SetMap16HighByteForCurrentObject_Page01(j);
@@ -1688,7 +1683,7 @@ uint8 StdObj13_GroundEdgesAndVine_0DB114(uint8 k, uint8 j, uint8 a) {  // 0db114
 uint8 StdObj13_GroundEdgesAndVine_0DB198(uint8 k, uint8 j, uint8 a) {  // 0db198
   if (((int8)(k - 3) < 0 || (int8)(k - 7) >= 0 && (int8)(k - 9) < 0) && k != 2) {
     uint8 v3 = 29;
-    uint8 v4 = *IndirPtr(&ptr_lo_map16_data, j);
+    uint8 v4 = ptr_lo_map16_data[j];
     while (v4 != kStdObj13_GroundEdgesAndVine_DATA_0DB15C[v3]) {
       if ((--v3 & 0x80) != 0)
         return a;
@@ -1746,8 +1741,7 @@ void StdObj15_MidwayAndGoalPoint(uint8 k) {  // 0db224
     SetMap16HighByteForCurrentObject_Page00(v1);
     SetMap16LowByte(v1, r3);
     if (v1 + 16 >= 256) {
-      ptr_lo_map16_data.addr += 256;
+      ptr_lo_map16_data += 256;
-      HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
     }
     uint8 v4 = v1 + 16;
     if (--r1) {
@@ -1758,8 +1752,7 @@ void StdObj15_MidwayAndGoalPoint(uint8 k) {  // 0db224
         SetMap16HighByteForCurrentObject_Page00(v4);
         SetMap16LowByte(v4, r3);
         if (v4 + 16 >= 256) {
-          ptr_lo_map16_data.addr += 256;
+          ptr_lo_map16_data += 256;
-          HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
         }
         v4 += 16;
       } while (--r1);
@@ -1782,13 +1775,13 @@ void StdObj15_MidwayAndGoalPoint(uint8 k) {  // 0db224
 
 void ExtObj41_YoshiCoin(uint8 k) {  // 0db2ca
   if ((kBitTable_Bank0D[ow_level_number_lo & 7] & flag_collected5_yoshi_coins[ow_level_number_lo >> 3]) == 0) {
-    uint16 r8 = PAIR16(kBank0DItemMemoryIndexes_Hi[misc_item_memory_setting], kBank0DItemMemoryIndexes_Lo[misc_item_memory_setting]) + 0x19f8;
+    uint16 r8 = misc_item_memory_setting * 0x80 + 0x19f8;
     uint8 r14 = 4 * blocks_screen_to_place_next_object;
     if ((loadlvl_R10 & 0x10) != 0)
       r14 |= 2;
     if ((blocks_sub_scr_pos & 8) != 0)
       r14 |= 1;
-    if ((kBitTable_Bank0D[blocks_sub_scr_pos & 7] & RomPtr_RAM(r8)[r14]) == 0) {
+    if ((kBitTable_Bank0D[blocks_sub_scr_pos & 7] & (g_ram + r8)[r14]) == 0) {
       uint8 v2 = blocks_sub_scr_pos;
       SetMap16HighByteForCurrentObject_Page00(blocks_sub_scr_pos);
       SetMap16LowByte(v2, 0x2D);
@@ -1806,13 +1799,13 @@ void StdObj16_PurpleCoins(uint8 k) {  // 0db336
   uint8 r1 = blocks_size_or_type >> 4;
   PreserveLevelDataPointerInObjects();
   while (1) {
-    uint16 r8 = PAIR16(kBank0DItemMemoryIndexes_Hi[misc_item_memory_setting], kBank0DItemMemoryIndexes_Lo[misc_item_memory_setting]) + 0x19f8;
+    uint16 r8 = misc_item_memory_setting * 0x80 + 0x19f8;
     uint8 r14 = 4 * blocks_screen_to_place_next_object;
     if ((loadlvl_R10 & 0x10) != 0)
       r14 |= 2;
     if ((v1 & 8) != 0)
       r14 |= 1;
-    uint8 r15 = kBitTable_Bank0D[v1 & 7] & RomPtr_RAM(r8)[r14];
+    uint8 r15 = kBitTable_Bank0D[v1 & 7] & (g_ram + r8)[r14];
     SetMap16HighByteForCurrentObject_Page00(v1);
     uint8 r12 = 44;
     if (r15)
@@ -1925,7 +1918,7 @@ void StdObj1E_ClimbingNetWithSideEdge(uint8 k) {  // 0db49e
 }
 
 void StdObj1E_ClimbingNetWithSideEdge_0DB4D9(uint8 k, uint8 j, uint8 a) {  // 0db4d9
-  uint8 v3 = *IndirPtr(&ptr_lo_map16_data, j);
+  uint8 v3 = ptr_lo_map16_data[j];
   if (v3 == 8) {
     a = kStdObj1E_ClimbingNetWithSideEdge_TopCornerTiles[k];
   } else if (v3 == 14) {
@@ -1936,7 +1929,7 @@ void StdObj1E_ClimbingNetWithSideEdge_0DB4D9(uint8 k, uint8 j, uint8 a) {  // 0d
 }
 
 void StdObj1E_ClimbingNetWithSideEdge_0DB4FE(uint8 k, uint8 j, uint8 a) {  // 0db4fe
-  uint8 v3 = *IndirPtr(&ptr_lo_map16_data, j);
+  uint8 v3 = ptr_lo_map16_data[j];
   if (v3 == 14) {
     a = kStdObj1E_ClimbingNetWithSideEdge_BottomCornerTiles[k];
   } else if (v3 == 8) {
@@ -2203,7 +2196,7 @@ void GrassObjXX_DiagonalLedge_LeftFacingDiagonalLedgeEntry(uint8 k) {  // 0db7aa
 }
 
 uint8 GrassObjXX_DiagonalLedge_AddDiagonalBlackLinesToDirt(uint8 j, uint8 a) {  // 0db84e
-  uint8 v2 = *IndirPtr(&ptr_lo_map16_data, j);
+  uint8 v2 = ptr_lo_map16_data[j];
   if (v2 != 37) {
     if (v2 != 63)
       ++a;
@@ -2313,16 +2306,16 @@ void GrassObj37_SmallTreeTrunk(uint8 k) {  // 0db966
 }
 
 void GrassObj37_SmallTreeTrunk_0DB997(uint8 k, uint8 j, uint8 a) {  // 0db997
-  uint8 *v3 = IndirPtr(&ptr_lo_map16_data, j);
+  uint8 *p = ptr_lo_map16_data + j;
 
   if (k == 1) {
-    if (*v3 == 0xB1 || *v3 == 0xB6)
+    if (*p == 0xB1 || *p == 0xB6)
-      a = *v3 + 1;
+      a = *p + 1;
-  } else if (*v3== 14) {
+  } else if (*p== 14) {
     SetMap16HighByteForCurrentObject_Page01(j);
     a = 13;
   }
-  *v3 = a;
+  *p = a;
 }
 
 void GrassObj36_LargeTreeTrunk(uint8 k) {  // 0db9c0
@@ -2346,7 +2339,7 @@ void GrassObj36_LargeTreeTrunk(uint8 k) {  // 0db9c0
 }
 
 void GrassObj36_LargeTreeTrunk_0DB9F6(uint8 k, uint8 j) {  // 0db9f6
-  if (*IndirPtr(&ptr_lo_map16_data, j) == 14) {
+  if (ptr_lo_map16_data[j] == 14) {
     SetMap16HighByteForCurrentObject_Page01(j);
     k = 11;
   }
@@ -2415,8 +2408,7 @@ void GrassObj33_ForestTreeTop(uint8 k) {  // 0dbadc
       r14 += 16;
       v1 = r14;
     } while ((--r1 & 0x80) == 0);
-    ptr_lo_map16_data.addr += 0xb0;
+    ptr_lo_map16_data += 0xb0;
-    ptr_hi_map16_data.addr = ptr_lo_map16_data.addr;
   } while ((--r15 & 0x80) == 0);
 }
 
@@ -2958,21 +2950,21 @@ void RopeObj3B_VerySteepSlopedLineGuide_VerySteepRightSlope() {  // 0dd0c3
 }
 
 void RopeObj3C_MushroomTop(uint8 k) {  // 0dd103
-  uint8 v1 = blocks_sub_scr_pos;
+  uint8 j = blocks_sub_scr_pos;
   uint8 r0 = blocks_size_or_type & 0xF;
   SetMap16HighByteForCurrentObject_Page01(blocks_sub_scr_pos);
   uint8 v2 = 7;
-  uint8 v3 = *IndirPtr(&ptr_lo_map16_data, v1);
+  uint8 v3 = ptr_lo_map16_data[j];
   if (!sign8(v3 - 115) && sign8(v3 - 118))
     v2 = 10;
   uint8 i;
-  for (i = HandleHorizontalSubScreenCrossingForCurrentObject(v1, v2); --r0;
+  for (i = HandleHorizontalSubScreenCrossingForCurrentObject(j, v2); --r0;
        i = HandleHorizontalSubScreenCrossingForCurrentObject(i, 8)) {
     SetMap16HighByteForCurrentObject_Page01(i);
   }
   SetMap16HighByteForCurrentObject_Page01(i);
   uint8 v5 = 9;
-  uint8 v6 = *IndirPtr(&ptr_lo_map16_data, i);
+  uint8 v6 = ptr_lo_map16_data[i];
   if (!sign8(v6 - 115) && sign8(v6 - 118))
     v5 = 11;
   HandleHorizontalSubScreenCrossingForCurrentObject(i, v5);
@@ -3396,22 +3388,19 @@ void UndergroundObj3C_VerySteepSlope_VerySteepLeftSlope() {  // 0ddd99
     SetMap16HighByteForCurrentObject_Page01(v0);
     SetMap16LowByte(v0, 0xCA);
     if (v0 + 16 >= 256) {
-      ptr_lo_map16_data.addr += 256;
+      ptr_lo_map16_data += 256;
-      HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
     }
     v0 += 16;
     SetMap16HighByteForCurrentObject_Page01(v0);
     SetMap16LowByte(v0, 0xCB);
     if (v0 + 16 >= 256) {
-      ptr_lo_map16_data.addr += 256;
+      ptr_lo_map16_data += 256;
-      HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
     }
     v0 += 16;
     SetMap16HighByteForCurrentObject_Page01(v0);
     SetMap16LowByte(v0, 0xF1);
     if (v0 + 16 >= 256) {
-      ptr_lo_map16_data.addr += 256;
+      ptr_lo_map16_data += 256;
-      HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
     }
     v0 += 16;
     int8 v8 = v1 - 2;
@@ -3419,8 +3408,7 @@ void UndergroundObj3C_VerySteepSlope_VerySteepLeftSlope() {  // 0ddd99
       SetMap16HighByteForCurrentObject_Page00(v0);
       SetMap16LowByte(v0, 0x3F);
       if (v0 + 16 >= 256) {
-        ptr_lo_map16_data.addr += 256;
+        ptr_lo_map16_data += 256;
-        HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
       }
       v0 += 16;
     }
@@ -3449,22 +3437,19 @@ void UndergroundObj3C_VerySteepSlope_VerySteepRightSlope() {  // 0dde3c
     SetMap16HighByteForCurrentObject_Page01(v0);
     SetMap16LowByte(v0, 0xCC);
     if (v0 + 16 >= 256) {
-      ptr_lo_map16_data.addr += 256;
+      ptr_lo_map16_data += 256;
-      HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
     }
     v0 += 16;
     SetMap16HighByteForCurrentObject_Page01(v0);
     SetMap16LowByte(v0, 0xCD);
     if (v0 + 16 >= 256) {
-      ptr_lo_map16_data.addr += 256;
+      ptr_lo_map16_data += 256;
-      HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
     }
     v0 += 16;
     SetMap16HighByteForCurrentObject_Page01(v0);
     SetMap16LowByte(v0, 0xF2);
     if (v0 + 16 >= 256) {
-      ptr_lo_map16_data.addr += 256;
+      ptr_lo_map16_data += 256;
-      HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
     }
     v0 += 16;
     int8 v8 = v1 - 2;
@@ -3472,8 +3457,7 @@ void UndergroundObj3C_VerySteepSlope_VerySteepRightSlope() {  // 0dde3c
       SetMap16HighByteForCurrentObject_Page00(v0);
       SetMap16LowByte(v0, 0x3F);
       if (v0 + 16 >= 256) {
-        ptr_lo_map16_data.addr += 256;
+        ptr_lo_map16_data += 256;
-        HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
       }
       v0 += 16;
     }
@@ -3511,18 +3495,14 @@ void UndergroundObj37_LargeCanvas(uint8 k) {  // 0ddf3a
     blocks_sub_scr_pos += 64;
     v1 = blocks_sub_scr_pos;
   } while ((--r1 & 0x80) == 0);
-  LOBYTE(ptr_lo_map16_data) = 0;
-  LOBYTE(lvlload_R4W) = 0;
-  LOBYTE(ptr_hi_map16_data) = 0;
   r0 = 0;
   uint8 r3 = 7;
   while (1) {
     r1 = 2;
     blocks_sub_scr_pos = kUndergroundObj37_LargeCanvas_CanvasPosLo[r0];
     uint8 v4 = blocks_sub_scr_pos;
-    HIBYTE(ptr_lo_map16_data) = kUndergroundObj37_LargeCanvas_CanvasPosHi[r0];
+    ptr_lo_map16_data = g_ram + (kUndergroundObj37_LargeCanvas_CanvasPosHi[r0] << 8);
-    HIBYTE(lvlload_R4W) = HIBYTE(ptr_lo_map16_data);
+    ptr_lo_map16_data_bak = ptr_lo_map16_data;
-    HIBYTE(ptr_hi_map16_data) = HIBYTE(ptr_lo_map16_data);
     uint8 r2 = 3;
     uint8 v5 = 0;
     do {
@@ -3658,7 +3638,7 @@ void ExtObj5F_LargeBackgroundArea(uint8 k) {  // 0de971
       SetMap16HighByteForCurrentObject_Page00(v0);
       SetMap16LowByte(v0++, 0x77);
     } while (v0);
-    HIBYTE(ptr_hi_map16_data) = ++HIBYTE(ptr_lo_map16_data);
+    ptr_lo_map16_data += 256;
   } while ((--r0 & 0x80) == 0);
 }
 
@@ -4001,7 +3981,7 @@ void GhostHouseObj34_WoodLedgeOnColumn(uint8 k) {  // 0deec0
     for (uint8 i = 120;; i = 121) {
       SetMap16LowByte(v5, i);
       if (v5 + 16 >= 256)
-        HIBYTE(ptr_hi_map16_data) = ++HIBYTE(ptr_lo_map16_data);
+        ptr_lo_map16_data += 256;
       v5 += 16;
       if (!--v6)
         break;

src/smw_cpu_infra.c

@@ -147,9 +147,11 @@ uint32 PatchBugs_SMW1(void) {
 }
 
 void SmwCpuInitialize(void) {
-  *SnesRomPtr(0x843B) = 0x60; // remove WaitForHBlank_Entry2
+  if (g_rom) {
-  *SnesRomPtr(0x2DDA2) = 5;
+    *SnesRomPtr(0x843B) = 0x60; // remove WaitForHBlank_Entry2
-  *SnesRomPtr(0xCA5AC) = 7;
+    *SnesRomPtr(0x2DDA2) = 5;
+    *SnesRomPtr(0xCA5AC) = 7;
+  }
 }
 
 static void SmwFixSnapshotForCompare(Snapshot *b, Snapshot *a) {
@@ -215,57 +217,6 @@ void SmwRunOneFrameOfGame_Emulated(void) {
   */
 }
 
-void SmwDrawPpuFrame(void) {
-  SimpleHdma hdma_chans[3];
-
-  Snes *snes = g_snes;
-
-  dma_startDma(snes->dma, mirror_hdmaenable, true);
-//  dma_initHdma(snes->dma);
-
-  SimpleHdma_Init(&hdma_chans[0], &g_snes->dma->channel[5]);
-  SimpleHdma_Init(&hdma_chans[1], &g_snes->dma->channel[6]);
-  SimpleHdma_Init(&hdma_chans[2], &g_snes->dma->channel[7]);
-
-  int trigger = snes->vIrqEnabled ? snes->vTimer + 1 : -1;
-
-  for (int i = 0; i <= 224; i++) {
-    ppu_runLine(snes->ppu, i);
-    SimpleHdma_DoLine(&hdma_chans[0]);
-    SimpleHdma_DoLine(&hdma_chans[1]);
-    SimpleHdma_DoLine(&hdma_chans[2]);
-//    dma_doHdma(snes->dma);
-    if (i == trigger) {
-      SmwVectorIRQ();
-      trigger = snes->vIrqEnabled ? snes->vTimer + 1 : -1;
-    }
-  }
-
-  /*
-  while (!snes->inNmi) {
-    snes_handle_pos_stuff(snes);
-
-    if (snes->cpu->irqWanted) {
-      snes->cpu->irqWanted = false;
-      SmwVectorIRQ();
-    }
-  }*/
-}
-
-void SmwRunOneFrameOfGame(void) {
-  Snes *snes = g_snes;
-  snes->vPos = snes->hPos = 0;
-  snes->cpu->nmiWanted = snes->cpu->irqWanted = false;
-  snes->inVblank = snes->inNmi = false;
-
-  if (snes->cpu->pc == 0x8000) {
-    snes->cpu->pc = 0x8001;
-    SmwVectorReset();
-  }
-  SmwRunOneFrameOfGame_Internal();
-
-  SmwVectorNMI();
-}
 
 const RtlGameInfo kSmwGameInfo = {
   "smw",

src/smw_rtl.c

@@ -4,6 +4,13 @@
 #include "common_cpu_infra.h"
 #include "snes/snes.h"
 
+const uint8 *ptr_layer1_data;
+const uint8 *ptr_layer2_data;
+uint8 ptr_layer2_is_bg;
+
+uint8 *ptr_lo_map16_data;
+uint8 *ptr_lo_map16_data_bak;
+
 void AddSprXPos(uint8 k, uint16 x) {
   AddHiLo(&spr_xpos_hi[k], &spr_xpos_lo[k], x);
 }
@@ -47,7 +54,41 @@ void SmwSavePlaythroughSnapshot() {
 }
 
 void UploadOAMBuffer() {  // 008449
-  memcpy(g_snes->ppu->oam, g_ram + 0x200, 0x220);
+  memcpy(g_ppu->oam, g_ram + 0x200, 0x220);
   RtlPpuWrite(OAMADDH, 0x80);
   RtlPpuWrite(OAMADDL, mirror_oamaddress_lo);
 }
+
+
+void SmwDrawPpuFrame(void) {
+  SimpleHdma hdma_chans[3];
+
+  Dma *dma = g_dma;
+
+  dma_startDma(dma, mirror_hdmaenable, true);
+
+  SimpleHdma_Init(&hdma_chans[0], &dma->channel[5]);
+  SimpleHdma_Init(&hdma_chans[1], &dma->channel[6]);
+  SimpleHdma_Init(&hdma_chans[2], &dma->channel[7]);
+
+  int trigger = g_snes->vIrqEnabled ? g_snes->vTimer + 1 : -1;
+
+  for (int i = 0; i <= 224; i++) {
+    ppu_runLine(g_ppu, i);
+    SimpleHdma_DoLine(&hdma_chans[0]);
+    SimpleHdma_DoLine(&hdma_chans[1]);
+    SimpleHdma_DoLine(&hdma_chans[2]);
+    //    dma_doHdma(snes->dma);
+    if (i == trigger) {
+      SmwVectorIRQ();
+      trigger = g_snes->vIrqEnabled ? g_snes->vTimer + 1 : -1;
+    }
+  }
+}
+
+void SmwRunOneFrameOfGame(void) {
+  if (*(uint16 *)reset_sprites_y_function_in_ram == 0)
+    SmwVectorReset();
+  SmwRunOneFrameOfGame_Internal();
+  SmwVectorNMI();
+}

src/smw_rtl.h

@@ -16,6 +16,9 @@ void SmwClearVram(uint16 vram_addr, uint16 value, int n);
 void SmwCopyToVramPitch32(uint16 vram_addr, const uint8 *src, int n);
 void SmwCopyToVramLow(uint16 vram_addr, const uint8 *src, int n);
 
+void SmwDrawPpuFrame(void);
+void SmwRunOneFrameOfGame(void);
+
 extern bool g_did_finish_level_hook;
 
 void AddSprXPos(uint8 k, uint16 x);
@@ -53,4 +56,8 @@ typedef struct GenTileArgs {
   uint16 r8;
   uint16 r12, r14;
   uint16 r10;
+  uint8 *ptr_lo_map16_data;
 } GenTileArgs;
+
+const uint8 *GetSpriteListPtr();
+uint8 GetCurrentSlope(int i);

src/smw_spc_player.c

@@ -842,6 +842,8 @@ music_keep_running:
   if (--p->counter_sf0c)
     return;
 Music_loop_1:
+  if (p->music_ptr_toplevel == 0)
+    return;
   for(;;) {
     t = WORD(p->ram[p->music_ptr_toplevel]);
     p->music_ptr_toplevel += 2;
@@ -861,8 +863,9 @@ Music_loop_1:
     }
   }
   uint16 *src = (uint16*)(p->ram + t);
-  for (int i = 7; i >= 0; i--)
+  for (int i = 7; i >= 0; i--) {
     p->channel[i].pattern_cur_ptr = WORD(src[i]);
+  }
   
   p->cur_chan_bit = 0x80;
   for (int i = 7; i >= 0; i--, p->cur_chan_bit >>= 1) {
@@ -1021,7 +1024,6 @@ static void HandleEffect(SmwSpcPlayer *p, Channel *c, uint8 effect) {
     break;
   case 0xe5:  // tremolo on
     c->tremolo_delay_ticks = p->ram[c->pattern_cur_ptr++];
-    printf("Writing to bad tremolo ram addr!\n");
     //c->tremolo_rate = p->ram[c->pattern_cur_ptr++];
     c->tremolo_depth = p->ram[c->pattern_cur_ptr++];
     break;
@@ -1116,7 +1118,6 @@ static void Chan_HandleTick(SmwSpcPlayer *p, Channel *c) {
       if (c->tremolo_count & 0x80 && c->tremolo_depth == 0xff) {
         c->tremolo_count = 0x80;
       } else {
-        printf("Reading bad tremolo ram addr!\n");
         //c->tremolo_count += c->tremolo_rate;
       }
       CalcTremolo(p, c);
@@ -1307,13 +1308,15 @@ static void SmwSpcPlayer_GenerateSamples(SpcPlayer *p_in) {
 }
 
 static void SmwSpcPlayer_Upload(SpcPlayer *p_in, const uint8_t *data) {
+  const uint8 *data_org = data;
   SmwSpcPlayer *p = (SmwSpcPlayer *)p_in;
   Dsp_Write(p, FLG, 0x60);
   Dsp_Write(p, KOF, 0xff);
   for (;;) {
     int numbytes = *(uint16 *)(data);
-    if (numbytes == 0)
+    if (numbytes == 0) {
       break;
+    }
     int target = *(uint16 *)(data + 2);
     data += 4;
     do {
@@ -1329,6 +1332,11 @@ static void SmwSpcPlayer_Upload(SpcPlayer *p_in, const uint8_t *data) {
   memset(p->base.input_ports, 0, sizeof(p->base.input_ports));
   memset(p->last_value_from_snes, 0, sizeof(p->last_value_from_snes));
   memset(p->new_value_from_snes, 0, sizeof(p->new_value_from_snes));
+
+  p->music_ptr_toplevel = 0;
+  for (int i = 0; i < 8; i++)
+    p->channel[i].pattern_cur_ptr = 0;
+
   Dsp_Write(p, FLG, 0x20);  
 }
 

src/snes/ppu.c

@@ -19,9 +19,8 @@ static bool ppu_evaluateSprites(Ppu* ppu, int line);
 static uint16_t ppu_getVramRemap(Ppu* ppu);
 
 
-Ppu* ppu_init(Snes* snes) {
+Ppu* ppu_init(void) {
   Ppu* ppu = malloc(sizeof(Ppu));
-  ppu->snes = snes;
   return ppu;
 }
 
@@ -30,24 +29,20 @@ void ppu_free(Ppu* ppu) {
 }
 
 void ppu_copy(Ppu *ppu, Ppu *ppu_src) {
-  Snes *snes = ppu->snes;
   size_t pitch = ppu->renderPitch;
   uint8_t *renderBuffer = ppu->renderBuffer;
   memcpy(ppu, ppu_src, sizeof(*ppu));
   ppu->renderBuffer = renderBuffer;
   ppu->renderPitch = (uint32_t)pitch;
-  ppu->snes = snes;
 }
 
 void ppu_reset(Ppu* ppu) {
   {
-    Snes *snes = ppu->snes;
     size_t pitch = ppu->renderPitch;
     uint8_t *renderBuffer = ppu->renderBuffer;
     memset(ppu, 0, sizeof(*ppu));
     ppu->renderBuffer = renderBuffer;
     ppu->renderPitch = (uint32_t)pitch;
-    ppu->snes = snes;
   }
   ppu->vramIncrement = 1;
 }
@@ -856,11 +851,8 @@ uint8_t ppu_read(Ppu* ppu, uint8_t adr) {
     return (result >> (8 * (adr - 0x34))) & 0xff;
   }
     case 0x37: {
-      // TODO: only when ppulatch is set
+      //assert(0);
-      ppu->hCount = ppu->snes->hPos / 4;
+      return 0;
-      ppu->vCount = ppu->snes->vPos;
-      ppu->countersLatched = true;
-      return ppu->snes->openBus;
     }
     case 0x38: {
       uint8_t ret = 0;

src/snes/ppu.h

@@ -9,11 +9,10 @@
 #include <stdint.h>
 #include <stdbool.h>
 
+#include "saveload.h"
+
 typedef struct Ppu Ppu;
 
-#include "snes.h"
-
-
 typedef struct BgLayer {
   uint16_t xhScroll;
   uint16_t xvScroll;
@@ -94,8 +93,6 @@ struct Ppu {
   uint8 cgwsel;
   // -- END OF SNAPSHOT
 
-  Snes *snes;
-
   // vram access
   uint16_t vramPointer;
   bool vramIncrementOnHigh;
@@ -218,7 +215,7 @@ enum {
 };
 
 
-Ppu* ppu_init(Snes* snes);
+Ppu* ppu_init(void);
 void ppu_free(Ppu* ppu);
 void ppu_copy(Ppu *ppu, Ppu *ppu_src);
 void ppu_reset(Ppu* ppu);

src/snes/snes.c

@@ -36,9 +36,7 @@ Snes* snes_init(uint8_t *ram) {
   snes->cpu = cpu_init(snes, 0);
   snes->apu = apu_init();
   snes->dma = dma_init(snes);
-  snes->my_ppu = ppu_init(snes);
+  snes->ppu = ppu_init();
-  snes->snes_ppu = ppu_init(snes);
-  snes->ppu = snes->snes_ppu;
   snes->cart = cart_init(snes);
   snes->input1 = input_init(snes);
   snes->input2 = input_init(snes);
@@ -68,6 +66,7 @@ void snes_saveload(Snes *snes, SaveLoadInfo *sli) {
   sli->func(sli, &snes->ramAdr, 4);
 
   snes->runningWhichVersion = 0;
+  snes->cpu->e = 0;
 }
 
 void snes_reset(Snes* snes, bool hard) {
@@ -75,8 +74,7 @@ void snes_reset(Snes* snes, bool hard) {
   cpu_reset(snes->cpu);
   apu_reset(snes->apu);
   dma_reset(snes->dma);
-  ppu_reset(snes->my_ppu);
+  ppu_reset(snes->ppu);
-  ppu_reset(snes->snes_ppu);
   input_reset(snes->input1);
   input_reset(snes->input2);
   if (hard)
@@ -150,14 +148,14 @@ void snes_handle_pos_stuff(Snes *snes) {
       dma_initHdma(snes->dma);
     } else if (snes->vPos == 225) {
       // ask the ppu if we start vblank now or at vPos 240 (overscan)
-      startingVblank = !ppu_checkOverscan(snes->ppu);
+      startingVblank = !ppu_checkOverscan(g_ppu);
     } else if (snes->vPos == 240) {
       // if we are not yet in vblank, we had an overscan frame, set startingVblank
       if (!snes->inVblank) startingVblank = true;
     }
     if (startingVblank) {
       // if we are starting vblank
-      ppu_handleVblank(snes->ppu);
+      ppu_handleVblank(g_ppu);
       snes->inVblank = true;
       snes->inNmi = true;
       if (snes->nmiEnabled) {
@@ -171,7 +169,7 @@ void snes_handle_pos_stuff(Snes *snes) {
   } else if (snes->hPos == 512) {
     // render the line halfway of the screen for better compatibility
     if (!snes->inVblank && !snes->disableRender) {
-      ppu_runLine(snes->ppu, snes->vPos);
+      ppu_runLine(g_ppu, snes->vPos);
     }
   } else if (snes->hPos == 1024) {
     // start of hblank
@@ -237,7 +235,7 @@ void snes_catchupApu(Snes* snes) {
 
 uint8_t snes_readBBus(Snes* snes, uint8_t adr) {
   if(adr < 0x40) {
-    return ppu_read(snes->ppu, adr);
+    return ppu_read(g_ppu, adr);
   }
   if(adr < 0x80) {
 //    assert(0);
@@ -259,7 +257,7 @@ uint8_t snes_readBBus(Snes* snes, uint8_t adr) {
 
 void snes_writeBBus(Snes* snes, uint8_t adr, uint8_t val) {
   if(adr < 0x40) {
-    ppu_write(snes->ppu, adr, val);
+    ppu_write(g_ppu, adr, val);
     return;
   }
   if(adr < 0x80) {
@@ -361,7 +359,7 @@ static void snes_writeReg(Snes* snes, uint16_t adr, uint8_t val) {
     case 0x4201: {
       if(!(val & 0x80) && snes->ppuLatch) {
         // latch the ppu
-        ppu_read(snes->ppu, 0x37);
+        ppu_read(g_ppu, 0x37);
       }
       snes->ppuLatch = val & 0x80;
       break;

src/snes/snes.h

@@ -21,7 +21,7 @@ typedef struct Snes Snes;
 struct Snes {
   Cpu* cpu;
   Apu* apu;
-  Ppu* ppu, *snes_ppu, *my_ppu;
+  Ppu* ppu;
   Dma* dma;
   Cart* cart;
   Input *input1;

src/types.h

@@ -152,6 +152,11 @@ static inline PairU16 MakePairU16(uint16 k, uint16 j) {
 #define MakePairU16_AY MakePairU16
 
 
+typedef struct MemBlk {
+  const uint8 *ptr;
+  size_t size;
+} MemBlk;
+MemBlk FindIndexInMemblk(MemBlk data, size_t i);
 
 #endif  // SM_TYPES_H_
 

src/util.c

@@ -170,3 +170,41 @@ void ByteArray_AppendByte(ByteArray *arr, uint8 v) {
   ByteArray_Resize(arr, arr->size + 1);
   arr->data[arr->size - 1] = v;
 }
+
+MemBlk FindIndexInMemblk(MemBlk data, size_t i) {
+  size_t end = data.size, left_off, right_off;
+  if (end < 2)
+    return (MemBlk) { 0, 0 };
+  
+  uint16 f = *(uint16 *)(data.ptr + (end -= 2));
+  size_t mx = f & 0xfff;
+  if (f & 0x4000) {
+    size_t next_mx = *(uint16 *)(data.ptr + (end -= 2));
+    if (next_mx >= 256) {
+      if (i > mx || mx * 2 > end)
+        return (MemBlk) { 0, 0 };
+      end -= mx * 2 + 2;
+      i = *(uint16 *)(data.ptr + end + i * 2);
+    } else {
+      if (i > mx || mx > end)
+        return (MemBlk) { 0, 0 };
+      end -= mx + 1;
+      i = *(uint8 *)(data.ptr + end + i);
+    }
+    mx = next_mx;
+  }
+  if (f & 0x8000) {
+    if (i > mx || mx * 2 > end)
+      return (MemBlk) { 0, 0 };
+    left_off = ((i == 0) ? mx * 2 : mx * 2 + *(uint16 *)(data.ptr + i * 2 - 2));
+    right_off = (i == mx) ? end : mx * 2 + *(uint16 *)(data.ptr + i * 2);
+  } else {
+    if (i > mx || mx * 4 > end)
+      return (MemBlk) { 0, 0 };
+    left_off = ((i == 0) ? mx * 4 : mx * 4 + *(uint32 *)(data.ptr + i * 4 - 4));
+    right_off = (i == mx) ? end : mx * 4 + *(uint32 *)(data.ptr + i * 4);
+  }
+  if (left_off > right_off || right_off > end)
+    return (MemBlk) { 0, 0 };
+  return (MemBlk) { data.ptr + left_off, right_off - left_off };
+}

src/variables.h

@@ -97,10 +97,16 @@
 #define credits_var65 (*(uint16*)(g_ram+0x65))
 #define credits_index (*(uint8*)(g_ram+0x67))
 
-#define ptr_layer1_data (*(LongPtr*)(g_ram+0x65))
+extern const uint8 *ptr_layer1_data;
-#define ptr_layer2_data (*(LongPtr*)(g_ram+0x68))
+extern const uint8 *ptr_layer2_data;
-#define ptr_lo_map16_data (*(LongPtr*)(g_ram+0x6B))
+extern uint8 *ptr_lo_map16_data;
-#define ptr_hi_map16_data (*(LongPtr*)(g_ram+0x6E))
+extern uint8 *ptr_lo_map16_data_bak;
+extern uint8 ptr_layer2_is_bg;
+
+#define xptr_layer1_data (*(LongPtr*)(g_ram+0x65))
+#define xptr_layer2_data (*(LongPtr*)(g_ram+0x68))
+#define xptr_lo_map16_data (*(LongPtr*)(g_ram+0x6B))
+#define xptr_hi_map16_data (*(LongPtr*)(g_ram+0x6E))
 
 #define player_current_state (*(uint8*)(g_ram+0x71))
 #define player_in_air_flag (*(uint8*)(g_ram+0x72))
@@ -122,8 +128,6 @@
 #define player_timer_pipe_warping (*(uint8*)(g_ram+0x88))
 #define player_pipe_action (*(uint8*)(g_ram+0x89))
 
-#define decomp_src (*(LongPtr*)(g_ram+0x8A))
-
 #define player_collision_var8a (*(uint8*)(g_ram+0x8A))
 #define player_collision_var8b (*(uint8*)(g_ram+0x8B))
 #define player_collision_var8c (*(uint8*)(g_ram+0x8C))