Maps: shared `SubCharacter*` funcs between different maps

[emoose]

All maps duplicate certain functions between them, best guess is that devs probably shared common .c files between the maps, eg. maps that include Lisa & Cheryl would probably include chara/lisa.c & chara/cheryl.c in their build.

The shared code is mostly identical between maps, but some funcs do get customized in certain ones, likely they included #ifdef checks in their .c files that would change code depending on map, in decomp we can handle that by doing similar kind of #ifdef MAP0_S00 to change the code (ideally we can change this to #ifdef HAS_XYZ_FEATURE later on)

Right now the repo handles code sharing on a function-by-function basis, instead of pulling in a whole .c for some chara/feature we're pulling in separate .h files of each function that belongs to it.

Eventually once more has been decomped/shared we should be able to group these sharedFunc_*.h files into single header files, similar to how the devs likely had them as separate single .c files (and maybe we can make them actual .c files at some point, depending on whether splat actually supports that)

---

There's two stages to sharing funcs between maps, first stage is to identify the funcs/data that are shared between them & rename the symbol name in each map to also match between maps (allowing other funcs to reference it by the same name), and second stage is to actually get a code-match for that function and insert the code into each map.

We usually opt to do these stages in reverse, since there's a good chance of false-positives we don't really want to do symbol renaming all in one go, so we usually only start renaming func symbols to sharedFunc after we have the code matched for one.

Once we know the code itself matches then any other shared funcs/data used by that code are likely fine to rename too.

---

maptool can handle both name & code sharing for you, a short guide can be found here (any issues feel free to @ on discord):

#74 (comment)

A table of likely-shared functions, maps they're shared on, expected % from matching them, can be found here:

https://docs.google.com/spreadsheets/d/1FkOURT4nvGIL8qTCTNMzEobDkONMWg7aznmi1DP-t9A/edit?usp=sharing

---

Old post:

Mentioned this on discord before but probably good to keep an issue tracking it too, maps seem to have some funcs shared between them, all related to SubCharacter:

Some matching map .s files (expand)

$ python compare.py map0_s01 map0_s02 0
Distances:
  map0_s01/func_800CFFB8.s and map0_s02/func_800CCE24.s: 0
  map0_s01/func_800D1B00.s and map0_s02/func_800CE1C8.s: 0
  map0_s01/func_800D1B3C.s and map0_s02/func_800CE204.s: 0
  map0_s01/func_800D1E5C.s and map0_s02/func_800CE548.s: 0
  map0_s01/func_800D1E5C.s and map0_s02/func_800CE768.s: 0
  map0_s01/func_800D1F14.s and map0_s02/func_800CE600.s: 0
  map0_s01/func_800D1F2C.s and map0_s02/func_800CE618.s: 0
  map0_s01/func_800D1F54.s and map0_s02/func_800CE640.s: 0
  map0_s01/func_800D1F6C.s and map0_s02/func_800CE658.s: 0
  map0_s01/func_800D2038.s and map0_s02/func_800CE724.s: 0
  map0_s01/func_800D2048.s and map0_s02/func_800CE734.s: 0
  map0_s01/func_800D20FC.s and map0_s02/func_800CE548.s: 0
  map0_s01/func_800D20FC.s and map0_s02/func_800CE768.s: 0
  map0_s01/func_800D210C.s and map0_s02/func_800CE778.s: 0
  map0_s01/func_800D211C.s and map0_s02/func_800CE788.s: 0
  map0_s01/func_800D215C.s and map0_s02/func_800CE7C8.s: 0
  map0_s01/func_800DA51C.s and map0_s02/func_800CE7DC.s: 0

