diff --git a/.gitignore b/.gitignore
index 2c014eb495..7bba4e3ac9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -46,3 +46,4 @@ texture_replacements/*
 svnrev.h
 ci-artifacts/
 out/build/
+__pycache__/
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 5bfcae9f77..6db58b557a 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -8,9 +8,9 @@
       "name": "Python",
       "type": "python",
       "request": "launch",
-      "program": "${workspaceFolder}/scripts/initial_gsrc_creation/replicate_folder_structure.py",
+      "program": "${workspaceFolder}/scripts/gsrc/update-from-decomp.py",
       "console": "integratedTerminal",
-      "cwd": "${workspaceFolder}/scripts/initial_gsrc_creation"
+      "cwd": "${workspaceFolder}"
     },
   ]
 }
diff --git a/Taskfile.yml b/Taskfile.yml
index 6196e59ec1..db2b7a73b9 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -78,17 +78,7 @@ tasks:
     cmds:
       - rm ./decompiler_out/**/*.asm
       - rm ./decompiler_out/**/*disasm.gc
-  # TODO - the below are broken, need to be updated or replaced
-  # update-gsrc:
-  #   cmds:
-  #     - python ./scripts/next-decomp-file.py --files "{{.FILES}}"
-  #     - task: decomp
-  #     - task: find-label-types
-  #     - python ./scripts/update-goal-src.py --files "{{.FILES}}"
-  #     - task: type-test
-  #     - task: check-gsrc-file
   # TOOLS
-  # TODO - broken!
   # analyze-ee-memory:
   #   cmds:
   #     - '{{.MEMDUMP_BIN_RELEASE_DIR}}/memory_dump_tool "{{.FILE}}" ./ > ee-analysis.log'
diff --git a/goal_src/jak2/kernel/gkernel.gc b/goal_src/jak2/kernel/gkernel.gc
index 03444d131f..9c8b500b33 100644
--- a/goal_src/jak2/kernel/gkernel.gc
+++ b/goal_src/jak2/kernel/gkernel.gc
@@ -5,6 +5,25 @@
 ;; name in dgo: gkernel
 ;; dgos: KERNEL
 
+;; og:ignore-errors:true
+;; og:ignore-form:defun kernel-dispatcher
+
+;; forward declared stuff
+(define-extern *kernel-clock* clock)
+(define-extern *debug-dead-pool* dead-pool-heap)
+(define-extern *null-process* process)
+(define-extern *vis-boot* symbol)
+(define-extern *listener-process* process)
+(define-extern *active-pool* process-tree)
+(define-extern *default-level* level)
+
+(define-extern change-parent (function process-tree process-tree process-tree))
+(define-extern search-process-tree (function process-tree (function process-tree object) process-tree))
+(define-extern iterate-process-tree (function process-tree (function object object) kernel-context object))
+(define-extern execute-process-tree (function process-tree (function object object) kernel-context object))
+(define-extern inspect-process-tree (function process-tree int int symbol process-tree))
+(define-extern process-disconnect (function process int))
+
 ;; DECOMP BEGINS
 
 ;; Version constants
