S_getChannel : If none available, return -1. Otherwise channel #.

V_DrawPatchFlipped Masks a column based masked pic to the screen. Flips horizontally, e.g. to mirror face.

V_Init

Updates stuff each tick

W_Reload Flushes any of the reloadable lumps in memory and reloads the directory.

Z_CheckHeap

Z_FileDumpHeap

Z_Init

* Free an exception object */

Default: IEEE-754 round-to-nearest, ties-to-even

Emit bit 31 extraction (sign-check based, shared by both loops).

Emit bit 31 extraction for the R22-big loop (separate labels).

Emit the R22-big comparison for bit i (R22 has bit 31 set).

Emit the R22>0 fused restoring comparison for bit i.

Create the boot sequence based on text_start.

Generate all runtime functions by importing from separate modules.

Emit the accumulated constant pool as a .rodata section. Handles the __main__ vs gen_runtime module identity issue: when gen_runtime.py runs

Emit inline SHL lattice for input_reg << shift_amount, accumulating into result_reg. Assumes: bit 31 handled/cleared, input biased +1. On

Generate Biased Non-Restoring Lattice code to extract a byte from T3. OPTIMIZED: - Sign check: 1 op hot path (T3 > 0 falls through t

Generate Biased Non-Restoring Lattice code to extract a halfword from T3. Arguments: - low_half: True for bits 0-15, False for bits

Emit the lattice core for Multiplication with early exit checkpoints. bits 30 down to 0. R20 = Accumulator (Result, directly in return regis

Generate __subleq_lb with O(1) modulo and O(32) bit extraction.

Generate code to load a value from [SP + offset] into dest_reg using indirect addressing.

Generate __subleq_memcpy as a jump to __subleq_memmove.

Generate __subleq_memcpy_aligned as alias for __subleq_memmove_aligned.

Generate optimized memmove using 3-phase algorithm when aligned. void *memmove(void *dest, const void *src, size_t n) Input: R21=dest, R2

Generate __subleq_memmove_aligned entry point. PRECONDITION: dest (R21) and src (R22) are both word-aligned. This means (dest-src) & 3 ==

Generate optimized memset using 3-phase algorithm. void *memset(void *dest, int c, size_t n) Input: R21=dest, R22=c, R23=n Output: R2

Generate __subleq_memset16: halfword-width memset using word stores. void *memset16(uint16_t *s, uint16_t v, size_t count) Input: R21=s,

Generate __subleq_memset32: word-aligned memset for u32 values. void *memset32(uint32_t *s, uint32_t v, size_t count) Input: R21=s, R22=v

Generate __subleq_memset_aligned entry point. PRECONDITION: dest (R21) is word-aligned. This means we skip: 1. The head-phase alignme

Binary dispatch over a list of (reg_value, target_shift) pairs.

Extract raw binary from ELF file.

Get the entry point address from an ELF file.

Get most-derived object info from vtable

Check if type_info is __si_class_type_info

Check if type_info is __vmi_class_type_info

Poll one key event from SDL's internal queue. Returns: positive = key down scancode, negative = key up, 0 = none

Phase 1: Search for a handler */

Phase 2: Run cleanups and transfer to handler */

Translate Linux console scancode to Doom keycode