$ python compare.py map0_s01 map4_s02 0
Distances:
  map0_s01/func_800CFFB8.s and map4_s02/func_800CECFC.s: 0
  map0_s01/func_800D1B00.s and map4_s02/func_800D00A0.s: 0
  map0_s01/func_800D1B3C.s and map4_s02/func_800D00DC.s: 0
  map0_s01/func_800D1E5C.s and map4_s02/func_800D0420.s: 0
  map0_s01/func_800D1E5C.s and map4_s02/func_800D0640.s: 0
  map0_s01/func_800D1F14.s and map4_s02/func_800D04D8.s: 0
  map0_s01/func_800D1F2C.s and map4_s02/func_800D04F0.s: 0
  map0_s01/func_800D1F54.s and map4_s02/func_800D0518.s: 0
  map0_s01/func_800D1F6C.s and map4_s02/func_800D0530.s: 0
  map0_s01/func_800D2038.s and map4_s02/func_800D05FC.s: 0
  map0_s01/func_800D2048.s and map4_s02/func_800D060C.s: 0
  map0_s01/func_800D20FC.s and map4_s02/func_800D0420.s: 0
  map0_s01/func_800D20FC.s and map4_s02/func_800D0640.s: 0
  map0_s01/func_800D210C.s and map4_s02/func_800D0AC0.s: 0
  map0_s01/func_800D211C.s and map4_s02/func_800D0AD0.s: 0
  map0_s01/func_800D215C.s and map4_s02/func_800D0B10.s: 0
  map0_s01/func_800D2170.s and map4_s02/func_800D0B24.s: 0
  map0_s01/func_800D21E4.s and map4_s02/func_800D0B98.s: 0
  map0_s01/func_800D2364.s and map4_s02/func_800D0D18.s: 0
  map0_s01/func_800D2B00.s and map4_s02/func_800D14B4.s: 0
  map0_s01/func_800D2B10.s and map4_s02/func_800D14C4.s: 0
  map0_s01/func_800D2B28.s and map4_s02/func_800D14DC.s: 0
  map0_s01/func_800D2B4C.s and map4_s02/func_800D1500.s: 0
  map0_s01/func_800D2BB0.s and map4_s02/func_800D1564.s: 0
  map0_s01/func_800D2BE4.s and map4_s02/func_800D1598.s: 0
  map0_s01/func_800D2BF4.s and map4_s02/func_800D15A8.s: 0
  map0_s01/func_800D5638.s and map4_s02/func_800DDE50.s: 0
  map0_s01/func_800D5E14.s and map4_s02/func_800DECAC.s: 0
  map0_s01/func_800D7AB0.s and map4_s02/func_800E0E2C.s: 0
  map0_s01/func_800D81B0.s and map4_s02/func_800E14F8.s: 0
  map0_s01/func_800D81D0.s and map4_s02/func_800E1518.s: 0
  map0_s01/func_800D8244.s and map4_s02/func_800E158C.s: 0
  map0_s01/func_800D8804.s and map4_s02/func_800E1B4C.s: 0
  map0_s01/func_800DA51C.s and map4_s02/func_800E9D28.s: 0

That's just a few of the maps that match, posted script to compare them here: https://gist.github.com/emoose/904c1660dd966dbcdf42b17f73da5ff8

Not sure what the best way to handle these is, maybe these are from some separate split .c file that they all include, but seems some funcs aren't included in all maps, would compiler have removed ones that aren't used? 🤔
(or in worst case, they might have just copy-pasted them across all the map files...)

Did add a couple of these to map0_s00.c before, wouldn't be too hard to copy them to other maps too for some extra %, but wonder if there's a better way to handle it.

[IWILLCRAFT-M0d]

Not sure what the best way to handle these is, maybe these are from some separate split .c file that they all include, but seems some funcs aren't included in all maps, would compiler have removed ones that aren't used? 🤔 (or in worst case, they might have just copy-pasted them across all the map files...)

That sounds horribly ortodox so I don't think they have done that. I have a little theory, maybe those functions comes from a general file that applies to all maps, however, functions that are not used on the overlay are ignored on compilation.

[emoose]

Yeah that's what I meant, the shared funcs here could be some .c file that each of the overlays builds with, maybe their map0_s00 makefile was setup something like

C_FILES = \
src/maps/map0_s00/map0_s00.c \
src/maps/shared/subchara.c \
src/maps/shared/theOtherCrapAfterSubcharaFuncs.c

Not sure how that would work with splat though, if we setup all overlays to split that section into a single file I guess it would get messy (especially when a few maps only include a few of the shared funcs...)

Thought I saw another project talk about same thing a few weeks ago, asking how to let overlays share a single .c file, might have been on discord/github somewhere but haven't been able to dig it up now.

Did find ethteck/splat#266 (comment) talked about the same kind of thing for sotn-decomp, and an issue they had with it.
Seems they ended up adding the shared Update func in a header file: https://github.com/Xeeynamo/sotn-decomp/blob/14915cfe0ce908ab9f3530caface90ce94b14490/src/st/update.h#L6
I guess when one of the overlay .c files includes that header the compiler adds it to that .c, again no idea how that would work with splat though.

[IWILLCRAFT-M0d]

I see interesting that solution, however I wonder if any of those shared functions get call out from another overlay (BODYPROG) and also we are going to be forced to give them a shared name, so I will suggest something like func_MapShared_(number) or func_maps_(number) on the meanwhile we figure out a proper names

[emoose]

Latest script is at https://github.com/Vatuu/silent-hill-decomp/blob/master/tools/maptool.py

Usage: python tools/maptool.py [-h] [--matchings] [--nonmatchings] [--update] map1 map2

By default script compares both nonmatchings/matchings of map1 vs nonmatchings of map2, if any funcs in map1 are named sharedFunc_XXXXXXXX_X_sXX which are identical to a non-matched func in map2, it'll print sym.txt & #include lines to let map2 share it.