@@ -16,30 +35,12 @@
 (define *kernel-boot-level* #f)
 (define *use-old-listener-print* #f)
 
-
 ;; Stats
 (define *deci-count* 0)
 (define *last-loado-length* 0)
 (define *last-loado-global-usage* 0)
 (define *last-loado-debug-usage* 0)
 
-;; forward declared stuff
-(define-extern *kernel-clock* clock)
-(define-extern *debug-dead-pool* dead-pool-heap)
-(define-extern *null-process* process)
-(define-extern *vis-boot* symbol)
-(define-extern *listener-process* process)
-(define-extern *active-pool* process-tree)
-(define-extern *default-level* level)
-
-
-(define-extern change-parent (function process-tree process-tree process-tree))
-(define-extern search-process-tree (function process-tree (function process-tree object) process-tree))
-(define-extern iterate-process-tree (function process-tree (function object object) kernel-context object))
-(define-extern execute-process-tree (function process-tree (function object object) kernel-context object))
-(define-extern inspect-process-tree (function process-tree int int symbol process-tree))
-(define-extern process-disconnect (function process int))
-
 (defmethod relocate object ((obj object) (arg0 int))
   "Most general relocate method."
   obj
@@ -90,8 +91,10 @@
 ;; the main execution stack that's not on the scratchpad
 (define *dram-stack* (the-as (pointer uint8) (malloc 'global DPROCESS_STACK_SIZE)))
 
+;; DECOMP DEVIATION
 ;; the top of the stack.
 (defconstant *kernel-dram-stack* (&+ *dram-stack* DPROCESS_STACK_SIZE))
+;; DECOMP DEVIATION
 
 ;; the top of the scratchpad stack
 (set! (-> *kernel-context* fast-stack-top) (the-as pointer #x70004000))
@@ -102,6 +105,7 @@
 ;; PC Port Scratchpad
 ;;;;;;;;;;;;;;;;;;;;;;;
 
+;; DECOMP DEVIATION
 (#cond
   (PC_PORT
   ;; we'll create a fake scratchpad:
@@ -140,7 +144,7 @@
      (< (the-as int ,x) (scratchpad-end))
      )
   )
-
+;; DECOMP DEVIATION
 
 ;;;;;;;;;;;;;
 ;; Thread
@@ -238,11 +242,13 @@
   (none)
   )
 
+;; decomp deviation
 (defun-debug stream<-process-mask ((arg0 object) (arg1 process-mask))
   "Print a process mask."
   (bit-enum->string process-mask arg1 arg0)
   arg1
   )
+;; decomp deviation
 
 (define *master-mode* 'game)
 (define *pause-lock* #f)
@@ -417,6 +423,7 @@
   obj
   )
 
+;; decomp deviation
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Context Suspend And Resume - Kernel
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -789,6 +796,8 @@
     )
   (none)
   )
+;; decomp deviation
+
 
 (defmethod new dead-pool ((allocation symbol) (type-to-make type) (arg0 int) (arg1 int) (arg2 string))
   "Allocate a tree of dead processes."
@@ -814,6 +823,7 @@
     )
   )
 
+;; decomp deviation
 (defmethod get-process dead-pool ((obj dead-pool) (arg0 type) (arg1 int))
   "Try to get a process from this dead pool. If it fails, try the debug dead pool and complain."
 
@@ -835,7 +845,6 @@
       ;; this didn't work right in the original game, just crash here.
       (break)
       )
-
     (cond
       (s4-0
         ;; got a process somehow, set the type and return.
@@ -854,6 +863,7 @@
       )
     )
   )
+;; decomp deviation
 
 (defmethod return-process dead-pool ((obj dead-pool) (arg0 process))
   "Return a process to the dead pool."
@@ -1127,6 +1137,7 @@
     )
   )
 
+;; decomp deviation
 (defmethod return-process dead-pool-heap ((obj dead-pool-heap) (proc process))
   "Return a process to a dead pool heap"
 
@@ -1215,6 +1226,8 @@
     )
   obj
   )
+;; decomp deviation
+
 (defmethod compact dead-pool-heap ((obj dead-pool-heap) (arg0 int))
   "Relocate processes to remove gaps and increase free memory."
 
@@ -1521,6 +1534,7 @@
   (the-as process-tree #f)
   )
 
+;; decomp deviation
 (defun kernel-dispatcher ()
   "Main entry point to GOAL from C++."
 
@@ -1649,6 +1663,7 @@
   )
 
 |#
+;; decomp deviation
 
 (defun sync-dispatcher ()
   "Run just the listener function. Used for SQL query stuff."
@@ -1726,6 +1741,7 @@
   `(the-as (function uint uint uint uint uint uint object) ,func)
   )
 
+;; decomp deviation
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Stack Frame Stuff
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1843,7 +1859,6 @@
     )
   )
 
-
 (defun throw-dispatch ((obj catch-frame) value)
   "Throw the given value to the catch frame.
   Only can throw a 64-bit value. The original could throw 128 bits."
@@ -1940,6 +1955,7 @@
   (format 0 "ERROR: throw could not find tag ~A~%" name)
   (break)
   )
+;; decomp deviation
 
 (defmethod new protect-frame ((allocation symbol) (type-to-make type) (arg0 (function none)))
   "Create a new protect frame, must be on the stack."
@@ -2086,6 +2102,7 @@
   arg0
   )
 
+;; decomp deviation
 (defmethod activate process ((obj process) (arg0 process-tree) (arg1 basic) (arg2 pointer))
   "Start a process!"
   ;; if we got the scratchpad stack, move to the fake scratchpad.
@@ -2140,7 +2157,6 @@
   (change-parent obj arg0)
   )
 
-
 (defun run-function-in-process ((obj process) (func function) a0 a1 a2 a3 a4 a5)
   "Switch to the given process and run the function. This is used to initialize a process.
   The function will run until it attempts to change state. At the first attempt to change state,
@@ -2242,9 +2258,8 @@
     (.add a4 a4)
     (.add a5 a5)
     )
-
   )
-
+;; decomp deviation
 
 (defun set-to-run ((thread cpu-thread) (func function) a0 a1 a2 a3 a4 a5)
   "Set the given thread to call the given function with the given arguments next time it resumes.
@@ -2290,6 +2305,7 @@
 (set! (-> dead-state code) (the (function none :behavior process) nothing))
 (define entity-deactivate-handler (the-as (function process entity-actor none) nothing))
 
+;; decomp deviation
 (defmethod deactivate process ((obj process))
   "Kill a process."
   (with-pp
@@ -2376,6 +2392,7 @@
     (none)
     )
   )
+;; decomp deviation
 
 ;;;;;;;;;;;;;;;;;;;
 ;; Kernel globals
diff --git a/scripts/add-all-heap-bases.py b/scripts/add-all-heap-bases.py
deleted file mode 100644
index bec7f93f37..0000000000
--- a/scripts/add-all-heap-bases.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import os
-
-new_file = []
-with open("./decompiler/config/all-types.gc") as f:
-  symbols_found = []
-  lines = f.readlines()
-
-  for line_num, line in enumerate(lines):
-    if "flag-assert" in line:
-      heap_base_amount = ""
-      flag_assert = line.split("#x")[1].strip()
-      heap_base_amount = flag_assert[len(flag_assert)-7:len(flag_assert)-4]
-      if len(flag_assert) > 1 and heap_base_amount != "000":
-        # First let's check to see if the heap-base already exists around this line
-        found_heapbase = False
-        for i in range(line_num - 4, line_num + 3):
-          temp_line = lines[i]
-          if "heap-base" in temp_line:
-            found_heapbase = True
-            break
-        if found_heapbase == False:
-          if line.startswith(";"):
-            new_file.append(";   :heap-base           #x{}\n".format(heap_base_amount.lstrip("0")))
-          else:
-            new_file.append("  :heap-base #x{}\n".format(heap_base_amount.lstrip("0")))
-    new_file.append(line)
-
-os.remove("./decompiler/config/all-types.gc")
-with open("./decompiler/config/all-types.gc", "w") as f:
-  f.writelines(new_file)
diff --git a/scripts/add-pragma-once-headers.py b/scripts/add-pragma-once-headers.py
deleted file mode 100644
index b8e214b68b..0000000000
--- a/scripts/add-pragma-once-headers.py
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import os
-from glob import glob
-
-
-folders = sys.argv
-cwd = os.getcwd()
-
-for folder in folders:
-  directory = os.path.join(cwd, folder)
-  files = [y for x in os.walk(directory) for y in glob(os.path.join(x[0], '*.h'))]
-  for fPath in files:
-    print("Processing %s" % fPath)
-    with open(fPath, 'r+') as f:
-        content = f.read()
-        f.seek(0, 0)
-        if (content.startswith("#pragma once") == False):
-          f.write("#pragma once\n\n" + content)
-
diff --git a/scripts/add-reference-test.py b/scripts/add-reference-test.py
deleted file mode 100644
index e3bb9f8be2..0000000000
--- a/scripts/add-reference-test.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# Decompiles and adds the file to the reference test folder
-from jak1_file_list import file_list
-
-import argparse
-parser = argparse.ArgumentParser()
-parser.add_argument("--file")
-args = parser.parse_args()
-
-if not args.file:
-  print("No --file argument provided!")
-  exit(1)
-
-import os
-
-# TODO - make customizable
-if not os.path.exists("./decompiler_out/jak1/{}_disasm.gc".format(args.file)):
-  print("File not already decompiled!")
-  exit(1)
-
-src_path = ""
-for f in file_list:
-  if f[2] != 3:
-    continue
-  if f[0] == args.file:
-    src_path = f[4]
-    break
-
-if not os.path.exists("./test/decompiler/reference/{}".format(src_path)):
-  os.makedirs("./test/decompiler/reference/{}".format(src_path))
-
-import shutil
-
-shutil.copy("./decompiler_out/jak1/{}_disasm.gc".format(args.file), "./test/decompiler/reference/{}/{}_REF.gc".format(src_path, args.file))
-print("Copied!")
diff --git a/scripts/nrepl-test.py b/scripts/examples/nrepl-test.py
similarity index 100%
rename from scripts/nrepl-test.py
rename to scripts/examples/nrepl-test.py
diff --git a/scripts/check-gsrc-file.py b/scripts/gsrc/check-gsrc-file.py
similarity index 100%
rename from scripts/check-gsrc-file.py
rename to scripts/gsrc/check-gsrc-file.py
diff --git a/scripts/gsrc/requirements.txt b/scripts/gsrc/requirements.txt
new file mode 100644
index 0000000000..ec512b4a94
--- /dev/null
+++ b/scripts/gsrc/requirements.txt
@@ -0,0 +1 @@
+rapidfuzz
diff --git a/scripts/initial_gsrc_creation/check_for_identical_objs.py b/scripts/gsrc/skeleton_creation/check_for_identical_objs.py
similarity index 100%
rename from scripts/initial_gsrc_creation/check_for_identical_objs.py
rename to scripts/gsrc/skeleton_creation/check_for_identical_objs.py
diff --git a/scripts/initial_gsrc_creation/init_folder_struct_jak2.py b/scripts/gsrc/skeleton_creation/init_folder_struct_jak2.py
similarity index 100%
rename from scripts/initial_gsrc_creation/init_folder_struct_jak2.py
rename to scripts/gsrc/skeleton_creation/init_folder_struct_jak2.py
diff --git a/scripts/initial_gsrc_creation/make_empty_obj_files.py b/scripts/gsrc/skeleton_creation/make_empty_obj_files.py
similarity index 100%
rename from scripts/initial_gsrc_creation/make_empty_obj_files.py
rename to scripts/gsrc/skeleton_creation/make_empty_obj_files.py
diff --git a/scripts/initial_gsrc_creation/remove_identical_objs.py b/scripts/gsrc/skeleton_creation/remove_identical_objs.py
similarity index 100%
rename from scripts/initial_gsrc_creation/remove_identical_objs.py
rename to scripts/gsrc/skeleton_creation/remove_identical_objs.py
diff --git a/scripts/gsrc/update-from-decomp.py b/scripts/gsrc/update-from-decomp.py
new file mode 100644
index 0000000000..67ce4a4fed
--- /dev/null
+++ b/scripts/gsrc/update-from-decomp.py
@@ -0,0 +1,967 @@
+# Updates a gsrc file from it's respective decompiled output
+# Tries it's very best to:
+# - retain all comments (100% of them)
+# - place them in either the exact same spot, or roughly the same spot
+# - retain decomp deviations (marked with ;; decomp deviation comment guards) and try to place them back
+#   - this will also automate the process of knowing if a file was modified or not if actually used
+#
+# This is done with a variety of heuristics and can obviously only be so
+# accurate on unstructured data like code
+#
+# Assumes this is ran from the root dir of the repository
+
+# Overview of the process:
+# - Collect all comments, associate as much metadata with them as possible so we can reposition them in the new output
+# - Potential metadata that will help (from most to least accurate)
+#   - symbol it is directly before/after (symbol names don't change, so this is VERY accurate (ie. a function name / type name))
+#   - forms/variable names it is directly before/after (these may change, might be the whole reason you are decompiling again!)
+#   - line number into a form (may also change, but independent of output)
+#   - containing form (if all else fails, we can atleast put it _near_ where it should go)
+# Update the decompilation
+# Attempt to add back all of the comment lines
+# - adjust indentation if needed
+#
+# 1. Get metadata from original file so we can reconstruct it
+# 2. Cleanup disasm file (get rid of most comments, etc)
+# 3. Add back all comment blocks to modified original file
+# 4. hope for the best...
+
+# Known Issues:
+# - use defuns as symbols (consistent names), but account for padding properly
+# - padding after decomp deviation blocks / blocks in general is wrong
+# - blocks starting inline (ie '(define foo 'bar) #|start of a block comment that continues on...)
+# - decomp deviation blocks inside forms can cause paren counting issues
+# -
+# - codes a mess, as one would probably expect for something as miserable as this, it needs a refactor
+# - there are likely ways to make this more efficient
+
+import argparse
+import re
+from rapidfuzz import fuzz
+from utils import get_gsrc_path_from_filename
+
+# TODO - rename and refactor all usages, it's not _always_ a comment anymore!
+# RetainedCode or something
+class CommentMeta:
+    def __init__(self):
+        self.data = ""
+        self.symbol_before = None
+        self.symbol_inline = None
+        self.symbol_after = None
+        self.symbol_padding_before = None
+        self.symbol_padding_after = None
+        # NOTE - maybe holding more than just 1 line before/after might help?
+        self.code_before = None
+        self.code_after = None
+        self.code_padding_before = None
+        self.code_padding_after = None
+        self.line_num_in_form = None  # None == top level
+        self.containing_form = None  # none - top level
+        self.containing_form_kind = None  # function|method|behaviour
+        self.containing_form_func_name = None  # or the method/behaviour
+        self.containing_form_type = None
+        self.inline = False
+        self.code_in_line = None  # only for inline comments
+        self.line_in_file = None  # a worst-case scenario fallback
+
+    def __str__(self):
+        return "{}:{}:{}".format(self.data, self.symbol_before, self.symbol_after)
+
+
+parser = argparse.ArgumentParser("update-from-decomp")
+parser.add_argument("--game", help="The name of the game", type=str)
+parser.add_argument("--file", help="The name of the file", type=str)
+parser.add_argument(
+    "--debug", help="Output debug metadata on every block", action="store_true"
+)
+parser.add_argument(
+    "--clearDebug", help="Clear debug metadata", action="store_true"
+)  # TODO - implement!
+args = parser.parse_args()
+
+gsrc_path = get_gsrc_path_from_filename(args.game, args.file)
+
+comments = []
+debug_lines = []
+
+
+def debug_nice_formatted_code(val):
+    if val is None:
+        return None
+    return val.strip()[0:20]
+
+
+# returns (symbol | None, padding)
+def backtrack_for_symbol(lines, index):
+    padding = 0
+    for i in range(index - 1, 0, -1):
+        tline = lines[i].strip()
+        matches = re.search(
+            r"(?:define|define-extern|defun|defstate|deftype)\s+([^\s]*)\s", tline
+        )
+        if matches is not None:
+            return matches.group(1), padding
+        elif (
+            not tline.strip() == "" and not tline.strip().startswith(";")
+        ) or "decomp begins" in tline.lower():
+            # we hit a non empty line (but it wasn't a symbol!)
+            return None, padding
+        elif tline.strip() == "":
+            padding = padding + 1
+    return None, padding
+
+
+def symbol_on_line(line):
+    tline = line.lstrip()
+    matches = re.search(
+        r"(?:define|define-extern|defun|defstate|deftype)\s+([^\s]*)\s", tline
+    )
+    if matches is not None:
+        return matches.group(1)
+    return None
+
+
+def lookahead_for_symbol(lines, index):
+    padding = 0
+    for i in range(index + 1, len(lines), 1):
+        tline = lines[i].lstrip()
+        matches = re.search(
+            r"(?:define|define-extern|defun|defstate|deftype)\s+([^\s]*)\s", tline
+        )
+        if matches is not None:
+            return matches.group(1), padding
+        elif (
+            not tline.strip() == "" and not tline.strip().startswith(";")
+        ) or "decomp begins" in tline.lower():
+            # we hit a non empty line (but it wasn't a symbol!)
+            return None, padding
+        elif tline.strip() == "":
+            padding = padding + 1
+    return None, padding
+
+
+def backtrack_for_code(lines, index):
+    padding = 0
+    for i in range(index - 1, 0, -1):
+        line = lines[i]
+        if line.strip() == "":
+            padding = padding + 1
+            continue
+        elif "decomp begins" in line.lower():
+            return None, padding
+        elif line.lstrip().startswith(";"):
+            continue
+        return line, padding
+
+
+def lookahead_for_code(lines, index):
+    padding = 0
+    for i in range(index + 1, len(lines), 1):
+        line = lines[i]
+        if line.strip() == "":
+            padding = padding + 1
+            continue
+        elif "decomp begins" in line.lower():
+            return None, padding
+        elif line.lstrip().startswith(";"):
+            continue
+        return line, padding
+
+
+# returns form, or none
+def is_line_start_of_form(line):
+    if line.rstrip().startswith(";"):
+        return None
+    matches = re.search(r"\(\s*([^\s.]*)\s+", line)
+    if matches is not None:
+        return line
+    return None
+
+
+def has_form_ended(stack, line):
+    # if the stack is empty, return true
+    line_before_comment = line.partition(";")[0]
+    for char in line_before_comment:
+        if char == "(":
+            stack.append(char)
+        elif char == ")":
+            if len(stack) == 0:
+                # unbalanced parens?
+                return True
+            stack.pop()
+            if len(stack) == 0:
+                return True
+        else:
+            if len(stack) == 0:
+                return True
+    return False
+
+
+def append_form_metadata(comment, form_start_line):
+    func_matches = re.search(r"\(defun(?:-debug)? ([^\s]*)", form_start_line)
+    if func_matches is not None:
+        comment.containing_form_kind = "function"
+        comment.containing_form_func_name = func_matches.group(1)
+        comment.containing_form_type = None
+        return
+    behavior_matches = re.search(
+        r"\((?:defbehavior) ([^\s]*) ([^\s]*)", form_start_line
+    )
+    if behavior_matches is not None:
+        comment.containing_form_kind = "behavior"
+        comment.containing_form_func_name = behavior_matches.group(1)
+        comment.containing_form_type = behavior_matches.group(2)
+        return
+    method_matches = re.search(r"\((?:defmethod) ([^\s]*) ([^\s]*)", form_start_line)
+    if method_matches is not None:
+        comment.containing_form_kind = "method"
+        comment.containing_form_func_name = method_matches.group(1)
+        comment.containing_form_type = method_matches.group(2)
+        return
+    comment.containing_form_kind = "unknown"
+    comment.containing_form_func_name = None
+    comment.containing_form_type = None
+
+
+decomp_ignore_forms = []
+decomp_ignore_errors = False
+
+with open(gsrc_path) as f:
+    lines_temp = f.readlines()
+    lines = []
+    # Get rid of debug lines, this is so i can re-run without having to reset the file
+    for line in lines_temp:
+        if "[DEBUG]" in line:
+            continue
+        # Check for comment annotate overrides / settings, this is the "nicest" place to shove this
+        if "og:ignore-errors" in line and "true" in line:
+            decomp_ignore_errors = True
+        if "og:ignore-form" in line:
+            decomp_ignore_forms.append(line.partition("ignore-form:")[2].strip())
+        lines.append(line)
+    # track if we are inside a define*/defun/defmethod/deftype/defstate
+    within_form = None
+    line_num_in_form = None
+    form_paren_stack = []
+    found_output = False
+    i = 0
+    while i < len(lines):
+        debug_lines.append(lines[i])
+        tline = lines[i].lstrip()
+        if "decomp begins" in tline.lower():
+            found_output = True
+            i = i + 1
+            continue
+        if not found_output:
+            i = i + 1
+            continue
+        # actually process code
+        if within_form is None:
+            # lets see if we are now in one
+            within_form = is_line_start_of_form(lines[i])
+            if within_form is not None:
+                line_num_in_form = 0
+                if has_form_ended(form_paren_stack, lines[i]):
+                    within_form = None
+                    form_paren_stack = []
+        elif within_form is not None:
+            # check if the form has ended by counting parens
+            if has_form_ended(form_paren_stack, lines[i]):
+                within_form = None
+                form_paren_stack = []
+                line_num_in_form = 0
+            else:
+                line_num_in_form = line_num_in_form + 1
+
+        if tline.startswith(";") or tline.startswith("#|"):
+            # treat decomp deviation blocks as essentially comments as well, so include them in a block comment if appropriate
+            # this is done because there is nothing to match them against (if a comment is inside them for example)
+            # so we have to copy them in full
+            in_deviation_block = False
+            if "decomp deviation" in tline.lower() or tline.startswith("#|"):
+                in_deviation_block = True
+            current_comment = CommentMeta()
+            current_comment.line_in_file = i
+            current_comment.data = lines[i]
+            (
+                current_comment.symbol_before,
+                current_comment.symbol_padding_before,
+            ) = backtrack_for_symbol(lines, i)
+            (
+                current_comment.code_before,
+                current_comment.code_padding_before,
+            ) = backtrack_for_code(lines, i)
+            current_comment.containing_form = within_form
+            if within_form is not None:
+                append_form_metadata(current_comment, within_form)
+            current_comment.line_num_in_form = line_num_in_form
+            current_comment.inline = False
+            # look ahead to handle block comments
+            if i + 1 < len(lines):
+                next_line = lines[i + 1]
+            if "decomp deviation" in next_line.lower() or next_line.startswith("|#"):
+                in_deviation_block = False
+            while i + 1 < len(lines) and (
+                in_deviation_block
+                or next_line.lstrip().startswith(";")
+                or next_line.lstrip().startswith("|#")
+            ):
+                debug_lines.append(lines[i + 1])
+                i = i + 1
+                current_comment.data = current_comment.data + next_line
+                if i + 1 < len(lines):
+                    next_line = lines[i + 1]
+                if "decomp deviation" in next_line.lower() or next_line.startswith(
+                    "|#"
+                ):
+                    in_deviation_block = False
+            (
+                current_comment.symbol_after,
+                current_comment.symbol_padding_after,
+            ) = lookahead_for_symbol(lines, i)
+            (
+                current_comment.code_after,
+                current_comment.code_padding_after,
+            ) = lookahead_for_code(lines, i)
+            comments.append(current_comment)
+            debug_lines.append(
+                ";; [DEBUG]: sym - {}:{} | {}:{} || code - {}...:{} | {}...:{}\n".format(
+                    current_comment.symbol_before,
+                    current_comment.symbol_padding_before,
+                    current_comment.symbol_after,
+                    current_comment.symbol_padding_after,
+                    debug_nice_formatted_code(current_comment.code_before),
+                    current_comment.code_padding_before,
+                    debug_nice_formatted_code(current_comment.code_after),
+                    current_comment.code_padding_after,
+                )
+            )
+            debug_lines.append(
+                ";; [DEBUG]: in_form - {}...:{}\n".format(
+                    debug_nice_formatted_code(current_comment.containing_form),
+                    current_comment.line_num_in_form,
+                )
+            )
+        # inline comments
+        # TODO - cleanup duplication
+        elif ";" in tline:
+            current_comment = CommentMeta()
+            current_comment.line_in_file = i
+            current_comment.data = ";" + tline.partition(";")[2]
+            (
+                current_comment.symbol_before,
+                current_comment.symbol_padding_before,
+            ) = backtrack_for_symbol(lines, i)
+            (
+                current_comment.symbol_after,
+                current_comment.symbol_padding_after,
+            ) = lookahead_for_symbol(lines, i)
+            (
+                current_comment.code_before,
+                current_comment.code_padding_before,
+            ) = backtrack_for_code(lines, i)
+            (
+                current_comment.code_after,
+                current_comment.code_padding_after,
+            ) = lookahead_for_code(lines, i)
+            current_comment.containing_form = within_form
+            if within_form is not None:
+                append_form_metadata(current_comment, within_form)
+            current_comment.line_num_in_form = line_num_in_form
+            current_comment.symbol_inline = symbol_on_line(tline)
+            current_comment.inline = True
+            current_comment.code_in_line = tline.partition(";")[0]
+            comments.append(current_comment)
+            debug_lines.append(
+                ";; [DEBUG]: sym - {}:{} | {}:{} || code - {}...:{} | {}...:{}\n".format(
+                    current_comment.symbol_before,
+                    current_comment.symbol_padding_before,
+                    current_comment.symbol_after,
+                    current_comment.symbol_padding_after,
+                    debug_nice_formatted_code(current_comment.code_before),
+                    current_comment.code_padding_before,
+                    debug_nice_formatted_code(current_comment.code_after),
+                    current_comment.code_padding_after,
+                )
+            )
+            debug_lines.append(
+                ";; [DEBUG]: in_form - {}...:{} || inline_code - {}...\n".format(
+                    debug_nice_formatted_code(current_comment.containing_form),
+                    current_comment.line_num_in_form,
+                    debug_nice_formatted_code(current_comment.code_in_line),
+                )
+            )
+        i = i + 1
+
+
+if args.debug:
+    with open(gsrc_path, "w") as f:
+        f.writelines(debug_lines)
+    exit(0)
+
+# Step 2: Cleanup the decomp output
+
+lines_to_ignore = [
+    ";;-*-Lisp-*-",
+    "(in-package goal)",
+    ";; definition",
+    ";; INFO:",
+    ";; failed to figure",
+    ";; Used lq/sq",
+    ";; this part is debug only",
+]
+
+if decomp_ignore_errors:
+    lines_to_ignore.append(";; ERROR:")
+    lines_to_ignore.append(";; WARN:")
+
+decomp_lines = []
+# cache all form definition lines from the incoming decompilation
+# this way, we can "quickly" figure out which form is the most relevant
+decomp_form_def_lines = []
+
+
+def should_ignore_line(line):
+    for ignore_line in lines_to_ignore:
+        if line.lower().startswith(ignore_line.lower()):
+            return True
+    return False
+
+
+# TODO - check for existance probably
+decomp_file_path = "./decompiler_out/{}/{}_disasm.gc".format(args.game, args.file)
+with open(decomp_file_path) as f:
+    lines = f.readlines()
+    i = 0
+    decomp_form_paren_stack = []
+    decomp_within_form = None
+    while i < len(lines):
+        line = lines[i]
+        if should_ignore_line(line):
+            i = i + 1
+            continue
+        decomp_within_form = is_line_start_of_form(line)
+        # Check if we should ignore the form
+        if decomp_within_form is not None:
+            # See if we should skip it
+            skip_form = False
+            for form_to_ignore in decomp_ignore_forms:
+                if form_to_ignore in decomp_within_form:
+                    skip_form = True
+                    break
+            if has_form_ended(decomp_form_paren_stack, line):
+                decomp_within_form = None
+                decomp_form_paren_stack = []
+                if not skip_form:
+                    decomp_lines.append(line)
+                i = i + 1
+            else:
+                if not skip_form:
+                    decomp_form_def_lines.append(decomp_within_form)
+                    decomp_lines.append(line)
+                while i < len(lines):
+                    i = i + 1
+                    line = lines[i]
+                    if not skip_form:
+                        decomp_lines.append(line)
+                    if has_form_ended(decomp_form_paren_stack, line):
+                        decomp_within_form = None
+                        decomp_form_paren_stack = []
+                        i = i + 1
+                        break
+        else:
+            decomp_lines.append(line)
+            i = i + 1
+
+
+# Step 3: Start merging the new code + comments
+final_lines = []
+decomp_started = False
+
+
+def get_symbol_at_line(line):
+    tline = line.strip()
+    matches = re.search(
+        r"(?:define|define-extern|defun|defstate|deftype)\s+([^\s]*)\s", tline
+    )
+    if matches is not None:
+        return matches.group(1)
+    return None
+
+
+def relevant_symbol_comments_for_line_before(line):
+    symbol = get_symbol_at_line(line)
+    if symbol is None:
+        return []
+    # Loop through comments, finding any that match the symbol
+    # they WILL be placed, so we can remove them from our list now
+    i = 0
+    relevant_comments = []
+    while i < len(comments):
+        comment = comments[i]
+        if comment.symbol_after == symbol:
+            relevant_comments.append(comment)
+            comments.pop(i)
+        else:
+            i = i + 1
+    return relevant_comments
+
+
+def padding_before_comment(comment):
+    if comment.containing_form is None:
+        if comment.symbol_after is not None:
+            return "\n" * comment.symbol_padding_after
+    return ""
+
+
+def relevant_symbol_comments_for_inline(line):
+    symbol = get_symbol_at_line(line)
+    if symbol is None:
+        return []
+    # Loop through comments, finding any that match the symbol
+    # they WILL be placed, so we can remove them from our list now
+    i = 0
+    relevant_comments = []
+    while i < len(comments):
+        comment = comments[i]
+        if comment.symbol_inline == symbol:
+            relevant_comments.append(comment)
+            comments.pop(i)
+        else:
+            i = i + 1
+    return relevant_comments
+
+
+def padding_after_comment(comment):
+    if comment.containing_form is None:
+        if comment.symbol_before is not None:
+            return "\n" * comment.symbol_padding_before
+    return ""
+
+
+def relevant_symbol_comments_for_line_after(line):
+    symbol = get_symbol_at_line(line)
+    if symbol is None:
+        return []
+    # Loop through comments, finding any that match the symbol
+    # they WILL be placed, so we can remove them from our list now
+    i = 0
+    relevant_comments = []
+    while i < len(comments):
+        comment = comments[i]
+        # if we can, we prefer to put comments before not after (more accurate re-creation)
+        if comment.symbol_after is None and comment.symbol_before == symbol:
+            relevant_comments.append(comment)
+            comments.pop(i)
+        else:
+            i = i + 1
+    return relevant_comments
+
+
+# the first half of the defmethod/etc lines (before arg list) is less likely to change
+# so we want to split it to weight it more heavily
+def split_def_line(line):
+    first_part = ""
+    second_part = ""
+    for index, char in enumerate(line):
+        if char == "(":
+            if index == 0:
+                first_part = first_part + char
+            else:
+                second_part = second_part + char
+            continue
+        else:
+            if second_part != "":
+                second_part = second_part + char
+            else:
+                first_part = first_part + char
+    return first_part, second_part
+
+
+def get_form_metadata(form_def_line):
+    func_matches = re.search(r"\(defun(?:-debug)? ([^\s]*)", form_def_line)
+    if func_matches is not None:
+        return "function", func_matches.group(1), None
+    behavior_matches = re.search(r"\((?:defbehavior) ([^\s]*) ([^\s]*)", form_def_line)
+    if behavior_matches is not None:
+        return "behavior", behavior_matches.group(1), behavior_matches.group(2)
+    method_matches = re.search(r"\((?:defmethod) ([^\s]*) ([^\s]*)", form_def_line)
+    if method_matches is not None:
+        return "method", method_matches.group(1), method_matches.group(2)
+    return "unknown", None, None
+
+
+built_in_method_names = [
+    "new",
+    "delete",
+    "print",
+    "inspect",
+    "length",
+    "asize-of",
+    "copy",
+    "relocate",
+    "memusage",
+]
+
+
+def different_method_names(form_func_name, comment_form_func_name):
+    if (
+        comment_form_func_name not in built_in_method_names
+        and form_func_name not in built_in_method_names
+    ):
+        return False
+    return form_func_name != comment_form_func_name
+
+
+def get_relevant_form_comments(form_def_line):
+    form_kind, form_func_name, form_type = get_form_metadata(form_def_line)
+    code_def_part, code_rest = split_def_line(form_def_line)
+    relevant_comments = []
+    i = 0
+    while i < len(comments):
+        comment = comments[i]
+        if comment.containing_form is None:
+            i = i + 1
+            continue
+        (
+            comment_form_kind,
+            comment_form_func_name,
+            comment_form_type,
+        ) = get_form_metadata(comment.containing_form)
+        # First disqualify the form if it's obviously unrelated
+        if comment_form_kind != "unknown":
+            if form_kind != comment_form_kind:
+                i = i + 1
+                continue
+            elif form_kind == "function" and comment_form_func_name != form_func_name:
+                i = i + 1
+                continue
+            elif form_kind == "behavior" and comment_form_func_name != form_func_name:
+                i = i + 1
+                continue
+            elif form_kind == "method" and (
+                comment_form_type != form_type
+                or different_method_names(form_func_name, comment_form_func_name)
+            ):
+                i = i + 1
+                continue
+        # Evaluate it's score (comments and current def line)
+        def_part, rest = split_def_line(comment.containing_form)
+        def_score = fuzz.ratio(code_def_part, def_part) * 0.65
+        if def_score == 65.0 and form_kind != "unknown":
+            relevant_comments.append(comment)
+            comments.pop(i)
+            continue
+        rest_score = fuzz.ratio(code_rest, rest) * 0.35
+        combined_score = def_score + rest_score
+        threshold = 50.0
+        if combined_score < threshold:
+            i = i + 1
+            continue
+        # Now, let's look at ALL other def lines yet to come from the decomp output
+        # if any are a better match, don't add the comment yet -- we'll add it when we get there!
+        # TODO - remove lines from the list as we find them so speed this up
+        found_better_form = False
+        for decomp_def_line in decomp_form_def_lines:
+            line_form_kind, line_form_func_name, line_form_type = get_form_metadata(
+                decomp_def_line
+            )
+            if form_kind != "unknown":
+                if form_kind != line_form_kind:
+                    continue
+                elif form_kind == "function" and line_form_func_name != form_func_name:
+                    continue
+                elif form_kind == "behavior" and line_form_func_name != form_func_name:
+                    continue
+                elif form_kind == "method" and (
+                    line_form_type != form_type
+                    or different_method_names(form_func_name, line_form_func_name)
+                ):
+                    continue
+                def_part, rest = split_def_line(decomp_def_line)
+                def_score = fuzz.ratio(code_def_part, def_part) * 0.65
+                if def_score == 65.0 and form_kind != "unknown":
+                    found_better_form = True
+                    break
+                rest_score = fuzz.ratio(code_rest, rest) * 0.35
+                if combined_score < def_score + rest_score:
+                    found_better_form = True
+                    break
+            # TODO otherwise? still test?
+        if found_better_form:
+            i = i + 1
+            continue
+        relevant_comments.append(comment)
+        comments.pop(i)
+    return relevant_comments
+
+
+# Simple fuzz ratio, but removes obvious outliers like empty lines / lines with only a paren
+def score_alg(line1, line2):
+    tline1 = line1.strip()
+    tline2 = line2.strip()
+    if tline1 == "" or tline1 == ")" or tline1 == "(":
+        return -1
+    if tline2 == "" or tline2 == ")" or tline2 == "(":
+        return -1
+    return fuzz.ratio(tline1, tline2)
+
+
+# TODO - improvement on comparison - a higher score on a longer line == better? some sort of weighting approach here too?
+
+with open(gsrc_path) as f:
+    lines = f.readlines()
+    within_form = None
+    line_num_in_form = None
+    form_paren_stack = []
+    for line in lines:
+        if "[DEBUG]" in line:
+            continue
+        if line.lower().lstrip().startswith(";; decomp begins"):
+            decomp_started = True
+            final_lines.append(line)
+            break
+        if not decomp_started:
+            final_lines.append(line)
+            continue
+
+    i = 0
+    while i < len(decomp_lines):
+        line = decomp_lines[i]
+        # Otherwise, its a part of the output we have to be more careful about
+        # For every line in the decompiled output, we scan our comment list to see if anything matches
+        # if it does, we insert it appropriately and remove the comment from the list
+        #
+        # This is the main source of inefficiency, but the process gets progressively faster as comments are eliminated
+        if within_form is None:
+            # lets see if we are now in one
+            within_form = is_line_start_of_form(line)
+            # TODO - check line for symbol matches?
+            if within_form is not None:
+                line_num_in_form = 0
+                if has_form_ended(form_paren_stack, line):
+                    within_form = None
+                    form_paren_stack = []
+                else:
+                    # Get all of the lines of the form at once
+                    form_start = decomp_lines[i]
+                    form_lines = [form_start]
+                    while i < len(decomp_lines):
+                        i = i + 1
+                        line = decomp_lines[i]
+                        if has_form_ended(form_paren_stack, line):
+                            within_form = None
+                            form_paren_stack = []
+                            break
+                        else:
+                            form_lines.append(line)
+                    # Add any comments needed to the form contents
+                    # - first we get all comments that have match well with the form's start line (ie. defmethod ....)
+                    form_comments = get_relevant_form_comments(form_start)
+                    # - for each comment, let's find which line matches it the best,
+                    # if NONE exceed the threshold (if both match the same, pick the first), we default to the line offset
+                    for comment in form_comments:
+                        highest_score = -1
+                        index_to_insert = -1
+                        threshold = 50.0
+                        place_kind = None
+                        for index, form_line in enumerate(form_lines):
+                            # skip any comments that were previously added
+                            if form_line.lstrip().startswith(";"):
+                                continue
+                            if comment.code_in_line is not None:
+                                score = score_alg(form_line, comment.code_in_line)
+                                if score >= threshold and score > highest_score:
+                                    index_to_insert = index
+                                    highest_score = score
+                                    place_kind = "inline"
+                            if comment.code_before is not None:
+                                score = score_alg(form_line, comment.code_before)
+                                if score >= threshold and score > highest_score:
+                                    index_to_insert = index
+                                    highest_score = score
+                                    place_comment_after = True
+                                    place_kind = "next_line"
+                            if comment.code_after is not None:
+                                score = score_alg(form_line, comment.code_after)
+                                if score >= threshold and score > highest_score:
+                                    index_to_insert = index
+                                    highest_score = score
+                                    place_comment_after = False
+                                    place_kind = "before_line"
+                        # add the comment!
+                        if index_to_insert == -1:
+                            if comment.inline:
+                                form_lines[comment.line_num_in_form] = (
+                                    form_lines[index_to_insert].rstrip()
+                                    + " "
+                                    + comment.data
+                                )
+                            else:
+                                form_lines.insert(
+                                    comment.line_num_in_form, comment.data
+                                )
+                        elif comment.inline:
+                            form_index = index_to_insert
+                            if place_kind == "next_line":
+                                form_index = index_to_insert + 1
+                            form_lines[form_index] = (
+                                form_lines[form_index].rstrip() + " " + comment.data
+                            )
+                        elif place_kind == "next_line":
+                            form_lines.insert(
+                                index_to_insert + 1,
+                                padding_before_comment(comment) + comment.data,
+                            )
+                        else:
+                            form_lines.insert(
+                                index_to_insert,
+                                padding_after_comment(comment) + comment.data,
+                            )
+                    # Add the lines to the final output
+                    for form_line in form_lines:
+                        final_lines.append(form_line)
+
+        # Otherwise, we are at the top-level!
+        if within_form is None:
+            before_comments = relevant_symbol_comments_for_line_before(line)
+            for comment in before_comments:
+                final_lines.append(padding_before_comment(comment) + comment.data)
+            inline_comments = relevant_symbol_comments_for_inline(line)
+            if len(inline_comments) > 0:
+                comment_str = ""
+                for comment in inline_comments:
+                    comment_str = comment_str + comment.data.strip()
+                comment_str = comment_str.replace(";", "")
+                final_lines.append(
+                    "{} ;; {}".format(line.rstrip(), comment_str.strip())
+                )
+            else:
+                final_lines.append(line)
+            after_comments = relevant_symbol_comments_for_line_after(line)
+            for comment in after_comments:
+                final_lines.append(padding_after_comment(comment) + comment.data)
+        # next line
+        i = i + 1
+
+# Step 3.b: Handle any remaining top level comments
+# If we can't find a code line that meets a threshold, default to their line number
+# - Why is this done after: if a comment is associated with nothing but code, we have no
+#   guarantee where it should go, so we have to wait until all code is populated
+# This is SUPER inefficient, so hopefully we've processed nearly all comments by this point
+for comment in comments:
+    within_form = None
+    line_num_in_form = None
+    form_paren_stack = []
+    found_output = True
+    i = 0
+    index_to_insert = -1
+    highest_score = -1
+    place_comment_after = True
+    threshold = 50.0
+    while i < len(final_lines):
+        debug_lines.append(final_lines[i])
+        tline = final_lines[i].lstrip()
+        if "decomp begins" in tline.lower():
+            found_output = True
+            i = i + 1
+            continue
+        if not found_output:
+            i = i + 1
+            continue
+        line = final_lines[i]
+        # We can try to claw back a bit of efficiency by skipping the inside of forms
+        if within_form is not None:
+            # check if the form has ended by counting parens
+            if has_form_ended(form_paren_stack, line):
+                if comment.code_in_line is not None:
+                    score = score_alg(line, comment.code_in_line)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                if comment.code_before is not None:
+                    score = score_alg(line, comment.code_before)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                        place_comment_after = True
+                if comment.code_after is not None:
+                    score = score_alg(line, comment.code_after)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                        place_comment_after = False
+                within_form = None
+                form_paren_stack = []
+                line_num_in_form = 0
+            else:
+                line_num_in_form = line_num_in_form + 1
+        else:
+            # lets see if we are now in a form
+            within_form = is_line_start_of_form(line)
+            if within_form is not None:
+                if comment.code_in_line is not None:
+                    score = score_alg(line, comment.code_in_line)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                if comment.code_before is not None:
+                    score = score_alg(line, comment.code_before)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                        place_comment_after = True
+                if comment.code_after is not None:
+                    score = score_alg(line, comment.code_after)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                        place_comment_after = False
+                line_num_in_form = 0
+            else:
+                # just normal code, check it
+                if comment.code_in_line is not None:
+                    score = score_alg(line, comment.code_in_line)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                if comment.code_before is not None:
+                    score = score_alg(line, comment.code_before)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                        place_comment_after = True
+                if comment.code_after is not None:
+                    score = score_alg(line, comment.code_after)
+                    if score >= threshold and score > highest_score:
+                        index_to_insert = i
+                        highest_score = score
+                        place_comment_after = False
+        i = i + 1
+    # end of while loop
+    # add the comment!
+    if index_to_insert == -1:
+        if comment.inline:
+            final_lines[comment.line_in_file] = (
+                final_lines[comment.line_in_file].rstrip() + " " + comment.data
+            )
+        else:
+            final_lines.insert(comment.line_in_file, comment.data)
+    elif comment.inline:
+        final_lines[index_to_insert] = (
+            final_lines[index_to_insert].rstrip() + " " + comment.data
+        )
+    elif place_comment_after:
+        final_lines.insert(
+            index_to_insert + 1,
+            padding_before_comment(comment) + comment.data,
+        )
+    else:
+        final_lines.insert(
+            index_to_insert,
+            padding_after_comment(comment) + comment.data,
+        )
+
+# Step 4: Write it out
+with open(gsrc_path, "w") as f:
+    f.writelines(final_lines)
diff --git a/scripts/gsrc/utils.py b/scripts/gsrc/utils.py
new file mode 100644
index 0000000000..331aa51dae
--- /dev/null
+++ b/scripts/gsrc/utils.py
@@ -0,0 +1,31 @@
+import json
+import os
+
+jak1_files = None
+jak2_files = None
+
+with open('./goal_src/jak1/build/all_objs.json', 'r') as f:
+  jak1_files = json.load(f)
+with open('./goal_src/jak2/build/all_objs.json', 'r') as f:
+  jak2_files = json.load(f)
+
+def get_file_list(game_name):
+  if game_name == "jak1":
+    return jak1_files
+  else:
+    return jak2_files
+
+def get_gsrc_path_from_filename(game_name, file_name):
+  file_list = get_file_list(game_name)
+  src_path = ""
+  for f in file_list:
+    if f[2] != 3:
+      continue
+    if f[0] == file_name:
+      src_path = f[4]
+      break
+  path = "./goal_src/{}/{}/{}.gc".format(game_name, src_path, file_name)
+  if not os.path.exists(path):
+    print("{} couldn't find in /goal_src/{}!".format(file_name, game_name))
+    exit(1)
+  return path
diff --git a/scripts/jak1-symbol-mapping.json b/scripts/jak1-symbol-mapping.json
deleted file mode 100644
index a1f89bf0d0..0000000000
--- a/scripts/jak1-symbol-mapping.json
+++ /dev/null
@@ -1,7144 +0,0 @@
-{
-  "actor-link-h": [
-    "entity-actor-count",
-    "entity-actor-lookup",
-    "entity-by-name",
-    "entity-by-aid",
-    "actor-link-subtask-complete-hook",
-    "actor-link-dead-hook",
-    "alt-actor-list-subtask-incomplete-count",
-    "actor-link-info"
-  ],
-  "air": ["point-in-air?", "points-in-air?", "add-debug-air-box"],
-  "air-h": ["point-in-air-box-area?", "point-in-air-box?", "air-box"],
-  "aligner-h": ["align-control"],
-  "ambient": [
-    "ambient-type-error",
-    "ambient-type-sound",
-    "ambient-type-sound-loop",
-    "ambient-type-poi",
-    "ambient-type-hint",
-    "ambient-type-light",
-    "ambient-type-dark",
-    "ambient-type-weather-off",
-    "ambient-type-ocean-off",
-    "ambient-type-ocean-near-off",
-    "ambient-type-music",
-    "level-hint-task-process",
-    "bottom-hud-hidden?",
-    "level-hint-init-by-other",
-    "level-hint-exit",
-    "level-hint-error",
-    "voicebox-spawn",
-    "hide-bottom-hud",
-    "level-hint-ambient-sound",
-    "level-hint-sidekick",
-    "level-hint-normal",
-    "ambient-hint-init-by-other",
-    "level-hint-process-cmd",
-    "task-known?",
-    "can-grab-display?",
-    "level-hint-displayed?",
-    "*execute-ambients*",
-    "ambient-inspect"
-  ],
-  "anim-tester": [
-    "*anim-tester*",
-    "anim-test-sequence",
-    "anim-test-edit-sequence-list-handler",
-    "*ANIM_TESTER-bank*",
-    "anim-test-seq-mark-as-edited",
-    "anim-test-seq-item",
-    "anim-tester-start",
-    "anim-tester-add-newobj",
-    "anim-tester-stop",
-    "anim-tester",
-    "initialize-anim-tester",
-    "anim-tester-save-object-seqs",
-    "anim-tester-num-print",
-    "anim-test-obj-list-handler",
-    "anim-tester-standard-event-handler",
-    "anim-tester-reset",
-    "anim-tester-process",
-    "anim-tester-get-playing-item",
-    "anim-tester-update-anim-info",
-    "anim-tester-interface",
-    "display-list-control",
-    "anim-test-anim-list-handler",
-    "anim-test-sequence-list-handler",
-    "anim-test-field-highlight-lw",
-    "*DISP_LIST-bank*",
-    "anim-tester-disp-frame-num",
-    "anim-test-seq-item-copy!",
-    "anim-tester-adjust-frame",
-    "anim-test-edit-seq-insert-item",
-    "anim-tester-pick-item-setup",
-    "*debug-menu-context*",
-    "anim-tester-save-all-objects",
-    "anim-tester-real-post",
-    "anim-test-obj-item-valid?",
-    "list-control",
-    "list-field",
-    "DISP_LIST-bank",
-    "anim-tester-bank",
-    "anim-test-obj",
-    "anim-test-obj-init",
-    "anim-test-sequence-init",
-    "anim-test-obj-remove-invalid",
-    "anim-tester-post",
-    "anim-tester-string-get-frame!!",
-    "anim-tester-load-object-seqs",
-    "anim-tester-add-object",
-    "anim-tester-set-name",
-    "anim-tester-add-sequence"
-  ],
-  "aphid": [
-    "*aphid-sg*",
-    "*aphid-nav-enemy-info*",
-    "aphid-invulnerable",
-    "aphid-vulnerable",
-    "aphid-init-by-other",
-    "aphid"
-  ],
-  "art-h": [
-    "new-dynamic-structure",
-    "joint-anim",
-    "joint-anim-matrix",
-    "joint-anim-transformq",
-    "joint-anim-drawable",
-    "joint-anim-compressed",
-    "joint-anim-frame",
-    "joint-anim-compressed-hdr",
-    "joint-anim-compressed-fixed",
-    "joint-anim-compressed-frame",
-    "joint-anim-compressed-control",
-    "art",
-    "art-element",
-    "art-mesh-anim",
-    "art-joint-anim",
-    "art-group",
-    "art-mesh-geo",
-    "art-joint-geo",
-    "skeleton-group",
-    "lod-group",
-    "lod-set",
-    "draw-control"
-  ],
-  "assert": [
-    "*run-time-assert-enable*",
-    "__assert",
-    "__assert-min-max-range-float",
-    "__assert-min-max-range-int",
-    "__assert-zero-lim-range-int"
-  ],
-  "assert-h": ["*__private-assert-info*", "__assert-info-private-struct"],
-  "assistant": ["*assistant-sg*", "check-drop-level-assistant", "assistant"],
-  "assistant-citadel": [
-    "*assistant-lavatube-end-sg*",
-    "assistant-lavatube-end"
-  ],
-  "assistant-firecanyon": ["*assistant-firecanyon-sg*", "assistant-firecanyon"],
-  "assistant-lavatube": [
-    "*assistant-lavatube-start-sg*",
-    "assistant-lavatube-start"
-  ],
-  "assistant-village2": [
-    "*assistant-village2-sg*",
-    "just-particles",
-    "assistant-levitator-blue-glow",
-    "assistant-levitator-blue-beam",
-    "*jaws-sg*",
-    "check-drop-level-assistant-bluehut",
-    "assistant-levitator"
-  ],
-  "assistant-village3": ["*assistant-village3-sg*", "assistant-villagec"],
-  "babak": ["*babak-sg*", "*babak-nav-enemy-info*", "babak"],
-  "babak-with-cannon": [
-    "beachcam-spawn",
-    "mistycam-spawn",
-    "babak-with-cannon-jump-off-cannon",
-    "babak-with-cannon-compute-ride-point",
-    "babak-with-cannon-compute-cannon-dir",
-    "babak-with-cannon-shooting",
-    "babak-with-cannon-jump-onto-cannon",
-    "babak-run-to-cannon",
-    "handle->process-safe",
-    "babak-with-cannon-ride-cannon-post",
-    "babak-with-cannon"
-  ],
-  "baby-spider": [
-    "baby-spider-hatching",
-    "baby-spider-resume",
-    "*baby-spider-sg*",
-    "*baby-spider-nav-enemy-info-for-cave-trap*",
-    "*baby-spider-nav-enemy-info*",
-    "baby-spider-die-fast",
-    "baby-spider-default-event-handler",
-    "baby-spider-init-by-other",
-    "baby-spider-spawn-params",
-    "baby-spider"
-  ],
-  "background": [
-    "background-upload-vu0",
-    "*instance-shrub-work*",
-    "*background-work*",
-    "time-of-day-interp-colors",
-    "draw-drawable-tree-instance-shrub",
-    "upload-vis-bits",
-    "time-of-day-interp-colors-scratch",
-    "draw-drawable-tree-tfrag",
-    "draw-drawable-tree-trans-tfrag",
-    "draw-drawable-tree-dirt-tfrag",
-    "draw-drawable-tree-ice-tfrag",
-    "*instance-tie-work*",
-    "tie-near-make-perspective-matrix",
-    "draw-drawable-tree-instance-tie",
-    "background-vu0-block",
-    "init-background",
-    "finish-background"
-  ],
-  "background-h": ["background-work"],
-  "balloonlurker": [
-    "balloonlurker-pilot-init-by-other",
-    "balloonlurker-patrol",
-    "*balloonlurker-sg*",
-    "balloonlurker-find-nearest-path-point",
-    "balloonlurker-snap-to-path-point",
-    "*balloonlurker-constants*",
-    "balloonlurker-pilot-idle",
-    "*balloonlurker-pilot-sg*",
-    "balloonlurker-pilot-die",
-    "*BALLOONLURKER-bank*",
-    "balloonlurker-die",
-    "balloonlurker-get-next-path-point",
-    "*balloonlurker-rudder-joint-home*",
-    "balloonlurker-play-sounds",
-    "balloonlurker-player-impulse",
-    "balloonlurker-mine-explode",
-    "balloonlurker-get-path-point",
-    "balloonlurker-event-handler",
-    "balloonlurker-post",
-    "balloonlurker-bank",
-    "balloonlurker",
-    "balloonlurker-pilot"
-  ],
-  "basebutton": [
-    "*warp-jump-mods*",
-    "target-warp-out",
-    "*warp-info*",
-    "*generic-button-sg*",
-    "basebutton-init-by-other",
-    "basebutton",
-    "warp-gate"
-  ],
-  "baseplat": [
-    "plat-code",
-    "plat-trans",
-    "plat-post",
-    "plat-event",
-    "eco-door-event-handler",
-    "baseplat",
-    "eco-door"
-  ],
-  "battlecontroller": [
-    "battlecontroller-task-completed?",
-    "battlecontroller-off",
-    "battlecontroller-camera-on",
-    "battlecontroller-spawn-creature-random-spawner",
-    "battlecontroller-disable-ocean",
-    "battlecontroller-update-spawners",
-    "battlecontroller-fill-all-spawners",
-    "battlecontroller-battle-begin",
-    "battlecontroller-spawn-creature-at-spawner",
-    "battlecontroller-spawn-creature",
-    "battlecontroller-spawners-full?",
-    "battlecontroller-default-event-handler",
-    "battlecontroller-draw-debug",
-    "battlecontroller-camera-off",
-    "battlecontroller-battle-end",
-    "battlecontroller-special-contents?",
-    "battlecontroller-special-contents-collected?",
-    "battlecontroller-set-special-contents-collected",
-    "battlecontroller-set-task-completed",
-    "battlecontroller-spawner",
-    "battlecontroller-creature-type",
-    "battlecontroller"
-  ],
-  "beach-obs": [
-    "*beachcam-sg*",
-    "*harvester-sg*",
-    "harvester-idle",
-    "harvester-inflate",
-    "*flutflutegg-sg*",
-    "flutflutegg-break",
-    "flutflutegg-idle",
-    "flutflutegg-physics-fall",
-    "flutflutegg-hit-sounds",
-    "flutflutegg-physics",
-    "*bladeassm-sg*",
-    "bladeassm-prebind-function",
-    "bladeassm-idle",
-    "flying-rock-init-by-other",
-    "*kickrock-sg*",
-    "flying-rock-rolling",
-    "flying-rock-idle",
-    "*ecoventrock-sg*",
-    "ecoventrock-break",
-    "ecoventrock-idle",
-    "spawn-flying-rock",
-    "*grottopole-sg*",
-    "move-grottopole-to-position",
-    "grottopole-idle",
-    "move-grottopole",
-    "grottopole-moving-up",
-    "grottopole-moving-down",
-    "*windmill-one-sg*",
-    "windmill-one-idle",
-    "*flutflut-naked-sg*",
-    "windmill-one",
-    "grottopole",
-    "ecoventrock",
-    "flying-rock",
-    "bladeassm",
-    "flutflutegg",
-    "harvester",
-    "beachcam"
-  ],
-  "beach-part": ["sound-beach-waterfall", "beach-part"],
-  "beach-rocks": ["*lrocklrg-sg*", "beach-rock", "lrocklrg"],
-  "billy": [
-    "*billy-sg*",
-    "*billy-sidekick-sg*",
-    "billy-kill-all-but-farthy",
-    "billy-playing",
-    "billy-game-update",
-    "billy-done",
-    "billy-snack-init-by-other",
-    "rat-about-to-eat?",
-    "billy-game-update-wave",
-    "billy-rat-init-by-other",
-    "*farthy-snack-sg*",
-    "billy-rat-salivate",
-    "billy-rat-eat",
-    "billy-snack-idle",
-    "billy-snack-eat",
-    "billy",
-    "billy-snack",
-    "billy-rat"
-  ],
-  "bird-lady": ["*bird-lady-sg*", "bird-lady"],
-  "bird-lady-beach": ["*bird-lady-beach-sg*", "bird-lady-beach"],
-  "blocking-plane": [
-    "blocking-plane-init-by-other",
-    "*ef-plane-sg*",
-    "blocking-plane-idle",
-    "blocking-plane"
-  ],
-  "bonelurker": [
-    "*bonelurker-sg*",
-    "*bonelurker-nav-enemy-info*",
-    "bonelurker-set-small-bounds-sphere",
-    "bonelurker-set-large-bounds-sphere",
-    "bonelurker-stun",
-    "bonelurker-stunned-event-handler",
-    "bonelurker-push-post",
-    "bonelurker"
-  ],
-  "bones": [
-    "*merc-bucket-info*",
-    "paused?",
-    "*bone-calculation-list*",
-    "bones-vu0-block",
-    "*texscroll-globals*",
-    "dump-mem",
-    "bone-list-init",
-    "texscroll-make-request",
-    "texscroll-execute",
-    "*use-generic*",
-    "bones-set-sqwc",
-    "bones-reset-sqwc",
-    "*merc-global-array*",
-    "bones-init",
-    "draw-bones-mtx-calc",
-    "bones-mtx-calc",
-    "bones-mtx-calc-execute",
-    "bones-wrapup",
-    "*bones-first*",
-    "dump-qword",
-    "bones-debug",
-    "dump-bone-mem",
-    "*default-shadow-settings*",
-    "draw-bones-shadow",
-    "draw-bones-generic-merc",
-    "draw-bones-merc",
-    "draw-bones-check-longest-edge",
-    "draw-bones-check-longest-edge-asm",
-    "draw-bones",
-    "draw-bones-hud",
-    "bone-calculation",
-    "bone-calculation-list",
-    "texscroll-globals",
-    "merc-effect-bucket-info",
-    "merc-bucket-info"
-  ],
-  "bones-h": [
-    "invalidate-cache-line",
-    "*merc-globals*",
-    "bone-buffer",
-    "bone-layout",
-    "bone-regs",
-    "bone-work",
-    "bone-debug",
-    "bone-memory",
-    "merc-globals",
-    "merc-global-array",
-    "shadow-dma-packet"
-  ],
-  "bouncer": [
-    "*bouncer-sg*",
-    "bouncer-wait",
-    "bouncer-fire",
-    "bouncer-smush",
-    "springbox"
-  ],
-  "bounding-box": ["box-vector-enside?", "box-vector-inside?"],
-  "bounding-box-h": ["bounding-box", "bounding-box4w", "bounding-box-both"],
-  "bsp": [
-    "print-cl-stat",
-    "clear-cl-stat",
-    "mem-usage-bsp-tree",
-    "*test-shrub*",
-    "bsp-camera-asm",
-    "print-collide-stats"
-  ],
-  "bsp-h": [
-    "map-bsp-tree",
-    "inspect-bsp-tree",
-    "bsp-node",
-    "bsp-header",
-    "game-level",
-    "view-frustum",
-    "cl-stat",
-    "collide-stats"
-  ],
-  "bully": [
-    "*bully-sg*",
-    "*bully-shadow-control*",
-    "bully-idle",
-    "bully-broken-cage-init-by-other",
-    "bully-start-spinning",
-    "bully-stop-spinning",
-    "bully-notice",
-    "bully-die",
-    "*bully-broken-cage-sg*",
-    "bully-broken-cage-explode",
-    "bully-default-event-handler",
-    "bully-post",
-    "bully-broken-cage",
-    "bully"
-  ],
-  "cam-combiner": ["cam-combiner-active", "cam-combiner-init"],
-  "cam-debug": [
-    "*camera-old-level*",
-    "*camera-old-cpu*",
-    "*camera-old-vu*",
-    "*camera-old-tfrag-bytes*",
-    "*camera-old-stat-string-tfrag-near*",
-    "*camera-old-stat-string-tfrag*",
-    "*camera-old-stat-string-total*",
-    "cam-collision-record-draw",
-    "master-draw-coordinates",
-    "cam-debug-draw-tris",
-    "cam-collision-record-step",
-    "*cam-collision-record-show*",
-    "*cam-collision-record*",
-    "*cam-collision-record-last*",
-    "*cam-collision-record-first*",
-    "camera-sphere",
-    "camera-line-rel",
-    "camera-fov-draw",
-    "*cam-debug-los-tri*",
-    "*cam-debug-los-tri-current*",
-    "*cam-debug-coll-tri*",
-    "*cam-debug-coll-tri-current*",
-    "cam-line-dma",
-    "camera-line2d",
-    "camera-plot-float-func",
-    "cam-debug-add-coll-tri",
-    "debug-euler",
-    "bike-cam-limit",
-    "external-cam-reset!",
-    "cam-dbg-scratch",
-    "cam-debug-tri",
-    "cam-collision-record",
-    "cam-collision-record-array"
-  ],
-  "cam-debug-h": [
-    "*timeplot-index*",
-    "*timeplot-table*",
-    "*yellowline-index*",
-    "*yellowline-table*",
-    "*greenline-index*",
-    "*greenline-table*",
-    "*blueline-index*",
-    "*blueline-table*",
-    "*redline-index*",
-    "*redline-table*",
-    "float-save-redline",
-    "float-lookup-redline",
-    "float-save-blueline",
-    "float-lookup-blueline",
-    "float-save-greenline",
-    "float-lookup-greenline",
-    "float-save-yellowline",
-    "float-lookup-yellowline",
-    "float-save-timeplot",
-    "float-lookup-timeplot",
-    "*cam-layout*"
-  ],
-  "cam-interface": [
-    "*camera-dummy-vector*",
-    "matrix-world->local",
-    "camera-angle",
-    "camera-teleport-to-entity"
-  ],
-  "cam-interface-h": [
-    "*camera-read-analog*",
-    "*camera-read-buttons*",
-    "*cam-free-move-along-z*",
-    "*camera-init-mat*",
-    "*camera*",
-    "*camera-combiner*",
-    "*camera-orbit-target*"
-  ],
-  "cam-layout": [
-    "cam-layout-stop",
-    "cam-layout-start",
-    "cam-layout",
-    "cam-layout-init",
-    "*camera-layout-blink*",
-    "*last-cur-entity*",
-    "clmf-next-entity",
-    "*clm-select*",
-    "*clm*",
-    "cam-layout-active",
-    "cam-layout-entity-info",
-    "cam-layout-entity-volume-info",
-    "cam-layout-do-menu",
-    "*camera-layout-message-ypos*",
-    "*CAM_LAYOUT-bank*",
-    "cam-layout-print",
-    "clm-list",
-    "cam-layout-function-call",
-    "cam-layout-do-action",
-    "function",
-    "clm",
-    "clmf-cam-flag-toggle-info",
-    "clmf-save-single",
-    "cam-layout-save-cam-rot",
-    "cam-layout-save-cam-trans",
-    "cam-layout-save-pivot",
-    "cam-layout-save-align",
-    "cam-layout-save-interesting",
-    "cam-layout-save-fov",
-    "cam-layout-save-focalpull",
-    "cam-layout-save-flags",
-    "cam-layout-save-introsplinetime",
-    "cam-layout-save-introsplineexitval",
-    "cam-layout-save-interptime",
-    "cam-layout-save-splineoffset",
-    "cam-layout-save-spline-follow-dist-offset",
-    "cam-layout-save-campointsoffset",
-    "cam-layout-save-tiltAdjust",
-    "cam-layout-save-stringMinLength",
-    "cam-layout-save-stringMaxLength",
-    "cam-layout-save-stringMinHeight",
-    "cam-layout-save-stringMaxHeight",
-    "cam-layout-save-stringCliffHeight",
-    "cam-layout-save-maxAngle",
-    "cam-layout-save-campoints-flags",
-    "cam-layout-save-focalpull-flags",
-    "cam-index-options->string",
-    "cam-slave-options->string",
-    "fov->maya",
-    "*clm-edit*",
-    "*clm-focalpull-attr*",
-    "*clm-index-attr*",
-    "*clm-intro-attr*",
-    "*clm-spline-attr*",
-    "*clm-vol-attr*",
-    "*volume-descriptor-current*",
-    "*volume-point-current*",
-    "*volume-normal-current*",
-    "cam-layout-entity-volume-info-create",
-    "clmf-next-volume",
-    "clmf-input",
-    "camera-fov-frame",
-    "interp-test-info",
-    "interp-test",
-    "v-slrp!",
-    "interp-test-deg",
-    "*volume-descriptor*",
-    "camera-line-setup",
-    "camera-line-draw",
-    "*volume-point*",
-    "*volume-normal*",
-    "cam-layout-intersect-dist",
-    "cam-layout-bank",
-    "clm-basic",
-    "clm-item-action",
-    "clm-item",
-    "clm-list-item",
-    "volume-descriptor-array",
-    "clmf-button-test",
-    "clmf-bna",
-    "clmf-implement",
-    "clmf-pos-rot",
-    "clmf-next-vol-dpad",
-    "clmf-to-edit-cam",
-    "clmf-to-vol-attr",
-    "clmf-to-spline-attr",
-    "clmf-to-intro-attr",
-    "clmf-to-index-attr",
-    "clmf-to-focalpull-attr",
-    "clmf-to-edit",
-    "clmf-to-select",
-    "clmf-look-through",
-    "clmf-save-one",
-    "clmf-save-all",
-    "clmf-cam-flag-toggle",
-    "clmf-cam-flag",
-    "clmf-cam-float-adjust",
-    "clmf-cam-meters",
-    "clmf-cam-fov",
-    "clmf-cam-deg",
-    "clmf-cam-intro-time",
-    "clmf-cam-interp-time",
-    "clmf-cam-float",
-    "clmf-cam-string",
-    "*clm-cam-attr*",
-    "*clm-cam-lookthrough*",
-    "*clm-save-all*",
-    "*clm-save-one*",
-    "cam-layout-restart"
-  ],
-  "cam-master": [
-    "list-keeper-init",
-    "cam-free-floating",
-    "cam-master-active",
-    "list-keeper-active",
-    "master-track-target",
-    "master-check-regions",
-    "camera-master-debug",
-    "master-unset-region",
-    "reset-target-tracking",
-    "reset-drawable-tracking",
-    "master-switch-to-entity",
-    "cam-fixed",
-    "cam-decel",
-    "reset-drawable-follow",
-    "reset-follow",
-    "cam-eye",
-    "in-cam-entity-volume?",
-    "master-base-region",
-    "setup-slave-for-hopefull",
-    "master-is-hopeful-better?",
-    "*CAMERA_MASTER-bank*",
-    "target-cam-pos",
-    "cam-master-init",
-    "camera-master-bank",
-    "list-keeper"
-  ],
-  "cam-start": ["cam-stop", "reset-cameras", "cam-start"],
-  "cam-states": [
-    "cam-bike-code",
-    "*CAM_BIKE-bank*",
-    "cam-calc-bike-follow!",
-    "cam-stick-code",
-    "*CAM_STICK-bank*",
-    "set-string-parms",
-    "cam-string-code",
-    "cam-string",
-    "cam-string-find-position-rel!",
-    "cam-string-set-position-rel!",
-    "cam-debug-reset-coll-tri",
-    "cam-string-follow",
-    "cam-string-line-of-sight",
-    "cam-string-joystick",
-    "cam-string-find-hidden",
-    "cam-collision-record-save",
-    "cam-string-move",
-    "cam-dist-analog-input",
-    "cam-los-collide",
-    "dist-info-init",
-    "*CAM_STRING-bank*",
-    "los-cw-ccw",
-    "cam-debug-add-los-tri",
-    "cam-los-spline-collide",
-    "cam-los-setup-lateral",
-    "slave-los-state->string",
-    "dist-info-print",
-    "dist-info-valid?",
-    "dist-info-append",
-    "cam-circular-code",
-    "cam-circular-position",
-    "cam-circular-position-into-max-angle",
-    "*CAM_BILLY-bank*",
-    "*CAM_EYE-bank*",
-    "cam-standoff",
-    "cam-standoff-calc-trans",
-    "cam-pov",
-    "cam-pov180",
-    "cam-pov-track",
-    "cam-eye-bank",
-    "cam-billy-bank",
-    "cam-billy",
-    "cam-endlessfall",
-    "cam-lookat",
-    "cam-string-bank",
-    "string-push-help",
-    "cam-draw-collide-cache",
-    "los-dist",
-    "collide-los-dist-info",
-    "collide-los-result",
-    "cam-stick-bank",
-    "cam-stick",
-    "cam-bike-bank",
-    "cam-bike"
-  ],
-  "cam-states-dbg": [
-    "*camera-orbit-info*",
-    "*CAM_ORBIT-bank*",
-    "cam-free-floating-move",
-    "cam-free-floating-input",
-    "*CAM_FREE-bank*",
-    "*CAM_POINT_WATCH-bank*",
-    "cam-point-watch",
-    "cam-orbit",
-    "cam-point-watch-bank",
-    "cam-free-bank",
-    "camera-free-floating-move-info",
-    "camera-orbit-info",
-    "CAM_ORBIT-bank"
-  ],
-  "cam-update": [
-    "*start-timer*",
-    "*timer-value*",
-    "*start-pos*",
-    "move-camera-from-pad",
-    "*save-camera-inv-rot*",
-    "update-view-planes",
-    "update-visible",
-    "*update-leaf-when-outside-bsp*",
-    "set-point",
-    "plane-from-points",
-    "update-camera"
-  ],
-  "cam-update-h": [
-    "*external-cam-options*",
-    "*external-cam-mode*",
-    "*camera-look-through-other*",
-    "*camera-other-fov*",
-    "*camera-other-trans*",
-    "*camera-other-matrix*",
-    "*camera-smush-control*",
-    "*camera-other-root*"
-  ],
-  "camera": [
-    "vector-into-frustum-nosmooth!",
-    "slave-matrix-blend-2",
-    "mat-remove-z-rot",
-    "parameter-ease-sin-clamp",
-    "cam-slave-get-intro-step",
-    "cam-slave-get-float",
-    "cam-slave-init-vars",
-    "cam-calc-follow!",
-    "slave-set-rotation!",
-    "camera-slave-debug",
-    "camera-line-rel-len",
-    "*cam-res-string*",
-    "cam-slave-get-flags",
-    "cam-circular",
-    "cam-standoff-read-entity",
-    "cam-spline",
-    "*camera-base-mode*",
-    "cam-fixed-read-entity",
-    "cam-slave-get-vector-with-offset",
-    "cam-slave-get-fov",
-    "cam-slave-get-interp-time",
-    "cam-slave-get-rot",
-    "cam-state-from-entity",
-    "parameter-ease-none",
-    "parameter-ease-clamp",
-    "parameter-ease-lerp-clamp",
-    "parameter-ease-sqrt-clamp",
-    "fourth-power",
-    "third-power",
-    "parameter-ease-sqr-clamp",
-    "cam-slave-go",
-    "cam-slave-init",
-    "cam-standard-event-handler",
-    "cam-curve-pos",
-    "cam-curve-setup",
-    "v-slrp2!",
-    "v-slrp3!"
-  ],
-  "camera-h": [
-    "*CAMERA-bank*",
-    "camera-bank",
-    "cam-index",
-    "tracking-point",
-    "tracking-spline-sampler",
-    "tracking-spline",
-    "cam-float-seeker",
-    "cam-vector-seeker",
-    "cam-rotation-tracker",
-    "camera-combiner",
-    "camera-slave",
-    "camera-master"
-  ],
-  "capture": [
-    "gs-set-default-store-image",
-    "gs-store-image",
-    "sync-path",
-    "file-stream-write",
-    "file-stream-close",
-    "store-image",
-    "gs-store-image-packet"
-  ],
-  "cave-trap": [
-    "cave-trap-idle",
-    "cave-trap-give-up",
-    "cave-trap-active",
-    "spider-vent-idle",
-    "cave-trap-default-event-handler",
-    "cave-trap",
-    "spider-vent",
-    "spawn-baby-spider-best",
-    "spawn-baby-spider-work"
-  ],
-  "cavecrystal-light": [
-    "*cavecrystal-engine*",
-    "cavecrystal-light-control-default-callback",
-    "cavecrystal-light",
-    "cavecrystal-light-control"
-  ],
-  "citadel-obs": [
-    "*citadelcam-sg*",
-    "citadelcam-idle",
-    "citadelcam-stair-plats",
-    "citb-generator-broken",
-    "citb-generator-idle",
-    "*citb-generator-sg*",
-    "*citb-generator-broken-sg*",
-    "citb-generator-trigger-others",
-    "citb-generator-break",
-    "*citb-hose-sg*",
-    "citb-hose-die",
-    "citb-hose-idle",
-    "citb-hose-spawn",
-    "*citb-coil-sg*",
-    "citb-coil-broken",
-    "citb-coil-idle",
-    "citb-coil-break",
-    "*citb-robotboss-sg*",
-    "citb-robotboss-die",
-    "citb-robotboss-idle",
-    "*citb-robotboss-nose-sg*",
-    "*citb-robotboss-head-sg*",
-    "*citb-robotboss-gun-sg*",
-    "*citb-robotboss-leftshoulder-sg*",
-    "*citb-robotboss-rightshoulder-sg*",
-    "*citb-robotboss-leftarm-sg*",
-    "*citb-robotboss-rightarm-sg*",
-    "*citb-robotboss-belly-sg*",
-    "*citb-launcher-sg*",
-    "*citb-button-sg*",
-    "*citb-iris-door-sg*",
-    "*citb-disc-d-sg*",
-    "*citb-disc-c-sg*",
-    "*citb-disc-b-sg*",
-    "*citb-disc-a-sg*",
-    "citb-disc-idle",
-    "*citb-arm-shoulder-b-sg*",
-    "*citb-arm-shoulder-a-sg*",
-    "*citb-arm-d-sg*",
-    "*citb-arm-c-sg*",
-    "*citb-arm-b-sg*",
-    "*citb-arm-a-sg*",
-    "citb-hose-event-handler",
-    "citb-arm-section",
-    "citb-arm",
-    "citb-arm-shoulder",
-    "citb-arm-a",
-    "citb-arm-b",
-    "citb-arm-c",
-    "citb-arm-d",
-    "citb-arm-shoulder-a",
-    "citb-arm-shoulder-b",
-    "citb-disc",
-    "citb-disc-a",
-    "citb-disc-b",
-    "citb-disc-c",
-    "citb-disc-d",
-    "citb-iris-door",
-    "citb-button",
-    "citb-launcher",
-    "citb-robotboss",
-    "citb-coil",
-    "citb-hose",
-    "citb-chains",
-    "citb-generator",
-    "citadelcam",
-    "citb-battlecontroller"
-  ],
-  "citadel-part": [
-    "citb-part",
-    "check-drop-level-firehose-pops",
-    "birth-func-random-rot"
-  ],
-  "citadel-sages": [
-    "*green-sagecage-sg*",
-    "citb-sage-draw-beam",
-    "*robotboss-sg*",
-    "*evilbro-citadel-sg*",
-    "*evilsis-citadel-sg*",
-    "*yellowsage-sg*",
-    "*bluesage-sg*",
-    "*redsage-sg*",
-    "citb-sagecage-init-by-other",
-    "citb-sagecage-idle",
-    "*citb-sagecage-sg*",
-    "citb-sagecage-update-collision",
-    "citb-sagecage-draw-bars",
-    "citb-sagecage",
-    "citb-sage",
-    "red-sagecage",
-    "blue-sagecage",
-    "yellow-sagecage",
-    "green-sagecage"
-  ],
-  "citb-bunny": [
-    "*citb-bunny-nav-enemy-info*",
-    "*citb-bunny-sg*",
-    "citb-bunny"
-  ],
-  "citb-drop-plat-CIT": [
-    "citb-drop-plat-idle",
-    "citb-drop-plat-spawn-children",
-    "citb-drop-plat-drop-children",
-    "citb-drop-plat-drop-all-children",
-    "citb-drop-plat-active",
-    "drop-plat-init-by-other",
-    "drop-plat-spawn",
-    "*citb-drop-plat-red-sg*",
-    "*citb-drop-plat-green-sg*",
-    "*citb-drop-plat-blue-sg*",
-    "*citb-drop-plat-yellow-sg*",
-    "*citb-drop-plat-sg*",
-    "drop-plat-set-fade",
-    "drop-plat-die",
-    "drop-plat-idle",
-    "drop-plat-drop",
-    "drop-plat-rise",
-    "drop-plat",
-    "handle-inline-array",
-    "citb-drop-plat"
-  ],
-  "citb-plat": [
-    "citb-exit-plat-idle",
-    "*citb-exit-plat-sg*",
-    "citb-exit-plat-move-player",
-    "citb-exit-plat-rise",
-    "*citb-firehose-sg*",
-    "citb-firehose-idle",
-    "citb-firehose-blast-particles",
-    "citb-firehose-active",
-    "citb-firehose-blast",
-    "*citb-stopbox-sg*",
-    "*citb-donut-sg*",
-    "*citb-rotatebox-sg*",
-    "*citb-chain-plat-sg*",
-    "*citb-chain-plat-constants*",
-    "citb-chain-plat-settle",
-    "*plat-citb-sg*",
-    "*plat-eco-citb-lit-sg*",
-    "*plat-eco-citb-unlit-sg*",
-    "citb-base-plat",
-    "citb-plat-eco",
-    "citb-plat",
-    "citb-stair-plat",
-    "citb-chain-plat",
-    "citb-rotatebox",
-    "citb-donut",
-    "citb-stopbox",
-    "citb-firehose",
-    "citb-exit-plat"
-  ],
-  "collectables": [
-    "collectable",
-    "eco-collectable",
-    "eco",
-    "eco-yellow",
-    "eco-red",
-    "eco-blue",
-    "health",
-    "eco-pill",
-    "money",
-    "fuel-cell",
-    "buzzer",
-    "ecovalve",
-    "vent",
-    "ventyellow",
-    "ventred",
-    "ventblue",
-    "ecovent",
-    "vent-wait-for-touch",
-    "vent-pickup",
-    "vent-standard-event-handler",
-    "vent-blocked",
-    "ecovalve-init-by-other",
-    "*ecovalve-sg*",
-    "ecovalve-idle",
-    "*eco-pill-count*",
-    "birth-pickup-at-point",
-    "*buzzer-sg*",
-    "fuel-cell-pick-anim",
-    "fuel-cell-clone-anim",
-    "*fuel-cell-tune-pos*",
-    "*fuel-cell-sg*",
-    "othercam-init-by-other",
-    "fuel-cell-animate",
-    "*money-sg*",
-    "add-blue-motion",
-    "check-blue-suck",
-    "initialize-eco-by-other",
-    "add-blue-shake",
-    "money-init-by-other",
-    "money-init-by-other-no-bob",
-    "fuel-cell-init-by-other",
-    "fuel-cell-init-as-clone",
-    "buzzer-init-by-other"
-  ],
-  "collectables-part": [
-    "eco-fadeout",
-    "eco-track-root-prim-fadeout",
-    "part-tracker-track-root",
-    "part-tracker-move-to-target",
-    "part-tracker-track-target",
-    "sparticle-track-root-money"
-  ],
-  "collide": ["*collide-vif0-init*"],
-  "collide-cache": [
-    "make-collide-list-using-line-sphere-inst-test",
-    "*already-printed-exeeded-max-cache-tris*",
-    "test-closest-pt-in-triangle",
-    "collide-puls-work",
-    "lsmi-work"
-  ],
-  "collide-cache-h": [
-    "*collide-work*",
-    "*collide-cache*",
-    "*collide-list*",
-    "collide-using-spheres-params",
-    "collide-puss-sphere",
-    "collide-puss-work",
-    "collide-puyp-work",
-    "collide-cache-tri",
-    "collide-cache-prim",
-    "collide-cache",
-    "collide-list-item",
-    "collide-list",
-    "collide-work"
-  ],
-  "collide-edge-grab": [
-    "*rotate-surface*",
-    "*no-walk-surface*",
-    "pbhp-stack-vars"
-  ],
-  "collide-edge-grab-h": [
-    "*collide-edge-work*",
-    "*edge-grab-info*",
-    "edge-grab-info",
-    "collide-edge-tri",
-    "collide-edge-edge",
-    "collide-edge-hold-item",
-    "collide-edge-hold-list",
-    "collide-edge-work"
-  ],
-  "collide-frag": ["sphere-cull"],
-  "collide-frag-h": [
-    "collide-frag-vertex",
-    "collide-frag-mesh",
-    "collide-fragment",
-    "drawable-inline-array-collide-fragment",
-    "drawable-tree-collide-fragment"
-  ],
-  "collide-func": [
-    "ray-sphere-intersect",
-    "raw-ray-sphere-intersect",
-    "ray-circle-intersect",
-    "ray-cylinder-intersect",
-    "ray-plane-intersect",
-    "ray-triangle-intersect",
-    "collide-do-primitives",
-    "moving-sphere-triangle-intersect",
-    "moving-sphere-sphere-intersect",
-    "moving-sphere-moving-sphere-intersect"
-  ],
-  "collide-h": ["*collide-test-flag*"],
-  "collide-mesh": ["sopt-work", "spat-work", "oot-work"],
-  "collide-mesh-h": [
-    "*collide-mesh-cache*",
-    "collide-tri-result",
-    "collide-mesh-tri",
-    "collide-mesh",
-    "collide-mesh-cache",
-    "collide-mesh-cache-tri"
-  ],
-  "collide-planes": [
-    "camera-bounding-box-draw",
-    "collide-planes-test0",
-    "collide-planes-test1",
-    "camera-cross",
-    "collide-planes-intersect",
-    "collide-planes"
-  ],
-  "collide-probe": [
-    "misty-ambush-height",
-    "distc",
-    "interpolate",
-    "collide-upload-vu0",
-    "collide-probe-instance-tie",
-    "collide-probe-node",
-    "collide-vu0-block",
-    "indent-to",
-    "probe-traverse-inline-array-node",
-    "probe-traverse-draw-node",
-    "creates-new-method?",
-    "overrides-parent-method?",
-    "describe-methods",
-    "probe-traverse-collide-fragment",
-    "*collide-probe-stack*",
-    "print-out",
-    "collide-probe-instance-tie-collide-frags",
-    "collide-probe-collide-fragment-tree-make-list",
-    "collide-probe-instance-tie-tree-make-list",
-    "collide-probe-make-list",
-    "misty-ambush-height-probe",
-    "pke-collide-test",
-    "collide-probe-stack-elem",
-    "collide-probe-stack"
-  ],
-  "collide-reaction-target": [
-    "collide-shape-moving-angle-set!",
-    "target-collision-low-coverage",
-    "poly-find-nearest-edge",
-    "target-collision-reaction",
-    "target-collision-no-reaction"
-  ],
-  "collide-shape": [
-    "*col-timer-enable*",
-    "*frame-timer*",
-    "*col-timer*",
-    "*race-track-surface*",
-    "target-attack-up",
-    "find-ground-point",
-    "default-collision-reaction",
-    "simple-collision-reaction",
-    "collide-shape-draw-debug-marks",
-    "debug-report-col-stats"
-  ],
-  "collide-shape-h": [
-    "*collide-hit-by-player-list*",
-    "*collide-usually-hit-by-player-list*",
-    "*collide-hit-by-others-list*",
-    "*collide-player-list*",
-    "*collide-shape-prim-backgnd*",
-    "*collide-shape-prim-water*",
-    "collide-sticky-rider",
-    "collide-sticky-rider-group",
-    "pull-rider-info",
-    "collide-shape-intersect",
-    "collide-overlap-result",
-    "overlaps-others-params",
-    "collide-prim-core",
-    "collide-shape-prim",
-    "collide-shape-prim-sphere",
-    "collide-shape-prim-mesh",
-    "collide-shape-prim-group",
-    "collide-shape",
-    "collide-shape-moving"
-  ],
-  "collide-target-h": ["collide-history", "control-info"],
-  "collide-touch": ["add-prims-touching-work"],
-  "collide-touch-h": [
-    "*touching-prims-entry-pool*",
-    "*touching-list*",
-    "touching-prim",
-    "touching-prims-entry",
-    "touching-prims-entry-pool",
-    "touching-shapes-entry",
-    "touching-list"
-  ],
-  "connect": [
-    "connection-process-apply",
-    "connectable",
-    "connection",
-    "engine"
-  ],
-  "crates": [
-    "crate-post",
-    "*crate-iron-sg*",
-    "*crate-steel-sg*",
-    "*crate-darkeco-sg*",
-    "*crate-barrel-sg*",
-    "*crate-bucket-sg*",
-    "*crate-wood-sg*",
-    "*CRATE-bank*",
-    "crate-standard-event-handler",
-    "crate-init-by-other",
-    "crate-bank",
-    "crate",
-    "barrel",
-    "bucket",
-    "crate-buzzer",
-    "pickup-spawner"
-  ],
-  "credits": [
-    "*title-credits-scale*",
-    "*title-credits-spacing*",
-    "set-credits-font-color",
-    "draw-title-credits",
-    "draw-end-credits"
-  ],
-  "cylinder": [
-    "ray-arbitrary-circle-intersect",
-    "camera-line",
-    "cylinder-verts",
-    "cylinder-flat-verts"
-  ],
-  "dark-crystal": [
-    "*dark-crystal-sg*",
-    "dark-crystal-spawn-fuel-cell",
-    "dark-crystal-idle",
-    "*dark-crystal-explode-sg*",
-    "*dark-crystal-exploder-params*",
-    "*dark-crystal-flash-delays*",
-    "dark-crystal-explode",
-    "dark-crystal-activate",
-    "dark-crystal"
-  ],
-  "dark-eco-pool": [
-    "ripple-for-dark-eco-pool",
-    "ripple-for-misty-dark-eco-pool",
-    "ripple-for-maincave-dark-eco-pool",
-    "ripple-for-sunken-dark-eco-helix-room",
-    "ripple-for-finalboss-dark-eco-pool",
-    "dark-eco-pool"
-  ],
-  "darkcave-obs": [
-    "*cavecrystal-sg*",
-    "*cavecrystal-light-control*",
-    "cavecrystal-idle",
-    "cavecrystal-active",
-    "cavecrystal"
-  ],
-  "darkvine": [
-    "*darkvine-sg*",
-    "darkvine-die",
-    "darkvine-idle",
-    "darkvine-retreat",
-    "darkvine-event-handler",
-    "darkvine"
-  ],
-  "debug": [
-    "debug-set-camera-pos-rot!",
-    "drawable-frag-count",
-    "add-debug-light",
-    "add-debug-vector",
-    "add-debug-text-3d",
-    "add-debug-x",
-    "add-debug-curve",
-    "add-debug-sphere",
-    "get-debug-text-3d",
-    "internal-draw-debug-text-3d",
-    "get-debug-line",
-    "internal-draw-debug-line",
-    "*debug-lines*",
-    "*debug-lines-trk*",
-    "*debug-text-3ds*",
-    "*debug-text-3d-trk*",
-    "draw-string",
-    "transform-float-point",
-    "add-debug-point",
-    "add-debug-outline-triangle",
-    "add-debug-triangle-normal",
-    "add-debug-flat-triangle",
-    "debug-reset-buffers",
-    "debug-draw-buffers",
-    "add-debug-line2d",
-    "add-debug-box",
-    "add-debug-sphere-with-transform",
-    "add-debug-spheres",
-    "add-debug-circle",
-    "add-debug-rot-matrix",
-    "add-debug-yrot-vector",
-    "add-debug-arc",
-    "add-debug-curve2",
-    "add-debug-points",
-    "debug-percent-bar",
-    "debug-pad-display",
-    "add-debug-lights",
-    "history-init",
-    "history-draw-and-update",
-    "dma-timeout-cam",
-    "display-file-info",
-    "debug-line",
-    "debug-text-3d",
-    "debug-tracking-thang"
-  ],
-  "debug-h": ["pos-history", "debug-vertex", "debug-vertex-stats"],
-  "debug-sphere": [
-    "*debug-sphere-table*",
-    "add-debug-line",
-    "make-debug-sphere-table",
-    "add-debug-sphere-from-table",
-    "debug-sphere-table"
-  ],
-  "decomp": ["unpack-comp-rle", "unpack-comp-huf", "huf-dictionary-node"],
-  "decomp-h": ["decomp-work"],
-  "default-menu": [
-    "*popup-menu-context*",
-    "build-continue-menu",
-    "debug-menu-make-camera-menu",
-    "debug-menu-make-shader-menu",
-    "debug-menu-make-instance-menu",
-    "debug-menu-make-task-menu",
-    "dm-current-continue",
-    "dm-task-get-money",
-    "dm-levitator-ready",
-    "dm-lavabike-ready",
-    "dm-give-all-cells",
-    "debug-menu-make-task-unknown-menu",
-    "debug-menu-make-task-need-hint-menu",
-    "debug-menu-make-task-need-introduction-menu",
-    "debug-menu-make-task-need-reminder-a-menu",
-    "debug-menu-make-task-need-reminder-menu",
-    "debug-menu-make-task-need-reward-speech-menu",
-    "debug-menu-make-task-need-resolution-menu",
-    "dm-give-cell",
-    "*instance-shrub-menu*",
-    "*instance-tie-menu*",
-    "build-instance-list",
-    "dm-edit-instance-toggle-pick-func",
-    "*enable-instance-tie-menu*",
-    "dm-boolean-toggle-pick-func",
-    "*shader-pick-menu*",
-    "build-shader-list",
-    "all-texture-tweak-adjust",
-    "debug-menu-make-camera-mode-menu",
-    "dm-cam-externalize",
-    "dm-cam-render-float",
-    "dm-cam-settings-func",
-    "dm-cam-settings-func-int",
-    "debug-create-cam-restore",
-    "dm-cam-mode-func",
-    "cam-robotboss",
-    "dm-instance-pick-func",
-    "dm-enable-instance-func",
-    "dm-shader-pick-func",
-    "debug-menu-node<?",
-    "*dm-cam-mode-interpolation*",
-    "dm-subdiv-float",
-    "dm-subdiv-int",
-    "dm-setting-language",
-    "dm-subdiv-draw-func",
-    "dm-ocean-subdiv-draw-func",
-    "dm-time-of-day-func",
-    "dm-time-of-day-func2",
-    "dm-time-of-day-pick-func",
-    "dm-actor-marks-pick-func",
-    "dm-compact-actor-pick-func",
-    "dm-actor-vis-pick-func",
-    "dm-game-mode-pick-func",
-    "dm-vu1-user-toggle-pick-func",
-    "dm-vu1-user-set-pick-func",
-    "dm-texture-user-toggle-pick-func",
-    "dm-texture-user-set-pick-func",
-    "dm-strip-lines-toggle-pick-func",
-    "dm-strip-lines-set-pick-func",
-    "dm-task-unknown",
-    "dm-task-hint",
-    "dm-task-introduction",
-    "dm-task-reminder-a",
-    "dm-task-reminder",
-    "dm-task-reward-speech",
-    "dm-task-resolution",
-    "dm-anim-tester-flag-func",
-    "dm-anim-tester-func",
-    "debug-menu-context-make-default-menus",
-    "popup-menu-context-make-default-menus"
-  ],
-  "demo-obs": ["static-screen-spawn"],
-  "depth-cue": [
-    "depth-cue-draw-front",
-    "*depth-cue-work*",
-    "depth-cue-set-stencil",
-    "depth-cue-draw-depth",
-    "depth-cue-calc-z",
-    "depth-cue"
-  ],
-  "depth-cue-h": ["depth-cue-data", "depth-cue-work"],
-  "dgo-h": ["dgo-entry", "dgo-file"],
-  "display": [
-    "draw-quad2d",
-    "set-display-env",
-    "set-draw-env",
-    "get-video-mode",
-    "*profile-y*",
-    "*profile-h*",
-    "*profile-x*",
-    "*profile-w*",
-    "*profile-ticks*",
-    "draw-string-xy",
-    "set-draw-env-offset",
-    "put-display-alpha-env",
-    "set-display2",
-    "allocate-dma-buffers",
-    "*font-context*",
-    "*pause-context*",
-    "draw-sprite2d-xy",
-    "screen-gradient",
-    "vif1-handler-debug",
-    "vif1-handler",
-    "install-handler",
-    "*vblank-counter*",
-    "vblank-handler",
-    "*oddeven*",
-    "set-display-gs-state",
-    "set-display-gs-state-offset",
-    "reset-display-gs-state",
-    "*vu0-dma-list*"
-  ],
-  "display-h": [
-    "set-display",
-    "put-draw-env",
-    "*pre-draw-hook*",
-    "*post-draw-hook*",
-    "display-env",
-    "draw-env",
-    "display-frame",
-    "virtual-frame",
-    "display"
-  ],
-  "dma": [
-    "flush-cache",
-    "dma-sync",
-    "reset-path",
-    "reset-graph",
-    "*video-reset-parm*",
-    "dma-sync-hang",
-    "dma-sync-crash",
-    "dma-send",
-    "dma-send-chain",
-    "dma-send-chain-no-tte",
-    "dma-send-chain-no-flush",
-    "dma-send-to-spr",
-    "dma-send-to-spr-no-flush",
-    "dma-send-from-spr",
-    "dma-send-from-spr-no-flush",
-    "dma-initialize",
-    "clear-vu0-mem",
-    "clear-vu1-mem",
-    "dump-vu1-mem",
-    "dump-vu1-range",
-    "reset-vif1-path",
-    "ultimate-memcpy",
-    "symlink2",
-    "symlink3"
-  ],
-  "dma-bucket": [
-    "dma-buffer-add-buckets",
-    "dma-buffer-patch-buckets",
-    "dma-bucket-insert-tag"
-  ],
-  "dma-buffer": [
-    "dma-buffer-length",
-    "dma-buffer-inplace-new",
-    "dma-buffer-free",
-    "dma-buffer-add-vu-function",
-    "dma-buffer-send",
-    "dma-buffer-send-chain",
-    "dma-packet",
-    "dma-packet-array",
-    "dma-gif-packet",
-    "dma-buffer"
-  ],
-  "dma-disasm": [
-    "disasm-dma-tag",
-    "disasm-vif-tag",
-    "*vif-disasm-table*",
-    "disasm-vif-details",
-    "*dma-disasm*",
-    "disasm-dma-list",
-    "vif-disasm-element"
-  ],
-  "dma-h": [
-    "uint16",
-    "dma-sync-fast",
-    "dma-send-no-scratch",
-    "dma-sync-with-count",
-    "dma-count-until-done",
-    "dma-chcr",
-    "dma-bank",
-    "dma-bank-source",
-    "dma-bank-vif",
-    "dma-bank-spr",
-    "dma-ctrl",
-    "dma-enable",
-    "dma-sqwc",
-    "dma-bank-control",
-    "vu-code-block",
-    "vu-stat",
-    "dma-tag",
-    "dma-bucket",
-    "vif-mask",
-    "vif-stcycl-imm",
-    "vif-unpack-imm",
-    "vif-tag"
-  ],
-  "double-lurker": [
-    "double-lurker-waiting-to-die",
-    "*double-lurker-sg*",
-    "*double-lurker-when-both-nav-enemy-info*",
-    "double-lurker-top-init-by-other",
-    "*double-lurker-nav-enemy-info*",
-    "double-lurker-resume",
-    "double-lurker-break-apart",
-    "double-lurker-buddy-was-hit",
-    "double-lurker-both-knocked-back",
-    "double-lurker-top-on-shoulders",
-    "double-lurker-top-resume",
-    "*double-lurker-top-sg*",
-    "*double-lurker-top-nav-enemy-info*",
-    "double-lurker-top-knocked-down",
-    "double-lurker-top-on-shoulders-die",
-    "double-lurker-default-event-handler",
-    "double-lurker-show-anims",
-    "double-lurker-knocked-back",
-    "double-lurker-top",
-    "double-lurker"
-  ],
-  "draw-node": [
-    "collide-cache-using-line-sphere-test",
-    "collide-cache-using-y-probe-test",
-    "collide-cache-using-box-test",
-    "draw-node-cull"
-  ],
-  "draw-node-h": ["draw-node", "drawable-inline-array-node", "draw-node-dma"],
-  "drawable": [
-    "display-frame-finish",
-    "display-sync",
-    "syncv",
-    "put-display-env",
-    "*surrogate-dma-buffer*",
-    "determine-pause-mode",
-    "display-frame-start",
-    "toggle-pause",
-    "deactivate-progress",
-    "*screen-shot*",
-    "debug-init-buffer",
-    "real-main-draw-hook",
-    "*hud-lights*",
-    "error-sphere",
-    "draw-instance-info",
-    "*edit-instance*",
-    "find-instance-by-name",
-    "prototype-bucket-type",
-    "*instance-mem-usage*",
-    "guard-band-cull",
-    "find-instance-by-index",
-    "prototype-bucket-recalc-fields",
-    "dma-add-process-drawable-hud",
-    "foreground-engine-execute",
-    "main-debug-hook",
-    "*add-sphere*",
-    "*generic-effect-mode*",
-    "main-draw-hook",
-    "swap-display",
-    "marks-cam-restore",
-    "eddie-cam-restore",
-    "gregs-jungle-cam-restore",
-    "gregs-village1-cam-restore",
-    "gregs-texture-cam-restore",
-    "gregs-texture2-cam-restore",
-    "cave-cam-restore",
-    "paals-cam-restore"
-  ],
-  "drawable-actor-h": [
-    "drawable-actor",
-    "drawable-tree-actor",
-    "drawable-inline-array-actor"
-  ],
-  "drawable-ambient-h": [
-    "drawable-ambient",
-    "drawable-tree-ambient",
-    "drawable-inline-array-ambient",
-    "level-hint",
-    "ambient-list"
-  ],
-  "drawable-group-h": ["*collide-nodes*", "drawable-group"],
-  "drawable-h": ["drawable", "drawable-error"],
-  "drawable-inline-array-h": ["drawable-inline-array"],
-  "drawable-tree-h": ["drawable-tree", "drawable-tree-array"],
-  "driller-lurker": [
-    "*driller-lurker-sg*",
-    "*driller-lurker-shadow-control*",
-    "driller-lurker-idle-drilling",
-    "driller-lurker-patrol",
-    "driller-lurker-chase",
-    "driller-lurker-jammed-standing",
-    "driller-lurker-attack",
-    "driller-lurker-patrol-pause",
-    "driller-lurker-die",
-    "driller-lurker-default-event-handler",
-    "driller-lurker-debug-play-anims",
-    "driller-lurker"
-  ],
-  "dynamics-h": [
-    "time-to-apex",
-    "time-to-ground",
-    "*standard-dynamics*",
-    "dynamics"
-  ],
-  "effect-control": ["sound-name-with-material", "*footstep-surface*"],
-  "effect-control-h": ["effect-control"],
-  "engines": [
-    "*background-draw-engine*",
-    "*matrix-engine*",
-    "*camera-engine*",
-    "*debug-engine*"
-  ],
-  "entity": [
-    "*compact-actors*",
-    "*vis-actors*",
-    "task-control-reset",
-    "init-entity",
-    "birth-viewer",
-    "update-actor-vis-box",
-    "process-status-bits",
-    "entity-by-meters",
-    "entity-process-count",
-    "entity-count",
-    "entity-remap-names",
-    "expand-vis-box-with-point",
-    "entity-task-complete-on",
-    "entity-task-complete-off",
-    "entity-speed-test"
-  ],
-  "entity-h": [
-    "*generate-actor-vis*",
-    "*generate-actor-vis-start*",
-    "*generate-actor-vis-output*",
-    "entity-nav-login",
-    "*ACTOR-bank*",
-    "entity-perm",
-    "entity-links",
-    "entity-perm-array",
-    "entity-links-array",
-    "entity",
-    "entity-camera",
-    "entity-ambient-data",
-    "entity-ambient-data-array",
-    "entity-ambient",
-    "entity-actor",
-    "entity-info",
-    "actor-bank"
-  ],
-  "entity-table": ["*entity-info*", "entity-info-lookup"],
-  "euler": ["matrix->eul", "eul->matrix", "set-eul!", "eul->quat", "quat->eul"],
-  "euler-h": ["EulSafe", "EulNext", "euler-angles"],
-  "evilbro": ["*evilsis-intro-sg*", "*evilbro-intro-sg*", "evilbro", "evilsis"],
-  "explorer": ["*explorer-sg*", "explorer"],
-  "eye": ["convert-eye-data", "*eye-work*", "render-eyes", "update-eyes"],
-  "eye-h": [
-    "*eye-control-array*",
-    "eye",
-    "eye-control",
-    "eye-control-array",
-    "eye-work"
-  ],
-  "fact-h": [
-    "process-drawable-art-error",
-    "*FACT-bank*",
-    "pickup-type->string",
-    "fact-bank",
-    "fact-info",
-    "fact-info-target",
-    "fact-info-enemy"
-  ],
-  "farmer": ["*farmer-sg*", "farmer"],
-  "file-io": [
-    "*file-temp-string*",
-    "file-stream-read",
-    "file-stream-open",
-    "file-stream-length",
-    "file-stream-read-string",
-    "make-file-name",
-    "make-vfile-name",
-    "file-info-correct-version?",
-    "file-stream",
-    "file-info"
-  ],
-  "final-door": [
-    "powercellalt-init-by-other",
-    "*powercellalt-sg*",
-    "*power-right-sg*",
-    "*power-left-sg*",
-    "fin-door",
-    "final-door",
-    "power-left",
-    "power-right",
-    "powercellalt"
-  ],
-  "firecanyon-obs": [
-    "*crate-darkeco-cluster-sg*",
-    "*spike-sg*",
-    "spike-down",
-    "spike-idle",
-    "spike-up",
-    "balloon-idle",
-    "balloon-popping",
-    "balloon",
-    "spike",
-    "crate-darkeco-cluster"
-  ],
-  "firecanyon-part": ["firecanyon-part"],
-  "fisher-JUN": [
-    "*fish-net-sg*",
-    "*fisher-sg*",
-    "*FISHER-bank*",
-    "fisher-fish-water",
-    "fisher-playing",
-    "*fisher-params*",
-    "fisher-game-update",
-    "fisher-done",
-    "fisher-draw-display",
-    "fisher-spawn-ambient",
-    "fisher-fish-init-by-other",
-    "*catch-fishc-sg*",
-    "*catch-fishb-sg*",
-    "*catch-fisha-sg*",
-    "fisher-fish-fall",
-    "fisher-fish-move",
-    "fisher-fish-caught",
-    "fisher-fish-die",
-    "fisher-bank",
-    "fisher-params",
-    "fisher",
-    "fisher-fish"
-  ],
-  "fishermans-boat": [
-    "fishermans-boat-spawn-particles",
-    "fishermans-boat-play-sounds",
-    "fishermans-boat-reset-physics",
-    "fishermans-boat-docked-village",
-    "*fb-evilbro-sg*",
-    "*fb-evilsis-sg*",
-    "fishermans-boat-docked-misty",
-    "*fishermans-boat-sg*",
-    "*boat-turning-radius-table*",
-    "*boat-throttle-control-table*",
-    "fishermans-boat-set-dock-point",
-    "fishermans-boat-set-path-point",
-    "fishermans-boat-next-path-point",
-    "*fishermans-boat-constants*",
-    "fishermans-boat-set-throttle-by-speed",
-    "fishermans-boat-player-control",
-    "fishermans-boat-entering-village",
-    "fishermans-boat-entering-misty",
-    "fishermans-boat-enter-dock?",
-    "fishermans-boat-leave-dock?",
-    "fishermans-boat-ride-to-village1",
-    "fishermans-boat-ride-to-misty",
-    "fishermans-boat-wave",
-    "fishermans-boat-post",
-    "fishermans-boat-leaving-village",
-    "fishermans-boat-leaving-misty",
-    "fishermans-boat-measurements",
-    "boat-stabilizer",
-    "vehicle-path",
-    "vehicle-controller",
-    "fishermans-boat"
-  ],
-  "floating-launcher": [
-    "*floating-launcher-sg*",
-    "floating-launcher-idle",
-    "floating-launcher-ready",
-    "floating-launcher-lowering",
-    "floating-launcher"
-  ],
-  "flutflut": [
-    "*flutflut-sg*",
-    "*flutflut-shadow-control*",
-    "flutflut-effect",
-    "flutflut"
-  ],
-  "flutflut-bluehut": ["*flutflut-bluehut-sg*", "flutflut-bluehut"],
-  "flying-lurker": [
-    "*flying-lurker-sg*",
-    "play-movie?",
-    "flying-lurker-move",
-    "flying-lurker-rotate",
-    "flying-lurker-die",
-    "flying-lurker-idle",
-    "first?",
-    "flying-lurker-start",
-    "flying-lurker-clone",
-    "flying-lurker-handler",
-    "flying-lurker-sleep",
-    "flying-lurker-play-intro",
-    "flying-lurker-inc-try-count",
-    "*ogrecam-sg*",
-    "flying-lurker-fly",
-    "flying-lurker-calc-anim-speed",
-    "flying-lurker-calc-speed",
-    "*plunger-lurker-sg*",
-    "plunger-lurker-die",
-    "plunger-lurker-idle",
-    "plunger-lurker-flee",
-    "plunger-lurker-plunge",
-    "plunger-lurker",
-    "flying-lurker"
-  ],
-  "font": [
-    "*font12-table*",
-    "*font24-table*",
-    "get-string-length",
-    "draw-string-adv"
-  ],
-  "font-h": [
-    "*font-default-matrix*",
-    "*font-work*",
-    "font-set-tex0",
-    "char-verts",
-    "char-color",
-    "font-context",
-    "font-work"
-  ],
-  "gambler": ["*gambler-sg*", "gambler"],
-  "game-h": [
-    "*global-attack-id*",
-    "process-drawable",
-    "process-drawable-reserved",
-    "attack-info",
-    "ground-tween-info"
-  ],
-  "game-info": [
-    "*level-task-data-remap*",
-    "get-task-control",
-    "level-hint-spawn",
-    "get-game-count",
-    "activate-orb-all",
-    "close-specific-task!",
-    "reset-all-hint-controls",
-    "*kernel-boot-message*",
-    "reset-actors",
-    "*spawn-actors*",
-    "set-blackout-frames",
-    "set-master-mode",
-    "stop",
-    "start",
-    "*default-continue*",
-    "position-in-front-of-camera!",
-    "*level-load-list*",
-    "game-task->string",
-    "trsq->continue-point"
-  ],
-  "game-info-h": [
-    "*GAME-bank*",
-    "*game-info*",
-    "game-bank",
-    "actor-id",
-    "level-buffer-state",
-    "load-state",
-    "continue-point",
-    "game-info"
-  ],
-  "game-save": [
-    "*auto-save-info*",
-    "auto-save-command",
-    "auto-save-init-by-other",
-    "progress-allowed?",
-    "print-game-text",
-    "get-aspect-ratio",
-    "get-task-status",
-    "lookup-level-info",
-    "calculate-completion",
-    "scf-get-time",
-    "*level-task-data*",
-    "game-save-elt->string",
-    "progress-level-index->string",
-    "auto-save-post",
-    "auto-save-check",
-    "game-save-tag",
-    "game-save",
-    "auto-save"
-  ],
-  "gcommon": [
-    "format",
-    "#f",
-    "structure",
-    "pair",
-    "binteger",
-    "type",
-    "valid?",
-    "type-type?",
-    "symbol",
-    "fact",
-    "array",
-    "number",
-    "integer",
-    "float",
-    "object",
-    "delete-car!",
-    "nmember",
-    "name=",
-    "nothing",
-    "identity",
-    "1/",
-    "+",
-    "-",
-    "*",
-    "/",
-    "ash",
-    "mod",
-    "rem",
-    "abs",
-    "min",
-    "max",
-    "logior",
-    "logand",
-    "lognor",
-    "logxor",
-    "lognot",
-    "false-func",
-    "true-func",
-    "_format",
-    "uint128",
-    "method-set!",
-    "basic",
-    "basic-type?",
-    "find-parent-method",
-    "ref",
-    "last",
-    "member",
-    "assoc",
-    "assoce",
-    "nassoc",
-    "nassoce",
-    "append!",
-    "delete!",
-    "insert-cons!",
-    "sort",
-    "mem-copy!",
-    "qmem-copy<-!",
-    "qmem-copy->!",
-    "mem-set32!",
-    "mem-or!",
-    "quad-copy!",
-    "*print-column*",
-    "print",
-    "printl",
-    "inspect",
-    "*debug-segment*",
-    "mem-print",
-    "*trace-list*",
-    "print-tree-bitmask",
-    "breakpoint-range-set!",
-    "vec4s",
-    "bfloat",
-    "inline-array-class"
-  ],
-  "generic": [
-    "*generic-foreground-sinks*",
-    "generic-init-buf",
-    "generic-dma-foreground-sink-init",
-    "generic-init-buffers",
-    "generic-sink"
-  ],
-  "generic-effect": [
-    "generic-work-init",
-    "generic-upload-vu0",
-    "upload-vu0-program",
-    "*generic-consts*",
-    "*generic-envmap-texture*",
-    "*target-lock*",
-    "generic-initialize-without-sink",
-    "generic-initialize",
-    "generic-wrapup",
-    "generic-dma-from-spr",
-    "generic-light-proc",
-    "generic-envmap-proc",
-    "generic-prepare-dma-double",
-    "generic-prepare-dma-single",
-    "generic-envmap-dproc",
-    "generic-interp-dproc",
-    "generic-no-light-proc",
-    "generic-no-light-dproc-only",
-    "generic-no-light-dproc",
-    "generic-no-light+envmap",
-    "generic-no-light",
-    "generic-envmap-only-proc",
-    "generic-light",
-    "generic-copy-vtx-dclr-dtex",
-    "generic-none",
-    "generic-none-dma-wait",
-    "generic-debug-light-proc",
-    "generic-post-debug"
-  ],
-  "generic-h": [
-    "gsf-vertex-array",
-    "gsf-fx-vertex-array",
-    "kmalloc",
-    "*gsf-buffer*",
-    "gsf-vertex",
-    "gsf-fx-vertex",
-    "gsf-header",
-    "gsf-ik",
-    "gsf-info",
-    "gsf-buffer",
-    "generic-frag",
-    "generic-strip",
-    "generic-envmap-saves",
-    "generic-interp-job",
-    "generic-saves",
-    "generic-gif-tag",
-    "ad-cmd",
-    "generic-envmap-consts",
-    "generic-consts",
-    "generic-storage"
-  ],
-  "generic-merc": [
-    "mercneric-vu0-block",
-    "*inv-init-table*",
-    "generic-merc-init-asm",
-    "mercneric-matrix-asm",
-    "mercneric-shader-asm",
-    "mercneric-bittable-asm",
-    "mercneric-convert",
-    "high-speed-reject",
-    "generic-merc-execute-asm",
-    "generic-merc-add-to-cue",
-    "generic-merc-execute-all",
-    "invinitdata"
-  ],
-  "generic-merc-h": [
-    "merc-matrix",
-    "generic-merc-tag",
-    "generic-merc-ctrl",
-    "generic-merc-ctrl-with-sfx",
-    "generic-merc-input",
-    "generic-merc-output",
-    "generic-merc-dcache",
-    "gm-shadow",
-    "generic-merc-work"
-  ],
-  "generic-obs": [
-    "line-in-view-frustum?",
-    "*particle-quat*",
-    "process-drawable-random-point!",
-    "touch-tracker-idle",
-    "cam-launcher-longfall",
-    "cam-launcher-shortfall",
-    "launcher-idle",
-    "process-drawable-from-entity!",
-    "launcher-deactivated",
-    "launcher-active",
-    "cam-launcher-long-joystick",
-    "beach-part-grotto-1",
-    "part-spawner-active",
-    "*lev-string*",
-    "med-res-level-idle",
-    "camera-tracker-process",
-    "hide-hud-quick",
-    "command-get-process",
-    "camera-change-to",
-    "camera-look-at",
-    "camera-pov-from",
-    "command-get-trans",
-    "manipy-init",
-    "part-tracker-process",
-    "part-tracker-notify",
-    "manipy-idle",
-    "clone-anim-once",
-    "convert-to-hud-object",
-    "swingpole-stance",
-    "swingpole-active",
-    "merc-eye-anim",
-    "clone-anim",
-    "command-get-camera",
-    "ja-anim-done?",
-    "camera-anim",
-    "camera-tracker-init",
-    "cam-launcher-joystick",
-    "launcher-init-by-other",
-    "touch-tracker-init",
-    "process-drawable-pair-random-point!",
-    "birth-func-set-quat",
-    "draw-eco-beam",
-    "target-start",
-    "camera-start",
-    "med-res-level",
-    "launcher"
-  ],
-  "generic-obs-h": [
-    "manipy",
-    "part-spawner",
-    "part-tracker",
-    "camera-tracker",
-    "touch-tracker",
-    "swingpole",
-    "gui-query",
-    "othercam",
-    "process-hidden"
-  ],
-  "generic-tie": [
-    "generic-tie-dma-to-spad",
-    "generic-tie-dma-to-spad-sync",
-    "*generic-tie*",
-    "generic-tie-decompress",
-    "generic-tie-upload-next",
-    "generic-tie-convert-proc",
-    "generic-tie-convert",
-    "generic-tie-display-stats",
-    "generic-tie-debug",
-    "generic-tie-execute"
-  ],
-  "generic-tie-h": [
-    "generic-tie-instance",
-    "generic-tie-input",
-    "generic-tie-run-control",
-    "generic-tie-base-point",
-    "generic-tie-bps",
-    "generic-tie-interp-point",
-    "generic-tie-ips",
-    "generic-tie-header",
-    "generic-tie-matrix",
-    "generic-tie-normal",
-    "generic-tie-control",
-    "generic-tie-stats",
-    "generic-tie-calls",
-    "generic-tie-shadow",
-    "generic-tie-work"
-  ],
-  "generic-vu0": ["generic-vu0-block"],
-  "generic-vu1": [
-    "generic-vu1-block",
-    "generic-add-constants",
-    "generic-setup-constants",
-    "generic-reset-buffers"
-  ],
-  "generic-vu1-h": ["pris-mtx", "generic-pris-mtx-save", "generic-constants"],
-  "generic-work-h": [
-    "*generic-debug*",
-    "generic-input-buffer",
-    "generic-debug",
-    "generic-vu1-header",
-    "generic-vu1-texbuf",
-    "generic-texbuf",
-    "generic-effect-work",
-    "generic-effect-buffer",
-    "generic-work"
-  ],
-  "geologist": ["*geologist-sg*", "geologist"],
-  "geometry": [
-    "curve-length",
-    "curve-get-pos!",
-    "vector-vector-distance-squared",
-    "curve-evaluate!",
-    "vector-vector-distance",
-    "circle-circle-xz-intersect",
-    "vector-normalize-copy!",
-    "forward-up->quaternion",
-    "matrix-from-two-vectors-partial-linear!",
-    "matrix-from-two-vectors-max-angle!",
-    "vector-negate!",
-    "vector-normalize-ret-len!",
-    "vector-flatten!",
-    "vector-normalize!",
-    "vector-cross!",
-    "forward-down->inv-matrix",
-    "forward-up-nopitch->inv-matrix",
-    "forward-down-nopitch->inv-matrix",
-    "vector-float*!",
-    "vector+float*!",
-    "vector-reflect!",
-    "vector-reflect-flat!",
-    "vector-reflect-true-flat!",
-    "vector-reflect-flat-above!",
-    "vector-segment-distance-point!",
-    "vector-line-distance",
-    "vector-line-distance-point!",
-    "vector-orient-by-quat!",
-    "forward-up-nopitch->quaternion",
-    "quaternion-from-two-vectors!",
-    "matrix-from-two-vectors!",
-    "matrix-from-two-vectors-max-angle-partial!",
-    "matrix-remove-z-rot",
-    "matrix-rot-diff!",
-    "quaternion-seek",
-    "vector-deg-seek",
-    "vector-deg-slerp",
-    "vector-vector-deg-slerp!",
-    "normal-of-plane",
-    "vector-3pt-cross!",
-    "closest-pt-in-triangle",
-    "point-in-triangle-cross",
-    "point-in-plane-<-point+normal!",
-    "circle-test",
-    "vector-circle-tangent-new",
-    "vector-circle-tangent",
-    "find-knot-span",
-    "calculate-basis-functions-vector!",
-    "curve-copy!",
-    "curve-closest-point",
-    "vector-plane-distance"
-  ],
-  "geometry-h": ["curve", "border-plane"],
-  "gkernel": [
-    "dead-state",
-    "entity-deactivate-handler",
-    "process-disconnect",
-    "*kernel-context*",
-    "throw",
-    "set-to-run-bootstrap",
-    "change-parent",
-    "inspect-process-tree",
-    "*listener-function*",
-    "*enable-method-set*",
-    "reset-and-call",
-    "*listener-process*",
-    "execute-process-tree",
-    "*active-pool*",
-    "*stdcon1*",
-    "*stdcon*",
-    "*debug-draw-pauseable*",
-    "*stdcon0*",
-    "*dram-stack*",
-    "search-process-tree",
-    "iterate-process-tree",
-    "*global-search-name*",
-    "process-not-name",
-    "process-by-name",
-    "*global-search-count*",
-    "*null-kernel-context*",
-    "*null-process*",
-    "process",
-    "*debug-dead-pool*",
-    "*vis-boot*",
-    "inspect-process-heap",
-    "*kernel-packages*",
-    "dgo-load",
-    "*kernel-version*",
-    "*irx-version*",
-    "*kernel-boot-mode*",
-    "*kernel-boot-level*",
-    "*deci-count*",
-    "*last-loado-length*",
-    "*last-loado-global-usage*",
-    "*last-loado-debug-usage*",
-    "load-package",
-    "unload-package",
-    "malloc",
-    "remove-exit",
-    "stream<-process-mask",
-    "*master-mode*",
-    "*pause-lock*",
-    "return-from-thread",
-    "return-from-thread-dead",
-    "process-count",
-    "kill-by-name",
-    "kill-by-type",
-    "kill-not-name",
-    "kill-not-type",
-    "kernel-dispatcher",
-    "throw-dispatch",
-    "previous-brother",
-    "change-brother",
-    "change-to-last-brother",
-    "run-function-in-process",
-    "set-to-run",
-    "*16k-dead-pool*",
-    "*8k-dead-pool*",
-    "*4k-dead-pool*",
-    "*target-dead-pool*",
-    "*camera-dead-pool*",
-    "*camera-master-dead-pool*",
-    "*nk-dead-pool*",
-    "*default-dead-pool*",
-    "*pickup-dead-pool*",
-    "*dead-pool-list*",
-    "*display-pool*",
-    "*camera-pool*",
-    "*target-pool*",
-    "*entity-pool*",
-    "*default-pool*"
-  ],
-  "gkernel-h": [
-    "process-tree",
-    "stack-frame",
-    "uint64",
-    "kernel-context",
-    "thread",
-    "cpu-thread",
-    "dead-pool",
-    "dead-pool-heap-rec",
-    "dead-pool-heap",
-    "catch-frame",
-    "protect-frame",
-    "handle",
-    "state",
-    "event-message-block"
-  ],
-  "glist": [
-    "glst-num-elements",
-    "glst-insert-after",
-    "glst-insert-before",
-    "glst-remove",
-    "glst-remove-tail",
-    "glst-remove-head",
-    "glst-add-tail",
-    "glst-add-head",
-    "glst-init-list!",
-    "glst-find-node-by-name",
-    "glst-get-node-by-index",
-    "glst-length-of-longest-name",
-    "glst-get-node-index"
-  ],
-  "glist-h": [
-    "glst-next",
-    "glst-prev",
-    "glst-head",
-    "glst-tail",
-    "glst-end-of-list?",
-    "glst-start-of-list?",
-    "glst-empty?",
-    "glst-node-name",
-    "glst-set-name!",
-    "glst-node",
-    "glst-named-node",
-    "glst-list"
-  ],
-  "gnawer": [
-    "*gnawer-sg*",
-    "gnawer-put-items-at-dest",
-    "gnawer-chewing-on-post",
-    "*gnawer-segment-infos*",
-    "gnawer-give-fuel-cell",
-    "gnawer-dying-give-pickups",
-    "gnawer-wait-to-run",
-    "gnawer-die",
-    "gnawer-run",
-    "gnawer-retreat-into-post",
-    "gnawer-falling-segment-init-by-other",
-    "gnawer-joint-callback",
-    "*gnawer-segment-sg*",
-    "gnawer-falling-segment",
-    "gnawer-segment-info",
-    "gnawer-segment",
-    "gnawer-route",
-    "gnawer"
-  ],
-  "green-eco-lurker": [
-    "spawn-minions",
-    "green-eco-lurker-init-by-other",
-    "green-eco-lurker-wait-to-appear",
-    "*green-eco-lurker-sg*",
-    "*green-eco-lurker-nav-enemy-info*",
-    "green-eco-lurker-appear-land",
-    "green-eco-lurker-appear",
-    "green-eco-lurker-tune-spheres",
-    "green-eco-lurker-gen-init-by-other",
-    "green-eco-lurker",
-    "green-eco-lurker-gen"
-  ],
-  "gs": [
-    "*fog-color*",
-    "psm-size",
-    "psm-page-height",
-    "psm->string",
-    "*default-regs-buffer*",
-    "default-buffer-init",
-    "open-gif-packet",
-    "add-reg-gif-packet",
-    "close-gif-packet",
-    "draw-context-set-xy",
-    "gs-pmode",
-    "gs-smode2",
-    "gs-display-fb",
-    "gs-display",
-    "gs-bgcolor",
-    "gs-csr",
-    "gs-bank",
-    "gs-frame",
-    "gs-zbuf",
-    "gs-xy-offset",
-    "gs-scissor",
-    "gs-prmode-cont",
-    "gs-color-clamp",
-    "gs-dthe",
-    "gs-test",
-    "gs-prim",
-    "gs-rgbaq",
-    "gs-xyz",
-    "gs-uv",
-    "gs-st",
-    "gs-xyzf",
-    "gs-trxpos",
-    "gs-trxreg",
-    "gs-trxdir",
-    "gs-bitbltbuf",
-    "gs-tex0",
-    "gs-tex1",
-    "gs-texa",
-    "gs-texclut",
-    "gs-miptbp",
-    "gs-alpha",
-    "gs-clamp",
-    "gs-fog",
-    "gs-fogcol",
-    "gif-ctrl",
-    "gif-mode",
-    "gif-stat",
-    "gif-cnt",
-    "gif-p3cnt",
-    "gif-p3tag",
-    "gif-bank",
-    "gif-tag-prim",
-    "gif-tag-count",
-    "gif-tag64",
-    "gif-tag",
-    "gs-gif-tag",
-    "gif-packet",
-    "draw-context"
-  ],
-  "gsound": [
-    "*flava-table*",
-    "math-camera-pos",
-    "target-pos",
-    "camera-pos",
-    "*sound-iop-info*",
-    "new-sound-id",
-    "get-sound-buffer-entry",
-    "sound-trans-convert",
-    "sound-stop",
-    "*ambient-spec*",
-    "effect-param->sound-spec",
-    "ear-trans",
-    "*debug-effect-control*",
-    "sound-play-by-spec",
-    "sound-play-by-name",
-    "*setting-control*",
-    "*sound-player-enable*",
-    "sound-angle-convert",
-    "*sound-player-rpc*",
-    "sound-set-ear-trans",
-    "activate-progress",
-    "*sound-loader-rpc*",
-    "kset-language",
-    "sound-command->string",
-    "sound-name=",
-    "str-is-playing?",
-    "current-str-id",
-    "current-str-pos",
-    "is-cd-in?",
-    "check-irx-version",
-    "sound-bank-load",
-    "sound-bank-unload",
-    "sound-music-load",
-    "sound-music-unload",
-    "sound-reload-info",
-    "set-language",
-    "list-sounds",
-    "sound-buffer-dump",
-    "swap-sound-buffers",
-    "free-last-sound-buffer-entry",
-    "sound-basic-cb",
-    "sound-set-volume",
-    "sound-set-reverb",
-    "sound-pause",
-    "sound-continue",
-    "sound-group-pause",
-    "sound-group-stop",
-    "sound-group-continue",
-    "sound-set-falloff-curve",
-    "sound-set-sound-falloff",
-    "sound-set-flava",
-    "sound-volume-off",
-    "show-iop-info",
-    "show-iop-memory",
-    "make-sqrt-table",
-    "flava-lookup",
-    "sound-iop-info",
-    "flava-table-row",
-    "flava-table"
-  ],
-  "gsound-h": [
-    "*current-sound-id*",
-    "*sound-bank-1*",
-    "*sound-bank-2*",
-    "sound-id",
-    "sound-bank-id",
-    "sound-name",
-    "sound-rpc-cmd",
-    "sound-play-parms",
-    "sound-rpc-bank-cmd",
-    "sound-rpc-sound-cmd",
-    "sound-rpc-group-cmd",
-    "sound-rpc-load-bank",
-    "sound-rpc-load-music",
-    "sound-rpc-unload-bank",
-    "sound-rpc-play",
-    "sound-rpc-pause-sound",
-    "sound-rpc-stop-sound",
-    "sound-rpc-continue-sound",
-    "sound-rpc-set-param",
-    "sound-rpc-set-master-volume",
-    "sound-rpc-pause-group",
-    "sound-rpc-stop-group",
-    "sound-rpc-continue-group",
-    "sound-rpc-get-irx-version",
-    "sound-rpc-set-language",
-    "sound-rpc-set-falloff-curve",
-    "sound-rpc-set-sound-falloff",
-    "sound-rpc-reload-info",
-    "sound-rpc-set-reverb",
-    "sound-rpc-set-ear-trans",
-    "sound-rpc-set-flava",
-    "sound-rpc-shutdown",
-    "sound-rpc-list-sounds",
-    "sound-rpc-unload-music",
-    "sound-rpc-union",
-    "sound-spec",
-    "ambient-sound"
-  ],
-  "gstate": [
-    "enter-state",
-    "inherit-state",
-    "send-event-function",
-    "looping-code"
-  ],
-  "gstring": [
-    "string-get-arg!!",
-    "*string-tmp-str*",
-    "string=",
-    "string->float",
-    "string->int",
-    "string-skip-whitespace",
-    "copyn-string<-charp",
-    "string-suck-up!",
-    "string-strip-trailing-whitespace!",
-    "string-strip-leading-whitespace!",
-    "string",
-    "string-skip-to-char",
-    "cat-string<-string_to_charp",
-    "copy-string<-string",
-    "string-charp=",
-    "string<-charp",
-    "charp<-string",
-    "copy-charp<-charp",
-    "cat-string<-string",
-    "catn-string<-charp",
-    "append-character-to-string",
-    "charp-basename",
-    "clear",
-    "string<?",
-    "string>?",
-    "string<=?",
-    "string>=?",
-    "string-cat-to-last-char",
-    "string-strip-whitespace!",
-    "string-get-int32!!",
-    "string-get-float!!",
-    "string-get-flag!!",
-    "*temp-string*"
-  ],
-  "helix-water": [
-    "*helix-water*",
-    "helix-water-idle",
-    "helix-water-activated",
-    "*helix-button-sg*",
-    "*helix-button*",
-    "helix-button-startup",
-    "helix-button-idle-down",
-    "helix-button-quick-activate",
-    "helix-button-activate",
-    "helix-button-idle-up",
-    "*helix-slide-door-sg*",
-    "*helix-slide-door*",
-    "helix-slide-door-idle-open",
-    "helix-slide-door-idle-closed",
-    "helix-slide-door-close",
-    "helix-slide-door",
-    "helix-button",
-    "helix-dark-eco",
-    "helix-water"
-  ],
-  "hint-control": [
-    "*hint-semaphore*",
-    "find-hint-control-index",
-    "start-hint-timer",
-    "increment-success-for-hint",
-    "can-hint-be-played?",
-    "update-task-hints"
-  ],
-  "hint-control-h": [
-    "level-hint-control",
-    "task-hint-control",
-    "task-hint-control-group"
-  ],
-  "hopper": [
-    "*hopper-sg*",
-    "*hopper-nav-enemy-info*",
-    "hopper-do-jump",
-    "hopper-jump-to",
-    "hopper-find-ground",
-    "hopper"
-  ],
-  "hud": [
-    "send-hud-increment-event",
-    "hud-hidden",
-    "hud-leaving",
-    "hud-in",
-    "hud-arriving",
-    "hud-init-by-other",
-    "hud-collecting"
-  ],
-  "hud-classes": [
-    "calculate-rotation-and-color-for-slice",
-    "*fuelcell-naked-sg*",
-    "part-hud-health-01-func",
-    "part-hud-health-02-func",
-    "part-hud-health-03-func",
-    "fuel-cell-hud-orbit-callback",
-    "fuel-cell-hud-starburst-3-callback",
-    "fuel-cell-hud-starburst-4-callback",
-    "fuel-cell-hud-center-callback",
-    "part-hud-buzzer-func",
-    "part-hud-eco-timer-01-func",
-    "part-hud-eco-timer-02-func",
-    "part-hud-eco-timer-03-func",
-    "part-hud-eco-timer-backing-func",
-    "part-hud-eco-timer-func",
-    "show-hud",
-    "hud-pickups",
-    "hud-health",
-    "hud-money-all",
-    "hud-money",
-    "hud-fuel-cell",
-    "hud-buzzers",
-    "hud-power"
-  ],
-  "hud-h": ["*hud-parts*", "hud-icon", "hud-particle", "hud", "hud-parts"],
-  "ice-cube": [
-    "*ice-cube-break-sg*",
-    "ice-cube-face-player",
-    "ice-cube-tired",
-    "ice-cube-retract-spikes",
-    "ice-cube-mean-charge-done",
-    "ice-cube-mean-turn-to-charge",
-    "ice-cube-become-mean",
-    "ice-cube-appear-land",
-    "ice-cube-appear",
-    "ice-cube-trying-to-appear",
-    "*ice-cube-sg*",
-    "*ice-cube-nav-enemy-info*",
-    "ice-cube-shatter",
-    "ice-cube-default-event-handler",
-    "ice-cube-mean-charge",
-    "ice-cube"
-  ],
-  "joint": [
-    "flatten-joint-control-to-spr",
-    "make-joint-jump-tables",
-    "calc-animation-from-spr",
-    "decompress-fixed-data-to-accumulator",
-    "decompress-frame-data-to-accumulator",
-    "decompress-frame-data-pair-to-accumulator",
-    "matrix-from-control!",
-    "matrix-from-control-channel!",
-    "matrix-from-control-pair!",
-    "matrix-from-joint-anim-frame",
-    "create-interpolated-joint-animation-frame",
-    "mem-size",
-    "jacc-mem-usage",
-    "joint-anim-inspect-elt",
-    "joint-anim-login",
-    "joint-control-channel-eval",
-    "joint-control-channel-eval!",
-    "joint-control-channel-group-eval!",
-    "joint-control-channel-group!",
-    "joint-control-copy!",
-    "joint-control-remap!",
-    "cspace<-cspace!",
-    "cspace<-rot-yxy!",
-    "cspace<-transform-yxy!",
-    "cspace<-transformq+trans!",
-    "cspace<-transformq+world-trans!",
-    "cspace-calc-total-matrix!",
-    "cspace<-matrix-no-push-joint!",
-    "cspace<-matrix-joint!",
-    "cspace<-parented-matrix-joint!",
-    "clear-frame-accumulator",
-    "normalize-frame-quaternions"
-  ],
-  "joint-exploder": [
-    "joint-exploder-joint-callback",
-    "joint-exploder-shatter",
-    "joint-exploder-init-by-other",
-    "joint-exploder-tuning",
-    "joint-exploder-static-joint-params",
-    "joint-exploder-static-params",
-    "joint-exploder-joint",
-    "joint-exploder-joints",
-    "joint-exploder-list",
-    "joint-exploder"
-  ],
-  "joint-h": [
-    "joint-control-channel",
-    "joint-control",
-    "matrix-stack",
-    "channel-upload-info",
-    "joint-work"
-  ],
-  "joint-mod-h": [
-    "joint-mod-spinner-callback",
-    "cspace<-parented-transformq-joint!",
-    "joint-mod-blend-local-callback",
-    "joint-mod-set-world-callback",
-    "cspace<-transformq!",
-    "joint-mod-set-local-callback",
-    "joint-mod-wheel-callback",
-    "vector<-cspace!",
-    "*joint-axis-vectors*",
-    "add-debug-text-sphere",
-    "last-try-to-look-at-data",
-    "joint-mod-look-at-handler",
-    "joint-mod-world-look-at-handler",
-    "joint-mod-rotate-handler",
-    "joint-mod-joint-set-handler",
-    "joint-mod-joint-set*-handler",
-    "add-debug-matrix",
-    "joint-mod-debug-draw",
-    "joint-mod",
-    "try-to-look-at-info",
-    "joint-mod-wheel",
-    "joint-mod-set-local",
-    "joint-mod-set-world",
-    "joint-mod-blend-local",
-    "joint-mod-spinner"
-  ],
-  "jungle-elevator": ["jungle-elevator"],
-  "jungle-mirrors": [
-    "*reflector-mirror-sg*",
-    "reflector-mirror-broken",
-    "reflector-mirror-idle",
-    "*reflector-mirror-break-sg*",
-    "peri-beamcam-init-by-other",
-    "draw-power-beam",
-    "reflector-origin-idle",
-    "reflector-origin-update",
-    "reflector-init-by-other",
-    "periscope-find-next",
-    "*periscope-base-sg*",
-    "periscope-find-reflection-angles",
-    "periscope-update-joints",
-    "periscope-power-on",
-    "periscope-has-power-input?",
-    "periscope-wait-for-player",
-    "periscope-idle",
-    "periscope-draw-beam",
-    "periscope-find-aim-at-angles",
-    "cam-periscope",
-    "periscope-crosshair",
-    "periscope-test-task-complete?",
-    "periscope-draw-beam-impact",
-    "periscope-wait-for-power-input",
-    "periscope-player-control",
-    "periscope-activate",
-    "periscope-set-target-direction",
-    "*periscope-mirror-sg*",
-    "reflector-idle",
-    "periscope-post",
-    "periscope-debug-trans",
-    "target-close-to-point?",
-    "periscope",
-    "reflector",
-    "reflector-origin",
-    "reflector-mirror"
-  ],
-  "jungle-obs": [
-    "ripple-for-jungle-water",
-    "*jngpusher-sg*",
-    "jngpusher-idle",
-    "*sidedoor-sg*",
-    "*maindoor-sg*",
-    "maindoor-open",
-    "maindoor-closed",
-    "*precurbridge-sg*",
-    "precurbridge-active",
-    "precurbridge-idle",
-    "*junglecam-sg*",
-    "precurbridge-activate",
-    "*accordian-sg*",
-    "accordian-idle",
-    "*lurkerm-piston-sg*",
-    "lurkerm-piston-idle",
-    "*lurkerm-short-sail-sg*",
-    "lurkerm-short-sail-idle",
-    "*lurkerm-tall-sail-sg*",
-    "lurkerm-tall-sail-idle",
-    "*towertop-sg*",
-    "towertop-idle",
-    "*logtrap-sg*",
-    "*med-res-firecanyon-sg*",
-    "*jungle-camera-sg*",
-    "precurbridge-span",
-    "logtrap",
-    "towertop",
-    "lurkerm-tall-sail",
-    "lurkerm-short-sail",
-    "lurkerm-piston",
-    "accordian",
-    "junglecam",
-    "precurbridgecam",
-    "precurbridge",
-    "maindoor",
-    "sidedoor",
-    "jngpusher",
-    "jungle-water"
-  ],
-  "jungle-part": ["jungle-part"],
-  "jungleb-obs": [
-    "*jng-iris-door-sg*",
-    "*eggtop-sg*",
-    "eggtop-close",
-    "eggtop-idle",
-    "eggtop",
-    "jng-iris-door"
-  ],
-  "junglefish": [
-    "*junglefish-sg*",
-    "*junglefish-nav-enemy-info*",
-    "junglefish"
-  ],
-  "junglesnake": [
-    "*junglesnake-sg*",
-    "junglesnake-sleeping",
-    "*junglesnake-twist-max-deltas*",
-    "junglesnake-tracking",
-    "junglesnake-attack",
-    "junglesnake-give-up",
-    "junglesnake-joint-callback",
-    "junglesnake-wake",
-    "junglesnake-die",
-    "junglesnake-default-event-handler",
-    "junglesnake-twist-joint",
-    "junglesnake-tilt-joint",
-    "junglesnake"
-  ],
-  "kermit": [
-    "*kermit-sg*",
-    "*kermit-nav-enemy-info*",
-    "kermit-get-tongue-target-callback",
-    "kermit-idle",
-    "kermit-disable-tongue",
-    "kermit-hop",
-    "kermit-set-nav-mesh-target",
-    "kermit-set-rotate-dir-to-player",
-    "kermit-chase",
-    "kermit-simple-post",
-    "kermit-player-target-pos",
-    "kermit-tongue-pos",
-    "kermit-check-tongue-is-clear?",
-    "kermit-retract-tongue",
-    "kermit-enable-tongue",
-    "spawn-kermit-pulse",
-    "kermit-check-to-hit-player?",
-    "kermit-tongue-stuck",
-    "kermit-patrol",
-    "kermit-attack",
-    "kermit-chase-new-position",
-    "kermit-give-up",
-    "kermit-get-head-dir-xz",
-    "kermit-set-rotate-dir-to-nav-target",
-    "kermit-notice",
-    "kermit-get-new-patrol-point",
-    "kermit-long-hop",
-    "kermit-short-hop",
-    "kermit-pulse-init-by-other",
-    "kermit-pulse-idle",
-    "kermit-pulse-impact",
-    "joint-mod-tracker-callback",
-    "build-matrix-from-up-and-forward-axes!",
-    "kermit-get-head-dir",
-    "kermit-post",
-    "joint-mod-tracker",
-    "kermit-pulse",
-    "kermit"
-  ],
-  "launcherdoor": [
-    "*launcherdoor-maincave-sg*",
-    "*launcherdoor-sg*",
-    "launcherdoor-open",
-    "launcherdoor-closed",
-    "launcherdoor"
-  ],
-  "lava": ["ripple-for-lava", "lava"],
-  "lavatube-energy": [
-    "*energylava-sg*",
-    "energylava-idle",
-    "*energyhub-sg*",
-    "energyarm-init-by-other",
-    "energyhub-stopped",
-    "energyhub-idle",
-    "energyhub-set-lava-height",
-    "energyhub-stop",
-    "energyhub-trans",
-    "energyarm-init",
-    "*energyarm-sg*",
-    "energyarm-stop",
-    "energyball-init-by-other",
-    "energyarm-idle",
-    "energyarm-trans",
-    "energyarm-no-ball",
-    "energyball-init",
-    "*energyball-sg*",
-    "energyball-idle",
-    "*energybase-sg*",
-    "energybase-stopped",
-    "energybase-idle",
-    "energybase-stopping",
-    "*energydoor-sg*",
-    "energydoor-player-dist",
-    "energydoor-closed-till-near",
-    "energydoor-opened",
-    "energydoor-closed-till-task",
-    "energydoor-opening",
-    "energydoor-open-handler",
-    "energydoor-closed-handler",
-    "energydoor-closing",
-    "energyarm-fall",
-    "energydoor",
-    "energybase",
-    "energyhub",
-    "energyarm",
-    "energyball",
-    "energylava"
-  ],
-  "lavatube-obs": [
-    "*lavayellowtarp-sg*",
-    "lavayellowtarp-idle",
-    "ripple-for-lavatube-lava",
-    "*lavaballoon-sg*",
-    "*chainmine-sg*",
-    "*lavafallsewerb-sg*",
-    "lavafallsewerb-idle",
-    "*lavafallsewera-sg*",
-    "lavafallsewera-idle",
-    "darkecobarrel-base-init",
-    "darkecobarrel-base-time",
-    "darkecobarrel-cycle-time",
-    "darkecobarrel-advance-curspawn",
-    "darkecobarrel-mover-init-by-other",
-    "darkecobarrel-base-done?",
-    "darkecobarrel-base-pos",
-    "darkecobarrel-spawner",
-    "darkecobarrel-mover-pos",
-    "darkecobarrel-mover-move",
-    "darkecobarrel-mover-die",
-    "*darkecobarrel-sg*",
-    "*lavashortcut-sg*",
-    "lavashortcut-idle",
-    "*lavafall-sg*",
-    "lavafall-idle",
-    "*lavabase-sg*",
-    "lavabase-idle",
-    "lavabase",
-    "lavafall",
-    "lavashortcut",
-    "darkecobarrel-leak",
-    "darkecobarrel-base",
-    "darkecobarrel-mover",
-    "darkecobarrel",
-    "lavafallsewera",
-    "lavafallsewerb",
-    "chainmine",
-    "lavaballoon",
-    "lavatube-lava",
-    "lavayellowtarp"
-  ],
-  "lavatube-part": ["lavatube-part"],
-  "level": [
-    "update-sound-banks",
-    "load-vis-info",
-    "*print-login*",
-    "on",
-    "unload",
-    "*login-state*",
-    "link-resume",
-    "level-update-after-load",
-    "add-bsp-drawable",
-    "remap-level-name",
-    "bg",
-    "play",
-    "show-level"
-  ],
-  "level-h": [
-    "*level*",
-    "level-vis-info",
-    "level-load-info",
-    "login-state",
-    "level",
-    "level-group"
-  ],
-  "level-info": [
-    "training",
-    "village1",
-    "beach",
-    "jungle",
-    "jungleb",
-    "misty",
-    "firecanyon",
-    "village2",
-    "sunken",
-    "sunkenb",
-    "swamp",
-    "rolling",
-    "ogre",
-    "village3",
-    "snow",
-    "maincave",
-    "darkcave",
-    "robocave",
-    "lavatube",
-    "citadel",
-    "finalboss",
-    "intro",
-    "demo",
-    "title",
-    "halfpipe",
-    "default-level"
-  ],
-  "light-eco": [
-    "*light-eco-big-sg*",
-    "light-eco-mother-appear",
-    "light-eco-mother-active",
-    "light-eco-mother-discipate",
-    "light-eco-child-init-by-other",
-    "*light-eco-small-sg*",
-    "light-eco-child-appear",
-    "light-eco-child-die",
-    "light-eco-child-idle",
-    "light-eco-child-hit-ground",
-    "light-eco-child-grabbed",
-    "check-drop-level-lighteco-big-pops",
-    "check-drop-level-lighteco-pops",
-    "light-eco-child-default-event-handler",
-    "light-eco-mother-default-event-handler",
-    "light-eco-mother-init-by-other",
-    "light-eco-child",
-    "light-eco-mother"
-  ],
-  "lights": [
-    "vu-lights<-light-group!",
-    "light-slerp",
-    "light-group-slerp",
-    "light-group-process!",
-    "*default-lights*",
-    "vu-lights-default!"
-  ],
-  "lights-h": [
-    "vu-lights",
-    "light",
-    "light-ellipse",
-    "light-array",
-    "light-volume",
-    "light-volume-sphere",
-    "light-volume-planes",
-    "light-volume-array",
-    "light-group"
-  ],
-  "load-boundary": [
-    "check-closed-boundary",
-    "check-open-boundary",
-    "load-state-want-vis",
-    "load-state-want-levels",
-    "load-state-want-display-level",
-    "load-state-want-force-vis",
-    "command-get-param",
-    "entity-birth-no-kill",
-    "part-tracker-init",
-    "command-list-get-process",
-    "command-get-quoted-param",
-    "command-get-int",
-    "*backup-load-state*",
-    "ambient-hint-spawn",
-    "command-get-float",
-    "*display-load-commands*",
-    "process-by-ename",
-    "point-in-polygon",
-    "*triangulation-buffer*",
-    "try-corner",
-    "split-monotone-polygon",
-    "fix-boundary-normals",
-    "triangulate-boundary",
-    "find-bounding-circle",
-    "render-boundary",
-    "check-boundary",
-    "edit-load-boundaries",
-    "*lb-editor-parms*",
-    "copy-load-command!",
-    "copy-load-boundary!",
-    "lb-add-plane",
-    "lb-add",
-    "save-boundary-cmd",
-    "replace-load-boundary",
-    "format-boundary-cmd",
-    "boundary-set-color",
-    "*boundary-polygon*",
-    "add-boundary-shader",
-    "draw-boundary-cap",
-    "draw-boundary-side",
-    "init-boundary-regs",
-    "render-boundary-tri",
-    "render-boundary-quad",
-    "draw-boundary-polygon",
-    "lb-del",
-    "lb-add-vtx-before",
-    "lb-add-vtx-after",
-    "lb-del-vtx",
-    "load-boundary-from-template",
-    "---lb-save",
-    "lb-add-load",
-    "lb-add-load-plane",
-    "lb-flip",
-    "lb-set-camera",
-    "lb-set-player",
-    "lb-copy",
-    "render-boundaries",
-    "command-get-time",
-    "lb-editor-parms"
-  ],
-  "load-boundary-data": ["*static-load-boundary-list*"],
-  "load-boundary-h": [
-    "*load-boundary-list*",
-    "*load-boundary-target*",
-    "lbvtx",
-    "load-boundary-crossing-command",
-    "load-boundary"
-  ],
-  "load-dgo": [
-    "*dgo-name*",
-    "link-begin",
-    "*load-dgo-rpc*",
-    "*dgo-time*",
-    "string->sound-name",
-    "*play-str-rpc*",
-    "*que-str-lock*",
-    "*load-str-lock*",
-    "*load-str-rpc*",
-    "str-load",
-    "str-load-status",
-    "str-load-cancel",
-    "str-play-async",
-    "str-play-stop",
-    "str-play-queue",
-    "str-ambient-play",
-    "str-ambient-stop",
-    "str-play-kick",
-    "dgo-load-begin",
-    "dgo-load-get-next",
-    "dgo-load-continue",
-    "dgo-load-cancel",
-    "find-temp-buffer",
-    "dgo-load-link",
-    "destroy-mem",
-    "load-dgo-msg",
-    "load-chunk-msg",
-    "dgo-header"
-  ],
-  "loader": [
-    "*load-state*",
-    "*art-control*",
-    "ja-channel-push!",
-    "ja-channel-set!",
-    "kill-current-level-hint",
-    "level-hint-surpress!",
-    "ja-aframe-num",
-    "ja-abort-spooled-anim",
-    "*preload-spool-anims*",
-    "*stack-top*",
-    "*kernel-sp*",
-    "art-group-load-check",
-    "drawable-load",
-    "art-load",
-    "ja-play-spooled-anim"
-  ],
-  "loader-h": [
-    "load-dir",
-    "load-dir-art-group",
-    "external-art-buffer",
-    "spool-anim",
-    "external-art-control"
-  ],
-  "logic-target": [
-    "init-target",
-    "target-print-stats",
-    "activate-hud",
-    "reset-target-state",
-    "init-sidekick",
-    "target-generic-event-handler",
-    "level-setup",
-    "target-continue",
-    "target-exit",
-    "target-calc-camera-pos",
-    "do-target-shadow",
-    "target-powerup-process",
-    "flag-setup",
-    "build-conversions",
-    "do-rotations1",
-    "read-pad",
-    "turn-to-vector",
-    "add-thrust",
-    "add-gravity",
-    "do-rotations2",
-    "reverse-conversions",
-    "bend-gravity",
-    "post-flag-setup",
-    "joint-points",
-    "target-real-post",
-    "target-compute-edge",
-    "target-compute-pole",
-    "target-compute-slopes",
-    "warp-vector-into-surface!",
-    "vector<-pad-in-surface!",
-    "draw-history",
-    "vector-turn-to",
-    "print-history",
-    "local-pad-angle",
-    "turn-around?",
-    "target-move-dist",
-    "target-compute-edge-rider",
-    "target-post",
-    "target-swim-post",
-    "target-no-stick-post",
-    "target-no-move-post",
-    "target-slide-down-post",
-    "target-no-ja-move-post"
-  ],
-  "lurkercrab": [
-    "*lurkercrab-sg*",
-    "*lurkercrab-nav-enemy-info*",
-    "lurkercrab-vulnerable",
-    "lurkercrab-invulnerable",
-    "lurkercrab-pushed",
-    "lurkercrab"
-  ],
-  "lurkerpuppy": [
-    "*lurkerpuppy-sg*",
-    "*lurkerpuppy-nav-enemy-info*",
-    "lurkerpuppy"
-  ],
-  "lurkerworm": [
-    "*lurkerworm-sg*",
-    "lurkerworm-prebind-function",
-    "lurkerworm-joint-callback",
-    "lurkerworm-idle",
-    "lurkerworm-rest",
-    "lurkerworm-strike",
-    "lurkerworm-sink",
-    "lurkerworm-rise",
-    "lurkerworm-spot",
-    "lurkerworm-die",
-    "lurkerworm-default-event-handler",
-    "lurkerworm-default-post-behavior",
-    "lurkerworm"
-  ],
-  "main": [
-    "display-loop",
-    "entity-by-type",
-    "*cheat-temp*",
-    "scf-get-territory",
-    "*progress-cheat*",
-    "scf-get-timeout",
-    "scf-get-inactive-timeout",
-    "*master-exit*",
-    "kernel-shutdown",
-    "*last-master-mode*",
-    "pause-allowed?",
-    "menu-respond-to-pause",
-    "hide-progress-screen",
-    "set-letterbox-frames",
-    "letterbox",
-    "blackout",
-    "*screen-filter*",
-    "main-cheats",
-    "off"
-  ],
-  "main-collide": [
-    "drawable-sphere-box-intersect?",
-    "instance-sphere-box-intersect?",
-    "instance-tfragment-add-debug-sphere"
-  ],
-  "main-h": [
-    "*stats-poly*",
-    "*stats-memory*",
-    "*stats-memory-short*",
-    "*stats-collide*",
-    "*stats-bsp*",
-    "*stats-buffer*",
-    "*stats-target*",
-    "*stats-dma-test*",
-    "*artist-all-visible*",
-    "*artist-flip-visible*",
-    "*artist-fix-visible*",
-    "*artist-fix-frustum*",
-    "*artist-error-spheres*",
-    "*artist-use-menu-subdiv*",
-    "*display-profile*",
-    "*display-sidekick-stats*",
-    "*display-quad-stats*",
-    "*display-tri-stats*",
-    "*display-perf-stats*",
-    "*display-ground-stats*",
-    "*display-collision-marks*",
-    "*display-collide-cache*",
-    "*display-render-collision*",
-    "*display-hipri-collision-marks*",
-    "*display-edge-collision-marks*",
-    "*display-geo-marks*",
-    "*display-target-marks*",
-    "*display-collide-history*",
-    "*display-xyz-axes*",
-    "*display-cam-collide-history*",
-    "*record-cam-collide-history*",
-    "*display-cam-master-marks*",
-    "*display-cam-other*",
-    "*display-camera-marks*",
-    "*camera-no-mip-correction*",
-    "*display-cam-los-info*",
-    "*display-cam-los-debug*",
-    "*display-cam-los-marks*",
-    "*display-cam-coll-marks*",
-    "*display-camera-info*",
-    "*display-camera-old-stats*",
-    "*display-camera-last-attacker*",
-    "*display-file-info*",
-    "*display-actor-marks*",
-    "*display-ambient-hint-marks*",
-    "*display-ambient-sound-marks*",
-    "*display-ambient-poi-marks*",
-    "*display-ambient-light-marks*",
-    "*display-ambient-dark-marks*",
-    "*display-ambient-weather-off-marks*",
-    "*display-ambient-ocean-off-marks*",
-    "*display-ambient-ocean-near-off-marks*",
-    "*display-ambient-music-marks*",
-    "*display-sprite-info*",
-    "*display-entity-errors*",
-    "*display-lights*",
-    "*display-instance-info*",
-    "*display-deci-count*",
-    "*sync-dma*",
-    "*display-strip-lines*",
-    "*display-nav-marks*",
-    "*display-path-marks*",
-    "*display-vol-marks*",
-    "*display-water-marks*",
-    "*display-actor-anim*",
-    "*display-process-anim*",
-    "*display-actor-vis*",
-    "*display-actor-graph*",
-    "*display-level-border*",
-    "*display-load-boundaries*",
-    "*display-memcard-info*",
-    "*display-split-boxes*",
-    "*display-split-box-info*",
-    "*display-texture-download*",
-    "*display-art-control*",
-    "*display-level-spheres*",
-    "*time-of-day-effects*",
-    "*time-of-day-fast*",
-    "*display-iop-info*",
-    "*ambient-sound-class*",
-    "*slow-frame-rate*",
-    "*weather-off*",
-    "*debug-pause*",
-    "*subdivide-draw-mode*",
-    "*ocean-subdivide-draw-mode*",
-    "*dproc*",
-    "*run*",
-    "*teleport*",
-    "*teleport-count*",
-    "*draw-hook*",
-    "*debug-hook*",
-    "*menu-hook*",
-    "*progress-hook*",
-    "*dma-timeout-hook*",
-    "*frame-stats*",
-    "frame-stats",
-    "screen-filter"
-  ],
-  "maincave-obs": [
-    "*caveelevator-sg*",
-    "caveelevator-joint-callback",
-    "cavecrystal-light-control-caveelevator-callback",
-    "caveelevator-cycle-active",
-    "caveelevator-one-way-idle-start",
-    "caveelevator-one-way-travel-to-start",
-    "caveelevator-one-way-idle-end",
-    "caveelevator-one-way-travel-to-end",
-    "*cavespatulatwo-sg*",
-    "cavespatulatwo-idle",
-    "*cavespatula-darkcave-sg*",
-    "*cavespatula-sg*",
-    "cavespatula-idle",
-    "caveflamepots-active",
-    "*cavetrapdoor-sg*",
-    "*cavecrusher-sg*",
-    "cavecrusher-idle",
-    "ripple-for-cave-water",
-    "*maincavecam-sg*",
-    "maincavecam",
-    "cave-water",
-    "cavecrusher",
-    "cavetrapdoor",
-    "caveflamepots",
-    "cavespatula",
-    "cavespatulatwo",
-    "caveelevator"
-  ],
-  "maincave-part": [
-    "check-drop-level-maincave-drip",
-    "maincave-part",
-    "darkcave-part"
-  ],
-  "math": [
-    "rand-vu",
-    "rand-vu-float-range",
-    "truncate",
-    "integral?",
-    "fractional-part",
-    "log2",
-    "seek",
-    "lerp",
-    "lerp-scale",
-    "lerp-clamp",
-    "seekl",
-    "rand-vu-init",
-    "rand-vu-nostep",
-    "rand-vu-percent?",
-    "rand-vu-int-range",
-    "rand-vu-int-count",
-    "*random-generator*",
-    "rand-uint31-gen",
-    "rgba",
-    "xyzw",
-    "xyzwh",
-    "random-generator"
-  ],
-  "math-camera": [
-    "*math-camera*",
-    "update-math-camera",
-    "fog-corrector-setup",
-    "*math-camera-fog-correction*",
-    "sprite-distorter-generate-tables",
-    "math-cam-start-smoothing",
-    "move-target-from-pad",
-    "transform-point-vector!",
-    "transform-point-qword!",
-    "transform-point-vector-scale!",
-    "init-for-transform",
-    "fog-corrector"
-  ],
-  "math-camera-h": ["vis-gif-tag", "cull-info", "math-camera"],
-  "matrix": [
-    "atan",
-    "matrix-4x4-determinant",
-    "matrix-3x3-determinant",
-    "matrix-axis-sin-cos!",
-    "sin",
-    "cos",
-    "matrix-rotate-y!",
-    "matrix-rotate-x!",
-    "matrix*!",
-    "vector-sincos!",
-    "matrix-rotate-z!",
-    "matrix-identity!",
-    "matrix-transpose!",
-    "vector-rotate*!",
-    "vector-matrix*!",
-    "*identity-matrix*",
-    "matrix+!",
-    "matrix-!",
-    "matrixp*!",
-    "vector3s-matrix*!",
-    "vector3s-rotate*!",
-    "matrix-inverse-of-rot-trans!",
-    "matrix-4x4-inverse!",
-    "matrix-translate!",
-    "matrix-translate+!",
-    "matrix-scale!",
-    "scale-matrix!",
-    "matrix-inv-scale!",
-    "column-scale-matrix!",
-    "matrix-rotate-zyx!",
-    "matrix-rotate-xyz!",
-    "matrix-rotate-zxy!",
-    "matrix-rotate-yxz!",
-    "matrix-rotate-yzx!",
-    "matrix-rotate-yxy!",
-    "matrix-rotate-yx!",
-    "matrix-axis-sin-cos-vu!",
-    "matrix-axis-angle!",
-    "matrix-lerp!",
-    "matrix3-determinant",
-    "matrix-3x3-inverse!",
-    "matrix-3x3-inverse-transpose!",
-    "matrix3-inverse-transpose!",
-    "matrix-4x4-inverse-transpose!",
-    "matrix-y-angle"
-  ],
-  "matrix-h": ["matrix-copy!", "matrix", "matrix3", "matrix4h"],
-  "mayor": ["*mayor-sg*", "mayor-lurkerm-reward-speech", "mayor"],
-  "memcard-h": [
-    "mc-get-slot-info",
-    "mc-run",
-    "mc-check-result",
-    "int32",
-    "mc-sync",
-    "show-mc-info",
-    "mc-handle",
-    "mc-file-info",
-    "mc-slot-info"
-  ],
-  "memory-usage": ["*max-dma*"],
-  "memory-usage-h": [
-    "*mem-usage*",
-    "*dma-mem-usage*",
-    "*temp-mem-usage*",
-    "memory-usage-info",
-    "memory-usage-block"
-  ],
-  "menu": [
-    "debug-menus-active",
-    "debug-menus-default-joypad-func",
-    "debug-menu-context-render",
-    "debug-menu-context-close-submenu",
-    "debug-menu-context-activate-selection",
-    "debug-menu-context-select-new-item",
-    "debug-menu-item-send-msg",
-    "debug-menu-send-msg",
-    "debug-menu-context-send-msg",
-    "debug-menu-item-submenu-msg",
-    "debug-menu-item-function-msg",
-    "debug-menu-item-flag-msg",
-    "debug-menu-item-var-msg",
-    "debug-menu-context-release-joypad",
-    "debug-menu-context-grab-joypad",
-    "debug-menu-item-var-joypad-handler",
-    "debug-menu-item-var-update-display-str",
-    "debug-menu-context-open-submenu",
-    "debug-menu-context-select-next-or-prev-item",
-    "debug-menu-render",
-    "debug-menu-item-render",
-    "debug-menu-item-submenu-render",
-    "debug-menu-item-function-render",
-    "debug-menu-item-flag-render",
-    "debug-menu-item-var-render",
-    "debug-menu-make-from-template",
-    "debug-menu-append-item",
-    "debug-menu-context-set-root-menu",
-    "debug-menu-func-decode",
-    "debug-menu-item-var-make-int",
-    "debug-menu-item-var-make-float",
-    "debug-menu-rebuild",
-    "debug-menu-context-default-selection",
-    "debug-menu-item-get-max-width",
-    "debug-menu-remove-all-items",
-    "debug-menu-find-from-template",
-    "debug-menus-handler",
-    "debug-menu-context",
-    "debug-menu-node",
-    "debug-menu",
-    "debug-menu-item",
-    "debug-menu-item-submenu",
-    "debug-menu-item-function",
-    "debug-menu-item-flag",
-    "debug-menu-item-var"
-  ],
-  "merc": [
-    "merc-vu1-init-buffer",
-    "merc-vu1-initialize-chain",
-    "merc-vu1-add-vu-function",
-    "*merc-ctrl-header*",
-    "get-eye-block",
-    "merc-stats-display",
-    "merc-stats",
-    "merc-edge-stats",
-    "merc-vu1-init-buffers"
-  ],
-  "merc-blend-shape": [
-    "*blerc-globals*",
-    "setup-blerc-chains-for-one-fragment",
-    "setup-blerc-chains",
-    "blerc-stats-init",
-    "*stats-blerc*",
-    "blerc-init",
-    "blerc-a-fragment",
-    "dma-from-spr",
-    "merc-dma-chain-to-spr",
-    "blerc-execute",
-    "merc-blend-shape",
-    "blerc-block-header",
-    "blerc-block",
-    "blerc-dcache",
-    "blerc-globals",
-    "blerc-context"
-  ],
-  "merc-death": [
-    "*merc-death-globals*",
-    "birth-func-death-sparks",
-    "death-beach-puppy",
-    "death-jungle-snake",
-    "death-default",
-    "death-warp-in",
-    "death-warp-out",
-    "merc-death-spawn",
-    "death-info"
-  ],
-  "merc-h": [
-    "merc-fragment-fp-data",
-    "merc-blend-data",
-    "ripple-merc-query",
-    "merc-byte-header",
-    "merc-fragment",
-    "merc-vtx",
-    "merc-fp-header",
-    "merc-mat-dest",
-    "merc-fragment-control",
-    "merc-blend-ctrl",
-    "mei-envmap-tint",
-    "mei-texture-scroll",
-    "mei-ripple",
-    "merc-extra-info",
-    "merc-effect",
-    "merc-eye-ctrl",
-    "merc-eye-anim-frame",
-    "merc-eye-anim-block",
-    "merc-ctrl-header",
-    "merc-ctrl",
-    "merc-vu1-low-mem",
-    "ripple-wave",
-    "ripple-wave-set",
-    "ripple-control"
-  ],
-  "merc-vu1": ["merc-vu1-block"],
-  "minecart": [
-    "minecartsteel-initialize-by-other",
-    "*minecartsteel-sg*",
-    "minecartsteel"
-  ],
-  "miners": [
-    "*cavegem-sg*",
-    "*minershort-sg*",
-    "minershort-trans-hook",
-    "*minertall-sg*",
-    "miners-anim-loop",
-    "minertall",
-    "minershort",
-    "cavegem"
-  ],
-  "misty-conveyor": [
-    "*keg-conveyor-sg*",
-    "keg-conveyor-paddle-init-by-other",
-    "keg-conveyor-idle",
-    "*keg-conveyor-paddle-sg*",
-    "keg-conveyor-paddle-idle",
-    "*keg-conveyor-keg-spawn-table*",
-    "keg-conveyor-spawn-keg",
-    "keg-conveyor-spawn-bouncing-keg",
-    "keg-init-by-other",
-    "*keg-sg*",
-    "keg-on-paddle",
-    "keg-die",
-    "keg-in-chute",
-    "keg-bounce-set-particle-rotation-callback",
-    "keg-update-smush",
-    "keg-on-path",
-    "keg-paddle-to-path",
-    "keg-event-handler",
-    "keg-post",
-    "keg-conveyor",
-    "keg-conveyor-paddle",
-    "keg"
-  ],
-  "misty-obs": [
-    "boat-fuelcell-spawn",
-    "boat-fuelcell-idle",
-    "*mistycam-sg*",
-    "boat-fuelcell-die",
-    "*mis-bone-platform-sg*",
-    "*bone-platform-constants*",
-    "*breakaway-left-sg*",
-    "*breakaway-mid-sg*",
-    "*breakaway-right-sg*",
-    "breakaway-idle",
-    "breakaway-fall",
-    "breakaway-about-to-fall",
-    "*mis-bone-bridge-sg*",
-    "mis-bone-bridge-fall",
-    "mis-bone-bridge-idle",
-    "mis-bone-bridge-hit",
-    "mis-bone-bridge-bump",
-    "*windturbine-sg*",
-    "windturbine-idle",
-    "*boatpaddle-sg*",
-    "boatpaddle-idle",
-    "mis-bone-bridge-event-handler",
-    "actor-wait-for-period",
-    "misty-cam-restore",
-    "boatpaddle",
-    "windturbine",
-    "mis-bone-bridge",
-    "breakaway",
-    "breakaway-right",
-    "breakaway-mid",
-    "breakaway-left",
-    "bone-platform",
-    "mistycam",
-    "misty-battlecontroller",
-    "boat-fuelcell"
-  ],
-  "misty-part": ["misty-part"],
-  "misty-teetertotter": [
-    "*teetertotter-sg*",
-    "teetertotter-idle",
-    "target-on-end-of-teetertotter?",
-    "teetertotter-launch",
-    "teetertotter-bend",
-    "teetertotter"
-  ],
-  "misty-warehouse": [
-    "*rounddoor-sg*",
-    "*silostep-sg*",
-    "silostep-rise",
-    "silostep-idle",
-    "misty-camera-view",
-    "silostep-camera",
-    "silostep",
-    "rounddoor"
-  ],
-  "mistycannon": [
-    "*mistycannon-sg*",
-    "mistycannon-prebind-function",
-    "mistycannon-postbind-function",
-    "angle-tracker-init-range!",
-    "mistycannon-pick-random-target-point",
-    "mistycannon-idle",
-    "mistycannon-waiting-for-player",
-    "cam-mistycannon",
-    "mistycannon-waiting-for-player-to-fuck-off",
-    "angle-tracker-seek!",
-    "mistycannon-aim-at-player",
-    "mistycannon-player-control",
-    "mistycannon-do-aim",
-    "mistycannon-find-trajectory",
-    "solve-missile-velocity",
-    "spawn-mistycannon-missile",
-    "angle-tracker-apply-move!",
-    "mistycannon-missile-init-by-other",
-    "mistycannon-collision-reaction",
-    "*mistycannon-missile-sg*",
-    "mistycannon-missile-idle",
-    "mistycannon-missile-explode",
-    "mistycannon-missile-in-water",
-    "angle-tracker-get-value",
-    "angle-tracker-set-value",
-    "solve-missile-tilt",
-    "mistycannon-find-best-solution",
-    "angle-tracker",
-    "mistycannon-missile",
-    "mistycannon-init-data",
-    "mistycannon",
-    "quadratic-solution",
-    "trajectory-params"
-  ],
-  "mood": [
-    "clear-mood-times",
-    "update-mood-quick",
-    "update-mood-flames",
-    "update-mood-light",
-    "target-joint-pos",
-    "update-mood-itimes",
-    "update-mood-fog",
-    "update-mood-sky-texture",
-    "update-mood-palette",
-    "*time-of-day-proc*",
-    "update-mood-interp",
-    "update-mood-lightning",
-    "*lightning-time2*",
-    "update-mood-lava",
-    "update-light-kit",
-    "set-target-light-index",
-    "*rolling-spheres-on*",
-    "*rolling-spheres-light0*",
-    "*rolling-spheres-light1*",
-    "*rolling-spheres-light2*",
-    "*rolling-spheres-light3*",
-    "*rolling-spheres-light4*",
-    "update-mood-caustics",
-    "update-mood-jungleb-blue",
-    "update-mood-prt-color",
-    "*flash0*",
-    "*flash1*",
-    "*flash2*",
-    "*flash3*",
-    "*flash4*",
-    "*flash5*",
-    "*flash6*",
-    "*flash7*",
-    "*lightning-index*",
-    "*lightning-time*",
-    "*lightning-frame-done*",
-    "*lightning-realtime-done*",
-    "*thunder-id0*",
-    "*thunder-id1*",
-    "*thunder-id2*",
-    "*thunder-id*",
-    "*thunder-count*",
-    "*lava-time*",
-    "update-mood-default",
-    "update-mood-misty",
-    "update-mood-village2",
-    "update-mood-swamp",
-    "update-mood-village1",
-    "update-mood-jungle",
-    "update-mood-jungleb",
-    "update-mood-sunken",
-    "update-mood-rolling",
-    "update-mood-firecanyon",
-    "update-mood-training",
-    "update-mood-maincave",
-    "update-mood-darkcave",
-    "update-mood-robocave",
-    "update-mood-snow",
-    "update-mood-village3",
-    "update-mood-lavatube",
-    "update-mood-ogre",
-    "update-mood-finalboss",
-    "update-mood-citadel",
-    "flames-state",
-    "lightning-state",
-    "light-time-state",
-    "light-state",
-    "lava-state",
-    "misty-states",
-    "swamp-village2-states",
-    "village1-states",
-    "jungle-states",
-    "sunken-states",
-    "rolling-states",
-    "firecanyon-states",
-    "training-states",
-    "maincave-states",
-    "robocave-states",
-    "snow-states",
-    "village3-states",
-    "lavatube-states",
-    "ogre-states",
-    "finalboss-states",
-    "citadel-states"
-  ],
-  "mood-h": [
-    "mood-fog",
-    "mood-fog-table",
-    "mood-lights",
-    "mood-lights-table",
-    "mood-sun",
-    "mood-sun-table",
-    "mood-context"
-  ],
-  "mood-tables": [
-    "make-light-kit",
-    "make-village1-light-kit",
-    "make-misty-light-kit",
-    "make-village2-light-kit",
-    "make-rolling-light-kit",
-    "make-village3-light-kit",
-    "update-mood-shadow-direction",
-    "update-mood-erase-color",
-    "update-mood-erase-color2",
-    "*default-interp-table*",
-    "*village1-palette-interp-table*",
-    "*misty-palette-interp-table*",
-    "*firecanyon-palette-interp-table*",
-    "*rolling-palette-interp-table*",
-    "*village2-sky-texture-table*",
-    "*finalboss-interp-table*",
-    "*village1-mood-fog-table*",
-    "*village1-mood-lights-table*",
-    "*village1-mood-sun-table*",
-    "*training-mood-fog-table*",
-    "*snow-mood-fog-table*",
-    "*snow-mood-lights-table*",
-    "*snow-mood-sun-table*",
-    "*jungleb-mood-fog-table*",
-    "*jungleb-mood-lights-table*",
-    "*jungleb-mood-sun-table*",
-    "*maincave-mood-fog-table*",
-    "*maincave-mood-lights-table*",
-    "*maincave-mood-sun-table*",
-    "*robocave-mood-fog-table*",
-    "*darkcave-mood-fog-table*",
-    "*darkcave-mood-lights-table*",
-    "*darkcave-mood-sun-table*",
-    "*misty-mood-fog-table*",
-    "*misty-mood-lights-table*",
-    "*misty-mood-sun-table*",
-    "*village2-mood-fog-table*",
-    "*village2-mood-lights-table*",
-    "*village2-mood-sun-table*",
-    "*swamp-mood-fog-table*",
-    "*swamp-mood-lights-table*",
-    "*swamp-mood-sun-table*",
-    "*sunken-mood-fog-table*",
-    "*sunken-mood-lights-table*",
-    "*sunken-mood-sun-table*",
-    "*rolling-mood-fog-table*",
-    "*rolling-mood-lights-table*",
-    "*rolling-mood-sun-table*",
-    "*firecanyon-mood-fog-table*",
-    "*firecanyon-mood-lights-table*",
-    "*firecanyon-mood-sun-table*",
-    "*ogre-mood-fog-table*",
-    "*ogre-mood-lights-table*",
-    "*ogre2-mood-lights-table*",
-    "*ogre3-mood-fog-table*",
-    "*ogre3-mood-lights-table*",
-    "*village3-mood-fog-table*",
-    "*village3-mood-lights-table*",
-    "*lavatube-mood-fog-table*",
-    "*lavatube-mood-lights-table*",
-    "*lavatube-mood-sun-table*",
-    "*finalboss-mood-sun-table*",
-    "*finalboss-mood-fog-table*",
-    "*citadel-mood-fog-table*",
-    "*citadel-mood-lights-table*",
-    "*citadel-mood-sun-table*",
-    "*default-mood*",
-    "*village1-mood*",
-    "*beach-mood*",
-    "*jungle-mood*",
-    "*jungleb-mood*",
-    "*misty-mood*",
-    "*firecanyon-mood*",
-    "*village2-mood*",
-    "*swamp-mood*",
-    "*sunken-mood*",
-    "*sunkenb-mood*",
-    "*rolling-mood*",
-    "*training-mood*",
-    "*maincave-mood*",
-    "*darkcave-mood*",
-    "*robocave-mood*",
-    "*snow-mood*",
-    "*ogre-mood*",
-    "*ogre2-mood*",
-    "*ogre3-mood*",
-    "*village3-mood*",
-    "*finalboss-mood*",
-    "*finalboss2-mood*",
-    "*lavatube-mood*",
-    "*citadel-mood*"
-  ],
-  "mother-spider": [
-    "*mother-spider-sg*",
-    "mother-spider-die-wait-for-children",
-    "mother-spider-idle",
-    "*mother-spider-threads*",
-    "*mother-spider-leg-infos*",
-    "mother-spider-leg-init-by-other",
-    "mother-spider-hit-while-birthing",
-    "mother-spider-birthing",
-    "mother-spider-traveling",
-    "mother-spider-birth-baby",
-    "mother-spider-tracking",
-    "mother-spider-hit-while-tracking",
-    "mother-spider-spit",
-    "mother-spider-stop-traveling",
-    "mother-spider-full-joint-callback",
-    "mother-spider-die-from-uppercut",
-    "mother-spider-die",
-    "*mother-spider-leg-sg*",
-    "mother-spider-leg-flying",
-    "wait-for-children",
-    "mother-spider-default-event-handler",
-    "mother-spider-death-event-handler"
-  ],
-  "mother-spider-egg": [
-    "*mother-spider-egg-unbroken-sg*",
-    "*mother-spider-egg-broken-sg*",
-    "mother-spider-egg-falling",
-    "mother-spider-egg-die-exit",
-    "mother-spider-egg-hatch",
-    "mother-spider-egg-die",
-    "mother-spider-egg-on-ground",
-    "mother-spider-egg-die-while-falling",
-    "mother-spider-egg-init-by-other",
-    "mother-spider-egg"
-  ],
-  "mother-spider-h": [
-    "mother-spider-leg",
-    "mother-spider-thread",
-    "mother-spider-leg-info",
-    "mother-spider-history",
-    "mother-spider-history-array",
-    "mother-spider"
-  ],
-  "mother-spider-proj": [
-    "mother-spider-proj-update-velocity",
-    "mother-spider-proj"
-  ],
-  "mspace-h": [
-    "joint",
-    "bone-cache",
-    "bone",
-    "skeleton",
-    "cspace",
-    "cspace-array"
-  ],
-  "mud": ["ripple-for-mud", "ripple-for-small-mud", "mud"],
-  "muse": [
-    "*muse-sg*",
-    "*muse-nav-enemy-info*",
-    "muse-idle",
-    "muse-check-dest-point",
-    "muse-caught",
-    "analyze-point-on-path-segment",
-    "muse-get-path-point",
-    "muse",
-    "point-on-path-segment-info"
-  ],
-  "nav-enemy": [
-    "*nav-enemy-dummy-shadow-control*",
-    "nav-enemy-rnd-int-range",
-    "nav-enemy-initialize-jump",
-    "nav-enemy-neck-control-look-at",
-    "nav-enemy-facing-point?",
-    "nav-enemy-turn-to-face-point",
-    "nav-enemy-execute-jump",
-    "nav-enemy-jump-land-anim",
-    "nav-enemy-rnd-float-range",
-    "nav-enemy-common-post",
-    "nav-enemy-execute-custom-jump",
-    "nav-enemy-initialize-custom-jump",
-    "nav-enemy-simple-post",
-    "nav-enemy-fall-and-play-death-anim",
-    "nav-enemy-neck-control-inactive",
-    "nav-enemy-frustrated?",
-    "nav-enemy-player-at-frustration-point?",
-    "nav-enemy-reset-frustration",
-    "nav-enemy-rnd-go-idle?",
-    "nav-enemy-notice-player?",
-    "nav-enemy-turn-to-face-dir",
-    "nav-enemy-facing-direction?",
-    "nav-enemy-test-point-near-nav-mesh?",
-    "nav-enemy-travel-post",
-    "nav-enemy-get-new-patrol-point",
-    "nav-enemy-set-hit-from-direction",
-    "nav-enemy-send-attack",
-    "nav-enemy-rnd-int-count",
-    "nav-enemy-rnd-float",
-    "nav-enemy-rnd-percent?",
-    "nav-enemy-default-event-handler",
-    "nav-enemy-jump-event-handler",
-    "process-drawable-death-event-handler",
-    "nav-enemy-patrol-post",
-    "nav-enemy-chase-post",
-    "nav-enemy-flee-post",
-    "nav-enemy-face-player-post",
-    "nav-enemy-falling-post",
-    "nav-enemy-death-post",
-    "nav-enemy-player-vulnerable?",
-    "nav-enemy-facing-player?",
-    "nav-enemy-test-nav-mesh-intersection-xz?",
-    "nav-enemy-test-point-in-nav-mesh?",
-    "nav-enemy-set-base-collide-sphere-collide-with",
-    "ja-group-index?",
-    "nav-enemy-jump-post",
-    "nav-enemy-jump-land-post",
-    "nav-enemy-init-by-other"
-  ],
-  "nav-enemy-h": ["nav-enemy-info", "nav-enemy"],
-  "navigate": [
-    "test-xz-point-on-line-segment?",
-    "ray-ccw-line-segment-intersection?",
-    "choose-travel-portal-vertex",
-    "init-ray",
-    "*edge-vert0-table*",
-    "*edge-vert1-table*",
-    "ray-line-segment-intersection?",
-    "point-triangle-distance-min",
-    "*edge-mask-table*",
-    "*nav-patch-route-table*",
-    "*nav-timer*",
-    "*nav-update-route-table-ray-count*",
-    "*nav-update-route-table-route-count*",
-    "nav-mesh-update-route-table",
-    "nav-mesh-lookup-route",
-    "nav-ray-test-local?",
-    "init-ray-local",
-    "init-ray-dir-local",
-    "*debug-traverse*",
-    "*debug-tests*",
-    "circle-triangle-intersection?",
-    "point-inside-rect?",
-    "recursive-inside-poly",
-    "point-inside-poly?",
-    "vu-point-triangle-intersection?",
-    "*color-red*",
-    "*color-blue*",
-    "*color-green*",
-    "*color-cyan*",
-    "*color-yellow*",
-    "*color-white*",
-    "*travel-timer*",
-    "*clip-for-spheres-timer*",
-    "*find-poly-timer*",
-    "*nav-timer-enable*",
-    "*nav-triangle-test-count*",
-    "*nav-last-triangle-test-count*",
-    "pke-nav-hack",
-    "debug-report-nav-stats",
-    "*debug-output*",
-    "*debug-nav*",
-    "*debug-nav-ray*",
-    "*debug-ray-offset*",
-    "*debug-nav-travel*",
-    "*color-black*",
-    "*color-gray*",
-    "*color-magenta*",
-    "*color-light-red*",
-    "*color-light-green*",
-    "*color-light-blue*",
-    "*color-light-cyan*",
-    "*color-light-magenta*",
-    "*color-light-yellow*",
-    "*color-dark-red*",
-    "*color-dark-green*",
-    "*color-dark-blue*",
-    "*color-dark-cyan*",
-    "*color-dark-magenta*",
-    "*color-dark-yellow*",
-    "*color-orange*",
-    "*nav-one-third*",
-    "inc-mod3",
-    "dec-mod3",
-    "circle-triangle-intersection-proc?",
-    "nav-ray-test",
-    "*debug-offset*",
-    "clip-vector-to-halfspace!",
-    "add-nav-sphere",
-    "add-collide-shape-spheres",
-    "circle-tangent-directions",
-    "find-closest-circle-ray-intersection",
-    "sign-bit",
-    "compute-dir-parm",
-    "*debug-ray-test*",
-    "*debug-ray-test-capture-mode*",
-    "*debug-ray-test-capture-output*",
-    "*test-ray-start-poly-id*",
-    "*test-ray-src-pos*",
-    "*test-ray-dest-pos*",
-    "debug-nav-validate-current-poly",
-    "start-collect-nav",
-    "end-collect-nav",
-    "nav-sphere-from-cam",
-    "cfs-travel-vec",
-    "cfs-work",
-    "nav-control-cfs-work"
-  ],
-  "navigate-h": [
-    "nav-mesh-connect",
-    "process-level-heap",
-    "*default-nav-mesh*",
-    "has-nav-mesh?",
-    "nav-poly",
-    "nav-vertex",
-    "nav-sphere",
-    "nav-ray",
-    "nav-route-portal",
-    "clip-travel-vector-to-mesh-return-info",
-    "nav-node",
-    "nav-lookup-elem",
-    "nav-mesh",
-    "check-vector-collision-with-nav-spheres-info",
-    "nav-gap-info",
-    "nav-control"
-  ],
-  "ocean": [
-    "*ocean-map*",
-    "ocean-interp-wave",
-    "ocean-generate-verts",
-    "*swamp-low-ocean-marker*",
-    "draw-ocean-texture",
-    "ocean-init-buffer",
-    "draw-ocean-far",
-    "draw-ocean-mid",
-    "ocean-end-buffer",
-    "draw-ocean-near",
-    "init-ocean-far-regs",
-    "render-ocean-far",
-    "render-ocean-quad",
-    "draw-large-polygon-ocean",
-    "draw-ocean",
-    "update-ocean"
-  ],
-  "ocean-frames": ["*ocean-wave-frames*"],
-  "ocean-h": [
-    "*ocean-work*",
-    "*ocean-facing*",
-    "*ocean-off*",
-    "*ocean-mid-off*",
-    "*ocean-near-off*",
-    "*ocean-heights*",
-    "*ocean-verts*",
-    "ocean-corner",
-    "ocean-wave-info",
-    "ocean-vertex",
-    "ocean-spheres",
-    "ocean-colors",
-    "ocean-mid-mask",
-    "ocean-mid-indices",
-    "ocean-mid-masks",
-    "ocean-trans-mask",
-    "ocean-trans-index",
-    "ocean-trans-indices",
-    "ocean-near-index",
-    "ocean-near-indices",
-    "ocean-near-colors",
-    "ocean-map",
-    "ocean-trans-strip",
-    "ocean-trans-strip-array",
-    "ocean-wave-data",
-    "ocean-wave-frames",
-    "ocean-work",
-    "ocean-vu0-work",
-    "ocean-texture-constants",
-    "ocean-texture-work",
-    "ocean-mid-vertex",
-    "ocean-mid-constants",
-    "ocean-mid-upload",
-    "ocean-mid-upload2",
-    "ocean-mid-work",
-    "ocean-near-constants",
-    "ocean-near-upload",
-    "ocean-near-vertex",
-    "ocean-near-work"
-  ],
-  "ocean-mid": [
-    "ocean-mid-block",
-    "ocean-mid-add-constants",
-    "ocean-mid-add-call",
-    "ocean-mid-add-upload",
-    "ocean-mid-add-call-flush",
-    "draw-ocean-transition",
-    "draw-ocean-mid-seams",
-    "ocean-seams-add-constants",
-    "ocean-mid-add-upload-top",
-    "ocean-mid-add-upload-bottom",
-    "ocean-mid-add-upload-middle",
-    "ocean-mid-camera-masks-bit?",
-    "ocean-mid-mask-ptrs-bit?",
-    "ocean-mid-add-upload-table",
-    "ocean-mid-camera-masks-set!",
-    "ocean-mid-add-matrices",
-    "ocean-mid-check",
-    "ocean-matrix*!",
-    "ocean-mid-setup-constants",
-    "ocean-vector-matrix*!"
-  ],
-  "ocean-near": [
-    "ocean-near-block",
-    "ocean-near-add-constants",
-    "ocean-near-add-heights",
-    "ocean-near-add-call",
-    "ocean-near-add-upload",
-    "ocean-near-add-matrices",
-    "ocean-near-setup-constants",
-    "ocean-near-add-call-flush"
-  ],
-  "ocean-tables": [
-    "*ocean-spheres-village1*",
-    "*ocean-colors-village1*",
-    "*ocean-near-indices-village1*",
-    "*ocean-trans-indices-village1*",
-    "*ocean-mid-indices-village1*",
-    "*ocean-mid-masks-village1*",
-    "*ocean-spheres-village2*",
-    "*ocean-colors-village2*",
-    "*ocean-near-indices-village2*",
-    "*ocean-trans-indices-village2*",
-    "*ocean-mid-indices-village2*",
-    "*ocean-mid-masks-village2*",
-    "*ocean-near-indices-sunken*",
-    "*ocean-trans-indices-sunken*",
-    "*ocean-mid-indices-sunken*",
-    "*ocean-mid-masks-sunken*",
-    "*ocean-map-village1*",
-    "*ocean-map-village2*",
-    "*ocean-map-sunken*"
-  ],
-  "ocean-texture": [
-    "ocean-texture-vu1-block",
-    "ocean-texture-add-constants",
-    "ocean-texture-add-envmap",
-    "ocean-texture-add-verts",
-    "ocean-texture-add-call-start",
-    "ocean-texture-add-call-rest",
-    "ocean-texture-add-verts-last",
-    "ocean-texture-add-call-done",
-    "*ocean-texture-work*",
-    "ocean-texture-setup-constants"
-  ],
-  "ocean-trans-tables": [
-    "*ocean-left-table*",
-    "*ocean-right-table*",
-    "*ocean-up-table*",
-    "*ocean-down-table*",
-    "*ocean-down-left-table*",
-    "*ocean-down-right-table*",
-    "*ocean-up-right-table*",
-    "*ocean-up-left-table*",
-    "*ocean-trans-left-table*",
-    "*ocean-trans-right-table*",
-    "*ocean-trans-up-table*",
-    "*ocean-trans-down-table*",
-    "*ocean-trans-down-left-table*",
-    "*ocean-trans-down-right-table*",
-    "*ocean-trans-up-right-table*",
-    "*ocean-trans-up-left-table*",
-    "*ocean-trans-corner-table*",
-    "*ocean-trans-strip-array*",
-    "*ocean-trans-st-table*"
-  ],
-  "ocean-transition": [
-    "ocean-make-trans-camera-masks",
-    "ocean-trans-add-upload-strip",
-    "ocean-trans-add-constants",
-    "draw-ocean-transition-seams",
-    "ocean-trans-camera-masks-bit?",
-    "ocean-trans-add-upload",
-    "ocean-trans-mask-ptrs-bit?",
-    "ocean-trans-add-upload-table",
-    "ocean-transition-check",
-    "ocean-trans-mask-ptrs-set!"
-  ],
-  "ocean-vu0": ["*ocean-vu0-work*", "ocean-vu0-block"],
-  "ogre-obs": [
-    "*shortcut-boulder-whole-sg*",
-    "*shortcut-boulder-broken-sg*",
-    "shortcut-boulder-idle",
-    "shortcut-boulder-break",
-    "ripple-for-ogre-lava",
-    "*ogre-bridgeend-sg*",
-    "ogre-bridgeend-idle",
-    "*ogre-bridge-sg*",
-    "*ogre-bridge-joint-array*",
-    "ogre-bridge-update-joints",
-    "ogre-bridge-activated",
-    "ogre-bridge-idle",
-    "ogre-bridge-break",
-    "ogre-bridge-activate",
-    "*ogre-isle-d-sg*",
-    "*ogre-isle-b-sg*",
-    "*ogre-isle-constants*",
-    "*ogre-step-b-sg*",
-    "*ogre-step-c-sg*",
-    "*ogre-step-a-sg*",
-    "*ogre-step-constants*",
-    "*tntbarrel-sg*",
-    "*med-res-snow-sg*",
-    "*ogre-isle-a-sg*",
-    "*ogre-isle-c-sg*",
-    "tntbarrel",
-    "ogre-plat",
-    "ogre-step",
-    "ogre-step-a",
-    "ogre-step-b",
-    "ogre-step-c",
-    "ogre-step-d",
-    "ogre-isle",
-    "ogre-isle-b",
-    "ogre-isle-c",
-    "ogre-isle-d",
-    "ogre-bridge",
-    "ogre-bridgeend",
-    "ogre-lava",
-    "shortcut-boulder"
-  ],
-  "ogre-part": ["ogre-part"],
-  "ogreboss": [
-    "*ogreboss-sg*",
-    "ogreboss-get-targets",
-    "*ogreboss*",
-    "ogreboss-dead",
-    "ogreboss-idle",
-    "ogreboss-reset-camera",
-    "ogreboss-trigger-steps",
-    "ogreboss-die",
-    "ogreboss-stage1",
-    "ogreboss-submerge",
-    "ogreboss-post",
-    "ogreboss-spawn-super-boulder",
-    "ogreboss-update-shuffling",
-    "ogreboss-stage3-throw",
-    "ogreboss-player-inside-range?",
-    "ogreboss-super-boulder",
-    "ogreboss-super-boulder-init-by-other",
-    "ogreboss-set-stage2-camera",
-    "ogreboss-move-far",
-    "ogreboss-roll-boulder",
-    "ogreboss-stage3-shuffle",
-    "ogreboss-stage3-hit",
-    "ogreboss-update-super-boulder",
-    "ogreboss-blend-hit-anim",
-    "ogreboss-bounce-boulder",
-    "ogreboss-bounce-boulder-init-by-other",
-    "ogreboss-set-stage1-camera",
-    "ogreboss-move-near",
-    "ogreboss-shoot-boulder",
-    "ogreboss-inc-try-count",
-    "ogreboss-stage2",
-    "ogreboss-emerge",
-    "ogreboss-pick-target",
-    "ogreboss-missile",
-    "ogreboss-missile-init-by-other",
-    "ogreboss-idle-loop",
-    "*ogreboss-cam-sg*",
-    "ogreboss-wait-for-player",
-    "ogreboss-intro",
-    "*ogreboss-column-sg*",
-    "*ogreboss-bounce-boulder-sg*",
-    "ogreboss-bounce-boulder-idle",
-    "*ogreboss-super-boulder-sg*",
-    "ogreboss-super-boulder-idle",
-    "ogreboss-super-boulder-impact-effect",
-    "ogreboss-super-boulder-roll",
-    "ogreboss-super-boulder-play-hit-anim",
-    "ogreboss-rock-explosion-effect",
-    "ogreboss-super-boulder-land",
-    "ogreboss-super-boulder-throw",
-    "ogreboss-super-boulder-hit",
-    "ogreboss-super-boulder-die",
-    "ogreboss-super-boulder-killed-player",
-    "*ogreboss-shoot-boulder-sg*",
-    "*ogreboss-missile-shadow-control*",
-    "ogreboss-missile-idle",
-    "*ogreboss-shoot-boulder-break-sg*",
-    "ogreboss-missile-impact",
-    "*ogreboss-shadow-control*",
-    "ogreboss-missile-seek",
-    "ogreboss-missile-scale-explosion",
-    "ogreboss-missile-init-data",
-    "ogreboss-super-boulder-event-handler",
-    "ogreboss-bounce-boulder-event-handler",
-    "ogreboss",
-    "ogreboss-debug-adjust-difficulty",
-    "ogreboss-attack-event-handler"
-  ],
-  "oracle": ["*oracle-sg*", "oracle"],
-  "orb-cache": [
-    "*orb-cache-top-sg*",
-    "orb-cache-top-complete",
-    "orb-cache-top-activate",
-    "orb-cache-top-idle",
-    "orb-cache-top"
-  ],
-  "orbit-plat": [
-    "*orbit-plat-sg*",
-    "orbit-plat-bottom-init-by-other",
-    "orbit-plat-wait-for-other",
-    "orbit-plat-idle",
-    "orbit-plat-riding",
-    "orbit-plat-rotating",
-    "get-rotate-point!",
-    "get-nav-point!",
-    "orbit-plat-still",
-    "orbit-plat-reset",
-    "*orbit-plat-bottom-sg*",
-    "orbit-plat-bottom-idle",
-    "orbit-plat-bottom",
-    "orbit-plat"
-  ],
-  "pad": [
-    "cpad-set-buzz!",
-    "*cpad-list*",
-    "cpad-get-data",
-    "get-current-time",
-    "get-integral-current-time",
-    "*cpad-debug*",
-    "cpad-invalid!",
-    "cpad-open",
-    "*cheat-mode*",
-    "analog-input",
-    "service-cpads",
-    "buzz-stop!",
-    "hw-cpad",
-    "cpad-info",
-    "cpad-list"
-  ],
-  "part-tester": [
-    "part-tester",
-    "*debug-part-dead-pool*",
-    "part-tester-init-by-other",
-    "*part-tester*",
-    "part-tester-idle",
-    "*part-tester-name*",
-    "start-part"
-  ],
-  "pat-h": [
-    "pat-material->string",
-    "pat-mode->string",
-    "pat-event->string",
-    "*pat-mode-info*",
-    "pat-surface",
-    "pat-mode-info"
-  ],
-  "path-h": ["string->symbol", "path-control", "curve-control"],
-  "pelican": [
-    "*pelican-sg*",
-    "pelican-wait-at-end",
-    "pelican-wait-at-nest",
-    "pelican-circle",
-    "pelican-fly",
-    "pelican-path-update",
-    "zero-func",
-    "*PELICAN-bank*",
-    "pelican-dive",
-    "pelican-post",
-    "pelican-from-nest",
-    "pelican-explode",
-    "pelican-spit",
-    "pelican-fly-to-end",
-    "pelican-to-nest",
-    "pelican-bank",
-    "pelican"
-  ],
-  "plant-boss": [
-    "*plant-boss-sg*",
-    "*plant-boss-shadow-control*",
-    "plant-boss-arm",
-    "plant-boss-arm-init",
-    "plant-boss-back-arms-init",
-    "plant-boss-vine-init",
-    "plant-boss-root-init",
-    "plant-boss-leaf",
-    "plant-boss-leaf-init",
-    "plant-boss-dead",
-    "plant-boss-far-idle",
-    "plant-boss-dead-idle",
-    "plant-boss-dead-bounce",
-    "plant-boss-generic-event-handler",
-    "plant-boss-post",
-    "plant-boss-spawn",
-    "plant-boss-attack",
-    "plant-boss-idle",
-    "plant-boss-reset",
-    "plant-boss-default-event-handler",
-    "plant-boss-hit",
-    "plant-boss-vulnerable",
-    "plant-boss-intro",
-    "*plant-boss-leaf-sg*",
-    "plant-boss-leaf-idle",
-    "plant-boss-leaf-die",
-    "plant-boss-leaf-open-idle",
-    "plant-boss-leaf-close",
-    "plant-boss-leaf-bounce",
-    "plant-boss-leaf-open",
-    "*plant-boss-root-sg*",
-    "plant-boss-root-idle",
-    "*plant-boss-vine-sg*",
-    "plant-boss-vine-idle",
-    "*plant-boss-back-arms-sg*",
-    "plant-boss-back-arms-idle",
-    "*plant-boss-arm-sg*",
-    "plant-boss-arm-idle",
-    "plant-boss-root-die",
-    "plant-boss-vine-die",
-    "plant-boss-vine-hit",
-    "plant-boss-back-arms-hit",
-    "plant-boss-back-arms-die",
-    "plant-boss-arm-die",
-    "plant-boss-arm-hit",
-    "plant-boss-eat",
-    "plant-boss"
-  ],
-  "plat": ["*plat-jungleb-sg*", "*plat-sunken-sg*", "*plat-sg*", "plat"],
-  "plat-button": [
-    "*plat-button-sg*",
-    "plat-button-camera-off",
-    "plat-button-camera-on",
-    "plat-button"
-  ],
-  "plat-eco": ["*plat-eco-lit-sg*", "*plat-eco-unlit-sg*", "plat-eco"],
-  "plat-flip": ["*plat-flip-sg*", "plat-flip-idle", "plat-flip"],
-  "pov-camera": ["pov-camera-play-and-reposition"],
-  "pov-camera-h": ["pov-camera"],
-  "powerups": ["eco-blue-glow", "cloud-track"],
-  "process-drawable": [
-    "process-entity-status!",
-    "process-grab?",
-    "process-release?",
-    "ja-post",
-    "make-nodes-from-jg",
-    "dma-add-process-drawable",
-    "add-process-drawable",
-    "*valid-con*",
-    "vector<-cspace+vector!",
-    "cspace-children",
-    "cspace-inspect-tree",
-    "*default-skel-template*",
-    "fill-skeleton-cache",
-    "execute-math-engine",
-    "draw-joint-spheres",
-    "process-drawable-idle",
-    "anim-loop",
-    "ja-done?",
-    "ja-min?",
-    "ja-max?",
-    "ja-num-frames",
-    "ja-frame-num",
-    "ja-aframe",
-    "ja-speed",
-    "ja-step",
-    "ja-group-size",
-    "ja-eval",
-    "ja-blend-eval",
-    "transform-post",
-    "rider-trans",
-    "rider-post",
-    "pusher-post",
-    "process-drawable-delay-player",
-    "process-drawable-fuel-cell-handler",
-    "process-drawable-birth-fuel-cell",
-    "process-drawable-valid?"
-  ],
-  "process-drawable-h": [
-    "joint-control-reset!",
-    "cspace-index-by-name",
-    "cspace-by-name",
-    "cspace-by-name-no-fail",
-    "cspace-index-by-name-no-fail",
-    "num-func-none",
-    "num-func-+!",
-    "num-func--!",
-    "num-func-loop!",
-    "num-func-seek!",
-    "num-func-blend-in!",
-    "num-func-chan",
-    "num-func-identity"
-  ],
-  "process-taskable": [
-    "othercam-running",
-    "othercam-calc",
-    "vector-for-ambient",
-    "hide-hud",
-    "hud-hidden?",
-    "process-taskable-clean-up-after-talking",
-    "process-taskable-hide-exit",
-    "process-taskable-play-anim-code",
-    "process-taskable-play-anim-trans",
-    "process-taskable-anim-loop",
-    "process-taskable-play-anim-enter",
-    "process-taskable-play-anim-exit",
-    "process-taskable-hide-handler",
-    "process-taskable-hide-enter"
-  ],
-  "progress": [
-    "progress-normal",
-    "progress-going-out",
-    "progress-gone",
-    "*progress-state*",
-    "get-next-task-up",
-    "get-next-level-up",
-    "get-next-level-down",
-    "get-next-task-down",
-    "*progress-save-info*",
-    "progress-coming-in",
-    "make-levels-with-tasks-available-to-progress",
-    "*progress-stack*",
-    "progress-init-by-other",
-    "init-game-options",
-    "progress-waiting",
-    "progress-global-state",
-    "make-current-level-available-to-progress",
-    "progress-debug"
-  ],
-  "progress-draw": [
-    "adjust-pos",
-    "draw-percent-bar",
-    "print-language-name",
-    "hide-progress-icons"
-  ],
-  "progress-h": [
-    "*progress-process*",
-    "*progress-last-task-index*",
-    "count-info",
-    "game-count-info",
-    "task-info-data",
-    "level-tasks-info",
-    "game-option",
-    "progress"
-  ],
-  "progress-part": [
-    "part-progress-hud-left-func",
-    "part-progress-hud-right-func",
-    "part-progress-hud-orb-func",
-    "part-progress-hud-buzzer-func",
-    "part-progress-hud-button-func",
-    "part-progress-hud-tint-func",
-    "part-progress-card-slot-01-func",
-    "part-progress-card-slot-02-func",
-    "part-progress-card-slot-03-func",
-    "part-progress-card-slot-04-func",
-    "part-progress-card-cell-func",
-    "part-progress-save-icon-func",
-    "fuel-cell-progress-hud-orbit-callback"
-  ],
-  "progress-static": [
-    "*main-options*",
-    "*title*",
-    "*options*",
-    "*main-options-demo*",
-    "*main-options-demo-shared*",
-    "*game-options*",
-    "*game-options-japan*",
-    "*game-options-demo*",
-    "*graphic-options*",
-    "*graphic-title-options-pal*",
-    "*sound-options*",
-    "*yes-no-options*",
-    "*ok-options*",
-    "*load-options*",
-    "*save-options*",
-    "*save-options-title*",
-    "*options-remap*",
-    "*language-name-remap*",
-    "*task-egg-starting-x*",
-    "*game-counts*"
-  ],
-  "projectiles": [
-    "projectile-collision-reaction",
-    "projectile-update-velocity-space-wars",
-    "find-nearest-attackable",
-    "find-ground-and-draw-shadow",
-    "*search-info*",
-    "spawn-projectile-blue",
-    "search-info"
-  ],
-  "projectiles-h": ["projectile", "projectile-yellow", "projectile-blue"],
-  "prototype-h": [
-    "prototype-bucket",
-    "prototype-bucket-shrub",
-    "prototype-inline-array-shrub",
-    "prototype-array-shrub-info",
-    "prototype-bucket-tie",
-    "prototype-array-tie",
-    "proxy-prototype-array-tie",
-    "instance"
-  ],
-  "pskernel": [
-    "deinstall-debug-handlers",
-    "return-from-exception",
-    "kernel-set-exception-vector",
-    "kernel-write",
-    "install-debug-handler",
-    "kernel-copy-function",
-    "kernel-copy-to-kernel-ram",
-    "kernel-write-function",
-    "kernel-read-function",
-    "kernel-read",
-    "kernel-check-hardwired-addresses",
-    "install-default-debug-handler",
-    "kernel-set-interrupt-vector",
-    "kernel-set-level2-vector",
-    "deinstall-debug-handler",
-    "resend-exception",
-    "lowmemmap"
-  ],
-  "puffer": [
-    "*puffer-sg*",
-    "*puffer-mean-sg*",
-    "puffer-idle",
-    "puffer-patrol",
-    "puffer-attack",
-    "puffer-die",
-    "puffer-default-event-handler",
-    "puffer-post",
-    "puffer",
-    "pick-patrol-point-away-from-buddy-work"
-  ],
-  "qbert-plat": [
-    "qbert-plat-master-wait-for-door",
-    "qbert-plat-master-idle",
-    "qbert-plat-master-do-door",
-    "qbert-plat-wait-for-master",
-    "*qbert-plat-sg*",
-    "*qbert-plat-constants*",
-    "qbert-plat-on-init-by-other",
-    "*qbert-plat-on-sg*",
-    "qbert-plat-on-mimic",
-    "qbert-plat-on-die",
-    "qbert-plat-event-handler",
-    "qbert-plat-on",
-    "qbert-plat",
-    "qbert-plat-master"
-  ],
-  "quaternion": [
-    "quaternion->matrix",
-    "quaternion-vector-angle!",
-    "vector-xz-length",
-    "vector-xz-normalize!",
-    "quaternion-from-two-vectors-max-angle!",
-    "vector-z-quaternion!",
-    "quaternion-normalize!",
-    "quaternion*!",
-    "acos",
-    "vector-x-quaternion!",
-    "quaternion-y-angle",
-    "vector-rad<-vector-deg/2!",
-    "vector-sincos-rad!",
-    "quaternion-dot",
-    "atan-series-rad",
-    "vector-sin-rad!",
-    "vector-length",
-    "sincos-rad!",
-    "quaternion-vector-len",
-    "atan2-rad",
-    "matrix->quaternion",
-    "quaternion-float*!",
-    "acos-rad",
-    "quaternion-norm",
-    "quaternion-axis-angle!",
-    "vector-angle<-quaternion!",
-    "quaternion-zero!",
-    "quaternion-identity!",
-    "quaternion-i!",
-    "quaternion-j!",
-    "quaternion-k!",
-    "quaternion-copy!",
-    "quaternion-set!",
-    "quaternion+!",
-    "quaternion-!",
-    "quaternion-negate!",
-    "quaternion-conjugate!",
-    "quaternion-float/!",
-    "quaternion-norm2",
-    "quaternion-inverse!",
-    "quaternion-right-mult-matrix!",
-    "quaternion-left-mult-matrix!",
-    "matrix-with-scale->quaternion",
-    "quaternion-log!",
-    "quaternion-exp!",
-    "quaternion-slerp!",
-    "quaternion-pseudo-slerp!",
-    "quaternion-zxy!",
-    "vector-y-quaternion!",
-    "quaternion-vector-y-angle",
-    "quaternion-rotate-local-x!",
-    "quaternion-rotate-local-y!",
-    "quaternion-rotate-local-z!",
-    "quaternion-rotate-y!",
-    "quaternion-rotate-x!",
-    "quaternion-rotate-z!",
-    "quaternion-delta-y",
-    "quaternion-rotate-y-to-vector!",
-    "vector-rotate-y!",
-    "vector-x-angle",
-    "quaterion<-rotate-y-vector",
-    "quaternion-validate",
-    "quaternion-xz-angle"
-  ],
-  "quaternion-h": ["*unity-quaternion*", "quaternion"],
-  "quicksandlurker": [
-    "*quicksandlurker-sg*",
-    "quicksandlurker-idle",
-    "orient-to-face-target",
-    "quicksandlurker-track",
-    "quicksandlurker-wait",
-    "quicksandlurker-popup",
-    "quicksandlurker-spit",
-    "spawn-quicksandlurker-missile",
-    "quicksandlurker-attack",
-    "quicksandlurker-check-hide-transition",
-    "quicksandlurker-hide",
-    "inc-angle",
-    "quicksandlurker-die",
-    "quicksandlurker-victory",
-    "quicksandlurker-missile-init-by-other",
-    "quicksandlurker-missile-idle",
-    "quicksandlurker-missile-impact",
-    "get-height-over-navmesh!",
-    "intersects-nav-mesh?",
-    "quicksandlurker-default-event-handler",
-    "quicksandlurker-post",
-    "quicksandlurker-yawn",
-    "quicksandlurker-missile",
-    "quicksandlurker-missile-init-data",
-    "quicksandlurker"
-  ],
-  "racer": [
-    "*racer-sg*",
-    "*racer-shadow-control*",
-    "blocking-plane-spawn",
-    "racer-effect",
-    "blocking-plane-destroy",
-    "*racer-explode-sg*",
-    "racer"
-  ],
-  "racer-part": [
-    "zoomer-heat-slice-color",
-    "part-hud-racer-speed-func",
-    "part-hud-racer-heat-func",
-    "part-hud-zoomer-heat-slice-01-func",
-    "part-hud-zoomer-heat-slice-02-func",
-    "part-hud-zoomer-heat-slice-03-func",
-    "hud-bike-heat",
-    "hud-bike-speed"
-  ],
-  "racer-states-L1-RACERP": [
-    "target-racing",
-    "target-racing-grab",
-    "target-racing-clone-anim",
-    "target-racing-get-off-hit-ground",
-    "target-racing-get-off-jump",
-    "target-racing-death",
-    "target-racing-smack-check",
-    "target-racing-jump",
-    "target-racing-bounce",
-    "target-racing-falling",
-    "target-racing-get-on",
-    "target-racing-get-off",
-    "target-racing-hit"
-  ],
-  "ramdisk": [
-    "*ramdisk-rpc*",
-    "*current-ramdisk-id*",
-    "ramdisk-load",
-    "ramdisk-sync",
-    "ramdisk-rpc-fill",
-    "ramdisk-rpc-load",
-    "ramdisk-rpc-load-to-ee"
-  ],
-  "res": ["*res-static-buf*", "uinteger", "part-group-pointer?"],
-  "res-h": ["*res-key-string*", "res-tag", "res-lump"],
-  "rigid-body": [
-    "*rigid-body-platform-constants*",
-    "matrix-3x3-triple-transpose-product",
-    "rigid-body-platform-event-handler",
-    "rigid-body-platform-post",
-    "rigid-body-platform-constants",
-    "rigid-body-control-point-inline-array",
-    "rigid-body-platform"
-  ],
-  "rigid-body-h": ["rigid-body", "rigid-body-control-point"],
-  "ripple": [
-    "ripple-update-waveform-offs",
-    "ripple-slow-add-sine-waves",
-    "*ripple-globals*",
-    "ripple-execute-init",
-    "ripple-create-wave-table",
-    "ripple-apply-wave-table",
-    "ripple-make-request",
-    "ripple-execute",
-    "ripple-matrix-scale",
-    "ripple-add-debug-sphere",
-    "ripple-find-height",
-    "ripple-request",
-    "ripple-globals"
-  ],
-  "robocave-part": ["robocave-part"],
-  "robotboss": [
-    "robotboss-blue-wait",
-    "robotboss-blue-dark-bomb",
-    "robotboss-always-trans",
-    "robotboss-shooting-trans",
-    "robotboss-blue-done",
-    "*robotboss-blueeco-sg*",
-    "robotboss-blue-beam",
-    "robotboss-position",
-    "robotboss-cut-cam",
-    "robotboss-set-dda",
-    "robotboss-cut-cam-exit",
-    "robotboss-setup-for-hits",
-    "robotboss-yellow-eco-on",
-    "robotboss-yellow-eco-off",
-    "robotboss-blue-dark-bomb-wait",
-    "robotboss-green",
-    "robotboss-green-wait",
-    "robotboss-green-dark-bomb",
-    "robotboss-greenshot",
-    "robotboss-handler",
-    "robotboss-green-dark-bomb-wait",
-    "robotboss-darkecobomb",
-    "robotboss-red",
-    "robotboss-red-wait",
-    "robotboss-is-red-hit",
-    "robotboss-redshot-fill-array",
-    "robotboss-redshot",
-    "robotboss-red-dark-bomb",
-    "*robotboss-redeco-sg*",
-    "robotboss-red-dark-bomb-wait",
-    "robotboss-yellow",
-    "robotboss-yellow-wait",
-    "robotboss-time-to-shoot-yellow",
-    "robotboss-is-yellow-hit",
-    "robotboss-yellowshot",
-    "robotboss-yellow-dark-bomb",
-    "*robotboss-yelloweco-sg*",
-    "robotboss-white-eco-movie",
-    "robotboss-daxter-sacrifice-movie",
-    "robotboss-yellow-dark-bomb-wait",
-    "robotboss-bomb-handler",
-    "robotboss-anim-blend-loop",
-    "redshot-launch-info",
-    "redshot-launch-array"
-  ],
-  "robotboss-h": ["robotboss-dda", "robotboss", "target-has-all-the-cells?"],
-  "robotboss-misc": [
-    "*finalbosscam-sg*",
-    "robotboss-manipy-trans-hook",
-    "*silodoor-sg*",
-    "*ecoclaw-sg*",
-    "*ecoclaw*",
-    "ecoclaw-idle",
-    "ecoclaw-activate",
-    "ecoclaw-beam-particle-callback",
-    "*med-res-snow1-sg*",
-    "ecoclaw-handler",
-    "finalbosscam-init-by-other",
-    "ecoclaw-part-info",
-    "ecoclaw",
-    "silodoor",
-    "finalbosscam"
-  ],
-  "robotboss-weapon": [
-    "*redring-sg*",
-    "arcing-shot-setup",
-    "yellowshot-idle",
-    "arcing-shot-calculate",
-    "redshot-idle",
-    "redshot-trans",
-    "redshot-wait",
-    "redshot-explode",
-    "redshot-particle-callback",
-    "*greenshot-sg*",
-    "greenshot-idle",
-    "*darkecobomb-sg*",
-    "darkecobomb-idle",
-    "darkecobomb-land",
-    "darkecobomb-explode-if-player-high-enough",
-    "darkecobomb-countdown",
-    "darkecobomb-explode",
-    "arcing-shot-draw",
-    "arcing-shot-debug-trajectory",
-    "darkecobomb-handler",
-    "darkecobomb-init-by-other",
-    "greenshot-init-by-other",
-    "redshot-handler",
-    "redshot-init-by-other",
-    "yellowshot-init-by-other",
-    "torus",
-    "torus-verts",
-    "arcing-shot",
-    "darkecobomb",
-    "greenshot",
-    "redshot",
-    "yellowshot"
-  ],
-  "rolling-lightning-mole": [
-    "*lightning-mole-sg*",
-    "peeper-up",
-    "peeper-down",
-    "peeper-hide",
-    "peeper-wait",
-    "*lightning-mole-nav-enemy-info*",
-    "lightning-mole-gone",
-    "lightning-mole-hiding",
-    "lightning-mole-yelp",
-    "*lightning-mole-hole*",
-    "lightning-mole-head-for-hole",
-    "lightning-mole-dive",
-    "lightning-mole-task-complete?",
-    "fleeing-nav-enemy-clip-travel",
-    "fleeing-nav-enemy-adjust-travel",
-    "fleeing-nav-enemy-chase-post-func",
-    "lightning-mole-debug-run",
-    "fleeing-nav-enemy-debug",
-    "fleeing-nav-enemy-adjust-nav-info",
-    "find-adjacent-bounds-one",
-    "find-adjacent-bounds",
-    "fleeing-nav-enemy-chase-post",
-    "lightning-mole-hole-post",
-    "lightning-mole-run-code",
-    "lightning-mole-debug-blend",
-    "check-drop-level-rolling-dirt",
-    "check-drop-level-rolling-dirt-finish",
-    "fleeing-nav-enemy-info",
-    "fleeing-nav-enemy",
-    "lightning-mole",
-    "peeper"
-  ],
-  "rolling-obs": [
-    "ripple-for-rolling-water",
-    "gorge-init",
-    "gorge-start-idle",
-    "gorge-in-front",
-    "gorge-start-ready",
-    "gorge-start-launch-start-banner",
-    "gorge-trans",
-    "gorge-start-draw-time",
-    "gorge-behind",
-    "gorge-start-racing",
-    "seconds->race-time",
-    "race-time-read",
-    "rolling-start-init-by-other",
-    "gorge-finish-init-by-other",
-    "gorge-abort-init-by-other",
-    "gorge-start-race-finished",
-    "gorge-start-race-aborted",
-    "race-time->string",
-    "race-time-less-than",
-    "race-time-save",
-    "gorge-finish-idle",
-    "gorge-abort-idle",
-    "*rolling-start-whole-sg*",
-    "*rolling-start-broken-sg*",
-    "rolling-start-whole",
-    "rolling-start-break",
-    "*happy-plant-sg*",
-    "happy-plant-opened",
-    "happy-plant-init",
-    "dark-plants-all-done",
-    "happy-plant-opening",
-    "*rollingcam-sg*",
-    "*dark-plant-sg*",
-    "dark-plant-randomize",
-    "dark-plant-gone",
-    "dark-plant-startup",
-    "dark-plant-idle",
-    "dark-plant-sprout",
-    "dark-plant-check-target",
-    "dark-plant-has-bad-neighbor",
-    "dark-plant-death",
-    "pusher-base-init",
-    "*pusher-sg*",
-    "gorge-pusher-idle",
-    "pusher-idle",
-    "dark-plant-trans",
-    "race-time-copy!",
-    "race-time->seconds",
-    "rolling-part",
-    "rollingcam",
-    "pusher-base",
-    "pusher",
-    "gorge-pusher",
-    "dark-plant",
-    "happy-plant",
-    "race-time",
-    "rolling-start",
-    "gorge",
-    "gorge-start",
-    "gorge-finish",
-    "gorge-abort",
-    "rolling-water"
-  ],
-  "rolling-race-ring": [
-    "*race-ring-sg*",
-    "first-ring?",
-    "race-ring-active",
-    "race-ring-wait",
-    "last-ring?",
-    "race-ring-idle",
-    "race-ring-blue-set-particle-rotation-callback",
-    "race-ring-set-particle-rotation-callback",
-    "race-ring"
-  ],
-  "rolling-robber": [
-    "*robber-sg*",
-    "robber-find-ground",
-    "robber-die",
-    "robber-dead",
-    "robber-initial",
-    "robber-initial-notice",
-    "robber-move",
-    "robber-calc-speed",
-    "robber-rotate",
-    "robber-flee",
-    "robber-calc-anim-speed",
-    "robber-got-away",
-    "robber-tired",
-    "robber-idle",
-    "robber-task-complete?",
-    "fuel-cell-init-as-spline-slider",
-    "fuel-cell-spline-slider",
-    "robber-event-handler",
-    "robber-debug",
-    "robber"
-  ],
-  "ropebridge": [
-    "*ropebridge-tunings*",
-    "ropebridge-joint-callback",
-    "ropebridge-idle",
-    "*ropebridge-70-rest-state*",
-    "*ropebridge-52-rest-state*",
-    "*ropebridge-32-rest-state*",
-    "*ropebridge-36-rest-state*",
-    "*ropebridge-32-sg*",
-    "*snow-bridge-36-sg*",
-    "*ropebridge-52-sg*",
-    "*ropebridge-70-sg*",
-    "*ropebridge-36-sg*",
-    "*vil3-bridge-36-sg*",
-    "ropebridge-tuning",
-    "ropebridge-spring-point",
-    "ropebridge"
-  ],
-  "rpc-h": ["rpc-busy?", "rpc-call", "rpc-buffer", "rpc-buffer-pair"],
-  "sage": ["*sage-sg*", "sage"],
-  "sage-bluehut": ["*sage-bluehut-sg*", "assistant-bluehut", "sage-bluehut"],
-  "sage-finalboss-FIN": [
-    "*sage-finalboss-sg*",
-    "sage-finalboss-extra-enter",
-    "sage-finalboss-extra-trans",
-    "sage-finalboss-credits",
-    "sage-finalboss-credit-particle",
-    "*jak-white-sg*",
-    "*robotboss-cinematic-sg*",
-    "*plat-eco-finalboss-lit-sg*",
-    "*plat-eco-finalboss-unlit-sg*",
-    "plat-eco-finalboss",
-    "sage-finalboss-particle",
-    "sage-finalboss"
-  ],
-  "sage-finalboss-part": [
-    "check-drop-level-eichar-lighteco-pops",
-    "check-drop-level-bigdoor-open-pops"
-  ],
-  "sage-village3": [
-    "*sage-village3-sg*",
-    "*evilbro-village3-sg*",
-    "*evilsis-village3-sg*",
-    "sage-villagec"
-  ],
-  "sculptor": [
-    "*sculptor-sg*",
-    "muse-to-idle",
-    "*sculptor-muse-sg*",
-    "sculptor"
-  ],
-  "seagull": [
-    "seagull-init-by-other",
-    "sound-seagull-squall",
-    "seagullflock-idle",
-    "seagullflock-at-waterfall",
-    "aybabtu",
-    "seagull-reaction",
-    "*seagull-sg*",
-    "seagull-idle",
-    "seagull-soaring",
-    "seagull-flying",
-    "seagull-landing",
-    "*seagull-boxes*",
-    "seagull-takeoff",
-    "seagull-post",
-    "beach-rock-trigger",
-    "seagull",
-    "seagullflock"
-  ],
-  "sequence-a-village1": [
-    "sequenceA-village1-init-by-other",
-    "sequenceA-village1-trans-hook",
-    "*sidekick-human-sg*",
-    "sequenceA-village1"
-  ],
-  "settings": [
-    "set-aspect-ratio",
-    "set-video-mode",
-    "scf-get-volume",
-    "scf-get-language",
-    "scf-get-aspect",
-    "*boot-video-mode*"
-  ],
-  "settings-h": ["setting-data", "setting-control", "scf-time"],
-  "shadow": [
-    "compute-and-draw-shadow",
-    "draw-shadow",
-    "add-fake-shadow-to-buffer",
-    "swap-fake-shadow-buffers"
-  ],
-  "shadow-cpu": [
-    "shadow-vu0-upload",
-    "shadow-vu1-init-buffer",
-    "shadow-dma-init",
-    "shadow-execute",
-    "shadow-dma-end",
-    "shadow-vu0-block",
-    "*shadow-data*",
-    "shadow-xform-verts",
-    "shadow-calc-dual-verts",
-    "shadow-scissor-edges",
-    "shadow-scissor-top",
-    "shadow-init-vars",
-    "shadow-find-facing-single-tris",
-    "shadow-find-single-edges",
-    "shadow-find-facing-double-tris",
-    "shadow-find-double-edges",
-    "shadow-add-verts",
-    "shadow-add-facing-single-tris",
-    "shadow-add-single-edges",
-    "shadow-add-double-tris",
-    "shadow-add-double-edges",
-    "shadow-execute-all",
-    "shadow-stats",
-    "shadow-dcache"
-  ],
-  "shadow-cpu-h": [
-    "shadow-queue-append",
-    "shadow-queue-reset",
-    "*shadow-queue*",
-    "*shadow*",
-    "*shadow-object*",
-    "*shadow-debug*",
-    "shadow-settings",
-    "shadow-control",
-    "shadow-data",
-    "shadow-work",
-    "shadow-run",
-    "shadow-queue",
-    "shadow-vertex",
-    "shadow-matrix-ref",
-    "shadow-edge",
-    "shadow-tri",
-    "shadow-header",
-    "shadow-geo"
-  ],
-  "shadow-h": [
-    "*fake-shadow-buffer-1*",
-    "*fake-shadow-buffer-2*",
-    "*fake-shadow-buffer*",
-    "fake-shadow",
-    "fake-shadow-buffer"
-  ],
-  "shadow-vu1": [
-    "shadow-vu1-block",
-    "shadow-vu1-add-constants",
-    "shadow-vu1-add-matrix",
-    "*shadow-vu1-tri-template*",
-    "shadow-vu1-constants",
-    "shadow-vu1-gifbuf-template"
-  ],
-  "sharkey": [
-    "*sharkey-sg*",
-    "*sharkey-nav-enemy-info*",
-    "sharkey-get-player-position",
-    "sharkey-follow-trajectory",
-    "sharkey-reset-position",
-    "sharkey-notice-player?",
-    "sharkey-move-to-attack-position",
-    "sharkey"
-  ],
-  "shover": ["*shover-sg*", "*shover*", "shover-idle", "shover"],
-  "shrubbery": [
-    "upload-generic-shrub",
-    "shrub-num-tris",
-    "shrub-init-frame",
-    "shrub-upload-model",
-    "shrub-do-init-frame",
-    "shrub-vu1-block",
-    "shrub-upload-view-data",
-    "shrub-init-view-data",
-    "mem-usage-shrub-walk",
-    "shrub-make-perspective-matrix",
-    "shrub-time",
-    "draw-inline-array-instance-shrub",
-    "draw-prototype-inline-array-shrub",
-    "shrub-upload-test",
-    "test-func"
-  ],
-  "shrubbery-h": [
-    "shrubbery-login-post-texture",
-    "*shrub-state*",
-    "billboard",
-    "shrub-view-data",
-    "shrubbery",
-    "instance-shrubbery",
-    "drawable-inline-array-instance-shrub",
-    "drawable-tree-instance-shrub",
-    "generic-shrub-fragment",
-    "prototype-shrubbery",
-    "prototype-trans-shrubbery",
-    "prototype-generic-shrub",
-    "shrubbery-matrix",
-    "shrub-near-packet",
-    "instance-shrub-work",
-    "instance-shrub-dma"
-  ],
-  "sidekick": [
-    "*sidekick-sg*",
-    "cspace<-cspace+quaternion!",
-    "sidekick-clone",
-    "*sidekick-remap*",
-    "starts"
-  ],
-  "sidekick-human": [
-    "sequenceC-trans-hook",
-    "*darkecocan-sg*",
-    "sequenceC-can-trans-hook",
-    "*darkecocan-glow-sg*",
-    "sequenceC-can-trans-hook-2",
-    "*lurker-army*",
-    "*evilbro-sg*",
-    "evilsib-trans-hook-wait",
-    "*evilsis-sg*",
-    "evilsib-trans-hook-hover",
-    "sequenceA",
-    "sequenceB",
-    "sequenceC",
-    "army-info"
-  ],
-  "sky": [
-    "sky-vu1-block",
-    "sky-add-frame-data",
-    "sky-make-sun-data",
-    "sky-make-moon-data",
-    "sky-make-light",
-    "sky-init-upload-data",
-    "sky-upload",
-    "sky-draw",
-    "sky-frame-data"
-  ],
-  "sky-h": [
-    "*sky-parms*",
-    "*sky-upload-data*",
-    "*sky-drawn*",
-    "*cloud-drawn*",
-    "sky-color-hour",
-    "sky-color-day",
-    "sky-circle-data",
-    "sky-sun-data",
-    "sky-moon-data",
-    "sky-orbit",
-    "sky-upload-data",
-    "sky-parms",
-    "sky-tng-data",
-    "sky-work",
-    "sky-vertex"
-  ],
-  "sky-tng": [
-    "copy-sky-texture",
-    "copy-cloud-texture",
-    "*sky-work*",
-    "init-sky-regs",
-    "*sky-tng-data*",
-    "render-sky-tri",
-    "sky-roof-polygons",
-    "close-sky-buffer",
-    "sky-cloud-polygons",
-    "set-tex-offset",
-    "render-sky-quad",
-    "sky-tng-setup-cloud-layer",
-    "sky-cloud-polygon-indices",
-    "draw-large-polygon",
-    "init-sky-tng-data",
-    "clip-polygon-against-positive-hyperplane",
-    "clip-polygon-against-negative-hyperplane",
-    "sky-duplicate-polys",
-    "sky-tng-setup-clouds",
-    "render-sky-tng"
-  ],
-  "sky-utils": [
-    "sky-set-sun-radii",
-    "sky-set-sun-colors",
-    "sky-set-sun-colors-sun",
-    "sky-set-sun-colors-halo",
-    "sky-set-sun-colors-aurora",
-    "sky-set-orbit"
-  ],
-  "smush-control-h": ["smush-control"],
-  "snow-ball": [
-    "snow-ball-idle",
-    "snow-ball-roller-init-by-other",
-    "*snow-ball-sg*",
-    "snow-ball-shadow-init-by-other",
-    "snow-ball-roller-idle",
-    "snow-ball-roller-path-update",
-    "snow-ball-roller-path-init",
-    "*snow-ball-shadow-sg*",
-    "*snow-ball-shadow-control*",
-    "snow-ball-shadow-idle",
-    "snow-ball-shadow",
-    "snow-ball-junction",
-    "snow-ball-path-info",
-    "snow-ball-roller",
-    "snow-ball"
-  ],
-  "snow-bumper": [
-    "*snow-bumper-sg*",
-    "snow-bumper-spawn-fuel-cell",
-    "snow-bumper-inactive-idle",
-    "snow-bumper-active-far-idle",
-    "snow-bumper-deactivate",
-    "snow-bumper-active-close-idle",
-    "snow-bumper"
-  ],
-  "snow-bunny": [
-    "snow-bunny-execute-jump",
-    "snow-bunny-initialize-jump",
-    "*snow-bunny*",
-    "*snow-bunny-nav-enemy-info*",
-    "*snow-bunny-sg*",
-    "snow-bunny-default-event-handler",
-    "snow-bunny",
-    "snow-bunny-retreat-work"
-  ],
-  "snow-flutflut-obs": [
-    "*flutflut-plat-large-sg*",
-    "*flutflut-plat-med-sg*",
-    "*flutflut-plat-small-sg*",
-    "elevator-idle-at-cave",
-    "elevator-travel-to-cave",
-    "elevator-idle-at-fort",
-    "elevator-travel-to-fort",
-    "flutflut-plat-hidden-idle",
-    "flutflut-plat-hide",
-    "flutflut-plat-appear",
-    "*snow-button-sg*",
-    "snow-button-up-idle",
-    "snow-button-deactivate",
-    "snow-button-activate",
-    "flutflut-plat",
-    "snow-button",
-    "flutflut-plat-small",
-    "flutflut-plat-med",
-    "flutflut-plat-large"
-  ],
-  "snow-obs": [
-    "*snow-switch-sg*",
-    "snow-log-button-idle-down",
-    "snow-log-button-idle-up",
-    "snow-log-button-activate",
-    "*snow-log-sg*",
-    "snow-log-wait-for-master",
-    "snow-log-active",
-    "snow-log-activate",
-    "snow-log-hidden",
-    "snow-switch-idle-down",
-    "snow-switch-idle-up",
-    "*snowcam-sg*",
-    "snow-switch-activate",
-    "*snow-gears-sg*",
-    "snow-gears-idle",
-    "snow-gears-stopped",
-    "snow-gears-halt",
-    "snow-gears-activate",
-    "*snow-fort-gate-sg*",
-    "snow-fort-gate-idle-open",
-    "snow-fort-gate-idle-closed",
-    "snow-fort-gate-activate",
-    "*snow-spatula-sg*",
-    "snow-spatula-idle",
-    "*snowpusher-sg*",
-    "snowpusher-idle",
-    "*snow-eggtop-sg*",
-    "snow-eggtop-idle-down",
-    "snow-eggtop-idle-up",
-    "snow-eggtop-activate",
-    "snow-switch-event-handler",
-    "snow-log-button-event-handler",
-    "snowcam",
-    "snow-eggtop",
-    "snowpusher",
-    "snow-spatula",
-    "snow-fort-gate",
-    "snow-gears",
-    "snow-switch",
-    "snow-log",
-    "snow-log-button"
-  ],
-  "snow-part": ["snow-bird-bob-func", "sparticle-snow-birds-moon", "snow-part"],
-  "snow-ram": ["*ram-sg*", "ram-fun-idle", "ram-idle", "ram-give-fuel-cell"],
-  "snow-ram-boss": [
-    "ram-boss-tracking",
-    "*ram-boss-nav-enemy-info-no-shield*",
-    "ram-boss-nav-resume",
-    "ram-boss-throw",
-    "ram-boss-nav-start",
-    "ram-boss-jump-down-hit-ground",
-    "ram-boss-jump-down",
-    "ram-boss-already-down",
-    "ram-boss-idle",
-    "*ram-boss-sg*",
-    "*ram-boss-nav-enemy-info*",
-    "ram-boss-lose-shield",
-    "ram-boss-up-defend-block",
-    "ram-boss-forward-defend-block",
-    "ram-boss-proj-launch",
-    "snow-ram-proj-update-velocity",
-    "ram-boss-proj-growing",
-    "ram-boss-on-ground-event-handler",
-    "ram-boss-init-by-other",
-    "ram-boss-show-anims",
-    "ram-boss-proj",
-    "ram-boss"
-  ],
-  "snow-ram-h": ["ram"],
-  "sparticle": [
-    "*particles-flag*",
-    "all-particles-60-to-50",
-    "all-particles-50-to-60",
-    "sp-process-particle-system",
-    "*sp-particle-system-2d*",
-    "*sp-particle-system-3d*",
-    "forall-particles-runner",
-    "sparticle-60-to-50",
-    "sparticle-50-to-60",
-    "forall-particles",
-    "sparticle-kill-it-level0",
-    "sparticle-kill-it-level1",
-    "forall-particles-with-key",
-    "sparticle-kill-it",
-    "forall-particles-with-key-runner",
-    "sp-get-approx-alloc-size",
-    "sp-process-block",
-    "sp-copy-to-spr",
-    "sp-process-block-3d",
-    "sp-process-block-2d",
-    "sp-copy-from-spr",
-    "sp-free-particle",
-    "sp-particle-copy!",
-    "sp-get-block-size",
-    "sp-kill-particle",
-    "sp-orbiter",
-    "memcpy",
-    "kill-all-particles-in-level",
-    "set-particle-frame-time",
-    "process-particles"
-  ],
-  "sparticle-h": [
-    "*sp-frame-time*",
-    "*sp-60-hz*",
-    "sparticle-cpuinfo",
-    "sparticle-launchinfo",
-    "sparticle-system"
-  ],
-  "sparticle-launcher": [
-    "*global-toggle*",
-    "sphere-in-view-frustum?",
-    "kill-all-particles-with-key",
-    "*part-id-table*",
-    "*particle-300hz-timer*",
-    "sp-relaunch-setup-fields",
-    "sp-init-fields!",
-    "*sp-launch-queue*",
-    "sp-launch-particles-var",
-    "sp-get-particle",
-    "*death-adgif*",
-    "particle-adgif",
-    "*part-group-id-table*",
-    "lookup-part-group-by-name",
-    "lookup-part-group-pointer-by-name",
-    "unlink-part-group-by-heap",
-    "*sp-launcher-lock*",
-    "*sp-launcher-enable*",
-    "particle-setup-adgif",
-    "*particle-adgif-cache*",
-    "sp-queue-launch",
-    "sp-adjust-launch",
-    "sp-euler-convert",
-    "sp-rotate-system",
-    "sp-launch-particles-death",
-    "sp-clear-queue",
-    "sp-relaunch-particle-2d",
-    "sp-relaunch-particle-3d",
-    "sparticle-track-root",
-    "sparticle-track-root-prim",
-    "birth-func-copy-rot-color",
-    "birth-func-copy2-rot-color",
-    "birth-func-copy-omega-to-z",
-    "birth-func-random-next-time",
-    "sparticle-birthinfo",
-    "sp-queued-launch-particles",
-    "sp-launch-queue",
-    "particle-adgif-cache"
-  ],
-  "sparticle-launcher-h": [
-    "sp-field-init-spec",
-    "sparticle-launcher",
-    "sparticle-group-item",
-    "sparticle-launch-state",
-    "sparticle-launch-group",
-    "sparticle-launch-control"
-  ],
-  "spider-egg": [
-    "*spider-egg-unbroken-sg*",
-    "*spider-egg-broken-sg*",
-    "spider-egg-idle",
-    "spider-egg-hatch",
-    "spider-egg-die",
-    "spider-egg"
-  ],
-  "spiderwebs": [
-    "*spiderwebs-sg*",
-    "spiderwebs-idle",
-    "*spider-jump-mods*",
-    "spiderwebs-bounce",
-    "spiderwebs-default-event-handler",
-    "spiderwebs"
-  ],
-  "sprite": [
-    "*sprite-hvdf-data*",
-    "*sprite-hvdf-control*",
-    "sprite-init-distorter",
-    "sprite-draw-distorters",
-    "sprite-vu1-block",
-    "sprite-add-frame-data",
-    "sprite-add-matrix-data",
-    "sprite-add-3d-all",
-    "*sprite-array-3d*",
-    "sprite-add-2d-all",
-    "*sprite-array-2d*",
-    "sprite-add-shadow-all",
-    "sprite-add-shadow-chunk",
-    "sprite-setup-header",
-    "*shadow-middot-texture*",
-    "sprite-add-3d-chunk",
-    "sprite-add-2d-chunk",
-    "sprite-setup-frame-data",
-    "*sprite-aux-list*",
-    "clear-sprite-aux-list",
-    "add-to-sprite-aux-list",
-    "sprite-set-3d-quaternion!",
-    "sprite-get-3d-quaternion!",
-    "sprite-draw",
-    "sprite-allocate-user-hvdf",
-    "sprite-release-user-hvdf",
-    "sprite-get-user-hvdf",
-    "sprite-header",
-    "sprite-hvdf-data",
-    "sprite-hvdf-control",
-    "sprite-aux-list",
-    "sprite-frame-data"
-  ],
-  "sprite-distort": [
-    "*sprite-distorter-sine-tables*",
-    "sprite-distort-vu1-block",
-    "sprite-distorter-sine-tables"
-  ],
-  "sprite-h": [
-    "sprite-vec-data-2d",
-    "sprite-array-2d",
-    "sprite-vec-data-3d",
-    "sprite-array-3d"
-  ],
-  "square-platform": [
-    "square-platform-master-idle",
-    "square-platform-master-activate",
-    "*square-platform-sg*",
-    "square-platform-lowered",
-    "square-platform-rising",
-    "square-platform-lowering",
-    "square-platform-raised",
-    "square-platform",
-    "square-platform-button",
-    "square-platform-master"
-  ],
-  "static-screen": ["static-screen-init-by-other", "static-screen"],
-  "stats-h": ["tr-stat", "merc-global-stats", "perf-stat", "perf-stat-array"],
-  "steam-cap": [
-    "*steam-cap-sg*",
-    "steam-cap-idle",
-    "steam-cap-control-pt",
-    "steam-cap"
-  ],
-  "subdivide": [
-    "*subdivide-settings*",
-    "*tfrag-work*",
-    "*perf-stats*",
-    "perf-stat-bucket->string",
-    "print-tr-stat",
-    "*merc-global-stats*",
-    "*stat-string-tfrag-near*",
-    "*stat-string-tfrag*",
-    "*stat-string-total*",
-    "clear-tr-stat",
-    "print-terrain-stats",
-    "update-subdivide-settings!",
-    "set-tfrag-dists!",
-    "*terrain-context*",
-    "GSH_ENABLE",
-    "GSH_BUCKET",
-    "GSH_WHICH_STAT",
-    "GSH_MAX_DISPLAY",
-    "GSH_TIME",
-    "*gomi-stats-hack*",
-    "start-perf-stat-collection",
-    "end-perf-stat-collection",
-    "print-perf-stats"
-  ],
-  "subdivide-h": [
-    "*terrain-stats*",
-    "*collide-stats*",
-    "subdivide-settings",
-    "subdivide-dists",
-    "gs-packed-rgba",
-    "gs-packed-xyzw",
-    "gs-packed-stq",
-    "gs-packed-gt",
-    "gs-packed-gt4",
-    "terrain-bsp",
-    "terrain-stats",
-    "dma-area",
-    "background-area",
-    "foreground-area",
-    "ambient-area",
-    "work-area",
-    "terrain-context"
-  ],
-  "sun-exit-chamber": [
-    "*exit-chamber-sg*",
-    "exit-chamber-button-init-by-other",
-    "exit-chamber-charger-puzzle",
-    "exit-chamber-idle-in-sunken",
-    "exit-chamber-idle-in-village",
-    "exit-chamber-lower",
-    "exit-chamber-rise",
-    "exit-chamber-charger-puzzle-beaten",
-    "*blue-eco-charger-sg*",
-    "blue-eco-charger-orb-init-by-other",
-    "blue-eco-charger-idle",
-    "blue-eco-charger-open",
-    "blue-eco-charger-close",
-    "blue-eco-charger-stuck-open",
-    "*blue-eco-charger-orb-sg*",
-    "blue-eco-charger-orb-idle",
-    "blue-eco-charger-orb-active",
-    "blue-eco-charger-orb",
-    "blue-eco-charger",
-    "exit-chamber-items",
-    "exit-chamber",
-    "exit-chamber-button"
-  ],
-  "sun-iris-door": [
-    "*sun-iris-door-sg*",
-    "sun-iris-door-open",
-    "sun-iris-door-closed",
-    "sun-iris-door-opening",
-    "sun-iris-door-closing",
-    "sun-iris-door-init-by-other",
-    "sun-iris-door"
-  ],
-  "sunken-elevator": ["*sunken-elevator-sg*", "sunken-elevator"],
-  "sunken-fish": [
-    "sunkenfisha-init-by-other",
-    "sunkenfisha-idle",
-    "*sunkenfisha-red-yellow-sg*",
-    "*sunkenfisha-yellow-blue-sg*",
-    "*sunkenfisha-yellow-eye-sg*",
-    "sunkenfisha"
-  ],
-  "sunken-obs": [
-    "*seaweed-sg*",
-    "*seaweed*",
-    "seaweed-idle",
-    "*side-to-side-plat-sg*",
-    "*sunkencam-sg*",
-    "water-vol-deadly",
-    "side-to-side-plat",
-    "sunkencam",
-    "seaweed"
-  ],
-  "sunken-part": ["sunken-part"],
-  "sunken-pipegame": [
-    "sunken-pipegame-button-init-by-other",
-    "sunken-pipegame-start-up",
-    "sunken-pipegame-idle",
-    "sunken-pipegame-end-play",
-    "sunken-pipegame-beat-challenge",
-    "sunken-pipegame-begin-play",
-    "sunken-pipegame-button",
-    "sunken-pipegame-prize",
-    "sunken-pipegame"
-  ],
-  "sunken-water": ["ripple-for-sunken-water", "sunken-water"],
-  "surface-h": [
-    "calc-terminal-vel",
-    "calc-terminal2-vel",
-    "calc-terminal4-vel",
-    "surface-interp!",
-    "surface-mult!",
-    "surface-clamp-speed",
-    "*walk-mods*",
-    "*walk-no-turn-mods*",
-    "*turn-around-mods*",
-    "*duck-mods*",
-    "*duck-attack-mods*",
-    "*jump-mods*",
-    "*double-jump-mods*",
-    "*smack-jump-mods*",
-    "*high-jump-mods*",
-    "*launch-jump-mods*",
-    "*forward-high-jump-mods*",
-    "*flip-jump-mods*",
-    "*forward-jump-mods*",
-    "*forward-pole-jump-mods*",
-    "*attack-mods*",
-    "*jump-attack-mods*",
-    "*uppercut-jump-mods*",
-    "*run-attack-mods*",
-    "*wheel-mods*",
-    "*wheel-flip-mods*",
-    "*flop-mods*",
-    "*flop-land-mods*",
-    "*wade-mods*",
-    "*swim-mods*",
-    "*dive-mods*",
-    "*dive-bottom-mods*",
-    "*pole-mods*",
-    "*grab-mods*",
-    "*edge-grab-mods*",
-    "*empty-mods*",
-    "*neutral-mods*",
-    "*stone-surface*",
-    "*edge-surface*",
-    "*wade-surface*",
-    "*slope-surface*",
-    "*quicksand-surface*",
-    "*tar-surface*",
-    "*grass-surface*",
-    "*ice-surface*",
-    "*tread-surface*",
-    "*standard-ground-surface*",
-    "*swim-surface*",
-    "surface"
-  ],
-  "swamp-bat": [
-    "swamp-bat-make-path-select-plane",
-    "swamp-bat-setup-new-path",
-    "swamp-bat-update-path",
-    "swamp-bat-slave-init-by-other",
-    "swamp-bat-idle",
-    "swamp-bat-launch-slave",
-    "swamp-bat-check-slave-paths-match?",
-    "swamp-bat-launch-slaves",
-    "swamp-bat-slave-get-new-path",
-    "*swamp-bat-slave-sg*",
-    "swamp-bat-slave-idle",
-    "swamp-bat-slave-return",
-    "swamp-bat-slave-strafe",
-    "swamp-bat-slave-swoop",
-    "swamp-bat-slave-post",
-    "swamp-bat-slave-die",
-    "swamp-bat-slave-launch",
-    "swamp-bat-slave-event-handler",
-    "swamp-bat-slave-path-post",
-    "swamp-bat-debug",
-    "swamp-bat-idle-path",
-    "swamp-bat",
-    "swamp-bat-slave"
-  ],
-  "swamp-blimp": [
-    "*swamp-blimp-sg*",
-    "swamp-rope-init-by-other",
-    "swamp-blimp-setup",
-    "swamp-blimp-idle",
-    "swamp-blimp-bye-bye",
-    "*SWAMP_BLIMP-bank*",
-    "*swamp-rope-sg*",
-    "tetherrock-get-info",
-    "swamp-rope-idle-rock",
-    "swamp-rope-idle-arm",
-    "swamp-rope-break",
-    "swamp-rope-post",
-    "swamp-rope-break-code",
-    "swamp-rope-update-bounding-spheres",
-    "*precursor-arm-sg*",
-    "precursor-arm-idle",
-    "precursor-arm-die",
-    "precursor-arm-slip",
-    "precursor-arm-sink",
-    "*swamp-tetherrock-sg*",
-    "swamp-tetherrock-die",
-    "swamp-tetherrock-hide",
-    "swamp-tetherrock-idle",
-    "swamp-tetherrock-break",
-    "*swamp-tetherrock-explode-sg*",
-    "swamp-rope-trans",
-    "blimp-trans",
-    "bustarock",
-    "swamp-blimp-bank",
-    "tetherrock-info",
-    "swamp-rope-rand-float",
-    "swamp-rope-oscillator",
-    "swamp-blimp-rand-vector",
-    "swamp-blimp-oscillator",
-    "swamp-tetherrock",
-    "precursor-arm",
-    "swamp-rope",
-    "swamp-blimp"
-  ],
-  "swamp-obs": [
-    "*swampcam-sg*",
-    "*tar-plat-sg*",
-    "*tar-plat-constants*",
-    "*swamp-rock-sg*",
-    "swamp-rock-idle",
-    "swamp-rock-break",
-    "*balance-plat-sg*",
-    "balance-plat-idle",
-    "swamp-spike-gate-down",
-    "swamp-spike-gate-up",
-    "swamp-spike-idle",
-    "*swamp-spike-sg*",
-    "swamp-spike-set-particle-rotation-callback",
-    "swamp-spike-default-event-handler",
-    "swamp-spike-post",
-    "swamp-rock-init-by-other",
-    "swamp-spike",
-    "swampgate",
-    "balance-plat",
-    "swamp-rock",
-    "tar-plat",
-    "swamp-barrel",
-    "swampcam",
-    "swamp-battlecontroller"
-  ],
-  "swamp-part": ["swamp-part"],
-  "swamp-rat": [
-    "swamp-rat-spawn",
-    "*swamp-rat-sg*",
-    "*swamp-rat-nav-enemy-info*",
-    "swamp-rat-update-wiggle-target",
-    "swamp-rat-update-wiggle-params",
-    "pointer",
-    "swamp-rat-default-event-handler",
-    "swamp-rat-init-by-other",
-    "swamp-rat"
-  ],
-  "swamp-rat-nest": [
-    "*swamp-rat-nest-dummy-c-sg*",
-    "*swamp-rat-nest-dummy-b-sg*",
-    "*swamp-rat-nest-dummy-a-sg*",
-    "swamp-rat-nest-idle",
-    "swamp-rat-nest-active",
-    "swamp-rat-nest-check-dummy",
-    "swamp-rat-nest-spawn-rat",
-    "swamp-rat-nest-gestate",
-    "swamp-rat-nest-dummy-init-by-other",
-    "swamp-rat-nest-die",
-    "swamp-rat-nest-pick-spawn-joint",
-    "swamp-rat-nest-victory",
-    "swamp-rat-nest-dummy-idle",
-    "swamp-rat-nest-dummy-hit",
-    "swamp-rat-nest-dummy-die",
-    "swamp-rat-nest-dummy-shake",
-    "swamp-rat-nest-dummy-take-damage",
-    "swamp-rat-nest-dummy-draw-spawn-joints",
-    "swamp-rat-nest-dummy-event-handler",
-    "swamp-rat-nest-default-event-handler",
-    "swamp-rat-nest",
-    "swamp-rat-nest-dummy",
-    "swamp-rat-nest-dummy-a",
-    "swamp-rat-nest-dummy-b",
-    "swamp-rat-nest-dummy-c"
-  ],
-  "sync-info-h": [
-    "sync-info",
-    "sync-info-eased",
-    "sync-info-paused",
-    "delayed-rand-float",
-    "oscillating-float",
-    "bouncing-float",
-    "delayed-rand-vector",
-    "oscillating-vector"
-  ],
-  "target": [
-    "target-land-effect",
-    "target-hit-ground",
-    "target-stance",
-    "target-high-jump",
-    "target-attack-air",
-    "target-wheel-flip",
-    "target-duck-stance",
-    "target-hit-ground-anim",
-    "target-hit-ground-hard",
-    "target-flop-hit-ground",
-    "target-yellow-jump-blast",
-    "target-swim-down",
-    "target-flop",
-    "mod-var-jump",
-    "init-var-jump",
-    "target-attack-uppercut-jump",
-    "target-attack",
-    "target-attack-uppercut",
-    "target-yellow-blast",
-    "target-wade-walk",
-    "target-walk",
-    "target-running-attack",
-    "target-falling-anim",
-    "target-falling-trans",
-    "target-duck-high-jump-jump",
-    "target-launch",
-    "target-duck-high-jump",
-    "target-double-jump",
-    "target-duck-walk",
-    "target-ice-walk",
-    "target-wheel",
-    "target-turn-around",
-    "target-stance-ambient",
-    "target-ice-stance",
-    "target-falling-anim-trans",
-    "target-startup",
-    "target-jump-forward"
-  ],
-  "target-death": [
-    "target-death-anim",
-    "death-movie-remap",
-    "*death-spool-array*",
-    "pov-camera-init-by-other",
-    "*deathcam-sg*",
-    "target-hit-effect",
-    "*smack-mods*",
-    "target-hit-setup-anim",
-    "target-hit-move",
-    "target-hit-orient",
-    "target-hit-push",
-    "*smack-up-mods*",
-    "velocity-set-to-target!",
-    "target-title",
-    "start-sequence-a",
-    "target-demo",
-    "task-closed?",
-    "target-warp-in",
-    "*auto-continue*",
-    "next-level"
-  ],
-  "target-flut": [
-    "target-flut-post-post",
-    "target-flut-stance",
-    "target-flut-grab",
-    "target-flut-clone-anim",
-    "target-flut-get-off-hit-ground",
-    "target-flut-falling-anim-trans",
-    "target-flut-get-off-jump",
-    "target-flut-death",
-    "target-flut-hit-ground",
-    "*flut-air-attack-mods*",
-    "target-flut-air-attack-hit-ground",
-    "target-flut-jump",
-    "target-flut-dangerous-event-handler",
-    "*FLUT-bank*",
-    "target-flut-falling",
-    "*flut-run-attack-mods*",
-    "target-flut-hit",
-    "*flut-jump-mods*",
-    "target-flut-hit-ground-anim",
-    "target-flut-walk",
-    "*flut-walk-mods*",
-    "target-flut-air-attack",
-    "*flut-double-jump-mods*",
-    "target-flut-double-jump",
-    "target-flut-standard-event-handler",
-    "target-flut-running-attack",
-    "flut-info",
-    "target-flut-get-on",
-    "target-flut-get-off",
-    "flut-bank",
-    "target-flut-post"
-  ],
-  "target-h": ["*target*", "*sidekick*", "target", "sidekick"],
-  "target-handler": [
-    "target-bonk-event-handler",
-    "target-standard-event-handler",
-    "target-send-attack",
-    "target-jump",
-    "target-attacked",
-    "target-hit",
-    "target-eco-powerup",
-    "target-load-wait",
-    "target-grab",
-    "target-look-around",
-    "target-billy-game",
-    "target-racing-start",
-    "target-flut-start",
-    "target-snowball-start",
-    "target-tube-start",
-    "target-periscope",
-    "target-fishing",
-    "target-final-door",
-    "target-play-anim",
-    "target-clone-anim",
-    "target-edge-grab",
-    "target-pole-cycle",
-    "target-swim-stance",
-    "target-wade-stance",
-    "target-apply-tongue",
-    "get-intersect-point",
-    "target-powerup-effect",
-    "target-shoved",
-    "target-dangerous-event-handler",
-    "target-jump-event-handler",
-    "target-walk-event-handler",
-    "target-state-hook-exit",
-    "target-effect-exit"
-  ],
-  "target-part": [
-    "birth-func-copy-target-y-rot",
-    "birth-func-ground-orient",
-    "birth-func-target-orient",
-    "birth-func-vector-orient",
-    "part-tracker-track-target-joint",
-    "process-drawable-burn-effect"
-  ],
-  "target-racer-L1-RACERP": [
-    "racer-collision-reaction",
-    "racer-service-slide",
-    "racer-xz",
-    "racer-thrust",
-    "racer-calc-gravity",
-    "racer-on-ground?",
-    "target-racing-smack",
-    "racer-collision",
-    "racer-integrate",
-    "racer-effects",
-    "racer-sounds",
-    "racer-bend-gravity",
-    "racer-find-prop-point",
-    "racer-cushion",
-    "*racer-mods*",
-    "*racer-air-mods*",
-    "racer-buzz",
-    "target-racing-center-anim",
-    "target-racing-turn-anim",
-    "target-racing-jump-anim",
-    "target-racing-land-anim",
-    "target-racing-post"
-  ],
-  "target-racer-h-L1-RACERP": [
-    "*RACER-bank*",
-    "*balloon-sg*",
-    "racer-info",
-    "racer-bank"
-  ],
-  "target-snowball": [
-    "target-snowball-post",
-    "target-snowball",
-    "*SNOWBALL-bank*",
-    "snowball-info",
-    "snowball-bank"
-  ],
-  "target-tube": [
-    "find-target-point",
-    "distance-from-tangent",
-    "target-tube",
-    "target-tube-death",
-    "*tube-jump-mods*",
-    "target-tube-post",
-    "target-tube-turn-anim",
-    "target-tube-jump",
-    "*tube-mods*",
-    "*tube-surface*",
-    "target-tube-hit",
-    "tube-thrust",
-    "tube-sounds",
-    "*tube-hit-mods*",
-    "*TUBE-bank*",
-    "tube-info",
-    "tube-bank",
-    "slide-control"
-  ],
-  "target-util": [
-    "*TARGET-bank*",
-    "target-slide-down",
-    "target-height-above-ground",
-    "target-falling",
-    "target-align-vel-z-adjust",
-    "target-collide-set!",
-    "*jchar-sg*",
-    "*target-shadow-control*",
-    "target-start-attack",
-    "target-danger-set!",
-    "average-turn-angle",
-    "can-play-stance-amibent?",
-    "can-jump?",
-    "move-legs?",
-    "fall-test",
-    "slide-down-test",
-    "smack-surface?",
-    "can-wheel?",
-    "can-duck?",
-    "can-exit-duck?",
-    "can-hands?",
-    "can-feet?",
-    "vector-local+!",
-    "move-forward",
-    "set-forward-vel",
-    "delete-back-vel",
-    "set-side-vel",
-    "target-timed-invulnerable",
-    "target-timed-invulnerable-off",
-    "ground-tween-initialize",
-    "ground-tween-update",
-    "target-rot",
-    "target-bank"
-  ],
-  "target2": [
-    "target-death",
-    "target-swim-jump-jump",
-    "target-swim-tilt",
-    "target-swim-up",
-    "target-swim-jump",
-    "target-swim-walk",
-    "projectile-init-by-other",
-    "*yellow-jump-mods*",
-    "target-edge-grab-jump",
-    "target-edge-grab-off",
-    "target-pole-flip-up-jump",
-    "target-pole-flip-forward-jump",
-    "target-pole-flip-up",
-    "target-pole-flip-forward",
-    "first-person-hud",
-    "*fp-hud-stack*",
-    "first-person-hud-init-by-other",
-    "target-stance-look-around",
-    "hud-normal",
-    "hud-coming-in",
-    "disable-hud",
-    "hud-going-out",
-    "hud-waiting",
-    "enable-hud",
-    "part-first-person-hud-left-func",
-    "part-first-person-hud-right-func",
-    "part-first-person-hud-selector-func",
-    "look-for-points-of-interest"
-  ],
-  "task-control": [
-    "task-status->string",
-    "*null-task-control*",
-    "*task-controls*",
-    "*assistant-tasks*",
-    "*assistant-village2-tasks*",
-    "*gambler-tasks*",
-    "*geologist-tasks*",
-    "*mayor-tasks*",
-    "*sage-tasks*",
-    "*sage-bluehut-tasks*",
-    "*oracle-village1-tasks*",
-    "*oracle-village2-tasks*",
-    "*oracle-village3-tasks*",
-    "*miners-tasks*",
-    "*sage-villagec-tasks*",
-    "*citb-greensage-tasks*",
-    "*citb-bluesage-tasks*",
-    "*citb-redsage-tasks*",
-    "*citb-yellowsage-tasks*",
-    "open-specific-task!",
-    "task-exists?",
-    "sages-kidnapped?"
-  ],
-  "task-control-h": [
-    "task-cstage",
-    "task-control",
-    "ambient-control",
-    "process-taskable"
-  ],
-  "text": [
-    "*level-text-file-load-flag*",
-    "*game-text-line*",
-    "*game-text-word*",
-    "set-font-color-alpha",
-    "load-game-text-info",
-    "text-is-loading",
-    "load-level-text-files",
-    "draw-debug-text-box",
-    "print-game-text-scaled",
-    "disable-level-text-file-loading",
-    "enable-level-text-file-loading"
-  ],
-  "text-h": [
-    "*text-group-names*",
-    "kheap",
-    "*common-text-heap*",
-    "*common-text*",
-    "game-text",
-    "game-text-info"
-  ],
-  "texture": [
-    "adgif-shader<-texture!",
-    "adgif-shader<-texture-with-update!",
-    "level-remap-texture",
-    "link-texture-by-id",
-    "lookup-texture-by-id",
-    "texture-page-login",
-    "texture-page-default-allocate",
-    "loading-level",
-    "*texture-pool*",
-    "loado",
-    "*font-texture*",
-    "global",
-    "*txt-dma-list*",
-    "texture-relocate",
-    "dma-buffer-add-ref-texture",
-    "upload-vram-pages",
-    "upload-vram-pages-pris",
-    "movie?",
-    "texture-page-near-allocate-1",
-    "texture-page-near-allocate-0",
-    "texture-page-common-allocate",
-    "texture-page-size-check",
-    "update-vram-pages",
-    "upload-vram-data",
-    "gs-page-width",
-    "gs-page-height",
-    "gs-largest-block",
-    "gs-block-width",
-    "gs-block-height",
-    "gs-find-block",
-    "ct32-24-block-table",
-    "ct16-block-table",
-    "ct16s-block-table",
-    "mz32-24-block-table",
-    "mz16-block-table",
-    "mz16s-block-table",
-    "mt8-block-table",
-    "mt4-block-table",
-    "physical-address",
-    "texture-qwc",
-    "texture-bpp",
-    "texture-page-dir-inspect",
-    "gs-blocks-used",
-    "texture-page-common-boot-allocate",
-    "texture-page-level-allocate",
-    "relocate-later",
-    "*shader-list*",
-    "*edit-shader*",
-    "adgif-shader-update!",
-    "adgif-shader-login",
-    "adgif-shader-login-no-remap",
-    "adgif-shader-login-fast",
-    "adgif-shader-login-no-remap-fast",
-    "adgif-shader<-texture-simple!"
-  ],
-  "texture-h": [
-    "*texture-enable-user-menu*",
-    "*texture-enable-user*",
-    "texture-mip->segment",
-    "*texture-relocate-later*",
-    "*texture-page-dir*",
-    "*sky-base-vram-word*",
-    "*sky-base-block*",
-    "*sky-base-page*",
-    "*depth-cue-base-vram-word*",
-    "*depth-cue-base-block*",
-    "*depth-cue-base-page*",
-    "*eyes-base-vram-word*",
-    "*eyes-base-block*",
-    "*eyes-base-page*",
-    "*ocean-base-vram-word*",
-    "*ocean-base-block*",
-    "*ocean-base-page*",
-    "texture-id",
-    "texture-pool-segment",
-    "texture-pool",
-    "texture",
-    "texture-page-segment",
-    "texture-page",
-    "shader-ptr",
-    "texture-link",
-    "texture-page-dir-entry",
-    "texture-page-dir",
-    "texture-relocate-later",
-    "adgif-shader",
-    "adgif-shader-array"
-  ],
-  "texture-upload": ["*ocean-texture*"],
-  "tfrag": [
-    "add-tfrag-mtx-0",
-    "add-tfrag-mtx-1",
-    "add-tfrag-data",
-    "tfrag-vu1-block",
-    "t-stat",
-    "*tfrag-display-stats*",
-    "tfrag-data-setup",
-    "tfrag-print-stats",
-    "tfrag-init-buffer",
-    "tfrag-end-buffer",
-    "draw-inline-array-tfrag",
-    "tfrag-near-init-buffer",
-    "tfrag-near-end-buffer",
-    "draw-inline-array-tfrag-near",
-    "stats-tfrag-asm"
-  ],
-  "tfrag-h": [
-    "tfragment-stats",
-    "tfragment-debug-data",
-    "generic-tfragment",
-    "tfragment",
-    "drawable-inline-array-tfrag",
-    "drawable-inline-array-trans-tfrag",
-    "drawable-tree-tfrag",
-    "drawable-tree-trans-tfrag",
-    "drawable-tree-dirt-tfrag",
-    "drawable-tree-ice-tfrag",
-    "drawable-tree-lowres-tfrag",
-    "drawable-tree-lowres-trans-tfrag",
-    "tfrag-dists",
-    "tfrag-data",
-    "tfrag-control",
-    "tfrag-stats",
-    "tfrag-packet",
-    "tfrag-work",
-    "tfrag-dma"
-  ],
-  "tfrag-methods": ["edge-debug-lines", "vis-cull"],
-  "tfrag-near": ["tnear-vu1-block", "tfrag-details", "clip-restore"],
-  "ticky": ["ticky"],
-  "tie": [
-    "tie-vu1-block",
-    "tie-init-consts",
-    "tie-float-reg",
-    "tie-int-reg",
-    "tie-init-engine",
-    "tie-end-buffer",
-    "tie-ints",
-    "tie-floats",
-    "tie-consts"
-  ],
-  "tie-h": [
-    "*instance-tie-work-copy*",
-    "tie-fragment",
-    "instance-tie",
-    "drawable-inline-array-instance-tie",
-    "drawable-tree-instance-tie",
-    "prototype-tie",
-    "tie-matrix",
-    "instance-tie-work",
-    "instance-tie-dma",
-    "prototype-tie-work",
-    "prototype-tie-dma"
-  ],
-  "tie-methods": [
-    "tie-init-buffers",
-    "*tie*",
-    "tie-debug-between",
-    "tie-debug-one",
-    "walk-tie-generic-prototypes",
-    "*pke-hack*",
-    "draw-inline-array-instance-tie",
-    "draw-inline-array-prototype-tie-generic-asm",
-    "draw-inline-array-prototype-tie-asm",
-    "draw-inline-array-prototype-tie-near-asm",
-    "tie-test-cam-restore",
-    "tie-instance-debug"
-  ],
-  "tie-near": [
-    "tie-near-vu1-block",
-    "tie-near-init-consts",
-    "tie-near-init-engine",
-    "tie-near-end-buffer",
-    "tie-near-int-reg",
-    "tie-near-float-reg",
-    "tie-near-consts"
-  ],
-  "tie-work": ["*prototype-tie-work*"],
-  "time-of-day": [
-    "make-sky-textures",
-    "sky-base-polygons",
-    "init-time-of-day",
-    "time-of-day-tick",
-    "time-of-day-effect",
-    "update-sky-tng-data",
-    "time-of-day-update",
-    "start-time-of-day",
-    "time-of-day-setup",
-    "set-time-of-day",
-    "init-time-of-day-context",
-    "update-time-of-day"
-  ],
-  "time-of-day-h": [
-    "*palette-fade-controls*",
-    "*time-of-day-mode*",
-    "*time-of-day-context*",
-    "palette-fade-control",
-    "palette-fade-controls",
-    "time-of-day-proc",
-    "time-of-day-palette",
-    "time-of-day-context",
-    "time-of-day-dma"
-  ],
-  "timer": [
-    "stopwatch-elapsed-ticks",
-    "timer-reset",
-    "timer-count",
-    "disable-irq",
-    "enable-irq",
-    "stopwatch-init",
-    "stopwatch-reset",
-    "stopwatch-start",
-    "stopwatch-stop",
-    "stopwatch-begin",
-    "stopwatch-end",
-    "stopwatch-elapsed-seconds"
-  ],
-  "timer-h": [
-    "*ticks-per-frame*",
-    "timer-init",
-    "timer-mode",
-    "timer-bank",
-    "timer-hold-bank",
-    "stopwatch",
-    "profile-frame",
-    "profile-bar"
-  ],
-  "tippy": ["tippy"],
-  "title-obs": [
-    "target-title-play",
-    "target-title-wait",
-    "*logo-japan-sg*",
-    "*logo-sg*",
-    "*ndi-sg*",
-    "logo-slave-init-by-other",
-    "*ndi-cam-sg*",
-    "*ndi-volumes-sg*",
-    "*logo-cam-sg*",
-    "*logo-volumes-japan-sg*",
-    "*logo-volumes-sg*",
-    "*logo-black-sg*",
-    "logo-init-by-other",
-    "logo",
-    "logo-slave"
-  ],
-  "training-obs": [
-    "*scarecrow-b-sg*",
-    "*scarecrow-b-break-sg*",
-    "*scarecrow-a-sg*",
-    "*scarecrow-a-break-sg*",
-    "*tra-iris-door-sg*",
-    "*tra-pontoon-sg*",
-    "*tra-pontoon-constants*",
-    "*training-cam-sg*",
-    "ripple-for-training-water",
-    "training-water",
-    "training-cam",
-    "tra-pontoon",
-    "tra-iris-door",
-    "scarecrow-a",
-    "scarecrow-b"
-  ],
-  "training-part": [
-    "check-drop-level-training-mist",
-    "check-drop-level-training-spout-rain",
-    "tra-bird-bob-func",
-    "tra-sparticle-seagull-moon",
-    "training-part"
-  ],
-  "trajectory-h": ["trajectory"],
-  "transform": [
-    "transform-matrix-calc!",
-    "vector-identity!",
-    "transform-matrix-parent-calc!",
-    "trs-matrix-calc!"
-  ],
-  "transform-h": ["transform", "trs"],
-  "transformq": [
-    "transformq-copy!",
-    "matrix<-transformq!",
-    "matrix<-no-trans-transformq!",
-    "matrix<-transformq+trans!",
-    "matrix<-transformq+world-trans!",
-    "matrix<-parented-transformq!"
-  ],
-  "transformq-h": ["deg-diff", "vector-y-angle", "transformq", "trsq", "trsqv"],
-  "trigonometry": [
-    "coserp180",
-    "coserp",
-    "sinerp",
-    "asin",
-    "atan0",
-    "sign",
-    "vector-rad<-vector-deg!",
-    "*sin-poly-vec2*",
-    "*sin-poly-vec*",
-    "*cos-poly-vec*",
-    "deg-",
-    "radmod",
-    "deg-seek",
-    "deg-seek-smooth",
-    "deg-lerp-clamp",
-    "binary-table",
-    "sincos-table",
-    "sin-rad",
-    "cos-rad",
-    "vector-cos-rad!",
-    "sincos!",
-    "tan-rad",
-    "tan",
-    "atan-rad",
-    "exp-slead",
-    "exp-strail",
-    "exp",
-    "sinerp-clamp",
-    "coserp-clamp",
-    "coserp180-clamp",
-    "ease-in-out",
-    "float-type"
-  ],
-  "twister": ["twist-joint", "twister"],
-  "types-h": ["int64", "uint32", "time-frame", "part-id"],
-  "vector": [
-    "*display*",
-    "vector+float!",
-    "vector*!",
-    "vector+*!",
-    "vector-*!",
-    "vector/!",
-    "vector-average!",
-    "vector--float*!",
-    "vector-float/!",
-    "vector-negate-in-place!",
-    "vector=",
-    "vector-delta",
-    "vector-seek!",
-    "vector-seek-2d-xz-smooth!",
-    "vector-seek-2d-yz-smooth!",
-    "vector-seek-3d-smooth!",
-    "seek-with-smooth",
-    "vector-seconds",
-    "vector-seconds!",
-    "vector-v!",
-    "vector-v+!",
-    "vector-v*float+!",
-    "vector-v++!",
-    "vector-v*float!",
-    "vector-v*float++!",
-    "vector-to-ups!",
-    "vector-from-ups!",
-    "vector-length-squared",
-    "vector-xz-length-squared",
-    "vector-vector-xz-distance",
-    "vector-vector-xz-distance-squared",
-    "vector-length-max!",
-    "vector-xz-length-max!",
-    "vector-rotate-around-y!",
-    "rotate-y<-vector+vector",
-    "vector-cvt.w.s!",
-    "vector-cvt.s.w!",
-    "rot-zxy-from-vector!",
-    "rot-zyx-from-vector!",
-    "vector-lerp!",
-    "vector-lerp-clamp!",
-    "vector4-lerp!",
-    "vector4-lerp-clamp!",
-    "vector-degi",
-    "vector-degf",
-    "vector-degmod",
-    "vector-deg-diff",
-    "vector-deg-lerp-clamp!",
-    "vector3s-copy!",
-    "vector3s+!",
-    "vector3s*float!",
-    "vector3s-!",
-    "spheres-overlap?",
-    "sphere<-vector!",
-    "sphere<-vector+r!",
-    "rand-vu-sphere-point!"
-  ],
-  "vector-h": [
-    "*null-vector*",
-    "*identity-vector*",
-    "*x-vector*",
-    "*y-vector*",
-    "*z-vector*",
-    "*up-vector*",
-    "vector-dot",
-    "vector-dot-vu",
-    "vector4-dot",
-    "vector4-dot-vu",
-    "vector+!",
-    "vector-!",
-    "vector-zero!",
-    "vector-reset!",
-    "vector-copy!",
-    "*zero-vector*",
-    "bit-array",
-    "vector4ub",
-    "vector4b",
-    "vector2h",
-    "vector2uh",
-    "vector3h",
-    "vector2w",
-    "vector3w",
-    "vector4w",
-    "vector4w-2",
-    "vector4w-3",
-    "vector4w-4",
-    "vector4h",
-    "vector8h",
-    "vector16b",
-    "vector",
-    "vector4s-3",
-    "vector-array",
-    "rgbaf",
-    "plane",
-    "sphere",
-    "isphere",
-    "box8s",
-    "box8s-array",
-    "cylinder",
-    "cylinder-flat",
-    "vertical-planes",
-    "vertical-planes-array",
-    "qword",
-    "vector3s"
-  ],
-  "video": ["set-hud-aspect-ratio"],
-  "video-h": ["*video-parms*", "video-parms"],
-  "viewer": [
-    "init-viewer-for-other",
-    "*viewer*",
-    "actor-get-arg!",
-    "viewer-ja-name",
-    "viewer-geo-name",
-    "init-viewer",
-    "art-part-name",
-    "*viewer-sg*",
-    "viewer-process",
-    "viewer-string",
-    "add-a-bunch",
-    "viewer"
-  ],
-  "vif-h": ["vif-stat", "vif-fbrst", "vif-err", "vif-bank"],
-  "village-obs-L1": [
-    "ripple-for-villagea-water",
-    "*revcycle-sg*",
-    "*revcycleprop-sg*",
-    "*hutlamp-sg*",
-    "set-period",
-    "hutlamp-idle",
-    "update-clock",
-    "village-fish-idle",
-    "villa-starfish-idle",
-    "process-drawable-child-count",
-    "starfish-spawn-child",
-    "starfish-init-by-other",
-    "starfish-idle",
-    "*starfish-sg*",
-    "*starfish-nav-enemy-info*",
-    "starfish-patrol",
-    "reflector-end-idle",
-    "*reflector-middle-sg*",
-    "reflector-middle-idle",
-    "*mayorgears-sg*",
-    "mayorgears-idle",
-    "*windspinner-sg*",
-    "windspinner-idle",
-    "*sagesail-sg*",
-    "sagesail-idle",
-    "*windmill-sail-sg*",
-    "windmill-sail-idle",
-    "*med-res-jungle-sg*",
-    "*med-res-jungle1-sg*",
-    "*med-res-jungle2-sg*",
-    "*med-res-beach-sg*",
-    "*med-res-beach1-sg*",
-    "*med-res-beach2-sg*",
-    "*med-res-beach3-sg*",
-    "*med-res-misty-sg*",
-    "*med-res-village11-sg*",
-    "*med-res-village12-sg*",
-    "*med-res-village13-sg*",
-    "*med-res-training-sg*",
-    "windmill-sail",
-    "sagesail",
-    "windspinner",
-    "mayorgears",
-    "reflector-middle",
-    "reflector-end",
-    "villa-starfish",
-    "starfish",
-    "village-fish",
-    "villa-fisha",
-    "villa-fishb",
-    "cyclegen",
-    "hutlamp",
-    "revcycleprop",
-    "revcycle",
-    "villagea-water"
-  ],
-  "village1-part": [
-    "villagea-part",
-    "bird-bob-func",
-    "sparticle-seagull-moon",
-    "check-drop-level-village1-fountain-nosplash",
-    "check-drop-level-village1-fountain"
-  ],
-  "village1-part2": ["check-drop-level-sagehut"],
-  "village2-obs": [
-    "ripple-for-villageb-water",
-    "*ogreboss-village2-sg*",
-    "ogreboss-village2-idle",
-    "ogreboss-village2-throw",
-    "*fireboulder-sg*",
-    "boulder1-trans",
-    "boulder2-trans",
-    "boulder3-trans",
-    "boulder4-trans",
-    "boulder4-trans-2",
-    "boulder4-trans-3",
-    "boulder3-trans-2",
-    "boulder2-trans-2",
-    "*exit-chamber-dummy-sg*",
-    "exit-chamber-dummy-wait-to-appear",
-    "exit-chamber-dummy-idle",
-    "*ceilingflag-sg*",
-    "ceilingflag-idle",
-    "fireboulder-disable-blocking-collision",
-    "fireboulder-idle",
-    "fireboulder-hover",
-    "fireboulder-be-clone",
-    "fireboulder-hover-stuff",
-    "*allpontoons-sg*",
-    "allpontoons-idle",
-    "allpontoons-be-clone",
-    "*pontoonten-sg*",
-    "*pontoonten-constants*",
-    "*pontoonfive-sg*",
-    "*pontoonfive-constants*",
-    "pontoon-die",
-    "pontoon-hidden",
-    "*village2cam-sg*",
-    "*med-res-rolling-sg*",
-    "*med-res-rolling1-sg*",
-    "*med-res-village2-sg*",
-    "ogreboss-village2-trans",
-    "village2cam",
-    "pontoon",
-    "pontoonfive",
-    "pontoonten",
-    "allpontoons",
-    "fireboulder",
-    "ceilingflag",
-    "exit-chamber-dummy",
-    "ogreboss-village2",
-    "villageb-ogreboss",
-    "villageb-water"
-  ],
-  "village2-part": ["villageb-part", "check-drop-level-sagehut2"],
-  "village3-obs": [
-    "*gondolacables-sg*",
-    "*pistons-sg*",
-    "*gondola-sg*",
-    "ripple-for-villagec-lava",
-    "*med-res-ogre-sg*",
-    "*med-res-ogre2-sg*",
-    "*med-res-ogre3-sg*",
-    "*med-res-finalboss-sg*",
-    "villagec-lava",
-    "gondola",
-    "pistons",
-    "gondolacables"
-  ],
-  "village3-part": ["villagec-part"],
-  "villagep-obs": [
-    "*village-cam-sg*",
-    "warp-gate-init-by-other",
-    "*warp-gate-switch-sg*",
-    "get-next-slot-up",
-    "get-next-slot-down",
-    "print-level-name",
-    "warpgate",
-    "warp-gate-switch",
-    "village-cam"
-  ],
-  "voicebox": [
-    "cam-voicebox",
-    "voicebox-init-by-other",
-    "*voicebox-sg*",
-    "empty-state",
-    "voicebox-track",
-    "camera-voicebox",
-    "voicebox"
-  ],
-  "vol": ["plane-volume-intersect-dist"],
-  "vol-h": ["plane-volume", "vol-control"],
-  "vu1-user-h": [
-    "*vu1-enable-user-menu*",
-    "*vu1-enable-user*",
-    "dma-foreground-sink",
-    "generic-bucket-state",
-    "generic-dma-foreground-sink",
-    "dma-foreground-sink-group"
-  ],
-  "wall-plat": [
-    "*wall-plat-sg*",
-    "wall-plat-sync-idle",
-    "wall-plat-retracted",
-    "wall-plat-retracting",
-    "wall-plat-extended",
-    "wall-plat-extending",
-    "wall-plat"
-  ],
-  "warrior": ["*warrior-sg*", "warrior"],
-  "water": [
-    "splash-spawn",
-    "part-water-splash-callback",
-    "ocean-get-height",
-    "birth-func-y->userdata",
-    "birth-func-ocean-height",
-    "check-water-level-drop",
-    "check-water-level-drop-and-die",
-    "check-water-level-above-and-die",
-    "water-vol-init-by-other"
-  ],
-  "water-anim": [
-    "*water-anim-look*",
-    "*water-anim-sunken-dark-eco-qbert-sg*",
-    "*water-anim-sunken-dark-eco-platform-room-sg*",
-    "*water-anim-sunken-dark-eco-helix-room-sg*",
-    "*water-anim-sunken-big-room-sg*",
-    "*water-anim-sunken-first-room-from-entrance-sg*",
-    "*water-anim-sunken-qbert-room-sg*",
-    "*water-anim-sunken-first-right-branch-sg*",
-    "*water-anim-sunken-circular-with-bullys-sg*",
-    "*water-anim-sunken-hall-with-one-whirlpool-sg*",
-    "*water-anim-sunken-hall-with-three-whirlpools-sg*",
-    "*water-anim-sunken-start-of-helix-slide-sg*",
-    "*water-anim-sunken-room-above-exit-chamber-sg*",
-    "*water-anim-sunken-hall-before-big-room-sg*",
-    "*water-anim-sunken-short-piece-sg*",
-    "*water-anim-sunken-big-room-upper-water-sg*",
-    "*water-anim-maincave-center-pool-sg*",
-    "*water-anim-maincave-lower-right-pool-sg*",
-    "*water-anim-maincave-mid-right-pool-sg*",
-    "*water-anim-maincave-lower-left-pool-sg*",
-    "*water-anim-maincave-mid-left-pool-sg*",
-    "*water-anim-maincave-water-with-crystal-sg*",
-    "*water-anim-robocave-main-pool-sg*",
-    "*water-anim-misty-mud-by-arena-sg*",
-    "*water-anim-misty-mud-above-skeleton-sg*",
-    "*water-anim-misty-mud-behind-skeleton-sg*",
-    "*water-anim-misty-mud-above-skull-back-sg*",
-    "*water-anim-misty-mud-above-skull-front-sg*",
-    "*water-anim-misty-mud-other-near-skull-sg*",
-    "*water-anim-misty-mud-near-skull-sg*",
-    "*water-anim-misty-mud-under-spine-sg*",
-    "*water-anim-misty-mud-by-dock-sg*",
-    "*water-anim-misty-mud-island-near-dock-sg*",
-    "*water-anim-misty-mud-lonely-island-sg*",
-    "*water-anim-misty-dark-eco-pool-sg*",
-    "*water-anim-ogre-lava-sg*",
-    "*water-anim-jungle-river-sg*",
-    "*water-anim-village3-lava-sg*",
-    "*water-anim-training-lake-sg*",
-    "*water-anim-darkcave-water-with-crystal-sg*",
-    "*water-anim-rolling-water-back-sg*",
-    "*water-anim-rolling-water-front-sg*",
-    "*water-anim-finalboss-dark-eco-pool-sg*",
-    "*water-anim-lavatube-energy-lava-sg*",
-    "*water-anim-village1-rice-paddy-sg*",
-    "*water-anim-village1-fountain-sg*",
-    "*water-anim-village1-rice-paddy-mid-sg*",
-    "*water-anim-village1-rice-paddy-top-sg*",
-    "*water-anim-village2-bucket-sg*",
-    "water-anim",
-    "water-anim-look"
-  ],
-  "water-h": ["water-control", "water-vol"],
-  "weather-part": [
-    "matrix-local->world",
-    "group-rain-screend-drop",
-    "update-snow",
-    "check-drop-level-rain",
-    "update-rain",
-    "cam-master-effect",
-    "sparticle-track-sun"
-  ],
-  "wedge-plats": [
-    "*wedge-plat-sg*",
-    "wedge-plat-outer-idle",
-    "wedge-plat-outer-tip",
-    "wedge-plat-idle",
-    "wedge-plat-tip",
-    "wedge-plat-master-idle",
-    "*wedge-plat-outer-sg*",
-    "wedge-plat-master",
-    "wedge-plat",
-    "wedge-plat-outer"
-  ],
-  "whirlpool": ["*whirlpool-sg*", "whirlpool-idle", "whirlpool"],
-  "wind": ["update-wind"],
-  "wind-h": [
-    "*wind-work*",
-    "*wind-scales*",
-    "wind-get-hashed-index",
-    "wind-vector",
-    "wind-work"
-  ],
-  "wobbler": ["wobbler"],
-  "yakow": [
-    "*YAKOW-bank*",
-    "*yakow-sg*",
-    "yakow-graze",
-    "yakow-task-complete?",
-    "yakow-idle",
-    "yakow-run-away",
-    "yakow-graze-kicked",
-    "yakow-walk-to",
-    "yakow-facing-player?",
-    "yakow-post",
-    "yakow-notice",
-    "yakow-facing-point?",
-    "yakow-facing-direction?",
-    "yakow-generate-travel-vector",
-    "yakow-common-post",
-    "yakow-cam",
-    "yakow-kicked",
-    "*village1cam-sg*",
-    "yakow-default-event-handler",
-    "yakow-simple-post",
-    "yakow-run-post",
-    "yakow-blend-walk-run",
-    "yakow-die",
-    "yakow-bank",
-    "yakow"
-  ],
-  "yeti": [
-    "yeti-resuming-start",
-    "yeti-first-time-start",
-    "yeti-slave-init-by-other",
-    "yeti-idle",
-    "yeti-slave-appear-jump-up",
-    "*yeti-sg*",
-    "*yeti-nav-enemy-info*",
-    "yeti-slave-appear-land",
-    "yeti-slave-default-event-handler",
-    "yeti-slave-show-anims",
-    "yeti-slave",
-    "yeti"
-  ]
-}
diff --git a/scripts/search-decomp/.gitignore b/scripts/search-decomp/.gitignore
deleted file mode 100644
index 89eab800ac..0000000000
--- a/scripts/search-decomp/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*.txt
-*.md
diff --git a/scripts/search-decomp/grep.py b/scripts/search-decomp/grep.py
deleted file mode 100644
index 17f91dd30d..0000000000
--- a/scripts/search-decomp/grep.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import re
-import os
-import argparse
-import time
-
-parser = argparse.ArgumentParser('pygrep')
-parser.add_argument('-d', '--directory', type=str, required=True, help='root directory to recursively search')
-parser.add_argument('-s', '--search_term_file', type=str, required=True, help='search term file')
-parser.add_argument('-o', '--output_file', type=str, required=True, help='output file name')
-args = parser.parse_args()
-
-summary_results = {}
-results = {}
-search_terms = []
-
-with open(args.search_term_file, "r") as f:
-  print("Initializing Search Term File")
-  for line in f:
-    token = line.strip()
-    # VU INSTRUCTION ADDITION. Appends all combinations of `dest` to replace `{DEST}`
-    vuDestCombinations = ["x", "xy", "xz", "xw", "xyz", "xzw", "xyzw", "y", "yz", "yw", "yzw", "z", "zw", "w"]
-    if "{DEST}" in token:
-      for combination in vuDestCombinations:
-        tempToken = token.replace("{DEST}", combination)
-        search_terms.append({
-          "term": tempToken
-        })
-        summary_results[tempToken.lower()] = 0
-        results[tempToken.lower()] = []
-    else:
-      search_terms.append({
-        "term": token
-      })
-      summary_results[token.lower()] = 0
-      results[token.lower()] = []
-
-print("Searching for {} tokens...".format(len(search_terms)))
-
-totalTimeStart = time.time()
-for index, search_term in enumerate(search_terms):
-  start = time.time()
-  term = search_term["term"].lower()
-  print("[{:.2f}%] - Searching for - {}...".format((index/len(search_terms) * 100), term), end="")
-  pattern = re.compile(re.escape(term) + "\s+")
-  for path, _, files in os.walk(args.directory):
-    for fn in files:
-      filepath = os.path.join(path, fn)
-      with open(filepath) as handle:
-        for lineno, line in enumerate(handle):
-          mo = pattern.search(line)
-          if mo:
-            result = "{}:{}:{}".format(filepath,
-                    lineno,
-                    line)
-            summary_results[term] = summary_results[term] + 1
-            results[term].append(result.strip())
-  print("Took {:.2f} seconds, Found - {} occurences.".format(time.time() - start, summary_results[term]))
-print("Took {} seconds in total".format(time.time() - totalTimeStart))
-
-if os.path.exists(args.output_file):
-  os.remove(args.output_file)
-
-with open(args.output_file, "w") as f:
-  print("Outputting Report")
-  f.write("USAGE SUMMARY\n")
-  for key in sorted(summary_results, key=summary_results.get, reverse=True):
-    f.write("{} - {}\n".format(key, summary_results[key]))
-  f.write("\nOCCURENCES\n")
-  for key, value in results.items():
-    f.write("{}\n".format(key))
-    for occurence in value:
-      f.write("- {}\n".format(occurence))
diff --git a/scripts/search-decomp/vu-fp-instructions.txt b/scripts/search-decomp/vu-fp-instructions.txt
deleted file mode 100644
index c2b6af8b3f..0000000000
--- a/scripts/search-decomp/vu-fp-instructions.txt
+++ /dev/null
@@ -1,122 +0,0 @@
-VABS.{DEST}
-VADD.{DEST}
-VADDA.{DEST}
-VADDAi.{DEST}
-VADDAq.{DEST}
-VADDAw.{DEST}
-VADDAx.{DEST}
-VADDAy.{DEST}
-VADDAz.{DEST}
-VADDi.{DEST}
-VADDq.{DEST}
-VADDw.{DEST}
-VADDx.{DEST}
-VADDy.{DEST}
-VADDz.{DEST}
-VCLIP.xyz
-VDIVx Q
-VFTOI0.{DEST}
-VFTOI12.{DEST}
-VFTOI15.{DEST}
-VFTOI4.{DEST}
-VIADD
-VIADDI
-VIAND
-VILWR.{DEST}
-VIOR
-VISUB
-VISWR.{DEST}
-VITOF0.{DEST}
-VITOF12.{DEST}
-VITOF15.{DEST}
-VITOF4.{DEST}
-VLQD.{DEST}
-VLQI.{DEST}
-VMADD.{DEST}
-VMADDA.{DEST}
-VMADDA.{DEST}
-VMADDAi.{DEST}
-VMADDAi.{DEST}
-VMADDAq.{DEST}
-VMADDAq.{DEST}
-VMADDAw.{DEST}
-VMADDAx.{DEST}
-VMADDAy.{DEST}
-VMADDAz.{DEST}
-VMADDi.{DEST}
-VMADDq.{DEST}
-VMADDw.{DEST}
-VMADDx.{DEST}
-VMADDy.{DEST}
-VMADDz.{DEST}
-VMAX.{DEST}
-VMAXi.{DEST}
-VMAXw.{DEST}
-VMAXx.{DEST}
-VMAXy.{DEST}
-VMAXz.{DEST}
-VMFIR
-VMINI.{DEST}
-VMINI.{DEST}
-VMINIi.{DEST}
-VMINIw.{DEST}
-VMINIx.{DEST}
-VMINIy.{DEST}
-VMINIz.{DEST}
-VMOVE.{DEST}
-VMR32.{DEST}
-VMSUB.{DEST}
-VMSUBA.{DEST}
-VMSUBAi.{DEST}
-VMSUBAq.{DEST}
-VMSUBAw.{DEST}
-VMSUBAx.{DEST}
-VMSUBAy.{DEST}
-VMSUBAz.{DEST}
-VMSUBi.{DEST}
-VMSUBq.{DEST}
-VMSUBw.{DEST}
-VMSUBx.{DEST}
-VMSUBy.{DEST}
-VMSUBz.{DEST}
-VMTIRx
-VMUL.{DEST}
-VMULA.{DEST}
-VMULAi.{DEST}
-VMULAq.{DEST}
-VMULAw.{DEST}
-VMULAx.{DEST}
-VMULAy.{DEST}
-VMULAz.{DEST}
-VMULi.{DEST}
-VMULq.{DEST}
-VMULw.{DEST}
-VMULx.{DEST}
-VMULy.{DEST}
-VMULz.{DEST}
-VNOP
-VOPMSUB.xyz
-VOPMULA.xyz
-VRGET.{DEST}
-VRINIT
-VRNEXT.{DEST}
-VRSQRT Q
-VRXORw
-VSQD.{DEST}
-VSQI.{DEST}
-VSQRTy
-VSUB.{DEST}
-VSUBA.{DEST}
-VSUBAi.{DEST}
-VSUBAq.{DEST}
-VSUBAw.{DEST}
-VSUBAx.{DEST}
-VSUBAy.{DEST}
-VSUBAz.{DEST}
-VSUBi.{DEST}
-VSUBq.{DEST}
-VSUBw.{DEST}
-VSUBx.{DEST}
-VSUBy.{DEST}
-VSUBz.{DEST}
-VWAIT Q
\ No newline at end of file
diff --git a/scripts/update-game-text-id.py b/scripts/update-game-text-id.py
deleted file mode 100644
index 9561c71554..0000000000
--- a/scripts/update-game-text-id.py
+++ /dev/null
@@ -1,61 +0,0 @@
-## Given a list of files(comma delimited), decompile it, then place it under the specified placeholder (if it exists)
-## if the placeholder doesn't exist, error out
-## the placeholder is `;; DECOMP BEGINS`
-
-import os
-
-print("Copying game-text-id enum")
-begin_str = ";; GAME-TEXT-ID ENUM BEGINS"
-end_str = ";; GAME-TEXT-ID ENUM ENDS"
-enum_lines = []
-with open('./decompiler/config/all-types.gc') as f:
-  lines = f.readlines()
-  found_enum = False
-  for line in lines:
-    if found_enum and end_str in line:
-      break
-    if found_enum:
-      enum_lines.append(line)
-    if begin_str in line:
-      found_enum = True
-new_texth_lines = []
-with open('goal_src/engine/ui/text-h.gc') as f:
-  lines = f.readlines()
-  found_enum = False
-  for line in lines:
-    if begin_str in line:
-      found_enum = True
-      new_texth_lines.append(begin_str + "\n")
-      new_texth_lines += enum_lines
-      new_texth_lines.append(end_str + "\n")
-      continue
-    if end_str in line:
-      found_enum = False
-      continue
-    if found_enum:
-      continue
-    new_texth_lines.append(line)
-os.remove('goal_src/engine/ui/text-h.gc')
-with open('goal_src/engine/ui/text-h.gc', "w") as f:
-  f.writelines(new_texth_lines)
-with open('goal_src/engine/pc/ui/text-h.gc') as f:
-  lines = f.readlines()
-  found_enum = False
-  for line in lines:
-    if begin_str in line:
-      found_enum = True
-      new_texth_lines.append(begin_str + "\n")
-      new_texth_lines += enum_lines
-      new_texth_lines.append(end_str + "\n")
-      continue
-    if end_str in line:
-      found_enum = False
-      continue
-    if found_enum:
-      continue
-    new_texth_lines.append(line)
-os.remove('goal_src/engine/pc/ui/text-h.gc')
-with open('goal_src/engine/pc/ui/text-h.gc', "w") as f:
-  f.writelines(new_texth_lines)
-print("game-text-id enum updated!")
-
diff --git a/scripts/update-goal-src.py b/scripts/update-goal-src.py
deleted file mode 100644
index 7d8df4c760..0000000000
--- a/scripts/update-goal-src.py
+++ /dev/null
@@ -1,131 +0,0 @@
-## Given a list of files(comma delimited), decompile it, then place it under the specified placeholder (if it exists)
-## if the placeholder doesn't exist, error out
-## the placeholder is `;; DECOMP BEGINS`
-
-from jak1_file_list import file_list
-import os
-import argparse
-parser = argparse.ArgumentParser()
-parser.add_argument("--files")
-args = parser.parse_args()
-
-files = args.files.split(",")
-
-throw_error = False
-
-# files in this list have manual modifications in in code block
-# sometimes these modifications don't prevent a compiler error
-# and are easy to commit
-#
-# if you know of / add such a modification, you should append to this
-# list, it will remind you such a file was touched by making a root file
-# that will be picked up by git to shame you
-files_with_modifications = [
-  "ambient",
-  "viewer",
-  "sunken-obs",
-  "cam-master",
-  "target-snowball",
-  "logic-target",
-  "default-menu",
-  "collide-shape",
-  "cam-states",
-  "misty-obs",
-  "lavatube-energy",
-  "sage-finalboss",
-  "progress",
-  "entity",
-  "ogreboss",
-  "navigate",
-  "ice-cube",
-  "snow-bunny",
-  "citadel-sages",
-  "racer-part",
-  "collectables-part",
-  "collectables",
-  "basebutton"
-]
-
-for file in files:
-  if file in files_with_modifications:
-    file_name = "{}.manual_restore_reminder".format(file)
-    with open(file_name, 'w') as fp:
-      pass
-
-  disasm_path = "./decompiler_out/jak1/{}_disasm.gc".format(file)
-  if not os.path.exists(disasm_path):
-    print("{} doesn't exist!".format(disasm_path))
-    throw_error = True
-    continue
-
-  src_path = ""
-  for f in file_list:
-    if f[2] != 3:
-      continue
-    if f[0] == file:
-      src_path = f[4]
-      break
-
-  if not os.path.exists("./goal_src/{}".format(src_path)):
-    print("{} couldn't find in /goal_src!".format(file))
-    throw_error = True
-    continue
-
-  file_path = "./goal_src/{}/{}.gc".format(src_path, file)
-  new_lines = []
-  with open(file_path) as f:
-    lines = f.readlines()
-    found_placeholder = False
-    for line in lines:
-      if ";; decomp begins" in line.lower():
-        found_placeholder = True
-        new_lines.append(line.upper())
-        break
-      new_lines.append(line)
-    if found_placeholder == False:
-      print("No placeholder found in {}, skipping".format(file_path))
-      throw_error = True
-      continue
-
-  # finally...update the file
-  lines_to_ignore = [
-    ";;-*-Lisp-*-",
-    "(in-package goal)",
-    ";; definition",
-    ";; INFO:",
-    ";; failed to figure",
-    ";; Used lq/sq"
-  ]
-  def skippable_line(line):
-    for prefix in lines_to_ignore:
-      if line.startswith(prefix):
-        return True
-    return False
-  with open(disasm_path) as f:
-    lines = f.readlines()
-    in_inspect_method = False
-    for i, line in enumerate(lines):
-      # strip inspect methods
-      if line.startswith("(defmethod inspect") or (line.startswith("(defmethod") and (i + 1 < len(lines) and "inspect" in lines[i+1])):
-        in_inspect_method = True
-        continue
-      if in_inspect_method and line == "\n":
-        in_inspect_method = False
-      elif in_inspect_method:
-        continue
-      # strip comments we dont care about
-      if skippable_line(line):
-        continue
-      # otherwise, add it to the file
-      new_lines.append(line)
-
-  # write the damn thing
-  os.remove(file_path)
-  with open(file_path, "w") as f:
-    f.writelines(new_lines)
-
-  print("Copied - {}!".format(file))
-
-
-if throw_error:
-  exit(1)