# Conflicts:
#	test.py

@@ -0,0 +350,4 @@
+        values.update(_fields(words, specs))
+    if opcode == 11:
+        values["size"] = values["size_raw"] / 256.0
+        values["bone_local_x"] = values["bone_local_x_raw"] / 256.0

@@ -0,0 +505,4 @@
+            target = int(command.parameter("target"))
+            if target % 4 or target < 0 or target >= len(data):
+                raise SubactionParseError(f"{context}: opcode {opcode} targets invalid data offset 0x{target:X}")
+            if opcode == 7 and target <= pc:

@@ -0,0 +322,4 @@
+        dat_index = self.dat_action_index(character, action)
+        if dat_index is None:
+            return None
+        return self.action(FIGHTER_KINDS[character.value].code, dat_index)

@@ -0,0 +470,4 @@
+            pc += 4
+            continue
+        if opcode == 2:
+            next_time = max(time, float(command.parameter("frame")))

@@ -0,0 +325,4 @@
+        record = self.action(FIGHTER_KINDS[character.value].code, dat_index)
+        if character is Character.NANA and not record.animation_size:
+            record = self.action(FIGHTER_KINDS[Character.POPO.value].code, dat_index)
+        return record if record.animation_size else None

@@ -41,2 +43,3 @@
     """
-    def __init__(self, write=False):
+    def __init__(self, write=False, *, iso_path=None):
+        warnings.warn(

@@ -109,0 +134,4 @@
+                "ISO-backed hitbox timing is unavailable for special states without fighter hitboxes; "
+                "the move may create an unparsed article or projectile"
+            )
+        return tuple(frame.local_frame for frame in record.timeline.frames if frame.active_hitboxes)

@@ -7,0 +62,4 @@
+retains those script-declared candidates and their condition flag.
+
+As with ``PlayerState.action_frame``, every exported ``local_frame`` and
+``FrameSnapshot.local_frame`` is one-indexed. ``ActionRecord.frame(1)`` always

@@ -0,0 +137,4 @@
+            header = stream.read(0x430)
+            if len(header) != 0x430:
+                raise DiscImageError("could not read the complete GameCube disc header")
+            if header[0:6] != b"GALE01":

@@ -0,0 +280,4 @@
+def _animation_snapshot_count(frame_count: float) -> int:
+    if frame_count <= 0:
+        return 0
+    return max(1, math.ceil(frame_count) - 1)

@@ -109,0 +131,4 @@
+        if record is None:
+            return ()
+        if not record.timeline.hitbox_generations and self.is_bmove(character, action):
+            raise DiscFrameDataError(

@@ -0,0 +155,4 @@
+                    f"FST size 0x{self.fst_size:X} exceeds the header maximum 0x{fst_max_size:X}"
+                )
+            stream.seek(self.fst_offset)
+            fst = stream.read(self.fst_size)

@@ -0,0 +91,4 @@
+
+    def _validate_reference_chain(self, offset: int, index: int) -> None:
+        seen = set()
+        while offset != 0xFFFFFFFF:

@@ -0,0 +738,4 @@
+        frame_count = max(
+            frame_count,
+            max((event.local_frame for event in events), default=0),
+            _frame(iasa_time) if iasa_time is not None else 0,

@@ -109,0 +130,4 @@
+        record = self._disc_action(character, action)
+        if record is None:
+            return ()
+        if not record.timeline.hitbox_generations and self.is_bmove(character, action):

@@ -629,0 +683,4 @@
+            count = 0
+            previous = None
+            for frame in frames:
+                if previous is None or frame != previous + 1:

@@ -0,0 +58,4 @@
+            location = struct.unpack_from(">I", self._file, reloc_start + index * 4)[0]
+            if location % 4 or location > self.data_size - 4:
+                self._fail(f"relocation {index} has invalid data offset 0x{location:X}")
+            if location in locations:

@@ -0,0 +74,4 @@
+            target, string_offset = struct.unpack_from(">II", self._file, roots_start + index * 8)
+            if target >= self.data_size:
+                self._fail(f"root {index} targets data offset 0x{target:X}")
+            name = self._file_c_string(strings_start + string_offset, strings_start, f"root {index}")

@@ -0,0 +737,4 @@
+    if animation_frame_count is not None:
+        frame_count = max(
+            frame_count,
+            max((event.local_frame for event in events), default=0),

@@ -0,0 +93,4 @@
+
+    def _validate_reference_chain(self, offset: int, index: int) -> None:
+        seen = set()
+        while offset != 0xFFFFFFFF:

@@ -0,0 +207,4 @@
+        result = []
+        for index, offset in enumerate(range(actions, boundary, 0x18)):
+            symbol_pointer = self.pointer(offset, description=f"action {index} symbol")
+            symbol = self.c_string(symbol_pointer, f"action {index} symbol") if symbol_pointer is not None else None

@@ -0,0 +462,4 @@
+            break
+        if opcode in (1, 2):
+            frame = float(command.parameter("frame"))
+            timer = timer + frame if opcode == 1 else frame - time

@@ -109,0 +144,4 @@
+                "the move may create an unparsed article or projectile"
+            )
+        return tuple(
+            frame.local_frame

@@ -629,0 +695,4 @@
+                return 0
+            return len(
+                {
+                    generation.start_frame

@@ -0,0 +200,4 @@
+            if not name or not name.isprintable() or "/" in name or "\\" in name or name in (".", ".."):
+                raise DiscImageError(f"FST entry {index} has unsafe name {name!r}")
+            parent_index, parent_end, parent_path = stack[-1]
+            path = f"{parent_path}/{name}" if parent_path else name

@@ -0,0 +438,4 @@
+    while True:
+        if len(executed) >= max_commands:
+            raise SubactionParseError(f"{context}: command guard exceeded {max_commands} executions")
+        state = (pc, time, timer, tuple(calls), tuple((loop[0], loop[1]) for loop in loops))

@@ -0,0 +375,4 @@
+                    )
+                    animation_frame_counts[animation_key] = frame_count
+            timeline = (
+                interpret_subaction(

@@ -109,0 +152,4 @@
+        if (
+            not record.timeline.hitbox_generations
+            and state is not None
+            and state.move_id in SPECIAL_MOVE_IDS

@@ -629,0 +722,4 @@
+                    if event.hitbox.requires_thrown_hitbox_owner:
+                        continue
+                    group = event.hitbox.hit_group
+                    if group not in active_groups:

@@ -0,0 +278,4 @@
+                f"disc member {entry.path!r} size 0x{entry.size:X} exceeds the supported maximum "
+                f"0x{self._MAX_MEMBER_SIZE:X}"
+            )
+        with self.path.open("rb") as stream:

@@ -0,0 +92,4 @@
+            references.append(DatRoot(name, target, True))
+        self.roots = tuple(roots)
+        self.references = tuple(references)
+        self.object_offsets = tuple(sorted(targets | {self.data_size}))

@@ -0,0 +539,4 @@
+        if opcode == 6:
+            if not calls:
+                raise SubactionParseError(f"{context}: return at DAT offset 0x{pc + 0x20:X} has no caller")
+            pc = calls.pop()

@@ -109,0 +145,4 @@
+        return self._disc_framedata.action_for_state(character, action)
+
+    def _disc_frame_offset(self, character, action):
+        return int((character, action) in _ISO_COMPATIBILITY_FRAME_OFFSETS)

@@ -629,0 +721,4 @@
+            count = 0
+            for animation_time, events in groupby(
+                record.timeline.hitbox_events,
+                key=lambda event: event.animation_time,

@@ -0,0 +130,4 @@
+    _MAX_MEMBER_SIZE = 0x214D00
+
+    def __init__(self, path: str | os.PathLike[str]):
+        self.path = Path(path)

@@ -0,0 +203,4 @@
+        except OSError as exc:
+            stream.close()
+            raise DiscImageError(f"cannot stat disc image {self.path!s}: {exc}") from exc
+        if self._identity(metadata) != self._image_identity:

@@ -0,0 +199,4 @@
+            self._fail("fighter action table is null")
+        if actions % 4:
+            self._fail(f"fighter action table has unaligned data offset 0x{actions:X}")
+        if self.next_object_offset(fighter) < fighter + 0x60:

@@ -0,0 +505,4 @@
+                raise SubactionParseError(f"{context}: loop at DAT offset 0x{pc + 0x20:X} has zero count")
+            if loop_depth >= max_loop_depth:
+                raise SubactionParseError(f"{context}: loop depth guard exceeded {max_loop_depth}")
+            control_stack.append((pc + 4, count))

@@ -109,0 +160,4 @@
+        assert disc_framedata is not None
+        state = disc_framedata.motion_state(character, action)
+        if (
+            not record.timeline.hitbox_generations

@@ -0,0 +96,4 @@
+
+    def _validate_reference_chain(self, offset: int, index: int, locations: set[int]) -> None:
+        seen = set()
+        while offset != 0xFFFFFFFF:

@@ -0,0 +547,4 @@
+            target_state = (target, control_snapshot)
+            if opcode == 7 and target_state in seen_control_flow:
+                script_loop = True
+                break

@@ -0,0 +132,4 @@
+    def __init__(self, path: str | os.PathLike[str]):
+        self.path = Path(path).resolve()
+        try:
+            stream = self.path.open("rb")

@@ -0,0 +490,4 @@
+                if (
+                    expanding_script_loop
+                    and animation_frame_count is not None
+                    and next_time >= animation_frame_count

@@ -0,0 +181,4 @@
+            file_descriptor = os.open(self.path, flags)
+        except IsADirectoryError as exc:
+            raise DiscImageError(f"disc image is not a regular file: {self.path!s}") from exc
+        except OSError as exc:

@@ -0,0 +557,4 @@
+            if opcode == 7 and target_state in seen_control_flow:
+                script_loop = True
+                repeated_state = (target, time, timer, control_snapshot)
+                if not animation_frame_count or time >= animation_frame_count or repeated_state in seen:

@@ -0,0 +130,4 @@
+    _MAX_MEMBER_SIZE = 0x214D00
+
+    def __init__(self, path: str | os.PathLike[str]):
+        self.path = Path(path).resolve()

@@ -0,0 +367,4 @@
+            if len(data) != dol_size:
+                raise DiscImageError("could not read the complete DOL")
+            self._assert_image_unchanged(stream)
+        digest = hashlib.sha1(data).hexdigest()