--update can also be used to automatically edit the map2 .c/.sym txt file when it detects a matched sharedFunc.

---

Assuming we want to share a func from map2_s00 to other maps:

• python tools/maptool.py map2_s00 map2_s01
• should hopefully print some funcs that are identical
• after decomping & matching one of those funcs, add it to map2_s00.c and make sure it builds + matches in the project

After getting the shared func matched + building in the first map:

• rename the func to sharedFunc_XXXXXXXX_2_s00 in map2_s00.c, and add entry for it to sym.map2_s00.txt with new name
• move sharedFunc_XXXXXXXX_2_s00 func to include/maps/shared/sharedFunc_XXXXXXXX_2_s00.h
• add #include "maps/shared/sharedFunc_XXXXXXXX_2_s00.h" line in its place in map2_s00.c
• if the decomped func makes use of other shared funcs in the map, make sure to rename those funcs to sharedFunc_XXXX_2_s00 in sym.txt and the maps .c too, and add them to shared.h (should work even for non-decomped funcs)
• make regenerate -j16 && make check -j16 and confirm everything still builds + matches (may need to add func prototype to include/maps/shared.h)

After sharedFuncs have been setup in the first map you can start replacing in other maps (before sharing funcs you might want to stage current changes with git add ., so you can revert the following if needed):

• run script again: python tools/maptool.py map2_s00 map2_s01
• if it's detected the sharedFunc it should print sym.txt/#include lines
• run python tools/maptool.py --update map2_s00 all to check all maps, and update .c/sym.txt of each of them to point to the shared func
• make regenerate -j16 && make check -j16 and hope for the best

After that hopefully the func should be shared properly, recommend checking with git diff and make sure that only the expected changes were made (maptool can sometimes share extra data than intended)

---

If a sharedFunc accesses some data var inside the map (D_800C7XXX onwards) it'll probably be accessing that data at different addrs depending on the overlay, you can also use tool to match the name/symbol of those variables across maps too:

• add sym.txt entry in first map renaming the var to sharedData_[address]_0_s00
• add extern for it to maps/shared.h
• update any sharedFunc code to access it with that new name.
• make regenerate -j16 && make check -j16 to confirm it builds, and allow splat to update names in the .s files.

Now when tool is used to share funcs it'll hopefully see the sharedData reference as well, and try to find the right addr for that data in the second map, updating sym.txt to point to it, if that worked the output from maptool should mention the sharedData.

[emoose]

Shared a couple AI funcs, it's looking like some AI funcs do actually change a bit between maps, eg. two of the 4 funcs that AI_Cybil_Update calls into are different between pretty much each map it's included in.

Was leaning toward them just including shared .c files for each char in the map, like mentioned above maybe with a makefile like

C_FILES = \
src/maps/map0_s00/map0_s00.c \
src/chars/cybil.c \
src/chars/creaper.c

but idk...

Doesn't look like these changed funcs are that wildly different at least, maybe could have had a bunch of #ifdef MAP0_S00 blocks in each of the C files which would add/remove stuff depending on map?

Guess once some of those differing funcs get decomped we can see if those differences could be slotted in like that.

[IWILLCRAFT-M0d]

Shared a couple AI funcs, it's looking like some AI funcs do actually change a bit between maps, eg. two of the 4 funcs that AI_Cybil_Update calls into are different between pretty much each map it's included in.

Was leaning toward them just including shared .c files for each char in the map, like mentioned above maybe with a makefile like

C_FILES = \
src/maps/map0_s00/map0_s00.c \
src/chars/cybil.c \
src/chars/creaper.c

That is actually what I think TS did on SH2 and even SH4 with monsters so it wouldn't be a bad idea to apply it, thing is how are we going to deal with Splat and makefile and in that case I would suggest something like

src/chars/cybil.c < (work being done here) \
src/maps/mapx_sxx/cybil.c < (use `#include "src/chars/cybil.c"` in order to insert the working funcs)

And apply a bit of code similar to the one you did for libsd you did on the makefile which would ask for what map is being compiled to then apply the parameter needed

[emoose]

Made a table of most of the shared funcs, shows number of maps sharing it + addr in each map, hopefully comes in useful: https://docs.google.com/spreadsheets/d/1FkOURT4nvGIL8qTCTNMzEobDkONMWg7aznmi1DP-t9A/edit?usp=sharing

Some of the sharedSymbol ones there are a bit weird, think those funcs had slight differences only in certain maps, so map it was named after might not show up in the list of maps it includes there.

(smaller funcs there could be false positives too)

Script used to generate it

import subprocess
import re
import csv
from collections import defaultdict
import itertools

mapNames = [
    "map0_s00", "map0_s01", "map0_s02",
    "map1_s00", "map1_s01", "map1_s02", "map1_s03", "map1_s04", "map1_s05", "map1_s06",
    "map2_s00", "map2_s01", "map2_s02", "map2_s03", "map2_s04",
    "map3_s00", "map3_s01", "map3_s02", "map3_s03", "map3_s04", "map3_s05", "map3_s06",
    "map4_s00", "map4_s01", "map4_s02", "map4_s03", "map4_s04", "map4_s05", "map4_s06",
    "map5_s00", "map5_s01", "map5_s02", "map5_s03",
    "map6_s00", "map6_s01", "map6_s02", "map6_s03", "map6_s04", "map6_s05",
    "map7_s00", "map7_s01", "map7_s02", "map7_s03",
]

# (func path) -> canonical function ID
func_to_id = {}

# function ID -> map name -> address
func_matrix = defaultdict(dict)

# Regex to extract function matches
match_re = re.compile(
    r"(?:nonmatchings|matchings)/([^/]+)/([a-zA-Z0-9_]+)\.s and (?:nonmatchings|matchings)/([^/]+)/([a-zA-Z0-9_]+)\.s: 0"
)

# Compare each unique pair
for mapA, mapB in itertools.combinations(mapNames, 2):
    print(f"Comparing {mapA} vs {mapB}...")
    proc = subprocess.run(
        ["python", "tools/maptool.py", mapA, mapB],
        capture_output=True,
        text=True,
        check=True
    )

    for line in proc.stdout.splitlines():
        m = match_re.search(line)
        if m:
            map1, addr1, map2, addr2 = m.groups()
            if map1.endswith("_2") or map1.endswith("_3"):
                map1 = map1[:-2]  # remove last 2 chars
            if map2.endswith("_2") or map2.endswith("_3"):
                map2 = map2[:-2]
                
            name1 = addr1
            name2 = addr2
            if addr1.startswith("func_"):
                addr1 = addr1[5:]
                name1 = f"0x{addr1}"
            if addr2.startswith("func_"):
                addr2 = addr2[5:]
                name2 = f"0x{addr2}"
                
            func1 = (map1, addr1)
            func2 = (map2, addr2)
            
            map1_n = map1.replace("map", "")

            # Retrieve or create function group IDs
            id1 = func_to_id.get(func1)
            id2 = func_to_id.get(func2)

            if id1 and id2:
                if id1 != id2:
                    # Merge id2 group into id1 group
                    for func, fid in list(func_to_id.items()):
                        if fid == id2:
                            func_to_id[func] = id1
                    for mapname, addr in func_matrix[id2].items():
                        func_matrix[id1][mapname] = addr
                    del func_matrix[id2]
                fid = id1
            elif id1 or id2:
                fid = id1 or id2
            else:
                # First time seen, use this map name for func ID
                if name1.startswith("0x"):
                    fid = f"func_{addr1}_{map1_n}"
                else:
                    fid = f"{addr1}_{map1_n}"
            
            func_to_id[func1] = fid
            func_to_id[func2] = fid
            func_matrix[fid][map1] = name1
            func_matrix[fid][map2] = name2

# Gather all unique map names used in any match
all_maps = sorted({m for presence in func_matrix.values() for m in presence})

# Output to CSV
output_file = "shared_functions.csv"
with open(output_file, "w", newline="") as csvfile:
    writer = csv.writer(csvfile)
    header = ["Function", "NumMapsSharing"] + all_maps
    writer.writerow(header)

    # Sort by number of maps containing the function (descending)
    sorted_items = sorted(func_matrix.items(), key=lambda item: len(item[1]), reverse=True)

    for fid, presence in sorted_items:
        map_count = len(presence)
        row = [fid, map_count] + [presence.get(m, "") for m in all_maps]
        writer.writerow(row)

print(f"Done. Wrote to {output_file}")

[emoose]

Looks like GhostChildAlessa funcs are complete, merging them to a single .h works fine: emoose@9e1eeac

We do lose out on the function addr comments though, but I guess with the ghidra script those aren't as important now.

Keeping it in a .h file isn't ideal though imo, atm the decls for these funcs are still in shared.h too, would be better to move those to its own .h and move this code into a .c instead.

Will try checking tomorrow if there's some way for splat to let us keep splits in different overlays in the same .c file somehow.

(or could we let splat ignore the split for this entirely now that we have it all as C code? Guess things like objdiff might depends on output from it though..)

[IWILLCRAFT-M0d]

I think that what we can do is make a source at src/maps/(folder), create the file split that generates in the folder of the overlay code and insert all functions by using #include poiting to the file that contains everything and for the addresses of the functions/data in each overlay I think what we should do is in the header file, where we declare everything, at the top of the file list where this functions/data are used like this:

 /** Functions and data used in:
 * MAP0_SXX
 * MAP1_SXX
 * MAP3_SXX
 * MAP5_SXX
 * MAP6_SXX (Unused)
 */

Then in functions/data declaration put addresses like this

 /** @brief blah blah blah blah
  * blah blah blah blah blah blah blah blah
  * blah blah blah blah blah blah blah blah
  * @note blah blah blah blah blah blah blah
  * 
  * Address in each overlay:
  * MAP0_SXX: 0x80XXXXXX
  * MAP1_SXX: 0x80XXXXXX
  * MAP3_SXX: 0x80XXXXXX (Unused)
  * MAP5_SXX: 0x80XXXXXX
  * MAP6_SXX: 0x80XXXXXX (Unused)
  */

And in case that function/data not being present in an overlay where other funcs/data it is then don't list the overlay, also we should clarify somewhere that in case of being labeled in this header files as unused in the list of addresses in each overlay that means that the code is present in that overlay, but unused as isn't intended to be used by the game rather than being that they cut the feature and even if in the unused instance have special code then use the @unused tag in the declaration as we previously established in the code conventions

For objdiff we shouldn't be worried, I'm pretty much sure that we can easly catch up and exclude the path of the base shared C file in the Python script that generates the configuration, and in case of not excluding it iirc in case of not giving it a target or obj to compare it will automatically be counted as 100% so that shouldn't affect us in any case

Will try checking tomorrow if there's some way for splat to let us keep splits in different overlays in the same .c file somehow.

I'm sure you already checked that as SOTN decomp run into the same issue, but they ended doing what we are doing right now

[emoose]

I think that what we can do is make a source at src/maps/(folder), create the file split that generates in the folder of the overlay code and insert all functions by using #include poiting to the file that contains everything

Yeah it looks like that might be the cleanest way for now, splat doesn't really seem to support having splits outside of the current src_path very well (since any ../ added to the split name will also be appended to the asm_path too, and any ../ in that path would always cause nonmatchings/matchings folders to become merged...), plus having it outside of the map folder would probably need extra makefile crap to get it included too, easiest to just make a MAPX_SXX/chara_alessa.c which would just #include the actual .c file.

[IWILLCRAFT-M0d]

plus having it outside of the map folder would probably need extra makefile crap to get it included too

No really since it compiles everything that is inside asm and src folders (excepting things inside matching/nonmatching folders)

[emoose]

Had a look into grouping some of the funcs, got chatgpt to make a script that can go through all the overlays and make a best-guess of how they could be grouped into .c files:

tools/jaccard.py (run from repo root)

import re
import json
from pathlib import Path
from collections import defaultdict, deque

# ---------------------------------------------------------
# Extraction regexes
# ---------------------------------------------------------

RE_INCLUDE = re.compile(
    r'#include\s+"maps/shared/([^"/]+)\.h"'
)

RE_INCLUDE_ASM = re.compile(
    r'INCLUDE_ASM\([^,]+,\s*([A-Za-z_][A-Za-z0-9_]*)'
)


def extract_functions_from_overlay(path: Path):
    text = path.read_text(errors="ignore")

    results = []
    for line in text.splitlines():
        if "func_" in line:
            continue
        m = RE_INCLUDE.search(line)
        if m:
            results.append(m.group(1))
            continue

        m = RE_INCLUDE_ASM.search(line)
        if m:
            results.append(m.group(1))
            continue

    return results


# ---------------------------------------------------------
# Load overlays
# ---------------------------------------------------------

def scan_overlay_tree(root: Path):
    overlays = {}
    for path in root.rglob("*.c"):
        funcs = extract_functions_from_overlay(path)
        if funcs:
            overlays[path.stem] = funcs
    return overlays


# ---------------------------------------------------------
# Compute Jaccard similarities
# ---------------------------------------------------------

def compute_jaccard(overlays):
    func_to_overlays = defaultdict(set)

    for ov_name, func_list in overlays.items():
        for f in func_list:
            func_to_overlays[f].add(ov_name)

    funcs = sorted(func_to_overlays.keys())
    jaccard = {}

    for i in range(len(funcs)):
        for j in range(i + 1, len(funcs)):
            A, B = funcs[i], funcs[j]
            setA = func_to_overlays[A]
            setB = func_to_overlays[B]
            inter = len(setA & setB)
            union = len(setA | setB)
            if union > 0:
                jaccard[(A, B)] = inter / union

    return jaccard


# ---------------------------------------------------------
# Build adjacency graph with a cutoff threshold
# ---------------------------------------------------------

def build_similarity_graph(jaccard, threshold=0.65):
    """
    Return graph: dict[str -> set[str]]
    Add an edge if Jaccard >= threshold.
    """
    graph = defaultdict(set)
    for (A, B), score in jaccard.items():
        if score >= threshold:
            graph[A].add(B)
            graph[B].add(A)
    return graph


# ---------------------------------------------------------
# Find connected components
# ---------------------------------------------------------
def connected_components(graph, overlay_order=None):
    visited = set()
    components = []

    for node in graph:
        if node in visited:
            continue

        comp = []
        queue = deque([node])
        visited.add(node)

        while queue:
            curr = queue.popleft()
            comp.append(curr)
            for nei in graph[curr]:
                if nei not in visited:
                    visited.add(nei)
                    queue.append(nei)

        # Preserve order from first overlay, if provided
        if overlay_order:
            comp.sort(key=lambda x: overlay_order.index(x) if x in overlay_order else float('inf'))

        components.append(comp)

    return components


# ---------------------------------------------------------
# Driver
# ---------------------------------------------------------

if __name__ == "__main__":
    root = Path("src/maps/")

    overlays = scan_overlay_tree(root)
    print(f"Loaded {len(overlays)} overlays.")

    jaccard = compute_jaccard(overlays)

    # Adjust threshold as needed — 0.65–0.8 works well for PSX overlays.
    graph = build_similarity_graph(jaccard, threshold=0.90)

    first_overlay_funcs = list(overlays.values())[0] if overlays else None
    groups = connected_components(graph, overlay_order=first_overlay_funcs)

    print("\nCandidate .c blocks:")
    for i, group in enumerate(groups, 1):
        print(f"\n=== group_{i:02d}.c ===")
        for f in group:
            print("   ", f)

Worked well for grouping stuff into Player.h (there's a couple funcs at the beginning that don't seem player-related though, maybe another split which was also always included)

With current repo this gives this output, can see a few issues with it but mostly looks good, should improve as we match more funcs / rename more shared things to use matching sharedFunc symbols:

jaccard.py output

Candidate .c blocks:

=== group_01.c ===
    Ai_AirScreamer_Init
    sharedFunc_800D4E84_0_s01
    sharedFunc_800D6A60_0_s01
    sharedFunc_800D569C_0_s01
    sharedFunc_800D2FB4_0_s01
    sharedFunc_800D63A4_0_s01
    sharedFunc_800D2E04_0_s01
    sharedFunc_800D3430_0_s01
    sharedFunc_800D7440_0_s01
    sharedFunc_800D5E78_0_s01
    sharedFunc_800D2274_0_s01
    sharedFunc_800D3CC4_0_s01
    sharedFunc_800D529C_0_s01
    sharedFunc_800D72E8_0_s01
    sharedFunc_800D5E14_0_s01
    sharedFunc_800D31D0_0_s01
    sharedFunc_800D5C90_0_s01
    sharedFunc_800D81D0_0_s01
    sharedFunc_800D8714_0_s01
    sharedFunc_800D62D8_0_s01
    sharedFunc_800D2200_0_s01
    sharedFunc_800D3758_0_s01
    sharedFunc_800D2B4C_0_s01
    sharedFunc_800D2BE4_0_s01
    sharedFunc_800D5D80_0_s01
    sharedFunc_800D7714_0_s01
    Ai_AirScreamer_Update
    sharedFunc_800D6600_0_s01
    sharedFunc_800D2B00_0_s01
    sharedFunc_800D3508_0_s01
    sharedFunc_800D6EC4_0_s01
    sharedFunc_800D2390_0_s01
    sharedFunc_800D3814_0_s01
    sharedFunc_800D71F0_0_s01
    sharedFunc_800D81B0_0_s01
    sharedSymbol_800D3B0C_0_s01
    sharedFunc_800D4A80_0_s01
    sharedFunc_800D5274_0_s01
    sharedFunc_800D82B8_0_s01
    sharedFunc_800D77D0_0_s01
    Chara_DamageTake
    sharedFunc_800D7120_0_s01
    sharedFunc_800D598C_0_s01
    sharedFunc_800D57C8_0_s01
    sharedFunc_800D21E4_0_s01
    sharedFunc_800D7560_0_s01
    sharedFunc_800D2B28_0_s01
    sharedFunc_800D76A0_0_s01
    sharedFunc_800D8804_0_s01
    sharedFunc_800D7B14_0_s01
    sharedFunc_800D2BB0_0_s01
    sharedFunc_800D87FC_0_s01
    sharedFunc_800D633C_0_s01
    sharedFunc_800D2364_0_s01
    sharedFunc_800D3928_0_s01
    sharedFunc_800D6C7C_0_s01
    sharedFunc_800D3DFC_0_s01
    sharedFunc_800D2B10_0_s01
    sharedFunc_800D7AB0_0_s01
    sharedFunc_800D2BF4_0_s01
    sharedFunc_800D3630_0_s01
    sharedFunc_800D5638_0_s01
    sharedFunc_800D8244_0_s01
    sharedFunc_800D7EBC_0_s01
    sharedFunc_800D5B10_0_s01

=== group_02.c ===
    Ai_Bloodsucker_Init
    sharedFunc_800D0E20_3_s03
    sharedFunc_800D0E80_3_s03
    sharedSymbol_800D0ECC_3_s03
    sharedSymbol_800D0E38_3_s03
    sharedFunc_800D0F28_3_s03
    Ai_Bloodsucker_Update

=== group_03.c ===
    Ai_Creaper_Init
    sharedFunc_800D983C_1_s02
    sharedFunc_800D7EE8_1_s02
    sharedFunc_800D8684_1_s02
    sharedFunc_800D99D0_1_s02
    sharedFunc_800D8F30_1_s02
    sharedFunc_800D82F0_1_s02
    sharedFunc_800D9960_1_s02
    sharedFunc_800D9528_1_s02
    sharedFunc_800D8244_1_s02
    sharedFunc_800D9774_1_s02
    Ai_Creaper_Update

=== group_04.c ===
    Ai_Groaner_Init
    sharedFunc_800E384C_2_s00
    sharedFunc_800E6338_2_s00
    sharedFunc_800DEC84_2_s00
    sharedFunc_800DDF74_2_s00
    sharedFunc_800DEC64_2_s00
    sharedFunc_800E5EC4_2_s00
    sharedFunc_800D69A0_2_s00
    sharedFunc_800DC98C_2_s00
    sharedFunc_800D5974_2_s00
    sharedFunc_800DC200_2_s00
    sharedFunc_800E04B0_2_s00
    sharedFunc_800E554C_2_s00
    sharedFunc_800DE250_2_s00
    sharedFunc_800DF8A0_2_s00
    sharedFunc_800DECA4_2_s00
    sharedFunc_800DEBCC_2_s00
    sharedFunc_800E5930_2_s00
    Ai_Groaner_Update
    sharedFunc_800DC598_2_s00
    sharedFunc_800E041C_2_s00
    sharedFunc_800DE578_2_s00
    sharedFunc_800E5AA4_2_s00
    sharedFunc_800DC30C_2_s00
    sharedFunc_800DE11C_2_s00
    sharedFunc_800E71E8_2_s00
    sharedFunc_800DF22C_2_s00
    sharedFunc_800DF710_2_s00
    sharedFunc_800DE6A8_2_s00
    sharedFunc_800DF24C_2_s00
    sharedFunc_800E33DC_2_s00
    sharedFunc_800DE1F8_2_s00
    sharedFunc_800D3C24_2_s00
    sharedFunc_800DF80C_2_s00
    sharedFunc_800E0698_2_s00
    sharedFunc_800DC67C_2_s00

=== group_05.c ===
    Ai_HangedScratcher_Init
    sharedFunc_800D2844_5_s00
    Ai_HangedScratcher_Update
    sharedFunc_800D2C18_5_s00
    sharedFunc_800D041C_5_s00
    sharedFunc_800D029C_5_s00
    sharedFunc_800D03F8_5_s00
    sharedFunc_800D26D8_5_s00
    sharedFunc_800D3300_5_s00
    sharedFunc_800CFF74_5_s00

=== group_06.c ===
    Ai_LarvalStalker_Init
    sharedFunc_800D17BC_1_s00
    Ai_LarvalStalker_Update
    sharedFunc_800D1DBC_1_s00
    sharedFunc_800D1524_1_s00
    sharedFunc_800CF168_1_s00
    sharedFunc_800D140C_1_s00

=== group_07.c ===
    Ai_PuppetDoctor_Update
    sharedFunc_800CEB90_3_s03
    Ai_PuppetNurse_Init
    sharedFunc_800CEEAC_3_s03
    sharedFunc_800CF3AC_3_s03
    Ai_PuppetNurse_Update
    sharedFunc_800CDF24_3_s03
    sharedFunc_800CEC88_3_s03
    sharedFunc_800D0828_3_s03
    sharedFunc_800CE398_3_s03
    sharedFunc_800CDA88_3_s03
    sharedFunc_800CFDD4_3_s03
    sharedFunc_800CE3CC_3_s03
    sharedFunc_800D0968_3_s03
    sharedFunc_800D0110_3_s03
    sharedFunc_800D03E4_3_s03
    sharedFunc_800D02E4_3_s03
    sharedFunc_800CF9F8_3_s03
    sharedFunc_800CFD18_3_s03
    Ai_PuppetNurse_UpdateMain
    sharedFunc_800D06AC_3_s03
    sharedFunc_800CEA64_3_s03
    sharedFunc_800CE5E4_3_s03
    Ai_PuppetNurse_Control
    sharedFunc_800CE500_3_s03
    sharedFunc_800CF90C_3_s03

=== group_08.c ===
    Ai_Romper_Init
    sharedFunc_800E8730_2_s02
    sharedFunc_800E8478_2_s02
    Ai_Romper_Update
    sharedFunc_800E86C0_2_s02
    sharedFunc_800E8DFC_2_s02
    sharedFunc_800E8A40_2_s02
    sharedFunc_800E66E8_2_s02
    sharedFunc_800E6420_2_s02
    sharedFunc_800E6758_2_s02
    sharedFunc_800E83D4_2_s02
    sharedFunc_800E60FC_2_s02
    sharedFunc_800E5FC8_2_s02

=== group_09.c ===
    Ai_Splithead_Init
    sharedFunc_800D0054_1_s05
    sharedFunc_800D4070_1_s05
    sharedFunc_800D274C_1_s05
    sharedFunc_800D3388_1_s05
    sharedFunc_800CF990_1_s05
    sharedFunc_800D3B30_1_s05
    sharedFunc_800CFE94_1_s05
    sharedFunc_800D2D74_1_s05
    Ai_Splithead_Update
    sharedFunc_800D267C_1_s05
    sharedFunc_800D3AFC_1_s05

=== group_10.c ===
    Ai_Stalker_Init
    sharedFunc_800D6554_0_s00
    sharedFunc_800D7E04_0_s00
    sharedFunc_800D70C4_0_s00
    sharedFunc_800D63D0_0_s00
    sharedFunc_800D5FCC_0_s00
    sharedFunc_800D54A8_0_s00
    sharedFunc_800D5C64_0_s00
    sharedFunc_800D6970_0_s00
    sharedFunc_800D7BE8_0_s00
    sharedFunc_800D5B48_0_s00
    sharedFunc_800D5098_0_s00
    sharedFunc_800D67FC_0_s00
    sharedFunc_800D3308_0_s00
    sharedFunc_800D654C_0_s00
    sharedFunc_800D492C_0_s00
    sharedFunc_800D670C_0_s00
    Ai_Stalker_Update
    sharedFunc_800D3B44_0_s00

=== group_11.c ===
    Anim_StartKeyframeIdxGet
    sharedFunc_800D88AC_0_s00
    sharedFunc_800D893C_0_s00
    sharedFunc_800D8964_0_s00
    sharedFunc_800D8A00_0_s00
    sharedFunc_800D923C_0_s00
    sharedFunc_800D8928_0_s00
    sharedFunc_800D9064_0_s00
    sharedFunc_800D8904_0_s00
    sharedFunc_800D88C0_0_s00
    sharedFunc_800D8950_0_s00
    sharedFunc_800D9078_0_s00
    sharedFunc_800D908C_0_s00
    sharedFunc_800D9188_0_s00
    sharedFunc_800D891C_0_s00

=== group_12.c ===
    MapEvent_DoorJammed
    MapEvent_DoorLocked

=== group_13.c ===
    sharedFunc_800CB6B0_0_s00
    sharedFunc_800CBBBC_0_s00
    sharedFunc_800CBC94_0_s00
    Particle_Update
    sharedFunc_800CF2A4_0_s01
    sharedFunc_800CEFD0_1_s02
    sharedFunc_800CFFF8_0_s00
    sharedFunc_800CE954_7_s03
    sharedFunc_800D01BC_0_s00
    sharedFunc_800CF9A8_0_s01

=== group_14.c ===
    sharedFunc_800CB7F4_1_s01
    sharedFunc_800CBA38_1_s01
    sharedFunc_800CB8A0_1_s01

=== group_15.c ===
    sharedFunc_800CBA4C_1_s02
    sharedFunc_800CBC98_1_s02
    sharedFunc_800CBD58_1_s02

=== group_16.c ===
    sharedFunc_800CD6B0_3_s03
    sharedFunc_800CD920_3_s03
    sharedFunc_800CD7F8_3_s03
    sharedFunc_800CD940_3_s03

=== group_17.c ===
    sharedFunc_800CE884_0_s02
    sharedFunc_800CE8B8_0_s02

=== group_18.c ===
    sharedFunc_800D0994_3_s00
    sharedFunc_800D09D4_3_s00

=== group_19.c ===
    sharedFunc_800E1114_6_s04
    sharedFunc_800E12D0_6_s04
    sharedFunc_800E1290_6_s04
    sharedFunc_800E1258_6_s04