mirror of
https://github.com/Cesarus85/ringfall-mjolnir-vr.git
synced 2026-10-17 17:00:35 +02:00
2254 lines
216 KiB
JSON
2254 lines
216 KiB
JSON
{
|
|
"version": 1,
|
|
"entries": [
|
|
{
|
|
"unit": "source/interface/hud_messaging",
|
|
"function": "_scripted_hud_set_objective",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the ordinary typed setter from the January instruction/relocation topology, the independent HCEA Xbox behavior, the Stian PC lift, and Aerocatia/demon's named HUD-message definitions. The retained function resolves the scenario HUD-message tag through HUD_MESSAGE_TEXT_DEFINITION_GET, obtains both records through TAG_BLOCK_GET_ELEMENT, requires exactly one _hud_message_type_text element, installs the objective, sums the authenticated up_ticks/fade_ticks scalar locals, and emits January's silent error for an invalid icon-bearing objective. Target and candidate share the 160-byte padded envelope and all eight relocation identities; objdiff reports 96.8 percent similarity. The only residual is address materialization for the adjacent timing fields: January loads fade_ticks through [hud_globals+0x11e], then advances the same base by 0x100 before adding up_ticks at +0x1c, while VC7 lowers the natural typed scalar source as two full-displacement reads at +0x11e/+0x11c. A coherent objective_color subobject pointer moved the base adjustment before the objective store and shrank the function to 144 padded bytes, so it was rejected. The fail-closed classifier returns UNKNOWN, hence the honest unclassified label rather than an invented compiler recipe. No one-use mixed alias, raw offset, volatile/register forcing, barrier, pragma, assembly, fake dependency, undefined behavior, forced inline, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining the asymmetric subobject-base lifetime.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 160,
|
|
"relocation_count": 8,
|
|
"normalized_sha256": "a83e487b78b95cb689279b7de9dfe2a3078ce9e67c5809282fdd7a6b3ebc6a54"
|
|
},
|
|
"base": {
|
|
"size": 160,
|
|
"relocation_count": 8,
|
|
"normalized_sha256": "c3e1fe857ff8074266e9c69b797a29e79f3bc99d6a09fdee025d4d8bd20d9d6e"
|
|
},
|
|
"objdiff_percent": 96.8
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/interface/hud_messaging",
|
|
"function": "_scripted_hud_get_timer_ticks",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the ordinary typed timer query from the January control-flow and relocation topology, HCEA's independent Xbox behavior, and the Stian January-PC lift. The retained function returns zero while the timer is hidden, NONE for the sentinel duration, the stored ticks while paused, and the 16-bit remaining-tick result while running. It uses the semantic hud_timer_data_definition owner and cseries word/short types; its owner declaration lives in interface/hud_messaging.h. Target and candidate share the 80-byte padded envelope, two relocation identities, and 97.5 percent objdiff similarity. Their meaningful streams differ only at the NONE return: January reloads the known sentinel as five-byte mov eax,-1, while VC7 naturally preserves the already-loaded short with three-byte or ax,ax. That two-byte materialization delta shifts the game_time_get relocation from +0x32 to +0x30; every subsequent meaningful instruction, including January's narrow sum and 32-bit subtraction schedule, is identical. Several bounded, source-authentic expression and local-total forms either reproduced this fixed point or worsened register allocation. The fail-closed classifier returns UNKNOWN, hence unclassified rather than an inferred recipe. No volatile/register forcing, barrier, pragma, assembly, raw offset, representation pun, fake dependency, forced inline, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining the full-width sentinel rematerialization.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 80,
|
|
"relocation_count": 2,
|
|
"normalized_sha256": "c28cd50e0150845564921ef4ab5bb445c5a9cb58ac319a84461460fa53686468"
|
|
},
|
|
"base": {
|
|
"size": 80,
|
|
"relocation_count": 2,
|
|
"normalized_sha256": "aaa93f528312a9d8cffdd2e9fed2f8b143dc031d73500550964b8eaeacd95350"
|
|
},
|
|
"objdiff_percent": 97.5
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/cseries/debug_memory",
|
|
"function": "_debug_realloc",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after the credible loop recovered in unmerged campaign commit c8ff585ee made debug_memory_fill_with_random byte-exact and changed the caller ABI enough for the target-proven result != NULL || size == 0 accounting predicate to reach January's 416-byte padded envelope and 25-relocation count. The retained typed C has the correct realloc bookkeeping: successful allocations update the heap total, zero-size frees subtract the old allocation, and failed nonzero reallocations leave accounting unchanged. January keeps the original pointer in ESI, requested size in EDI, and allocation file in EBX from entry; VC7 instead keeps the reconstructed allocation_file/allocation_line locals in a different register/stack schedule. With the now-exact private helper as genuinely new evidence, one bounded single-header parameter-reuse retest still shrank the caller to 400 bytes and a 12-byte frame, so it was reverted. Earlier documented predicate-only, separate-header donor, single-header lifetime, formal-order, end-pointer, and lexical-scope families are exhausted. No register hint, volatile access, barrier, pragma, inline assembly, undefined behavior, fake dependency, inert expression, or nonsensical control flow is retained. Reopen only for authoritative January/cache-beta source, authenticated local/debug information, or a natural same-compiler donor that explains the ESI/EDI/EBX entry lifetimes while retaining the 16-byte frame.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 416,
|
|
"relocation_count": 25,
|
|
"normalized_sha256": "d812408198d3b0ffe7e64a41f32db28bceb17093d3b341f8c2c7d75e0f47f1d1"
|
|
},
|
|
"base": {
|
|
"size": 416,
|
|
"relocation_count": 25,
|
|
"normalized_sha256": "697e6e5109aee7ca97b938ee02877b832ecfb48ed0456393977b12be2688bebb"
|
|
},
|
|
"objdiff_percent": 81.89706
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_statistics",
|
|
"function": "_game_statistics_record_kill",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained ordinary C keeps the source-authentic attacker-loop initialization order recovered by Fable and uses the direct typed statistics.kills[0] increment corroborated by the later Sapien/HCEA topology. It has the exact 672-byte padded envelope and all 22 relocation identities. The only residual is the independent credited-kill schedule at +0x1AE: January increments kills[0] before loading last_kill_time, while VC7 hoists that load first. A one-use block-local short * alias makes the function byte-exact solely by hiding the adjacent-field alias relationship from the optimizer; no Bungie, HCEA, PDB, or local semantic provenance supports that carrier, so it is rejected under the anti-fake-match rule. No barrier, volatile access, assembly, fake dependency, or optimizer-only alias is retained. Reopen only for authoritative January source/local-lifetime evidence or a naturally semantic same-compiler donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 672,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "faed51b584f65f1a0f97f4416a0f599800dceeb2352a80dcf565d92d37724a69"
|
|
},
|
|
"base": {
|
|
"size": 672,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "c83a7c0613ccce274d91ca76f8f2315496ee2b9eefa91862c84160ff35ce5c0b"
|
|
},
|
|
"objdiff_percent": 99.04306
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/cutscene/recorded_animations",
|
|
"function": "_recorded_animation_play_internal",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained ordinary-C reconstruction has the same 0x280 padded size and all 38 relocation identities as January. The residual is confined to four independent instructions after tag_data_get_pointer: January loads animation_threads_debug before storing the returned event stream and masks the thread index before materializing &thread->event_stream; VC7 emits the store before the external-global load and materializes the field address before the mask. Making only animation_threads_debug static produces exact function bytes but a wrong 9-byte BSS owner with wrong symbol offsets/linkage. Making all three BSS definitions static restores the byte count but still gives wrong named offsets and removes the external _debug_recording owner required by hs_globals_external. Temporary-local and statement-order variants either enlarge the residual or change register allocation across the rest of the function. The natural, link-correct source is therefore parked rather than accepting a function-only false positive.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 640,
|
|
"relocation_count": 38,
|
|
"normalized_sha256": "df113ef0763a2a945aaf24c999e7976d55b0f998719fff88ba52585d73eb1a7c"
|
|
},
|
|
"base": {
|
|
"size": 640,
|
|
"relocation_count": 38,
|
|
"normalized_sha256": "21d8285c6b390376e50a99d6b6de987fbbaf585cafe83d99973a40c5072c0be7"
|
|
},
|
|
"objdiff_percent": 98.57143
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/xbox/shader_transparent_chicago_preprocessor",
|
|
"function": "_shader_transparent_chicago_create",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after 28 recorded ordinary-C source-shape experiments, two compatible VC7 builds, the January donor census, and the later HCEA implementation were exhausted. The retained coherent C is byte-identical to January through the map loop and preserves all 17 relocation identities. The residual is the success-result/loop-index allocation at the tail: January keeps TRUE live in AL and increments the index in ECX, while both available VC7 builds home the result and reuse EAX for the increment, producing 416 padded bytes versus January's 432. Attempts to manufacture the AL lifetime were either optimized back to this fixed point or perturbed broader control flow. No volatile or register forcing, compiler barrier, inline assembly, undefined behavior, inert expression, or nonsensical branch is retained. The September 2001 linker map independently recovers shader_map_verify for the same compiland, the combiner-table name is explicitly descriptive, and the exact 16-byte leaf plus exact 208-byte owned table remain natural source. Reopen only for authoritative January source, a strict same-topology donor, or a compatible VC7/QFE that naturally emits the target allocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 432,
|
|
"relocation_count": 17,
|
|
"normalized_sha256": "c465d59ce6f43d7005db48b642ce3e8db33dafbba3f1a5aa84185c0c626e7aa7"
|
|
},
|
|
"base": {
|
|
"size": 416,
|
|
"relocation_count": 17,
|
|
"normalized_sha256": "c716cea5de50b243cc52ee306678f80207c76f7fd5b203e1049f69d86ea2a687"
|
|
},
|
|
"objdiff_percent": 96.15504
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/memory/circular_queue",
|
|
"function": "_circular_queue_dequeue_data",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked under the current house rule after 37 recorded legal-C experiments, both compatible local VC7 builds, January and October 2001 machine-topology comparison, donor scanning, and the later HCEA queue family were exhausted. The retained ordinary C preserves all 12 relocation identities, seven strict-exact sibling functions, and every owned rdata byte. January and October materialize FALSE in BL, then reuse EBX for read_offset and keep separate success/failure tails; the current compiler instead assigns the queue to EBX, read_offset to EDI, and folds failure directly into AL, producing 240 padded bytes versus 256. A natural single-iteration loop reaches the BL/EBX lifetime but also triggers a second validator inline, growing to 336 bytes and 17 relocations. Preventing that clone destroys the desired lifetime, while taking the validator address changes its private ABI and regresses exact siblings. Barriers, register hints, forced inlining/noinline, redundant predicates, union overlays, switches, and synthetic control flow are rejected rather than retained. The exact January symbol atlas recovers the private helper name circular_queue_verify. Reopen only for authoritative source/locals, a strict same-topology donor, or a general natural compiler control that prevents the nested clone without changing the helper ABI.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 256,
|
|
"relocation_count": 12,
|
|
"normalized_sha256": "2981341a22238a314c0f885d555149dc279257b6109242e674f38ccfb0ccd1f9"
|
|
},
|
|
"base": {
|
|
"size": 240,
|
|
"relocation_count": 12,
|
|
"normalized_sha256": "40adf3be1fa79c0b9aaf6b169e37da2e59aa4e306efef68a9573b7aa7ec8dede"
|
|
},
|
|
"objdiff_percent": 93.947365
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/xbox/rasterizer_xbox_hardware_geometry",
|
|
"function": "_rasterizer_vertex_buffer_new",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Target and candidate have equal 0x170 padded size and all 20 relocation identities/addresses. The remaining 11 normalized bytes are confined to the post-copy structure-field stores: VC7 chooses AX/CX for the type value, schedules the hardware-buffer reload at a different point, and moves one independent base-address store across the EDI restore. Broad declaration, field-order, barrier, helper, alias, qualifier, and topology matrices did not reproduce the target without regressing the exact prefix or relocation schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 368,
|
|
"relocation_count": 20,
|
|
"normalized_sha256": "5442bf32f8b49c2a3ebab9e35337bd0f9c1cbbd9eb833e3788b0b93634672f55"
|
|
},
|
|
"base": {
|
|
"size": 368,
|
|
"relocation_count": 20,
|
|
"normalized_sha256": "bf6b5feafdc7750b7b3c8c4c309a5d08573eb1c12360276c11b1fe62941b09af"
|
|
},
|
|
"objdiff_percent": 97.47445
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/xbox/rasterizer_xbox_hardware_geometry",
|
|
"function": "_rasterizer_triangle_buffer_new",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Target and candidate have equal 0x160 padded size and all 24 relocation identities/addresses. The remaining eight normalized bytes are confined to the final four structure-field stores: the target reloads the hardware buffer into ECX before the offset/base stores, while VC7's current source reloads it into EAX after them. A preserved 160-case control-flow/barrier/field-order supersearch plus focused lifetime, alias, helper, qualifier, and initialization matrices found no legal-C form that changes only this schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 352,
|
|
"relocation_count": 24,
|
|
"normalized_sha256": "e90e066bbde0d04c87a43f665fcd7a131ff0e0d1c7a5354b82062ae5b822396c"
|
|
},
|
|
"base": {
|
|
"size": 352,
|
|
"relocation_count": 24,
|
|
"normalized_sha256": "b0fdebbf1336f8336a37bb436ad10ea3ebbf9f105715dec74c87d16c283b457e"
|
|
},
|
|
"objdiff_percent": 98.203255
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/action_converse",
|
|
"function": "_action_converse_perform",
|
|
"class": "register-allocation",
|
|
"evidence": "The gameplay inline-assembly transcription was removed under the house rule limiting sparse assembly to helper/math code. The retained ordinary-C reconstruction has the same 0x100 padded size and eight relocation identities as January. Five grounded C shapes were exhausted; the remaining packet difference is VC7 retaining the shared TRUE value in EBX/BL while the lawful source folds the four uses into immediate operands. The clean semantic C is therefore parked as a register-allocation residual rather than forcing exact bytes.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 256,
|
|
"relocation_count": 8,
|
|
"normalized_sha256": "7a3fad8fb69307c132558b906832d4d31f0334734fc76d18fe773189b5a38d5d"
|
|
},
|
|
"base": {
|
|
"size": 256,
|
|
"relocation_count": 8,
|
|
"normalized_sha256": "288862a662942eb5b03ee84809dbd6b6aea1c023d52915f2bc373192e7c212cb"
|
|
},
|
|
"objdiff_percent": 93.14815
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/cseries/cseries",
|
|
"function": "_stristr",
|
|
"class": "asm-implemented",
|
|
"evidence": "Parked under asm-implemented: our source implements this function with MSVC inline assembly, so it is byte-identical to January by construction rather than by reconstruction. This violates the campaign's standing 'no asm' rule, and the two rules interact badly - an assembly transcription always compares exact, so section_infos_equal cannot distinguish it from a genuine C recovery; only reading the source can. Parked rather than deleted so the exact tally stops counting it as a C reconstruction while the bytes remain reproducible. Same treatment as the pre-existing vendored-assembly park for matrix4x3_multiply. To unpark, replace the __asm with C that gates exact. Audit and full inventory: research/asm_credited_functions_audit.md. Whole body is a single __asm block; no C remains. 2026-08-16 recovery attempt: expressible in C but a near-miss at 72/96. Semantically-correct C reaches 85 bytes off naively, 74 after moving the empty-needle return to the tail (the branch-polarity lever), and 72 with a while(*haystack) loop; prologue, csstrlen call, search loop and _strnicmp call all land correctly. Residue is a spill preference: January holds the first needle character in bl across the function and spills length into the dead needle parameter slot [ebp+0xc]; we keep length in ebx and spill the character to [ebp+0xf]. Measured inert: declaration order both ways, register on either/both locals, int/long/unsigned long length (int regresses to 103), length scoped inside the if, character hoisted out of the loop, continue- and while-form loops, length computed before the guard. Same spill class as the standing parks. Not replaced - swapping a byte-exact asm body for a 72-byte residual is not a recovery. See research/asm_credited_functions_audit.md. 2026-08-16 spill-flip attempt, refined: the 72-byte while(*haystack) form is STRUCTURALLY WRONG - it rotates the loop, duplicating the load/test at the back edge and forcing lea eax,[esi-1] instead of dec esi/mov eax,esi. The structurally correct form is the for(;;) at 74/96, whose loop body matches January instruction-for-instruction (load, inc, test, je, cmp, jne back-edge, strnicmp, test, jne back-edge, dec, return). Byte count is therefore the wrong metric here; 74 is closer than 72. With that structure fixed the residue is isolated to a single free-register contest: esi and edi hold haystack and needle in both builds, and exactly one of {first, length} can have ebx because both live ranges span a call (first across csstrlen, length across _strnicmp). January gives ebx to first (mov bl,[edi], cmp al,bl) and spills length into the dead needle slot [ebp+0xc]; we give ebx to length and spill first to [ebp+0xf] - which is also inside the dead needle slot, so both compilers reuse the same storage and differ only in which value wins the register. Additional inert levers measured this round: char/byte/unsigned char for the first character and the loop character, long/unsigned long/const long for the length, assignment inside the while condition, pointer-compare-before-increment, and length computed before the guard. Same free-register-preference class as the register-allocation parks; reachable in principle, lever not found. 2026-08-16 c2 debugger result (NEGATIVE, closes a line of investigation): built tools/c2dbg32/repro_stristr.c, a single-function TU reproducing the tie exactly (96B, ndiff 74, same mov ebx,eax for length and same spill of first to [ebp+0xf]), and breakpointed every mapped allocator site during its compile. The machinery runs - interference dispatch 0x1074d343 x6, relation 0x107091ae x8, overlap probe 0x10735a41 x5, interference test 0x1070943b x3, coalescing copy 0x10701961 x15, leaf-register write 0x10715873 x2, preference store 0x1075f5f2 x5, finalizer 0x107144cf x3 - but it never touches the registers in question: both leaf-register writes assign register byte 1, and ALL FIFTEEN coalescing copies propagate register byte 1 (ecx==1 at every hit). ebx/esi/edi are 3/6/7 zero-based and never appear. The mapped sites allocate the eax-family scratch class; the callee-saved assignment and the spill choice are made in a pass that is still unmapped. Further breakpoint work on these VAs therefore cannot reach this tie (nor the sibling register-mirror and spill parks). Progress needs the callee-saved/spill pass located from scratch - the entry point is the code that decides a live range is memory-resident, not the code that stamps [node+0x28]. See tools/c2dbg32/IR_LAYOUT.md. 2026-08-16 CORRECTION to this entry's earlier c2 claims: 0x10715873 does NOT write a physical register. Four probes differing only in the C type of the spilled locals show the byte it stamps into node[+0x28] is uniform across every node in a compile and tracks operand size - char->1, short->2, int->3, __int64->4 (13/13/13/7 hits, one distinct value each). It is an operand WIDTH class, not a register; thirteen simultaneously-live values cannot share one register. This also resolves the 'discrepancy' noted during the original record_kill work (rwprobe used short fields, every write showed al=2 while the code used ecx) - that was the width of a short, not a register quirk. Consequently the earlier 'read the register write' and 'traced the preferred-register argument' results for this function are WITHDRAWN: the physical-register assignment site and the spill decision are both still unlocated. The mechanism narrative (both candidate registers free, outcome set upstream) stands on the instruction-level evidence, but no compiler-internal site has been confirmed to make it. See tools/c2dbg32/IR_LAYOUT.md.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 96,
|
|
"relocation_count": 2,
|
|
"normalized_sha256": "8068cc55c81c4109e4d2eef813744d2c42fbea33b53c93a8c192bb7ad03e0428"
|
|
},
|
|
"base": {
|
|
"size": 96,
|
|
"relocation_count": 2,
|
|
"normalized_sha256": "8068cc55c81c4109e4d2eef813744d2c42fbea33b53c93a8c192bb7ad03e0428"
|
|
},
|
|
"objdiff_percent": 100
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/effects/particles",
|
|
"function": "_code_0008fcd0",
|
|
"class": "asm-implemented",
|
|
"evidence": "Parked under asm-implemented: our source implements this function with MSVC inline assembly, so it is byte-identical to January by construction rather than by reconstruction. This violates the campaign's standing 'no asm' rule, and the two rules interact badly - an assembly transcription always compares exact, so section_infos_equal cannot distinguish it from a genuine C recovery; only reading the source can. Parked rather than deleted so the exact tally stops counting it as a C reconstruction while the bytes remain reproducible. Same treatment as the pre-existing vendored-assembly park for matrix4x3_multiply. To unpark, replace the __asm with C that gates exact. Audit and full inventory: research/asm_credited_functions_audit.md. Whole body is a single __asm block; no C remains.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 16,
|
|
"relocation_count": 1,
|
|
"normalized_sha256": "41eed58c9a0765d9d594f1473bc1c296a81493ee3d057b5d8313a81cc9f1b470"
|
|
},
|
|
"base": {
|
|
"size": 16,
|
|
"relocation_count": 1,
|
|
"normalized_sha256": "41eed58c9a0765d9d594f1473bc1c296a81493ee3d057b5d8313a81cc9f1b470"
|
|
},
|
|
"objdiff_percent": 100
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/effects/particles",
|
|
"function": "_code_0008ff30",
|
|
"class": "asm-implemented",
|
|
"evidence": "Parked under asm-implemented: our source implements this function with MSVC inline assembly, so it is byte-identical to January by construction rather than by reconstruction. This violates the campaign's standing 'no asm' rule, and the two rules interact badly - an assembly transcription always compares exact, so section_infos_equal cannot distinguish it from a genuine C recovery; only reading the source can. Parked rather than deleted so the exact tally stops counting it as a C reconstruction while the bytes remain reproducible. Same treatment as the pre-existing vendored-assembly park for matrix4x3_multiply. To unpark, replace the __asm with C that gates exact. Audit and full inventory: research/asm_credited_functions_audit.md. Whole body is a single __asm block; no C remains.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 80,
|
|
"relocation_count": 6,
|
|
"normalized_sha256": "959a33a1ae57de3e7dd04e07b55a619b337b744570172bfc142f692253108258"
|
|
},
|
|
"base": {
|
|
"size": 80,
|
|
"relocation_count": 6,
|
|
"normalized_sha256": "959a33a1ae57de3e7dd04e07b55a619b337b744570172bfc142f692253108258"
|
|
},
|
|
"objdiff_percent": 100
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/xbox/rasterizer_xbox_hardware_bitmaps",
|
|
"function": "_rasterizer_bitmap_new",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Target and candidate have equal 0x190 padded size and all 26 relocation identities/addresses. They are instruction-identical through +0x159 and differ in exactly one normalized byte: VC7 directs the final failure JNE to a second byte-identical bitmap->hardware_format = NULL / return TRUE epilogue, while January directs it to the first epilogue. More than 50 ordinary-C control-flow shapes covering shared and split returns, branch polarity, goto topology, success materialization, and local lifetimes either preserve this one-byte duplicate-epilogue branch-threading choice or regress earlier exact code. The retained source is the plain semantic form; no asm, volatile/register forcing, pragmas, barriers, undefined behavior, byte patch, or comparator exception is used.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 400,
|
|
"relocation_count": 26,
|
|
"normalized_sha256": "041cef84e2a13eeae0fccfaef6e8e897a5c5926bf850bc6c10bc245f3df8a82d"
|
|
},
|
|
"base": {
|
|
"size": 400,
|
|
"relocation_count": 26,
|
|
"normalized_sha256": "719469460357f06cde7f452e16e02ba79ac639e85e0fad244f8e01cb7bd5efcd"
|
|
},
|
|
"objdiff_percent": 99.96377
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/memory/lra_cache",
|
|
"function": "_lra_allocate",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after the complete E1-E50 source-shape corpus, two compatible VC7 builds, all committed/dirty LRA bodies, 1,092 rebuilt artifacts, the later Claude naming/line-anchor audit, and the open Marathon source were reviewed. January carries a zero through the allocator loop and duplicates the initial pass/deletion stores; VC7 instead merges/rematerializes them, leaving the honest C 32 padded bytes short with identical four relocation destinations but addresses 0x13/0x5F/0x83/0x88 versus 0x13/0x6B/0x89/0x8E. The only 400-byte form used _ReadWriteBarrier() as a codegen anchor and is rejected as fake compiler steering. Its barrier-free ordinary-C remainder stayed 368 bytes and worsened normalized distance from 320 to 331 bytes (SHA f719c088...), so the simpler coherent early-return source is retained. Reopen only for authoritative January source/locals, a real donor with the same loop-carried-zero dependency, a compatible original C2/QFE, or a newly proven meaningful C topology outside the exhausted families.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 400,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "93beee39f5b398662960640adbdef20b5569e5407bff1526a6021970f3001e2f"
|
|
},
|
|
"base": {
|
|
"size": 368,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "bd671ca359d22c92b9d24e5428f9c62f6fc4397f1643ed41d5a7df44ccdaa9ef"
|
|
},
|
|
"objdiff_percent": 65.6755
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bungie_net/common/prime_numbers",
|
|
"function": "_primegen",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked under the source-credibility rule after the E1-E27 ordinary-C corpus, the Stian and Pastudan sieve donors, the January symbol atlas, compatible VC7 builds, and the later donor-lifetime packet were exhausted. The retained coherent sieve has the target 352-byte padded envelope, all 12 relocation destinations/types in order, three strict-exact siblings, and all 72 owned rdata bytes exact. January keeps odd_count in EBX and num_primes in ESI while assigning three distinct stack lifetimes; the available compiler instead emits a two-slot frame for the natural source. A pre-allocation k initialization improves the score to 91.14815% but creates the third slot by a different, explicitly non-original lifetime route, so it is rejected. A separate statement move can manufacture exact bytes but has no credible source rationale and is also rejected. The production source therefore remains the simplest donor-consistent C. Reopen only for authoritative local-variable provenance, an original-source donor with the same simultaneous allocation, or a verified compatible compiler/QFE that naturally emits it.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 352,
|
|
"relocation_count": 12,
|
|
"normalized_sha256": "2428a7a00be6ab6f96efe9dda273d824a0cc9829aeeb2dd5f4c9b35b2b7992b1"
|
|
},
|
|
"base": {
|
|
"size": 352,
|
|
"relocation_count": 12,
|
|
"normalized_sha256": "66e1c7859e354a6bf7caccb70b260e99d516be6a94837571ecc60dd5b43edda6"
|
|
},
|
|
"objdiff_percent": 81.614815
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmaps_quantitize",
|
|
"function": "_row_dither",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked after the full row-dither provenance packet, the later 1,571-worktree freshness census, all ten source identities, both obvious source statement orders, and the declaration/loop-tail/pointer/dependency families were exhausted. The retained natural Floyd-Steinberg C has the same 464-byte padded size, zero relocations, exact frame/control flow, and differs only in the order of three independent loop-maintenance operations: January emits inc EAX; add EBX,2; add ECX,2, while the retained compiler emits add EBX,2; inc EAX; add ECX,2. Reversing the two source statements puts ECX between EAX and EBX instead. Barriers, pragmas, artificial dependencies, volatile/register forcing, inline assembly, and byte patches are rejected. The January atlas and multiple cross-build maps recover row_dither; bitmap_quantitize_read_row and bits_per_channel_reversed are descriptive names because no original private names were found. Reopen only for original local/statement provenance, a same-compiler natural-C donor with this dependency context, or a genuinely new lawful scheduling control.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 464,
|
|
"relocation_count": 0,
|
|
"normalized_sha256": "a5feef0c98bc8565991a9cf9722e0258d2bd556e23fc0326891aa0ce0ebca5db"
|
|
},
|
|
"base": {
|
|
"size": 464,
|
|
"relocation_count": 0,
|
|
"normalized_sha256": "7afe02e297bf06dd682a9c44bfd00aacf39c2f7ea0c0f45acce838dc9b696da4"
|
|
},
|
|
"objdiff_percent": 98.809525
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bungie_net/common/key_agreement",
|
|
"function": "_key_agreement_get_packet_type",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked after a bounded ordinary-C type and expression audit. The retained private helper has the exact four relocation identities and the authentic January assertion/file strings; it reads the key-agreement packet type from the final encoded message byte after requiring `_message_type_packet`. The compiler strength-reduces `GET_MESSAGE_TYPE` to `and al, 0x0C; cmp al, 0x0C`, while January emits `shr al, 2; and al, 3; cmp al, 3`, leaving a 64-byte candidate against the 80-byte target. `key_agreement_get_packet_type` is a descriptive inferred private name: Stian/Pastudan's research-only `key_agreement_peek_packet_type` refers instead to the separate public `_is_message_encryption_key_message` predicate and was deliberately not misapplied here. No volatile/register forcing, barrier, pragma, assembly, or artificial dependency was admitted.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 80,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "17992eecb37a652d03f0088ce5123c158674116e7b2c88fe56083c3627f03278"
|
|
},
|
|
"base": {
|
|
"size": 64,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "c85c2f19f63571e94b0334e0868eb18f2f2ec585b54cdf229b114e38c0c79eb3"
|
|
},
|
|
"objdiff_percent": 95.75
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bungie_net/common/key_agreement",
|
|
"function": "_initiate_key_exchange",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked with the simplest coherent Diffie-Hellman initiation flow: generate parameters and public key, build into the same-TU 0x200-byte buffer, byte-swap the header, write the complete message, and return the write result. Target and retained source have equal 128-byte padded size and the same six relocation identities. January preserves a preinitialized byte-sized TRUE result and a larger local frame; retaining `boolean result = TRUE; return result;` solely to influence code generation lacked independent source provenance and was rejected under the source-credibility rule. Direct `return TRUE`/`FALSE` is retained even though it scores lower. No exact candidate was found or rejected, and no compiler-steering construct is present.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 128,
|
|
"relocation_count": 6,
|
|
"normalized_sha256": "dd522968df4407b121545dc0bc712ea05f9e82a71fb21fcb1c46474c55defb9d"
|
|
},
|
|
"base": {
|
|
"size": 128,
|
|
"relocation_count": 6,
|
|
"normalized_sha256": "193bbbb3b54c0db91978f2077f02bde2b3be2f86ebdb0cdef3489da18be109fc"
|
|
},
|
|
"objdiff_percent": 69.57895
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bungie_net/common/key_agreement",
|
|
"function": "_complete_key_exchange",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked as an explicitly labeled January-disassembly reconstruction, not recovered named source. The retained typed C has the exact 416-byte padded envelope, 17 relocation identities, message-type gate, packet-tail dispatch, packet-group decode calls, type-zero secret generation ranges [0xFF, prime limb - 2], finalize reply through the same-TU 0x200-byte buffer, and type-one/private-key completion semantics proved by January control flow and canonical public-key/data-packet APIs. The long/short union overlays are the canonical interface bridge already used by `network_messages.c`: January initializes full-word stack slots while packet-group APIs consume `short *`. Bounded local-scope/type/order variants only moved independent calls and stores; the retained form is the simplest semantically coherent equal-envelope source. Pastudan's opaque `FUN_00080620` body was never copied. No exact candidate was found or rejected, and no volatile, barrier, pragma, assembly, pointer-address trick, or forced lifetime is present.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 416,
|
|
"relocation_count": 17,
|
|
"normalized_sha256": "53856558cb7b53bc40e2c4dd12c3bfe285e4dc90bb5d3c27ab1680c4cb50377f"
|
|
},
|
|
"base": {
|
|
"size": 416,
|
|
"relocation_count": 17,
|
|
"normalized_sha256": "b1abf287400c1b3843364d05327512ff963fce5fb159f46f73100852027a411a"
|
|
},
|
|
"objdiff_percent": 84.85987
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/players",
|
|
"function": "_players_compute_combined_pvs",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The typed combined-PVS routine has equal 368-byte sections and the same 22 relocation identities as January. The remaining difference begins after objects_get_activating_cluster_index: January loads player_data and prepares the iterator before the result home, while the retained ordinary C stores the call result first; all subsequent relocation targets remain the same schedule shifted by that window. The natural direct call replaces the former cast/codegen lever. Prior bounded source-shape evidence is in docs/object_matching_logs/players_obj.md under _code_000a9ff0; current source/provenance is also corroborated by ../../research-cache/halocea-full-blobs-20260830/src/blam/game/players_compute_combined_pvs.c. Reopen only with an authentic statement/lifetime form, never with barriers, aliases, or dead code.",
|
|
"measurements": {
|
|
"target": { "size": 368, "relocation_count": 22, "normalized_sha256": "9e3ab79a5087c8d11b97f52c30afc3f596faa4aa6122480dc9f16d247be8ca9f" },
|
|
"base": { "size": 368, "relocation_count": 22, "normalized_sha256": "82b53aacde9159b3131bf4c6318eb83423cad5b9b34e640096a551974b889bba" },
|
|
"objdiff_percent": 86.75781
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/players",
|
|
"function": "_player_teleport_on_bsp_switch",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The clean typed BSP-switch teleport has equal 320-byte sections and all 21 relocation identities. The remaining packet is a prologue/local-home and call-scheduling difference; target and base retain the same calls, strings, and global references. The old volatile double-write is rejected as inert compiler steering. The prior bounded schedule analysis is in docs/object_matching_logs/players_obj.md; the workspace-local HCEA topology is at ../../research-cache/halocea-full-blobs-20260830/src/blam/game/player_teleport_on_bsp_switch.c:31. Reopen only with first-party local-lifetime evidence or a naturally explanatory caller shape.",
|
|
"measurements": {
|
|
"target": { "size": 320, "relocation_count": 21, "normalized_sha256": "73f7fae1e4082fd761f5db63b3648a2b5ca519901a19abd8499126c231447c5c" },
|
|
"base": { "size": 320, "relocation_count": 21, "normalized_sha256": "6a0e944e17ba05d12ccc28139b4f2f1b08b0269b79dfab7869c3db5e14b6eef7" },
|
|
"objdiff_percent": 83.31193
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/players",
|
|
"function": "_players_reconnect_to_structure_bsp",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained typed reconnection flow has equal 736-byte sections and all 40 relocation identities. Its remaining variation is scheduling around iterator/leaf/teleport temporaries; no relocation ownership differs. The previous volatile field reads are removed as invalid source. Semantic topology is independently present at ../../research-cache/halocea-full-blobs-20260830/src/blam/game/players_reconnect_to_structure_bsp.c; the strict historical boundary is docs/object_matching_logs/players_obj.md. Reopen only with provenance for the temporary lifetime/order, not a codegen control.",
|
|
"measurements": {
|
|
"target": { "size": 736, "relocation_count": 40, "normalized_sha256": "de7f7f7138236ad854dd13a4d754a97a5041c10d9dbef3260d18cffcb8eb886b" },
|
|
"base": { "size": 736, "relocation_count": 40, "normalized_sha256": "f11d3315e7512d470ca979b7cba3155b740ea99178c1ae924414a98be35aa74c" },
|
|
"objdiff_percent": 98.64103
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/players",
|
|
"function": "_unit_should_autopick_weapon",
|
|
"class": "register-allocation",
|
|
"evidence": "The ordinary typed pickup predicate has equal 144-byte sections and all seven relocation identities; divergence is only the register/lifetime arrangement between the two unit_approve_weapon_pickup calls. The removed volatile weapon-definition pointer was a codegen-only alias with no game-state semantics. The credibility cleanup log records the rejection; source retains the direct typed pointer. Reopen only with authenticated local-lifetime evidence, not register, volatile, barrier, or inline controls.",
|
|
"measurements": {
|
|
"target": { "size": 144, "relocation_count": 7, "normalized_sha256": "1c1da7cda8b1b98ddf4579327d112f3078eb5e2ca2d69aba7cea8f568610999f" },
|
|
"base": { "size": 144, "relocation_count": 7, "normalized_sha256": "6a23f54863687bd0996b1997d252d5206513dee16b478876afb34a216307d309" },
|
|
"objdiff_percent": 87.083336
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/memory/lrar_cache",
|
|
"function": "_lrar_allocate",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "The retained allocation is the natural typed source: every block lookup calls the same private lrar_get_block helper, and all six formerly address-named private routines now have descriptive LRA-family names. The prior 12/12 result is rejected because it required __declspec(noinline) plus two selectively hand-expanded copies of lrar_get_block's validation body. With those source-shaping controls removed, 11/12 functions remain strict exact. January calls lrar_get_block at offsets +131 and +207, while this incomplete reconstruction's VC7 translation unit inlines the helper validation paths and grows the function from 784 bytes/27 relocations to 1056 bytes/47 relocations. The fail-closed classifier reports UNKNOWN; the narrower TU-context label records only the directly observed selective-inlining boundary, not a claimed recipe. The published Marathon source was checked as a first-party style analogue but contains no LRAR implementation. Reopen only with original LRAR source, a historically supported call-graph restoration, or another natural source form; never restore noinline, duplicated helper bodies, pragmas, barriers, volatile controls, or dead code for byte credit.",
|
|
"measurements": {
|
|
"target": { "size": 784, "relocation_count": 27, "normalized_sha256": "a34c14dad0afc2a3462c738ca6153c3b46d2bdd0164b176dd208295594f86663" },
|
|
"base": { "size": 1056, "relocation_count": 47, "normalized_sha256": "8a2fe453345af3d00eaf476f17eedbfc67629d8af6d6a036cc097d669dcc3652" },
|
|
"objdiff_percent": 67.61811
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_engine",
|
|
"function": "_game_engine_verify_current_map",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "The private game_engine_verify_current_map label is absent from January's PDB but comes from the corresponding verbose-symbol HCEA build, where it is adjacent to the same netgame_verify_spawn_points/netgame_verify_equipment validator cluster; it is strong cross-build authentic-name evidence, not a claimed January public label. The former exact result is rejected because it depended on definition-local __declspec(noinline) attributes on find_netgame_flags/find_netgame_flag with no original-source provenance. Natural C leaves both scan helpers strict exact, but VC7 inlines the exact find_netgame_flags body through the private netgame_flag_verify_team_exists helper, expanding this caller from January's 640 bytes/52 relocations to 1104 bytes/60 relocations. Six target-only functions prove this translation unit is incomplete, making altered whole-TU optimizer context plausible but not establishing it as the cause. The fail-closed classifier reports UNKNOWN; the TU-context label records the directly observed nested-inlining boundary and does not assert a source recipe. Reopen only after recovering missing same-TU call-graph context or finding first-party source evidence; never reintroduce noinline or other compiler controls solely to recover exact bytes.",
|
|
"measurements": {
|
|
"target": { "size": 640, "relocation_count": 52, "normalized_sha256": "b3bce6413d9406f83ea59885922cd47be96d95e3fad738820f5802d54dbde7f8" },
|
|
"base": { "size": 1104, "relocation_count": 60, "normalized_sha256": "de767fa67df3d2a492eea148ae2b672336b474dd808ca04347637c5a2a0309ab" },
|
|
"objdiff_percent": 10.130045
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/sound/ima_adpcm",
|
|
"function": "_decompress_ima_adpcm_audio_data",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked after the historical source census and the focused statement/declaration-order experiments recorded in the two IMA ADPCM ledgers. The retained ordinary C implements the coherent Bungie IMA decompressor with the exact 416-byte padded envelope and the same two table destinations. January stores decremented input_data_size before materializing sample_count * 2, while VC7 schedules the materialization first; the resulting packet shifts the step-size-table relocations from +178/+275 to +181/+277. Attempts to perturb this schedule either did not move it or regressed the surrounding loop. No volatile access, barrier, pragma, inline assembly, fake dependency, dead branch, or manual byte logic is retained. Reopen only for authoritative source/local ordering or a natural same-compiler donor.",
|
|
"measurements": {
|
|
"target": { "size": 416, "relocation_count": 2, "normalized_sha256": "c308b60091d47921aeb30f63188ec5317c64aa9fa52b9e53721774ecd34176f9" },
|
|
"base": { "size": 416, "relocation_count": 2, "normalized_sha256": "92f27a5e493fd0e401a7ee0c7c823e3040bddfdd6100cccb5b4f673be630d882" },
|
|
"objdiff_percent": 80.8125
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/math/periodic_functions",
|
|
"function": "@periodic_function_build_variable_period_x_table@4",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained ordinary C is the authenticated HCEA/Fable waveform-table reconstruction, uses the January-atlas __fastcall name and the shared cseries fast_ftol policy, and has the exact 256-byte envelope and all 18 relocation destinations. After 21 bounded natural-source experiments, only a two-instruction EDX/ECX ordering tie remains around the first cosine constant; artificial volatile, barrier, pragma, dead-dependency, inline-assembly, and compiler-control forms are rejected. The integration ledger records the donor history and negative controls. Reopen only for original January source or new same-compiler scheduling evidence.",
|
|
"measurements": {
|
|
"target": { "size": 256, "relocation_count": 18, "normalized_sha256": "802ef4da9736bcaf8a616c56d03ba3e9322b229ad4b3814c60909462d7ebacf3" },
|
|
"base": { "size": 256, "relocation_count": 18, "normalized_sha256": "af8e65f5d773f0fb1e635264e54d3e63fccee99c69b65364a72be56cdca323b4" },
|
|
"objdiff_percent": 91.233765
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/s3tc/s3tc",
|
|
"function": "_DecodeBlockAlpha3__single_pixel",
|
|
"class": "unclassified",
|
|
"evidence": "The retained function is coherent DXT5 alpha-decoding C with the target's named block structures and sole relocation, rather than a byte-oriented construction. The local symbol atlas maps January's own RVA to an exact-equivalent typed original-Xbox symbol that demangles to a const input block plus signed short/short coordinates; several August/September 2001 Xbox builds independently carry the same types for both single-pixel helpers. HCEA agrees but is only LLM re-sourced corroboration. A bounded width grid tested long/long (432 bytes, 93.677635%), long/short (448 bytes, 94.13816%), short/long (432 bytes, 93.2829%), and short/short (448 bytes, 94.13816%); the source-backed short/short signature is retained instead of selecting a full-width spelling merely because it matches the target size envelope. The remaining tail differs in argument promotion, register use, and accumulator scheduling, while the fail-closed classifier reports UNKNOWN. Reopen only with authentic Microsoft/Bungie source or evidence that naturally explains the promotions and tail schedule; never use artificial widths, dead logic, barriers, volatile qualifiers, or compiler controls for byte credit.",
|
|
"measurements": {
|
|
"target": { "size": 432, "relocation_count": 1, "normalized_sha256": "b869ae2d8e5be4b6efe4fef80b120931dfc7da90d6d9c21a03a60b019f8e6ba5" },
|
|
"base": { "size": 448, "relocation_count": 1, "normalized_sha256": "db57324424c861cd2aa46b18de4452ba9f44e124138cbc496e7884d616d70c79" },
|
|
"objdiff_percent": 94.13816
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/effects/decals",
|
|
"function": "_decal_update",
|
|
"class": "unclassified",
|
|
"evidence": "The retained helper is coherent typed decal-aging source under the HCEA/PDB-authenticated private name `static void decal_update(long)`. It resets decal intensity, preserves permanent decals, fades finite-lifetime decals with cseries flag macros, releases locked-count ownership once, and deletes expired rasterizer vertices. Defining the helper in the same translation unit is required: VC7 rejects an undefined static prototype with C2129, and the complete private definition naturally gives the strict-exact public decals_update wrapper its January EDI live-in call convention without a fabricated ABI declaration. The remaining helper residual combines register/x87 scheduling with January's 32-bit inline FISTP conversion; ordinary C emits __ftol2, while /QIfist emits the wrong qword FISTP. No inline assembly, compiler flag, volatile access, register forcing, dead dependency, or fake control flow is retained. Reopen only for authoritative January source or a natural same-compiler helper/math spelling that emits the dword conversion and surrounding schedule.",
|
|
"measurements": {
|
|
"target": { "size": 400, "relocation_count": 25, "normalized_sha256": "dcc6a629481fabd93292d708b860675421698d6ef2dc9e0679b57331d784d35f" },
|
|
"base": { "size": 384, "relocation_count": 26, "normalized_sha256": "1ab3a89f52527a51460b6a1afa552e825fe26353faf14970500d56510166cf27" },
|
|
"objdiff_percent": 94.21311
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/object_lights",
|
|
"function": "_light_mark",
|
|
"class": "unclassified",
|
|
"evidence": "The retained private helper is ordinary, coherent marker-state C and is emitted through the real lights_prepare_for_object_dynamic -> find_point_lights_for_object_in_cluster call topology; no anchor, duplicate helper, or standalone byte carrier remains. January and the candidate have the same 96-byte envelope and all eight relocation identities, but VC7 selects a different natural assertion/marker control-flow schedule. Source respellings that merely manufacture the target branch layout are rejected under the anti-fake-match rule. Reopen only for authoritative January source or independent same-compiler source/topology evidence that naturally explains the schedule; do not use volatile access, fake dependencies, assembly, or optimizer steering.",
|
|
"measurements": {
|
|
"target": { "size": 96, "relocation_count": 8, "normalized_sha256": "1175088cd02bd3341a0ff200c3356917ecd5b27958606b0c9d68ef92c07a5300" },
|
|
"base": { "size": 96, "relocation_count": 8, "normalized_sha256": "780f93f2adfaad0f187e7271a5e1516d6416d6881e7a7476969cf21eec2c887f" },
|
|
"objdiff_percent": 84.84849
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/object_lights",
|
|
"function": "_light_unmarked",
|
|
"class": "unclassified",
|
|
"evidence": "The retained private helper is the direct semantic predicate `lights_globals.marker != light->marker`, naturally called by find_point_lights_for_object_in_cluster. A previously discovered if/return/return spelling reaches the January 96-byte stream only by artificial source topology and is explicitly rejected; the honest one-expression function is 80 bytes with the same eight relocation identities. Reopen only for authoritative January source or independent evidence for a natural historical control-flow spelling. Do not admit the known byte-oriented respelling, volatile state, dead branches, assembly, or a fake caller.",
|
|
"measurements": {
|
|
"target": { "size": 96, "relocation_count": 8, "normalized_sha256": "6aa93207648f0793874a395bb091edda96bd71c50fd33a1eb3ef9d34ce6ff498" },
|
|
"base": { "size": 80, "relocation_count": 8, "normalized_sha256": "9ea9773df405cf2faefd56cf8476c76d416f5c00bbc2df13ea5f149b7b2c087f" },
|
|
"objdiff_percent": 77.40741
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/object_lights",
|
|
"function": "_light_reconnect_to_map",
|
|
"class": "unclassified",
|
|
"evidence": "The retained ordinary-C reconstruction reconnects a live light through the recovered cluster-partition flow and calls the real same-TU light_compute_bounding_sphere helper with its full semantic signature. It is a coherent owner function, not a wrapper or code-size carrier. The remaining gap is broad VC7 statement/register/x87 topology: 592 bytes and 24 relocations versus January's 640 bytes and 25 relocations. Reopen for authoritative January source, recovered light-datum fields, or a natural same-compiler donor that explains the missing relocation and schedule; reject representation-punning adapters, duplicate geometry helpers, artificial temporaries, volatile access, assembly, and fake control flow.",
|
|
"measurements": {
|
|
"target": { "size": 640, "relocation_count": 25, "normalized_sha256": "0bdb2e5147c6d190bb396e3c19d040bdfa2ec6a01efa1c6269b65283ffc7d488" },
|
|
"base": { "size": 592, "relocation_count": 24, "normalized_sha256": "8ceb97c81b99398fe7f92ff1bb956a41392c4bd0f8ca396932b17f3fc43c01bf" },
|
|
"objdiff_percent": 76.022026
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/object_lights",
|
|
"function": "_find_point_lights_for_object_in_cluster",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The authenticated private helper is naturally retained because lights_prepare_for_object_dynamic calls it; it traverses the real cluster light partition and uses light_unmarked/light_mark as one link-closed marker packet. Restoring the real earlier object_get_self_illumination owner function changed the lawful same-TU optimizer context and naturally improved this helper from 576 to January's exact 560-byte padded envelope while preserving all 31 relocation identities. The remaining difference is a small ordinary instruction-scheduling residual recorded at 99.3617 percent. No uncalled duplicate, address-derived name, dummy carrier, forced inline, or compiler construct is retained. Reopen only for authoritative January source or independent same-compiler evidence for the traversal/lifetime shape; do not use volatile access, fake dependencies, manual address logic, or assembly.",
|
|
"measurements": {
|
|
"target": { "size": 560, "relocation_count": 31, "normalized_sha256": "39d22fa1133941bdd6a0b52cfe5ff4e0df3e109e21e6318f46774740811f96be" },
|
|
"base": { "size": 560, "relocation_count": 31, "normalized_sha256": "3c814b365210b7757eb6ba5dee596c15ec8fefe476a335ad299af138e89876a2" },
|
|
"objdiff_percent": 99.3617
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/object_lights",
|
|
"function": "_object_get_self_illumination",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after restoring the complete ordinary-C implementation from January disassembly and relocation evidence and corroborating its object/attachment recursion against the later HCEA source. The retained function uses the typed object_definition_get, object_get, and light_get accessors, iterates the semantic _object_attachment_type_light slots, accumulates real_rgb_color_brightness, and recursively visits the first child and next sibling. January and the candidate have the same 208-byte padded envelope, all seven relocation identities, and the same 84-instruction semantic sequence; the generated report records 96.35135 percent similarity. The residual is confined to the placement of stack cleanup and two independent zero initializations before the attachment loop. Three natural declaration/scope arrangements either produced this fixed point or a broader prologue split, so the source is parked rather than adding an optimizer-only carrier. No forced inline/noinline, volatile or register forcing, barrier, pragma, assembly, fake dependency, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the initialization schedule.",
|
|
"measurements": {
|
|
"target": { "size": 208, "relocation_count": 7, "normalized_sha256": "f104fb248006b06b69810ac8eb1b9460fba97be1e28353017b9867084897a681" },
|
|
"base": { "size": 208, "relocation_count": 7, "normalized_sha256": "cfef1bd48ce36ee1ba93ff9b23618e5ea288f0810e834eb9b0e27c8e161bd302" },
|
|
"objdiff_percent": 96.35135
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/object_lights",
|
|
"function": "_light_compute_bounding_sphere",
|
|
"class": "unclassified",
|
|
"evidence": "The authenticated private helper is a real dependency of light_reconnect_to_map and computes the light's semantic radius/position from the typed light definition; it is not the distinct unwritten light_get_bounding_sphere function at the following January address. Target and candidate share a 240-byte envelope and five relocations, but differ in natural conditional/x87 scheduling and relocation identity. Reopen only for authoritative January source, recovered type/field evidence, or a natural same-compiler donor that explains both instruction and relocation choices; reject type-punning call adapters, duplicate math helpers, volatile access, fake branches, and assembly.",
|
|
"measurements": {
|
|
"target": { "size": 240, "relocation_count": 5, "normalized_sha256": "6daa7a1efe4519f3cc34c9fe6e40e087e21dc929be8f1f0b43ecaedee13ced3a" },
|
|
"base": { "size": 240, "relocation_count": 5, "normalized_sha256": "ac87c6b4c87e36b4bba6c3557c3c369a52480987b4627865ff0efb4d339ccb1a" },
|
|
"objdiff_percent": 63.494507
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bungie_net/common/thread_win32",
|
|
"function": "_get_mutex_from_pool",
|
|
"class": "csplit-relocation-alias",
|
|
"evidence": "Not a code-generation difference. The natural loop bound is &thread_globals.mutex_references[MAXIMUM_MUTEX_REFERENCES].in_use, one past the static thread_globals object at image address 3262248 with size 1544, so the resolved address lies 36 bytes inside the following external transport_address_string object at 3263792. csplit attributes relocation 2 to _transport_address_string+36; VC7 correctly emits the same address as _thread_globals+1580. Both resolve to 3263828. Target and candidate otherwise have the same 64-byte section, normalized bytes, three type-6 relocations at offsets 5/27/40, and resolved destinations 3262548/3263828/3262512. No false cross-module mutex declaration, raw overlay, manual address, or compiler control is retained.",
|
|
"measurements": {
|
|
"target": { "size": 64, "relocation_count": 3, "normalized_sha256": "3b67f561243fc178ef970c0e26668272cdfd5b49b5f94800b85cbeeb4e051c6f" },
|
|
"base": { "size": 64, "relocation_count": 3, "normalized_sha256": "3b67f561243fc178ef970c0e26668272cdfd5b49b5f94800b85cbeeb4e051c6f" },
|
|
"objdiff_percent": 100.0
|
|
}
|
|
},
|
|
{
|
|
"unit": "libs/libcmt/stream",
|
|
"function": "__getstream",
|
|
"class": "unclassified",
|
|
"evidence": "The retained source is the coherent VC7 CRT stream-pool scan under the CRT's /O1 /Gy recipe. Target and base have the same 290-byte text and the same resolved SEH funclet destination, but the base carries 21 relocations while January carries 22: the local call is encoded directly instead of through a compiler-generated relocation against __getstream plus an addend. This is not semantically credited because a relocation entry is absent, even though masking relocation fields makes the bytes identical. Sixteen compiler-flag variants and three locally distinct VC7 suites reproduce the same compiler-internal SEH-label choice. No assembly, volatile access, fake dependency, dead branch, or compiler-control source shaping is retained. Reopen only for authentic CRT source/compiler provenance or a natural source lever that emits the missing relocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 290,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "0d80b800690d9a29528f639890684a4686fb466026ab9f3a09f7b15eaf8e1fb6"
|
|
},
|
|
"base": {
|
|
"size": 290,
|
|
"relocation_count": 21,
|
|
"normalized_sha256": "54fc2e036b80bd063638e338df7ee32d35e3822bfd05126fc3c966f367aefec9"
|
|
},
|
|
"objdiff_percent": 100.0
|
|
}
|
|
},
|
|
{
|
|
"unit": "libs/libcmt/woutput",
|
|
"function": "__woutput",
|
|
"class": "register-allocation",
|
|
"evidence": "The retained output.c is coherent VC7 CRT wide-printf source compiled through the authentic thin woutput.c wrapper. Five private helpers are strict exact under their conventional CRT names. The remaining __woutput residual has the target's 30 relocation entries and is 1928 versus 1932 bytes. Alignment isolates a stack-slot-colouring/register-residency fixed point: January shares radix with textlen while this compiler shares radix with text, with related zero/register materialization differences. Declaration, live-range, type, statement-order, and supported-flag experiments do not move the result naturally; three distinct local VC7 suites emit the same candidate. No volatile access, assembly, fake dependency, nonsensical branch, or artificial compiler steering is retained. Reopen only for authentic CRT source/local-lifetime evidence or a naturally semantic same-compiler donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1932,
|
|
"relocation_count": 30,
|
|
"normalized_sha256": "c502f6356f6b521fad46d3e5ce24dbf72ffb973bd74e5037c4e196d9554bf618"
|
|
},
|
|
"base": {
|
|
"size": 1928,
|
|
"relocation_count": 30,
|
|
"normalized_sha256": "cd33ec1e195055aa1d208d36af2b16a1eb0906833ea06c483574bd52d6ebf716"
|
|
},
|
|
"objdiff_percent": 95.571915
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/scenario/wind",
|
|
"function": "_wind_variance_initialize",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "The retained ordinary-C reconstruction implements the HCEA-corroborated cyclic variance table directly: seed eight keyframes for each of three axes, then fill seven intermediate samples with uniform_cubic_spline_vector3d using the four wrapped neighbouring keyframes. January and the candidate share the seed-loop instruction/relocation topology apart from stack-home offsets, the same nine relocation destinations as a multiset, and the external wind_variance_initialize storage class. January emits a 0x38 frame and recomputes three wrapped-keyframe addresses inside the axis loop; VC7 hoists those typed array addresses and uses a 0x40 frame, producing 400 padded bytes versus January's 384. Unsigned word neighbour indices are retained because January's movzx sequence directly proves unsigned 16-bit values; the smaller signed-short candidate emits movsx and is structurally wrong. A pointer-induction refinement grew to 432 bytes and 10 relocations, while the earlier phase-union lifetime carrier was rejected as fake matching. The per-TU spline rename schedule follows the existing glow.c include precedent and leaves the canonical spline call unresolved, preventing the header's two target-absent inline COMDAT owners. The complete text-owner census is 10 versus 10 with no missing, surplus, or storage-class mismatch; all seven inherited exact wind functions and units.obj 189/189 remain strict exact. No union punning, volatile access, assembly, fake dependency, address-derived name, or nonsensical branch is retained. Reopen only for authoritative January source, a same-compiler donor with the target lifetime topology, or a natural loop/local spelling that prevents address hoisting without changing ownership.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 384,
|
|
"relocation_count": 9,
|
|
"normalized_sha256": "1d5cd879825797c62a8f525b3f47ac10ee86b61f82da861f5ae6e6db4afa41ff"
|
|
},
|
|
"base": {
|
|
"size": 400,
|
|
"relocation_count": 9,
|
|
"normalized_sha256": "75c381860540e026071ff2e96633e80efbc09849bb0dc828d3cc04dc2c522146"
|
|
},
|
|
"objdiff_percent": 60.99206
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/math/matrix_math",
|
|
"function": "_matrix4x3_multiply",
|
|
"class": "asm-implemented",
|
|
"evidence": "Authenticated original-assembly recovery admitted under the 2026-08-31 house rule that helper and math functions may sparingly use inline assembly. Intel Application Note AP-930 (June 1999, order 245045-001) publishes the matching PIII_Mult00_3x3_3x3 kernel as naked hand-written SSE assembly; January adapts that schedule for the 4x3 position row. A user-supplied 2026-08-31 discussion adds independent cross-platform testimony from Aerocatia: Halo PC selects SSE, 3DNow, or apparent-C variants; the PC SSE and Xbox XBE instruction streams are the same except that Xbox leaves the final scalar scale product to x87, and the same SSE stream survives in a PC executable produced with the roughly twenty-years-newer 2020 Digsite compiler. The recovered source therefore retains the hand-scheduled SSE kernel in one __asm block and leaves result->scale = a->scale * b->scale as ordinary C. Four natural pointer locals reproduce VC7's wrapper and parameter-slot homes. The campaign compiler emits the exact 336-byte, zero-relocation target with no object splicing, alternate assembler, byte directives, or post-processing. This park is provenance accounting for admitted original assembly, not a fuzzy-codegen exception; it remains valid only while the compiled function stays exact.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 336,
|
|
"relocation_count": 0,
|
|
"normalized_sha256": "0436d82fe1070f30523ce8798bcce3b7625099794f5d0ab3fbf9a9c33802314e"
|
|
},
|
|
"base": {
|
|
"size": 336,
|
|
"relocation_count": 0,
|
|
"normalized_sha256": "0436d82fe1070f30523ce8798bcce3b7625099794f5d0ab3fbf9a9c33802314e"
|
|
},
|
|
"objdiff_percent": 100.0
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actor_combat",
|
|
"function": "_actor_combat_find_nearby_target",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained source uses the HCEA-authenticated private signature, typed real_point3d/real_vector3d arithmetic, the January random-seed API, and the existing collision-vector API. Target and candidate have the same 352-byte envelope, twelve relocations, and identical relocation identities. The only meaningful residual is the final inline point expansion: January keeps height live on the x87 stack through direction.k and then pops it, while VC7 recognizes the last use and folds the memory operand. Natural typed-local, pointer-alias, and expression-shape variants did not reproduce January without fake lifetime steering. No synthetic helper, volatile access, inactive-union overlay, assembly, or point_from_line3d COMDAT is retained. Reopen only for authoritative source or a natural same-compiler lifetime/inlining donor.",
|
|
"measurements": {
|
|
"target": { "size": 352, "relocation_count": 12, "normalized_sha256": "d81707099ff33b584760980c0676308538c7bd08d3f6988d4aaec680fb9b26e6" },
|
|
"base": { "size": 352, "relocation_count": 12, "normalized_sha256": "ea9a37ad3b0e51df21b0011f3b93aa55152b23bbb72ddde606d46a33173afb96" },
|
|
"objdiff_percent": 97.28814
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actor_combat",
|
|
"function": "_actor_combat_check_collateral_damage",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained source expresses each typed real_vector3d squared distance directly and coherently. Target and candidate are both 880 bytes with 21 identical relocation identities and 293 instructions; only six x87 stack-index opcode choices in the first inlined distance expression differ. Reordering terms can perturb the result but is not supported by source evidence and was rejected as fake matching. No duplicate math helper, volatile access, representation punning, assembly, or candidate-only helper COMDAT is retained. Reopen only for authoritative source or natural same-compiler expression/lifetime evidence.",
|
|
"measurements": {
|
|
"target": { "size": 880, "relocation_count": 21, "normalized_sha256": "eb4aee9d9f4765a5505126a61d5ef2bdabe4c40f9de3cba7d3cd7cc9771ee0d0" },
|
|
"base": { "size": 880, "relocation_count": 21, "normalized_sha256": "811617f77eb8c57aa71254cae2acdee20a270e90855aeb6976bbd25faca08ecc" },
|
|
"objdiff_percent": 99.89474
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actor_combat",
|
|
"function": "_actor_combat_plan_grenade_trajectory",
|
|
"class": "register-allocation",
|
|
"evidence": "The retained function now uses the HCEA-authenticated build-trajectory argument order and typed grenade constants. Target and candidate have the same 288-byte envelope, five relocations, and identical relocation identities. January uses a 0x30-byte frame by reusing a dead incoming parameter home slot, while this VC7 source shape uses a 0x34-byte frame and a separate local slot. Natural declaration/lifetime and signature corrections do not reproduce the stack-slot colouring. No volatile access, raw overlay, fake dependency, assembly, or manual stack control is retained. Reopen only for authoritative source or a natural same-compiler stack-lifetime donor.",
|
|
"measurements": {
|
|
"target": { "size": 288, "relocation_count": 5, "normalized_sha256": "7edcb9d4e87b0a5fe7d095bf5ba048614e46a9708e7d858889cbeb627aa0a0de" },
|
|
"base": { "size": 288, "relocation_count": 5, "normalized_sha256": "ff9a7477deb2aa304240db075c9182d629f8b82c13cf4e4c48a51af1efc5170a" },
|
|
"objdiff_percent": 94.7
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actor_combat",
|
|
"function": "_actor_combat_reaim_grenade",
|
|
"class": "register-allocation",
|
|
"evidence": "The retained typed C follows the HCEA-corroborated grenade-projectile lookup, projectile_aim outputs, normalized planar-facing test, ballistic line-of-fire test, and successful aim latch. Target and candidate both contain 448 padded bytes, 16 relocations, and 162 instructions. Moving the velocity calculation ahead of gravity selection, as both HCEA and January require, raises the natural reconstruction to 98.509674%. The remaining code differences are a four-byte frame/stack-slot coloring shift plus one independent post-tag_get move/stack-cleanup schedule; the calls, branches, arithmetic, and stores otherwise retain January's topology. Natural declaration-order and early-return forms either preserve the slot coloring or worsen the branch polarity. No forced register directive, volatile lifetime, barrier, fake dependency, assembly, or nonsensical control flow is retained. Reopen only for authoritative January local-variable/source evidence or a natural same-compiler stack-allocation donor.",
|
|
"measurements": {
|
|
"target": { "size": 448, "relocation_count": 16, "normalized_sha256": "8d2e09aa4f73bc982c4cf17d6e4f9a963ffd7db0b486ff7f037d19966ef52772" },
|
|
"base": { "size": 448, "relocation_count": 16, "normalized_sha256": "b2a1aa5cad19d1cfaa1f0cf99729c8edd10f30854f973029e38af9b104e2c54c" },
|
|
"objdiff_percent": 98.509674
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actor_combat",
|
|
"function": "_actor_aim_projectile",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained ordinary C reconstructs the firing-state gate, acknowledged-prop target recovery, authenticated actor-debug snapshots, cached-point/vector selection, out-of-line normalize3d ownership, weapon-vector cone clamp, and burst-error output. The parameter name vector is proved by both January assertion literals and the actors.h owner declaration. Target and candidate both contain 720 padded bytes, 27 relocations, and 237 instructions. The meaningful code is identical except for the ordering of independent loads and stores while copying weapon_vector into the debug record at +0x274; all following offsets reconverge. Natural debug-field statement orders were tested, and the alternatives either move the boolean store earlier or enlarge the function. No alias carrier, volatile access, barrier, fake dependency, forced inline/noinline, assembly, or invented control flow is retained. Reopen only for authoritative January source/local ordering or a natural same-compiler aggregate-copy scheduling donor.",
|
|
"measurements": {
|
|
"target": { "size": 720, "relocation_count": 27, "normalized_sha256": "22aacf2cc27693354c5025ab0df43e759489116f19e4e3600ad74e4f1e8973ac" },
|
|
"base": { "size": 720, "relocation_count": 27, "normalized_sha256": "44113369d29436c6449ac416cc0a68340f752929938a3f099acd6fd10ab6101c" },
|
|
"objdiff_percent": 98.017395
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actor_combat",
|
|
"function": "_actor_aim_grenade",
|
|
"class": "unclassified",
|
|
"evidence": "The retained reconstruction follows the HCEA-corroborated prop-state bands, semantic target retest, grenade re-aim, vehicle/non-vehicle direction selection, 30-degree facing clamp, and final speed scaling. January's vehicle path demonstrably reuses the working three-real storage that previously held the prop body point; the C expresses that representation-safe point/vector reuse explicitly rather than retaining the older coincidental uninitialized-local candidate. January has a 544-byte/22-relocation function while the current natural C has 576 bytes and the same relocation count. The residual is a broader VC7 frame-coloring and x87-expression schedule, so no narrower blocker is claimed. No volatile access, barrier, fake dependency, forced register or inline control, assembly, or semantically invalid carrier is retained. Parked at the requested fuzzy threshold pending authoritative January source/local records or a natural same-compiler control-flow donor.",
|
|
"measurements": {
|
|
"target": { "size": 544, "relocation_count": 22, "normalized_sha256": "e0f88f129bff43bffd1418d177c79d4849c02f0e71e1acf1cf188c16030193fb" },
|
|
"base": { "size": 576, "relocation_count": 22, "normalized_sha256": "e38739d6afd1c17b9b91505748fdddcf9ec66a7a3b41e586e4b2b88eb1bb6398" },
|
|
"objdiff_percent": 79.125
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/memory/lruv_cache",
|
|
"function": "_lruv_debug_to_file",
|
|
"class": "register-allocation",
|
|
"evidence": "The retained body is coherent typed C and follows the HaloCEA-authenticated cache->name, unsigned age, and lruv_cache_bytes_to_pages topology while preserving January's measured control-flow envelope. Target and candidate are both 464 bytes with 20 relocations. Their symbolic relocation-target multisets match 20/20; the three raw-owner differences are only csplit's external-versus-local representation of the shared empty, space, and newline string literals. The remaining divergence begins in the callee-saved register cycle and continues as ordinary VC7 stack colouring and instruction scheduling. Fifty-five documented natural-C experiments, the Demon-oracle pair, the unsigned-age one-shot, and a twelve-blob branch sweep found no strict source-level closure. No barrier, volatile access, register hint, fake dependency, raw overlay, assembly, manual byte control, or nonsensical type pun is retained. Reopen only for authenticated January source/local records or a natural same-compiler lifetime/topology donor that changes the initial register cycle.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 464,
|
|
"relocation_count": 20,
|
|
"normalized_sha256": "fb7c7a22cacb060e9e3fa2e5a57942daa52e259dccc6b7796bf744bf28d291bb"
|
|
},
|
|
"base": {
|
|
"size": 464,
|
|
"relocation_count": 20,
|
|
"normalized_sha256": "8b2776c4666f22765aba53a34d4bff1f09d4223456d38fb1ee53b3ae69b355aa"
|
|
},
|
|
"objdiff_percent": 91.38323
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/memory/lruv_cache",
|
|
"function": "_lruv_block_new",
|
|
"class": "register-allocation",
|
|
"evidence": "The retained body is coherent typed C recovered in local donor commit 1ed2fd9efa4a322edd654d5fe9caf47ed2fe8e59 and independently corroborated at the control-flow and semantic level by Aerocatia/demon commit edb96c7614b80b4a80a3b0cee5c5fb7c7804a3c7. The public donor is used only as a semantic oracle: canonical helper names, types, assertions, and ring macros remain authoritative. Unlike the frozen historical candidate, this natural body needs no _ReadWriteBarrier, volatile access, fake dependency, raw address, or foreign local prototype; it initializes one new_block_index, scans holes with a typed best_hole, uses the named ring macro, and returns through one common path. Target and base now share the 1312-byte and 48-relocation envelope. The remaining divergence begins in the first callee-saved register cycle and is classified as register allocation. Reopen only for authenticated January source or a natural same-compiler lifetime fact that changes that cycle.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1312,
|
|
"relocation_count": 48,
|
|
"normalized_sha256": "d008a8c97b45d969b3d824f6e3daa6caa018c04e9092b80c4ec64d84e3ab954b"
|
|
},
|
|
"base": {
|
|
"size": 1312,
|
|
"relocation_count": 48,
|
|
"normalized_sha256": "9420f4204689f729b2a0ad60ec74481598e2c207d13e312eccdf559f614e3b5b"
|
|
},
|
|
"objdiff_percent": 94.18722
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/action_uncover",
|
|
"function": "_action_uncover_perform",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained body is coherent typed C recovered from January disassembly and the established action-uncover donor, with HCEA commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c corroborating the short selector/change ABI and high-level state transitions. January and candidate have the same 544-byte envelope, 164 instructions, and all 19 relocation addresses, types, destinations, and addends. Only 43 normalized byte positions differ in the contiguous +0xA2..+0xD3 pursuit-point copy: January loads all three point dwords before interleaving the independent flag/surface/cluster stores, while VC7 lowers the natural aggregate assignment as alternating loads and stores. The prior aggregate, scalar, alias, helper, field-order, scope, barrier, and 45 documented defined-C topology families are exhausted; forcing the target schedule would require prohibited gameplay assembly or artificial source. Reopen only for authenticated January source/local records, a strict same-compiler C donor, or a new natural lifetime fact that preserves the frame, relocations, compact source LEA, and downstream exact suffix.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 544,
|
|
"relocation_count": 19,
|
|
"normalized_sha256": "ddd3ed044dc0de47ecb6ba83ac683372ff87b3cb7d8fee318d20da5467c39ed8"
|
|
},
|
|
"base": {
|
|
"size": 544,
|
|
"relocation_count": 19,
|
|
"normalized_sha256": "f6c5eb3588f3efccd66611ba0c133b20dc3fb449fad4894f3022b8e9c6f04bd0"
|
|
},
|
|
"objdiff_percent": 98.77778
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_cinematics",
|
|
"function": "_rasterizer_screen_effects_initialize_for_new_map",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained ordinary C is the authenticated HCEA/January map-reset logic: clear the 0x78-byte cinematic state and restore all four script values to 1.0f. Target and candidate share the 48-byte padded envelope, three relocation identities, and the same stores. The only residual is placement of the csmemset caller cleanup: January restores ESP after the first three constant stores, while VC7 restores it before all four. Separate assignments, chained assignments, and refreshed typed-pointer variants did not change that cleanup packet naturally. No volatile access, barrier, fake dependency, dead branch, assembly, or manual stack logic is retained. Reopen only for authoritative January source or a natural same-compiler declaration/statement-order donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 48,
|
|
"relocation_count": 3,
|
|
"normalized_sha256": "e53fee00ab5bd5eb887f92dd8dbe300dae55ac8ca59c1a5c9c1ab26e62441804"
|
|
},
|
|
"base": {
|
|
"size": 48,
|
|
"relocation_count": 3,
|
|
"normalized_sha256": "aefa986ca6e38326688e349fd4c7592575ef8ccb312f80881b6a17da2dae42e8"
|
|
},
|
|
"objdiff_percent": 59.933334
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_cinematics",
|
|
"function": "_rasterizer_screen_effect_set_convolution",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained typed C implements the HCEA-corroborated convolution setter: disable video, store the signed-short pass/type controls and radius endpoints, then establish start/end times from game ticks using the canonical real type and TICKS_PER_SECOND. Target and candidate have the same four relocation identities. Their meaningful instruction streams are identical through the time calculation; January duplicates ST(0), pops one copy into convolution_time[0], then adds the duration, while VC7 uses FST for the first store and keeps the original value live, producing a 96-byte padded candidate versus January's 112-byte envelope. Direct helper calls, nested/chained assignments, and in-place time mutation all reproduce the retained compiler choice. No volatile access, fake lifetime carrier, barrier, assembly, or nonsensical logic is retained. Reopen only for authoritative January source or a natural same-compiler x87-lifetime donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 112,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "7beef58f5328b7768b506801a5528055389723414ad6c8ea1e4eead421e8aa48"
|
|
},
|
|
"base": {
|
|
"size": 96,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "643836a5bcf9eb11b33169e7e072dfdc1b76414c26549dc49c3b1ac33322fa9a"
|
|
},
|
|
"objdiff_percent": 95.15151
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_cinematics",
|
|
"function": "_rasterizer_screen_effect_set_filter",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained typed C is the HCEA-corroborated filter setter: disable video, store both light-enhancement and desaturation interpolation bounds, compute the game-time interval, retain the additive flag, and clear both convolution-mask flags. Target and candidate share the 112-byte padded envelope and all four relocation identities. The residual is independent store and x87 scheduling: VC7 interleaves two endpoint stores with the video-clear packet, hoists the three byte flags around the time multiply, and uses FST for the first time endpoint; January keeps those packets in a different order. Bounded statement/declaration-order variants did not move all three choices together without artificial dependencies. No volatile access, barrier, assembly, pointer trick, or fake control flow is retained. Reopen only for authoritative January source or natural same-compiler scheduling evidence.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 112,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "de4709a02eba43f11818fd1edf0124d200de56a81157be6670dfa8fff0834794"
|
|
},
|
|
"base": {
|
|
"size": 112,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "41794657785400453f29a5dc48efb8f179b2cbf92a31ee9de493f4cc27dcf1a3"
|
|
},
|
|
"objdiff_percent": 81.53846
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_cinematics",
|
|
"function": "_rasterizer_screen_effect_set_video",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained source implements the complete January/HCEA video-mode path with typed game-global bitmap references, the attested line-225 assertion, the named bitmap_group_get and TAG_BLOCK_GET_ELEMENT APIs, a full parameter/interpolation reset, and the original silent error. Target and candidate share the 288-byte padded envelope, twenty relocation identities, and 84 aligned instructions. Two independent caller-cleanup ties remain: January delays csmemset's ADD ESP,0xC until after the ten interpolation-zero stores and delays the first bitmap lookup's cleanup until after storing video_scanline_map; VC7 performs each cleanup immediately before those independent stores. Natural typed pointer locals recover the exact envelope from earlier 272/16 and 368/33 candidates but do not move the two cleanup instructions. No volatile access, barrier, assembly, raw tag arithmetic, fake dependency, or dead control flow is retained. Reopen only for authoritative January source or a natural same-compiler caller-cleanup donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 288,
|
|
"relocation_count": 20,
|
|
"normalized_sha256": "eb1b757f0f5e5dbfb23a66ea08ec4cd3b8eeb4ce6385ea9c8a0f3e4e5916c46a"
|
|
},
|
|
"base": {
|
|
"size": 288,
|
|
"relocation_count": 20,
|
|
"normalized_sha256": "c3a12c86831011cf9431a23afc3b9a196dbab9395404f46342d03b99f2281c03"
|
|
},
|
|
"objdiff_percent": 95.2381
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/cutscene/cinematics",
|
|
"function": "_cinematic_render",
|
|
"class": "register-allocation",
|
|
"evidence": "The retained reconstruction is coherent Halo cinematic rendering source corroborated by the later HCEA control flow and the January instruction/relocation topology. It advances letterbox interpolation from game ticks, draws two 1/8-height black bars, validates and fades four queued chapter titles, sets the authored text bounds/colors/shadow, renders the localized string, and retires expired titles. The authenticated cseries fast_ftol helper supplies the original dword x87 conversions; there is no inline assembly in cinematic_render itself. Target and candidate share the 1280-byte envelope and all 57 relocation identities and addresses. The remaining 46 normalized byte differences are confined to VC7 stack-slot coloring for the elapsed/bar/helper temporaries and the shadow-color pack schedule. The preserved declaration, scope, expression, HCEA-layout, helper-call, subtraction, and shadow-pack matrices found no closer authentic source form; artificial barriers, volatile lifetimes, representation punning, forced register dependencies, direct gameplay assembly, and exact-only control flow were rejected. The translation unit also emits a candidate-only 32-byte zero-relocation _fast_ftol COMDAT from the authenticated external-inline helper, while January selects that owner from actor_combat.obj; this separate ownership surplus prevents whole-object completion even though delayed titles are strict exact. Reopen the function only for authoritative January source/local-variable records or a natural same-compiler donor that explains the remaining slot/pack schedule, and reopen whole-object admission only with a proven COMDAT ownership schedule that does not add a cinematics owner.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1280,
|
|
"relocation_count": 57,
|
|
"normalized_sha256": "a89dcee38e6a239615cde9f2d1f3b2fc577ced717e620de08a6397f74a0e6288"
|
|
},
|
|
"base": {
|
|
"size": 1280,
|
|
"relocation_count": 57,
|
|
"normalized_sha256": "1eb7cfd27d9ce0693adee50153f2c344766443274dcf486917756d03eb2bf7ac"
|
|
},
|
|
"objdiff_percent": 99.32809
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actor_type_flood",
|
|
"function": "_actor_type_flood_desire_shamble",
|
|
"class": "unclassified",
|
|
"evidence": "The retained body is coherent typed C reconstructed from the January function and corroborated semantically by HCEA commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c. It uses the canonical actor_variant_definition fields, named charge, movement-switching, combat-status, prop-state, unit-state, and damage-flag constants, the owner-header prototypes, and the existing typed actor/unit/prop accessors. The one deliberate topology difference from HCEA follows the January binary: movement-switching type 2 with no target or a target outside combat_range_upper_bound continues into the update body. Target and candidate have the same 44 relocation destination identities in the same order, all target-owned non-code remains exact, and the exact flood_decide_action sibling is preserved. VC7 emits 1312 padded bytes versus January's 1296 because it tail-sinks the false epilogue; the resulting five near branches and live-range changes account for the downstream drift. The retained source contains no volatile/register steering, optimizer barrier, raw offset access, speculative structure, inline assembly, fake dependency, or dead control flow. Reopen only for authenticated January source/local records or a natural same-compiler source fact that places the false epilogue inside the early decision region.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1296,
|
|
"relocation_count": 44,
|
|
"normalized_sha256": "067d3d1a80f86aaa9906529ad2cfe9f187bb77f1168c60c0208ddc98a69f14bc"
|
|
},
|
|
"base": {
|
|
"size": 1312,
|
|
"relocation_count": 44,
|
|
"normalized_sha256": "47bcacd072921ce5ae46bb953f730061896e6db84e7a8e2a2c5fdfd82136f548"
|
|
},
|
|
"objdiff_percent": 84.69773
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_transparent_geometry",
|
|
"function": "_rasterizer_transparent_geometry_initialize",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "The retained ordinary C is the complete transparent-geometry lifecycle initializer: it allocates the primary 384-group pool, the 384-entry sorted-index array, and the secondary 32-group pool with the January source path and line numbers, clears both group counts, reports the attested silent allocation error, and initializes the Xbox auxiliary buffer. This topology is independently corroborated by the later HCEA implementation, the Stian lift, and the historical b6adf6705 donor. Target and candidate share the 160-byte padded envelope, 51-instruction count, and all 16 logical relocation destinations. The sole fixed point is block placement: January keeps the error block before the auxiliary-buffer call, while VC7 lays out the success call before the error block and uses SETNE for the successful return. Four documented natural result-lifetime/error-path families, public donors, and a 1,571-worktree census produced the same candidate hash or regressed it. No assembly, volatile access, barrier, fake dependency, dead branch, raw address, or optimizer-only carrier is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor that explains this block order.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 160,
|
|
"relocation_count": 16,
|
|
"normalized_sha256": "63251d0d8cc730b0de774a4c06b489f06bd0af5849fa8281705d46e40473e678"
|
|
},
|
|
"base": {
|
|
"size": 160,
|
|
"relocation_count": 16,
|
|
"normalized_sha256": "15f6dc8cbb204d551c2c25b60baf4e21ca760125fc43678f40cb24a48fcbdbe4"
|
|
},
|
|
"objdiff_percent": 76.0
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_transparent_geometry",
|
|
"function": "_rasterizer_sort_external",
|
|
"class": "register-allocation",
|
|
"evidence": "The retained ordinary C is the cross-build HCEA rasterizer_sort_external topology: fill the short sorted-index array with identity order while invoking rasterizer_sort_internal, qsort it with group_sorted_indices_cmpfn, then stamp each group's resulting sorted_index. The semantic names replace the former address placeholders in both source and the symbol atlas. Target and candidate share the 176-byte padded envelope and 14 logical relocation destinations. The residual is VC7 lifetime allocation and scheduling: January forms the first-pass group through ECX from an EDX base and delays loading the qsort base, while the natural candidate uses EAX/ECX and loads that base earlier. Direct-expression, block-local-pointer, pre-test-index, Pastudan loop-local pointer, HCEA, declaration-order, and register-lifetime families are already exhausted; the best natural trial aligned the tail but not the first-pass allocation. No assembly, volatile/register forcing, barrier, fake dependency, raw offset, or synthetic control flow is retained. Reopen only for authoritative January local/statement provenance or a strict same-compiler C donor that naturally emits the target allocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 176,
|
|
"relocation_count": 14,
|
|
"normalized_sha256": "4f78b8476535a901325781b67d7ed04665e59478fb419ddd0c607c95220655d5"
|
|
},
|
|
"base": {
|
|
"size": 176,
|
|
"relocation_count": 14,
|
|
"normalized_sha256": "30cd227ef42506ffe5a4050491eff57faef6a200cbffc05301077bca69f40a50"
|
|
},
|
|
"objdiff_percent": 80.08772
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_utilities",
|
|
"function": "_bitmap_2d_shrink",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after selectively reconciling the coherent typed donor body and corroborating its 2D shrink topology and semantic private name against HCEA commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c. Target and candidate have the same 656-byte padded envelope and all 18 relocation identities. The candidate is 244 instructions versus January's 245; the remaining gap begins in the nested sample loop, where VC7 chooses the opposite accumulator operand, address-call setup, and channel-sum register schedule before reconverging. The retained source uses bitmap_data fields, cseries types and macros, named enum constants, and ordinary loops; no volatile access, barrier, artificial alias, undefined behavior, manual offset logic, assembly, or nonsensical exact-only control flow is retained. Reopen only for authoritative January source/local records or a natural same-compiler declaration/lifetime donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 656,
|
|
"relocation_count": 18,
|
|
"normalized_sha256": "e032c32d2cf00f0b14b44627abd321b829450ea9d964b379b1ad51969755c87c"
|
|
},
|
|
"base": {
|
|
"size": 656,
|
|
"relocation_count": 18,
|
|
"normalized_sha256": "bf78c45c893b86a2ac84467a577030719437cc0f2c6018219368533a0fbbec59"
|
|
},
|
|
"objdiff_percent": 95.15126
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_utilities",
|
|
"function": "_bitmap_3d_shrink",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after selectively reconciling the coherent typed donor body and corroborating its 3D shrink topology and semantic private name against HCEA commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c. Target and candidate share the 800-byte padded envelope and all 18 relocation identities. January emits 285 instructions while the retained source emits 290; VC7 assigns the scale, output dimensions, destination pointer, and nested voxel-loop indices to different callee-saved registers and stack slots, cascading through the averaging packet while preserving behavior and call topology. The 77.116196% residual is therefore recorded honestly rather than forced with source that exists only to steer the allocator. No volatile access, barrier, artificial alias, register hint, raw offset, assembly, undefined behavior, or fake control flow is retained. Reopen only for authoritative January source/local records or a natural same-compiler declaration/lifetime donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 800,
|
|
"relocation_count": 18,
|
|
"normalized_sha256": "5435cdf751f34b0fcdd56e703d1f8feb3d21dd3c4f95ac2a8bc65b06b9e9e8b4"
|
|
},
|
|
"base": {
|
|
"size": 800,
|
|
"relocation_count": 18,
|
|
"normalized_sha256": "c6a725afd52b660d466d6b1131ccca6d8335786d26aa8fae2fa0c56344f55fa1"
|
|
},
|
|
"objdiff_percent": 77.116196
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_utilities",
|
|
"function": "_bitmap_2d_alpha_bleed",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after selectively reconciling the coherent typed donor body and authenticating bitmap_2d_alpha_bleed from HCEA commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c. Target and candidate have the same 560-byte padded envelope, 196 aligned instructions, and all 24 relocation identities. The only normalized difference is the order of two independent stack reloads at +0x191/+0x194 after the neighborhood loop: January reloads ECX then EAX, while VC7 reloads EAX then ECX. The retained source uses the natural row/neighborhood loops and typed bitmap access. No volatile access, barrier, fake dependency, assembly, undefined behavior, manual byte forcing, or nonsensical source is retained. Reopen only for authoritative January source/local records or a natural same-compiler scheduling donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 560,
|
|
"relocation_count": 24,
|
|
"normalized_sha256": "cd45e448842f8046230b47dbafdb56d1c273af2d59757dde48c47f6c19208e94"
|
|
},
|
|
"base": {
|
|
"size": 560,
|
|
"relocation_count": 24,
|
|
"normalized_sha256": "6c6241f24b04a6ac891bc1c8f5eb5957c70ec09aa910ecc94ba41535b8bb264f"
|
|
},
|
|
"objdiff_percent": 99.934784
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/render/render_particles",
|
|
"function": "_render_particles",
|
|
"class": "register-allocation",
|
|
"evidence": "The retained ordinary-C reconstruction implements the complete January particle-render path with authenticated shared types and names: visibility and perspective filtering, the PDB-recorded single current_sprite_group pointer reused by the grouping and draw passes, sorted sprite batches, attached-object transforms, LOD/fade handling, named U/V mirror flags, and the original unguarded zero-by-zero secondary-map-radius division. Target and candidate share the 1168-byte padded envelope and all 39 relocation identities, addresses, types, destinations, and addends; objdiff reports 99.82228% for the function. The remaining 59 normalized positional differences are stack-slot/local-coloring choices. A two-shadow-pointer spelling reduced that count to 45, but contradicts the HCEA/PDB local record and is rejected as a less credible exactness-oriented source shape. The apparently idempotent detached-object sentinel write is retained because January directly stores -1 to particle_datum.object_index at function offset +0x2E3; removing it changes the function envelope and relocation positions. No volatile access, compiler barrier, forced inline/noinline, assembly, undefined behavior, fake dependency, inert branch, or nonsensical logic is retained. Both helper functions and the owned profile section remain strict exact. Reopen only for authoritative January source/local-variable records or a natural same-compiler lifetime donor that explains the remaining stack allocation while preserving the one-pointer topology.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1168,
|
|
"relocation_count": 39,
|
|
"normalized_sha256": "97e541b16e87e1e09094430247df715ca41e4ecc679738f638d09e1bbfffcc4e"
|
|
},
|
|
"base": {
|
|
"size": 1168,
|
|
"relocation_count": 39,
|
|
"normalized_sha256": "8a7510241d251d090a30b22282d8569ad88fc8a4c0e94713687f2e0475db94f2"
|
|
},
|
|
"objdiff_percent": 99.82228
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/widgets/light_volumes",
|
|
"function": "_light_volume_render",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked under the current house rule after the complete source-history and worktree census, the authenticated HCEA renderer/interpolator/type records at commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c, the January disassembly, and the recorded bounded legal-C experiment families were rechecked from canonical ec4ae894a. The retained typed C implements the complete marker, view-angle, distance-fade, object-function, sprite-count, exponent, color-interpolation, and rasterizer path without fake steering. January emits a 912-byte function with a 0xA4 frame; VC7 emits 928 bytes with a 0xA8 frame. Both have 47 relocation types and destinations in the same semantic order. The remaining structural boundary is January's immediate 1.0f distance-fade store interleaved with the marker delta and its compact x87-valued inlined pow1 joins, while the available compiler materializes an earlier distance-fade local and memory phis for the later exponent results. Statement-position, scope, helper-edge, conditional-expression, direct-consumption, loop-count/divisor, HCEA-topology, compiler-version, and donor-branch families either reproduce this fixed point or lose the proven frame/relocation topology. No volatile access, register hint, barrier, assembly, raw offset, representation cast, undefined behavior, fake dependency, or nonsensical branch is retained. Reopen only for authoritative January source/local records, a natural same-compiler donor that distinguishes the x87 lifetime, or a genuinely distinct authentic VC7/QFE compiler.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 912,
|
|
"relocation_count": 47,
|
|
"normalized_sha256": "2e43dbc111ad125565ead94aff803117a92a3bb3215d18254e28281e204d0031"
|
|
},
|
|
"base": {
|
|
"size": 928,
|
|
"relocation_count": 47,
|
|
"normalized_sha256": "a4e273c7939882fcf1dadf774289b21742f1f88e718136216c33eaf04d55a94f"
|
|
},
|
|
"objdiff_percent": 75.711266
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/scenario/wind",
|
|
"function": "_wind_variance_get",
|
|
"class": "unclassified",
|
|
"evidence": "The retained ordinary-C helper implements the HCEA-corroborated position/time wind-noise sampler with project real/vector types, the exact two-role three-axis countdown topology, and defined unsigned-character access to the low byte of the bias-added real's object representation. January and the candidate own the same eight relocation destinations and agree through the loop except for January's full-width AND 0x7FFFFFFF sign clear versus VC7's x87 FABS instruction; target/candidate are 224/208 padded bytes. A split fabs assignment emits the same x87 instruction. The only machine-wide exact artifact reads an inactive union member and remains prohibited. Marathon's authenticated cseries.h spells ABS as a conditional expression, not this integer sign clear, and has no direct wind donor. A one-instruction inline-assembly probe reproduced the AND but forced VC7 to spill the live magnitude, changed the frame from 0x0C to 0x10, and remained nonexact, so it was rejected rather than expanding assembly solely to steer x87 lifetime. All seven exact wind siblings remain exact and the already parked natural initializer is measurement-stable. No union punning, volatile access, assembly, fake dependency, address-derived name, or nonsensical branch is retained. Reopen only for authoritative January source or a defined same-compiler full-width sign-clear idiom with provenance.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 224,
|
|
"relocation_count": 8,
|
|
"normalized_sha256": "4df611f5e5a98c97ca86e2ea03d29c3057296fb1382b36fc687c31f0e58db1a6"
|
|
},
|
|
"base": {
|
|
"size": 208,
|
|
"relocation_count": 8,
|
|
"normalized_sha256": "951ffdb4c1b81a50bceb55a1b2ac7167c51c20a3bdb8542b61524c88e89c37d6"
|
|
},
|
|
"objdiff_percent": 93.333336
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/structures/structure_lens_flares",
|
|
"function": "_build_structure_lens_flares",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after retaining the coherent Fable witness topology and authenticating the private name compare_temp_markers from the September 2001 cachebeta linker map in the local Halo symbol atlas. Target and candidate have the same 4336-byte padded envelope, 156 relocations, and 1327 decoded instructions; three sibling functions and all owned data are strict exact. The remaining differences are instruction scheduling and local/register lifetime choices in the recovered plane/grid packet, which also move several relocation positions while preserving the call and constant topology. The retained source uses project real/plane types, named shader enum constants, the witnessed scoped ds_x temporary, and the late offset assignment. It expands the three scalar point updates directly to preserve the January inline schedule without emitting a point_from_line3d COMDAT. The candidate-only 32-byte fast_ftol helper COMDAT is authenticated shared helper code but receives no object-completion credit. The closest shared structures header was rejected because the correct void prototype regressed protected units.obj from 189/189 to 188/189 through VC7 definition-position sensitivity; a dedicated natural owner header preserves both units.obj and hs.obj while removing the use-site prototype. No volatile access, compiler barrier, artificial alias, wrong fi4 cast, address-derived name, fake dependency, undefined behavior, assembly, or nonsensical control flow is retained. Reopen only for authoritative January source/local records or a natural same-compiler scheduling donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 4336,
|
|
"relocation_count": 156,
|
|
"normalized_sha256": "40aa8e486e52fe258065ae9cc9bd892679b15fd7845008cc0ebe1651788cf33b"
|
|
},
|
|
"base": {
|
|
"size": 4336,
|
|
"relocation_count": 156,
|
|
"normalized_sha256": "57d6f033f379373528ec40ed132b8af7db73b6f1a087be9ddc3ad2f30d55fc46"
|
|
},
|
|
"objdiff_percent": 99.29274
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/tool/connected_geometry",
|
|
"function": "_connected_geometry_find_or_add_vertex",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked after replacing the Fable compact loop with the independently reconstructed Stian topology while keeping canonical real_point3d and dynamic-array types. Target and candidate have the same 192-byte padded envelope, all eight relocation types, destinations, and addresses, and 80 decoded instructions. The remaining divergence is confined to two equivalent coordinate-difference evaluations and the final three scalar copies: January keeps point.y and point.z on x87 across each getter, while VC7 uses an integer bit-copy into the same four-byte local before reloading it; the final stores use an interchangeable ECX/EDX allocation. The direct Fable conjunction and reversed inline absolute-difference forms both collapsed to 176 bytes, while the donor-shaped named pending coordinate recovered January's frame, size, relocation packet, and instruction count. The retained code is coherent typed C with no volatile access, alias trick, compiler directive, inline assembly, raw offset, or inert dependency. Reopen only for authoritative January local/source records or a natural same-compiler source donor that establishes the remaining x87 lifetime and copy-register choices.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 192,
|
|
"relocation_count": 8,
|
|
"normalized_sha256": "c21c80fafbc4175df12584cdd83cf153b979272feeab86c9354405901df8253a"
|
|
},
|
|
"base": {
|
|
"size": 192,
|
|
"relocation_count": 8,
|
|
"normalized_sha256": "e42aac4dc8c567a7fd1f8072038969e00f4fce226c654ca16451e47d20c9afc0"
|
|
},
|
|
"objdiff_percent": 91.02597
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/tool/connected_geometry",
|
|
"function": "_triangle_coplanar",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after recovering the natural typed C predicate from the independently corroborating Stian reconstruction and HCEA geometry types, then preserving January's authenticated y+z+x dot-product topology. Target and candidate have the same 384-byte padded envelope, 11 relocation destinations and addresses, and 151 decoded instructions. The sole remaining difference is one dependency-free x87 operand choice at target offsets +0x11D/+0x11F: January loads point2.x and multiplies by plane.n.i, while VC7 loads plane.n.i and multiplies by point2.x. Sequential accumulation closes the later dot-product schedule exactly. Measured inert or inferior: reversing the point2.x expression operands, reversing the final product operands, explicit final grouping, k+i+j grouping, sequential point2 accumulation, and a named point-product temporary. The retained source uses real_point3d/real_plane3d, typed dynamic-array records, authenticated private symbol and enum-independent bit tests; it contains no assembly, volatile access, fake dependency, raw address name, undefined offset access, or nonsensical control flow. Reopen only for authoritative January source/local records or a natural same-compiler x87 scheduling donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 384,
|
|
"relocation_count": 11,
|
|
"normalized_sha256": "02acd868e062aee29df8e260c3fbd62221e3f2ced5e5f43573a1a288e6129d54"
|
|
},
|
|
"base": {
|
|
"size": 384,
|
|
"relocation_count": 11,
|
|
"normalized_sha256": "4a01cf6dc779006e22869160f05e1640de65f3f9559f720f03f2ab716e7eff99"
|
|
},
|
|
"objdiff_percent": 99.87755
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_geometry",
|
|
"function": "_uncompress_int32_to_real_vector3d",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Equal 144-byte padded size, 9/9 relocations with identical destinations, and 49/49 instructions. The sole divergence is one dependency-free transposition: January emits `fadd __real@3f800000` before `shl eax, 0x16`, the candidate emits them in the opposite order, which also shifts that one relocation's address by three bytes. The bit fields, scales, masks, destructive shift sequence and the local real_vector3d copied out through *result are all confirmed. Measured inert: folding the second shift into the k expression, long-hand assignment, hoisting the shift ahead of j, and a division form of the k scale.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 144,
|
|
"relocation_count": 9,
|
|
"normalized_sha256": "aa4a69683e5f1148413f6029acfc993341346b93b86809dcb5450896dcc3944d"
|
|
},
|
|
"base": {
|
|
"size": 144,
|
|
"relocation_count": 9,
|
|
"normalized_sha256": "8199ac81b23a4607ed8191dbe2f95cb11da85761ecf353514714f8261562b55f"
|
|
},
|
|
"objdiff_percent": 95.0
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_geometry",
|
|
"function": "_compress_real_vector3d_to_int32",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Equal 544-byte padded size, 38/38 relocations address-for-address identical, and 181/181 instructions. The sole divergence is the debug round-trip's aggregate copy: January issues all three dword loads from the returned pointer before any store, the candidate interleaves load and store per component. Two spellings bracket the target and neither reaches it - one local gives January's correct sub esp,0x10 frame with the interleaved copy, a separate decompressed local gives the grouped copy with a 12-byte-too-large frame. The one-local form is retained because a frame-size mismatch is structural. Measured inert: copying through a named pointer, that pointer scoped to an inner block, declaring v2 first, and combinations.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 544,
|
|
"relocation_count": 38,
|
|
"normalized_sha256": "1bb3b5c9d4712b2fc2ec7e9dc9f3f8e791496a82595ca154ca76719067cd60a7"
|
|
},
|
|
"base": {
|
|
"size": 544,
|
|
"relocation_count": 38,
|
|
"normalized_sha256": "e0b39fc94ba068043e045bae7c75a86a90a7853fe417e0bfe894324d4e6811e5"
|
|
},
|
|
"objdiff_percent": 96.34682
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_geometry",
|
|
"function": "_compress_real_vector3d_to_int32_clamp",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Equal 512-byte padded size, 38/38 relocations address-for-address identical, and 164/164 instructions. Same single divergence and the same exhausted control set as its non-clamp twin above; the two share the round-trip block verbatim.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 512,
|
|
"relocation_count": 38,
|
|
"normalized_sha256": "ba84758e70f380dff5a1f53fc34fd72500d77f38cdef7529edeff8c5ccdffe3c"
|
|
},
|
|
"base": {
|
|
"size": 512,
|
|
"relocation_count": 38,
|
|
"normalized_sha256": "8983acf2b5bc6570cede768472facdfc4bd6d012eb30038ed0d53f04341fc3a5"
|
|
},
|
|
"objdiff_percent": 94.8
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/main/main",
|
|
"function": "_compute_subframe_counts",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after restoring the HCEA-authenticated subframe-count algorithm together with its authentic compute_window_bounds caller and January's line-1308 num_players>0 assertion. The real caller makes VC7 retain the helper naturally and recover January's private convention: num_players arrives in EBX and only the two result pointers are stack arguments. Target and candidate have the same 112-byte padded envelope and all four relocation identities at the same addresses. The residual is confined to one loop-termination spelling: January materializes vertical*horizontal<num_players with setl/test/je, while the direct ordinary-C predicate emits cmp/jge. Bounded boolean-temporary, predicate-polarity, while/do-while, and product-local spellings did not recover that instruction choice without degrading the otherwise exact body. No public prototype, forced linkage, volatile access, compiler barrier, assembly, fake dependency, inert expression, or nonsensical control flow is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining the materialized boolean.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 112,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "d5b5047a8d0a783c6ec4e08a1f96d2df2346801a8a8e8364f8faa50ab6e139de"
|
|
},
|
|
"base": {
|
|
"size": 112,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "edd705dfff90e3b299dca140e8b7558db363d700e2a276ef89b21011be641136"
|
|
},
|
|
"objdiff_percent": 94.347824
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/main/main",
|
|
"function": "_compute_window_bounds",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after restoring the complete HCEA-authenticated window-geometry routine with January's three exact assertions, semantic rectangle2d types, and named rasterizer screen_bounds/frame_bounds fields. Target and candidate have the same 496-byte padded envelope, all 25 relocation identities at the same addresses, and the same 176 decoded instructions. The only two differences are commutative integer products: January copies horizontal_index or first_player_spans_two_columns into EDX and multiplies by horizontal_count, while VC7 copies horizontal_count into EDX and multiplies by the other operand. Ordinary declaration-order, product-local, operand-order, and expression-grouping corrections either compile to this fixed point or perturb more code, so the natural donor topology is retained. No carrier variable, volatile access, barrier, assembly, fake dependency, raw-address field, or nonsensical control flow is present. The public prototype is isolated in main_runtime.h because adding the rectangle type to broad main.h changed an unrelated shell_xbox rdata COMDAT owner under C2; the narrow owner header preserves every consumer. Reopen only for authoritative January source/local records or a natural same-compiler register-lifetime donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 496,
|
|
"relocation_count": 25,
|
|
"normalized_sha256": "9e74a78d008dcdaa4ecd0e8290296cab0e4bc43a5ea1222200a9867d80677e76"
|
|
},
|
|
"base": {
|
|
"size": 496,
|
|
"relocation_count": 25,
|
|
"normalized_sha256": "102856c3048a4eca32fbcb6e11ad419f5f9d1d581ee12f6832cf90a2f73e99bf"
|
|
},
|
|
"objdiff_percent": 99.87578
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_allegiance",
|
|
"function": "_game_allegiance_broken",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule with the HCEA/Pastudan-authenticated allegiance state transition retained as ordinary typed C. The January cachebeta symbol atlas itself recovers `_game_allegiance_broken` at 0x496300, and multiple Gearbox CE maps plus later HCEA PDBs independently preserve the same private name and static `(game_allegiance *, boolean, boolean)` role; the old address-derived label was removed. Target and candidate have the same 416-byte padded envelope, both relocation identities, all 142 decoded instructions, and the same bit-matrix/state/AI-notification control flow. The remaining allocation cycle is January keeping `permanently_broken` in DL and the bounded team words in CX/SI while VC7 keeps the boolean in CL and the team words in SI/DI, extending one ESI save through the tail. The prior bounded source-shape packet exhausted semantic team aliases, declaration/scope order, bit-index locals, global/local access, and predicate spellings, and a new census of all 1,646 registered worktrees found only ten source blobs with this retained source as the unique complete frontier. No register hint, volatile access, compiler barrier, pragma, assembly, fake dependency, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January local-variable records, original source, or a natural same-compiler donor that explains the boolean/team-word allocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 416,
|
|
"relocation_count": 2,
|
|
"normalized_sha256": "3eba7c13f76df6f625c5abf7165fe4e320ba92642bad6390de317f45dfcd0f9e"
|
|
},
|
|
"base": {
|
|
"size": 416,
|
|
"relocation_count": 2,
|
|
"normalized_sha256": "abbb6b20b7bb98348e048ae1252104ab55585fc1da07cdc14e12e699d681ef34"
|
|
},
|
|
"objdiff_percent": 94.296875
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_allegiance",
|
|
"function": "_game_allegiance_create",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule with the coherent HCEA/Pastudan-authenticated create-or-replace flow, bounded eight-record table, January-owned overflow error, typed record stores, and private `game_allegiance_broken` transition retained. Target and candidate have the same 224-byte padded envelope, all five relocation identities in order, and the same 82 decoded instructions. The residual is a closed callee-saved allocation cycle: January keeps the globals base in EDI and the hot team field in DX, while VC7 keeps globals in EDX and shrink-wraps EDI around the search field. The earlier bounded packet exhausted index widths, predicate and declaration order, alias scopes, pointer versus indexed traversal, global reloads, store order, and helper spelling without finding a lawful source lever, and the new 1,646-worktree/ten-blob census found no later frontier. No volatile/register forcing, compiler barrier, pragma, assembly, inert carrier, fake dependency, undefined behavior, or nonsensical exactness control is retained. Reopen only for authoritative January locals/source or a natural same-compiler donor that explains the EDI/DX lifetime assignment.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 224,
|
|
"relocation_count": 5,
|
|
"normalized_sha256": "47961c6c1d4c59a901156d907b22388d0b0a39a06f367b8403cd9e97ada8ed1f"
|
|
},
|
|
"base": {
|
|
"size": 224,
|
|
"relocation_count": 5,
|
|
"normalized_sha256": "be3a5bd445aa935a156513c29538f662a0d940b83315fab36696cf7603821b0d"
|
|
},
|
|
"objdiff_percent": 83.69334
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actions",
|
|
"function": "_actor_action_handle_vehicle_entry",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked after replaying every distinct Actions source blob visible to the campaign and retaining the complete ordinary-C vehicle-entry policy reconstructed from January control flow and the later HCEA implementation. Target and candidate have the same 960-byte padded envelope, all 22 relocation identities at the same addresses, and 96.54422% objdiff similarity; normalized comparison leaves 39 differing instruction positions in otherwise aligned streams. The best natural source differs in false-result tail topology and register assignment. An enclosing negative-guard rewrite increased the difference count from 39 to 240 and was reverted. No volatile/register forcing, barrier, pragma, assembly, fake dependency, inert carrier, or nonsensical branch is retained. Reopen only for authoritative January locals/source or a natural same-compiler donor that explains the remaining result/register lifetime.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 960,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "df9b95a1daf88c72ac92d1bf7a1877f8cc3acfab8916e7ffc18c640ec793630f"
|
|
},
|
|
"base": {
|
|
"size": 960,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "80e7bf257e70635f1a9a668d895ab372d01671ab05db2a55b2db8afbb8866ac3"
|
|
},
|
|
"objdiff_percent": 96.54422
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actions",
|
|
"function": "_actor_action_handle_lost_contact",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked after the complete lost-contact state machine was reconstructed from January's relocation/control-flow graph and cross-checked against the later HCEA behavior, then replayed against all distinct Actions donors. Target and candidate share the 1,872-byte padded envelope and all 55 relocation destinations in semantic order. The remaining broad packet difference is the compiler's private-helper convention, frame coloring, and x87/register scheduling rather than missing behavior. A declaration-order and CodeView-oriented lifetime experiment worsened the result and was reverted. No artificial local, volatile access, barrier, pragma, assembly, fake dependency, or nonsensical control flow is retained. Reopen only for authoritative January local-variable records/source, a compatible original C2/QFE, or a natural same-compiler donor that recovers the private calling/lifetime schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1872,
|
|
"relocation_count": 55,
|
|
"normalized_sha256": "1b2dca7a160e365844a4f791b96e850838684053047eede1d2efc59a260c9834"
|
|
},
|
|
"base": {
|
|
"size": 1872,
|
|
"relocation_count": 55,
|
|
"normalized_sha256": "0e96d40ea2f3812285e7d27ea025aef17c91be73dad2c67b35f68a8ea670c422"
|
|
},
|
|
"objdiff_percent": 95.328384
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actions",
|
|
"function": "_actor_action_handle_danger_avoidance",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked with the coherent negative danger predicate and complete typed avoidance policy retained after the historical donor replay. Target is 1,520 padded bytes and the natural candidate is 1,504, while both carry the same 34 relocation destinations in semantic order. The only discovered strict-exact form replaces `if (!body_within_danger)` with an empty positive arm and moves all real work into `else`; independent Fable review identified that shape as score-only fake matching, so it is explicitly rejected. Source keeps the natural condition and semantic private helper name instead. No volatile/register forcing, barrier, pragma, assembly, artificial carrier, undefined behavior, or nonsensical exactness control is retained. Reopen only for authoritative January source/locals or a natural donor that explains the 16-byte control-flow/codegen gap.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1520,
|
|
"relocation_count": 34,
|
|
"normalized_sha256": "50e4161c4fc3e7ba8a3a310dc7254db5ccb8c9731b76038f7a53114d511a8807"
|
|
},
|
|
"base": {
|
|
"size": 1504,
|
|
"relocation_count": 34,
|
|
"normalized_sha256": "b1d5ecaf33b392f8b6071a515b226a8c41e112097105096e0216f9554e3b328f"
|
|
},
|
|
"objdiff_percent": 90.41458
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actions",
|
|
"function": "_actor_action_try_to_dive",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked after reconstructing the complete January dive eligibility, target selection, debug bookkeeping, and animation/action transition in ordinary typed C and exhausting the recorded declaration, aggregate-vector, scope, and linkage variants. The candidate retains all 29 semantic relocation destinations but is 704 padded bytes against January's 720. Static-linkage and aggregate/lifetime experiments could recover isolated allocation features only while perturbing broader code and were reverted. No forced inlining, volatile access, barrier, pragma, assembly, fake dependency, or nonsensical control flow is retained. Reopen only for authoritative January locals/source, the original translation-unit context, or a natural same-compiler donor that explains the remaining frame/allocation schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 720,
|
|
"relocation_count": 29,
|
|
"normalized_sha256": "2548ce8b22f46d482056a0e7fce5078dfa8f2d4d5e064a9e1943c90b8147d990"
|
|
},
|
|
"base": {
|
|
"size": 704,
|
|
"relocation_count": 29,
|
|
"normalized_sha256": "1489a21aa830ee0316bfe8fea3886993bee7ad2372e4c0173669cbf618ca2c9e"
|
|
},
|
|
"objdiff_percent": 85.18107
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actions",
|
|
"function": "_actors_searching_same_position",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked after retaining the complete bounded actor-search predicate in ordinary typed C and replaying all distinct historical Actions bodies. Target and candidate share the 320-byte padded envelope and all 14 relocation destinations in semantic order. The remaining packet is a closed register/lifetime allocation difference; prior predicate, declaration, iterator, and local-scope variants either compiled to this fixed point or disturbed more of the function. No volatile/register forcing, barrier, pragma, inline assembly, artificial dependency, inert expression, or nonsensical control flow is retained. Reopen only for authoritative January locals/source or a natural same-compiler register-allocation donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 320,
|
|
"relocation_count": 14,
|
|
"normalized_sha256": "0f8d4038344e6058a388fc236ba1a32a119bb69d13fa1b6c9f7b806c25071fb1"
|
|
},
|
|
"base": {
|
|
"size": 320,
|
|
"relocation_count": 14,
|
|
"normalized_sha256": "844a679f805ae87f3195ebaddccc8fe5fe9c8b5e507a5d09e895dfbba1baac62"
|
|
},
|
|
"objdiff_percent": 87.87611
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/physics/breakable_surfaces",
|
|
"function": "_breakable_surface_effect",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconciling the unique complete Claude frontier with all twelve distinct breakable-surfaces source variants found across the registered worktrees, January disassembly and relocations, the HCEX PDB/PowerPC implementation, the HCEA donor, the October reconstruction, and the local same-compiler donor census. The retained source reconstructs the complete traversal, projection, particle-grid, impulse, tint, and sound logic with semantic project types and names; uses the authenticated shared fast_ftol helper for January's x87 integer conversion; recovers rectangle2d bounds, natural block lifetimes, vertex-point lvalues, the grouped j/k plane-distance association, and January's alpha-evaluation order; and preserves all eleven exact sibling functions. Target and candidate have the same 4032-byte padded envelope and all 117 relocation types and symbolic destinations in the same sequence; the freshly regenerated campaign report records 99.8042 percent similarity. A transparent scalar expansion models the header-inline point_from_line3d body while obeying the project-wide rule that this translation unit must not emit a point_from_line3d COMDAT. The remaining decoded differences are two commutative x87 operand-role selections in one cross_product3d expansion and one equivalent x87 stack schedule in the first scalar-expanded grid offset. More than seventy ordinary-C declaration, scope, association, helper, expression-order, and compiler-shape probes either returned to this fixed point or degraded broader code; direct open coding removed the COMDAT but lost the target envelope, while the retained parameter-style bindings preserve both semantics and envelope without volatile access, a compiler barrier, forced inline/noinline, assembly in this routine, a fake dependency, inert control flow, undefined behavior, or nonsensical coincidental matching. Reopen only for authoritative January source/local records, an authenticated compatible compiler/QFE, or a natural same-compiler donor that explains these x87 operand and stack choices.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 4032,
|
|
"relocation_count": 117,
|
|
"normalized_sha256": "510486a7d0a1f2fc1dfb8f0c47990c57f83ce1030ef5e4db8dfc42943dc56bfa"
|
|
},
|
|
"base": {
|
|
"size": 4032,
|
|
"relocation_count": 117,
|
|
"normalized_sha256": "678a8125d160643a9f1226240128c662bcbb85e7f968f8fd3ed0f0b411f77797"
|
|
},
|
|
"objdiff_percent": 99.8042
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/items/items",
|
|
"function": "_item_update",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete January item-update state machine as ordinary typed C. The audit covered every Items ledger, complete repository history, 1,554 registered worktrees collapsing to five source blobs, HCEA, Stian's January-shaped reconstruction, Pastudan, and Marathon; no exact source or stronger complete candidate exists. The retained e02971df lineage was reconciled with semantic private/global names, the Items-owned prototype, cseries real types and flag macros, correct collision enums, and the existing January point_from_line3d inline schedule. Target and candidate have the same 2,352-byte padded envelope, 110 relocation identities in order, the exact 0xC8 frame, no unwritten blocks, and behavior-complete collision, rest-support, acceleration, interpolation, and lifetime cleanup paths; the freshly regenerated campaign report records 95.414246 percent similarity. Remaining aligned differences are bounded C2 scheduling choices in early candidate/collision setup, two sound-location stores, angular-dot grouping, flag read/modify/write selection, support-index and rotation-axis copies, the final bounce x87 multiply, and cosine-load placement; after rested-item validation the meaningful tail is instruction-for-instruction equivalent modulo a seven-byte accumulated offset, with seven target-envelope padding NOPs. The repository classifier returns UNKNOWN and therefore this entry fails closed as unclassified. Natural probes of support-store placement, support-index lifetime, vector helper use, angular expression grouping, rotation-axis copies, clamp/bounce spelling, and declaration order either reproduced the same object or worsened size/score and were inverse-restored. No register/volatile hint, compiler barrier, pragma, assembly, fake dependency, undefined behavior, raw offset, address-derived identifier, forced inline, or nonsensical exactness control is retained. Reopen only for authenticated January source or local-variable records, or a natural same-compiler donor that explains all remaining scheduling windows together.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 2352,
|
|
"relocation_count": 110,
|
|
"normalized_sha256": "78237a8528e5d6a858b7aced1df0d8037225ec19da1b3b625c74c900d8ee8b02"
|
|
},
|
|
"base": {
|
|
"size": 2352,
|
|
"relocation_count": 110,
|
|
"normalized_sha256": "3daa5a96ffd38c2e133967126ca722610b145121e9690eb92a76f5a026b736f5"
|
|
},
|
|
"objdiff_percent": 95.414246
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/interface/hud_nav_points",
|
|
"function": "_custom_render_nav_point",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete January four-argument waypoint renderer from the January target and the later HCEA semantic donor. The retained ordinary C implements camera-distance scaling, view projection, ellipse clamping and optional rotation, typed waypoint bitmap retrieval, opacity/fade color packing, the on-screen meter readout, and January's full stack guard. Target and candidate have the same 1632-byte padded envelope, all 95 relocation identities at the same addresses, and the same instruction boundaries throughout. Only eight normalized bytes remain at +0x58A: January pushes the zero override-scale argument before loading decimal_value and distance, while VC7 hoists those two independent loads before that push. Direct and block-local decimal expressions, explicit and implicit short conversion, and literal/local zero spellings reproduce the same schedule. The complete Git/worktree/COFF census, HCEA commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c, and Marathon commit ce4fdc63f20f6fa39616a86e717118f4d8bdf25c provide no closer source. No volatile access, compiler barrier, artificial alias, forced inlining, pragma, fake dependency, assembly, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining that final argument-load schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1632,
|
|
"relocation_count": 95,
|
|
"normalized_sha256": "287a20cd338648964303d1f60b46e9cdf94753f43718b48f8c648a0dd9e60306"
|
|
},
|
|
"base": {
|
|
"size": 1632,
|
|
"relocation_count": 95,
|
|
"normalized_sha256": "ad77c226edfd32a6644d9d531123945d71c2341f7b2aaa929edef572045157ca"
|
|
},
|
|
"objdiff_percent": 99.579155
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/interface/hud_nav_points",
|
|
"function": "_hud_render_nav_points",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked under the current house rule with the complete typed four-waypoint traversal retained. The routine validates the local player and arrow bitmap, resolves flag/object/game-engine destinations with typed tag and object access, applies the vertical offset, and calls the reconstructed renderer with the named screen type. All 17 relocation identities remain in the same semantic order. January biases its ESI loop cursor to reference_index at datum+8 and addresses the other fields negatively, producing 400 padded bytes; the direct typed pointer loop anchors ESI at the datum base and produces 416. Natural indexed-for, short/long index, and count-derived array forms do recover the +8 cursor but spill the count and perturb the frame/register allocation, giving a structurally worse 416-byte family; the direct pointer form remains the best lawful source. No raw byte cursor, containing-record alias, volatile access, compiler barrier, forced inlining, pragma, assembly, fake dependency, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January source/local records or a natural same-compiler typed traversal that explains the biased cursor without spilling the count.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 400,
|
|
"relocation_count": 17,
|
|
"normalized_sha256": "f2bb689a08030b4b54e28e13307de141eab53b71b0acc334bc2bec2f1dd78391"
|
|
},
|
|
"base": {
|
|
"size": 416,
|
|
"relocation_count": 17,
|
|
"normalized_sha256": "0df4703281637b185fa8bd6f44392a688be3a3e4e2b11e6bc6314ae756823274"
|
|
},
|
|
"objdiff_percent": 95.26667
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/cache/xbox_sound_cache",
|
|
"function": "__sound_cache_sound_request",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked under the current house rule with the complete sound-cache request policy retained in ordinary typed C: lazy allocation, LRU touch, optional blocking load, software reference accounting, and coherent success/failure returns. January homes the result boolean and preserves separate false-return tails, while the available VC7 build folds those paths and emits 368 padded bytes and 27 relocations against January's 352 and 25. The complete repository and donor census found one strict candidate that depends on a volatile result solely to control code generation; it is rejected. Natural declaration, predicate, return, scope, and parameter-order probes return to this fixed point or disturb broader semantics. No volatile/register forcing, barrier, pragma, forced inline, assembly, fake dependency, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January source/local records, an authenticated compiler/QFE difference, or a natural same-compiler donor that explains the result lifetime and return topology.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 352,
|
|
"relocation_count": 25,
|
|
"normalized_sha256": "92c886403f8cde61d3d896b9ed86e8834df085c15e28f3db224e2e28628e968a"
|
|
},
|
|
"base": {
|
|
"size": 368,
|
|
"relocation_count": 27,
|
|
"normalized_sha256": "8949af89c5592c066f29a1ea7dd9514f23d783eb55548ce806a9c5fe91ba055f"
|
|
},
|
|
"objdiff_percent": 83.92623
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/cache/xbox_sound_cache",
|
|
"function": "_render_inverse_transform_screen_point",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after restoring the HCEA-authenticated private name, typed point/vector signature, and parameter order. Target and candidate share the 256-byte padded envelope and all 22 relocation identities in semantic order. Their normalized instruction streams have the same length and behavior; the residual is the equivalent ECX/EDX assignment of the two output pointers. Ordinary declaration, type, expression, and parameter-order probes converge on this compiler allocation. No volatile/register forcing, barrier, pragma, forced inline, assembly, fake dependency, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January locals/source, an authenticated compiler/QFE difference, or a natural same-compiler register-allocation donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 256,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "c39690660070bc740fc89bc34ed735ce9c30406d8f26cfe5f853c9d2e5261bee"
|
|
},
|
|
"base": {
|
|
"size": 256,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "d434a17b8d90be4fa31d5651b27f45be31c5a6c6e5d0c21b366fc2d174e23acc"
|
|
},
|
|
"objdiff_percent": 99.347824
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/cache/xbox_sound_cache",
|
|
"function": "_sound_cache_debug_render",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked under the current house rule with the complete debug page-usage renderer retained in ordinary typed C. Target and candidate share the 368-byte padded envelope and all 14 relocation identities in semantic order. Moving the four debug colors under the debug predicate naturally recovered January's flag/color prefix; the remaining packet is the nested-loop local/register schedule and the equivalent private render helper ECX/EDX allocation. Declaration and scope permutations either reproduce this fixed point or worsen the broader stream. No volatile/register forcing, barrier, pragma, forced inline, assembly, fake dependency, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January source/local records, an authenticated compiler/QFE difference, or a natural same-compiler donor that explains the private-helper ABI and nested-loop lifetimes together.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 368,
|
|
"relocation_count": 14,
|
|
"normalized_sha256": "4c8eb53f6c7feaadf4c4b83d4b2587f923802d0cfa271d08fb642c35e0cb225e"
|
|
},
|
|
"base": {
|
|
"size": 368,
|
|
"relocation_count": 14,
|
|
"normalized_sha256": "10efee1b75e2372c741dc9d5bd93615fec17157ad0d52456f032c5d758df8dc3"
|
|
},
|
|
"objdiff_percent": 86.17647
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/structures/structure_detail_objects",
|
|
"function": "_structure_detail_objects_initialize",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked after restoring the HCEA-authenticated allocation and default normal initialization in ordinary typed C and preserving the three exact relocation destinations. Target and candidate share the 80-byte padded envelope and differ only in the schedule of the independent stack cleanup and global runtime-data store: January restores the three game_state_malloc arguments before publishing the allocation, while VC7 publishes the allocation first and then adjusts ESP. The direct-global, declaration-order, assignment-order, aggregate-initializer, and temporary-pointer source families either return to this fixed point or enlarge the function and relocation set; the direct-global spelling specifically grows to 96 bytes and six relocations. No barrier, volatile access, pragma, assembly, fake dependency, inert expression, or nonsensical branch is retained. Reopen only for authoritative January locals/source or a natural same-compiler scheduling donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 80,
|
|
"relocation_count": 3,
|
|
"normalized_sha256": "99e687328f033302450f35257d1339d168279f9876fcd14b9180ddaa52f618d5"
|
|
},
|
|
"base": {
|
|
"size": 80,
|
|
"relocation_count": 3,
|
|
"normalized_sha256": "46c693d13661a9d71dd5516590b0c9d7c29e22dc1cc38eea6ff94d60c88ddd82"
|
|
},
|
|
"objdiff_percent": 76.36364
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/structures/structure_detail_objects",
|
|
"function": "_structure_render_detail_objects",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked after reconstructing the complete January visible-cell rebuild and render path from the target disassembly and relocations, the first-party HCEA function, and the independent Pastudan PC lift. The retained ordinary C has the exact 1,136-byte padded envelope and 31 relocations; it uses named cell/layer/view structures, typed tag-block accessors, the authenticated fast_ftol helper, January's intrinsic memset/abs lowering, the exact lower/upper-bound helpers, and the original lower_bound_cell<=upper_bound_cell assertion. The residual spans VC7 frame coloring, local/register allocation, one reciprocal/count-access scheduling swap, and x87 lifetimes. Natural runtime/view aliases, declaration and scope order, loop spelling, direct-global fallback, and reciprocal placement were boundedly tested; variants either returned to this fixed point, disturbed the exact helper family, or added unsupported alias-only source. No forced inline/noinline, barrier, volatile access, pragma, assembly in this routine, fake dependency, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January source/local records, the original translation-unit context, or a natural same-compiler donor that explains the allocation and x87 schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1136,
|
|
"relocation_count": 31,
|
|
"normalized_sha256": "dbf237f0819e54a61d67102c174e6f79789603a62a8adbac4e97c21e01394658"
|
|
},
|
|
"base": {
|
|
"size": 1136,
|
|
"relocation_count": 31,
|
|
"normalized_sha256": "eb6883e150ad20816c89d64a99075684ab290ad767736f7942e56317ac3d4fb1"
|
|
},
|
|
"objdiff_percent": 76.39528
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/structures/structure_detail_objects",
|
|
"function": "_render_debug_detail_objects",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked after restoring the complete debug traversal from January disassembly and relocations, cross-checking its control/traversal/reset subset against the later HCEA renderer, and using the independent Pastudan PC lift for the target-specific packed decode and drawing path. The retained ordinary C performs the target-backed duplicate enable check, visible layer/cell traversal, optional reference-plane offset, packed detail-object decode, clipping test, point draw, cell bounds draw, clipped overlay, and one-shot debug-state reset using semantic project types and named structures. It preserves all 33 relocation destinations in semantic sequence and compiles to 736 padded bytes versus January's 752; the residual is x87 stack/frame and pointer-lifetime scheduling. A credible dot_product4d spelling recovered the 752-byte envelope but introduced a 34th unsupported multiply-by-one relocation and was reverted; direct-vector, declaration/scope, bounds-arithmetic, comparison-order, view-data access, and loop-shape variants either return to this fixed point or regress relocation topology. No forced inline/noinline, barrier, volatile access, pragma, assembly in this routine, fake dependency, undefined behavior, or nonsensical branch is retained. Reopen only for authoritative January source/local records, the original translation-unit context, or a natural same-compiler donor that explains the remaining x87 and frame schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 752,
|
|
"relocation_count": 33,
|
|
"normalized_sha256": "3e4c30c13847d08060c08d64bd9114a3c6592eb827ba69d422c93f046d70a6a7"
|
|
},
|
|
"base": {
|
|
"size": 736,
|
|
"relocation_count": 33,
|
|
"normalized_sha256": "4457d66b4b59e307e3671bba697b89ab0c51f05f4c7b48284ef89a92b068a822"
|
|
},
|
|
"objdiff_percent": 78.78802
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/action_alert",
|
|
"function": "_action_alert_next_position",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete alert-position traversal from January disassembly and relocation evidence, the later HCEA semantic implementation, and the matching AI data definitions. The retained ordinary C rejects disabled actors, resolves the actor's encounter and squad through typed accessors, filters every move position by current position, actor distance, noncombat sequence, and nearby props, records unavailable positions with the cseries bit-vector macro, performs weighted-random selection, and implements forward, ping-pong, and per-tick-random traversal with semantic enum constants. It also recovers the private name action_alert_next_position and preserves all eleven exact siblings. Target and candidate carry the same 18 relocation identities in order; January is 784 padded bytes, the candidate is 768, and the freshly generated campaign report records 99.46479 percent similarity. Aligned instruction comparison shows the complete geometry, iterator, bit-vector, random-selection, and traversal body is byte-identical; the residual is limited to January preloading the NONE result in EAX, consequent AL/CL and EAX/ECX register choices in the entry guard, two equivalent full-EAX versus AX sentinel returns, and target-envelope padding. Bounded ordinary-C experiments covered combined, separate, and enclosing entry guards; short and long default-result lifetimes; declaration order; direct versus assigned random returns; natural for/while traversal; and switch/default shapes. They either returned to this fixed point or disturbed exact body code; no volatile or register forcing, compiler barrier, pragma, inline assembly, fake dependency, raw offset, undefined behavior, forced inline, or nonsensical control flow is retained. Reopen only for authoritative January source/local-variable records or a natural compatible-compiler donor explaining the default-result register lifetime.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 784,
|
|
"relocation_count": 18,
|
|
"normalized_sha256": "677fd6cc1a9e66de32123c4614de5a0cc1188501baee69ea20fd5bf74eac3fe4"
|
|
},
|
|
"base": {
|
|
"size": 768,
|
|
"relocation_count": 18,
|
|
"normalized_sha256": "4e16c85b544ded3352df48ee7baa0e19b5a34a45e421a975cf11cd771184f371"
|
|
},
|
|
"objdiff_percent": 99.46479
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/physics/collision_usage",
|
|
"function": "_collision_log_render",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete collision-usage renderer in ordinary typed C from the January disassembly and relocation topology, the historical Punpckhdq scope skeleton, and the independent Stian PC semantic donor. HCEA independently corroborates the exported debug controls; the open Marathon corpus was searched but has no direct collision-profiler analogue. The retained function scans all eight collision functions and three periods, aggregates and sorts all 22 semantic collision users, formats totals or the six busiest users, selects the terminal draw mode, renders each line, and advances the cursor. Its private formatter is independently strict exact and naturally follows January's inline schedule. January is 1,584 padded bytes with 79 relocations; the candidate is 1,536 bytes with 76 and the fresh campaign report records 82.027954 percent. The remaining boundary is broad VC7 frame/register scheduling: January reads only rasterizer_globals+16 while the candidate's typed rectangle copy also reads +12, and January's aggregation directly materializes collision_usage_buffer+24/+32/+36 while the candidate keeps a typed usage pointer. Earlier documented declaration, scope, direct-expression, frame-bound, source-pointer, and assertion-spelling families either returned to this fixed point or disturbed wider control flow. No forced inline/noinline, volatile or register forcing, barrier, pragma, assembly, fake dependency, raw offset, undefined behavior, or nonsensical exactness branch is retained. The fail-closed classifier returns UNKNOWN. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the frame and aggregation lifetimes together.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1584,
|
|
"relocation_count": 79,
|
|
"normalized_sha256": "dc4c9ded347bbcf3f6a5577d375e9611458a2c6b06039e89a01b7b47ceb1a213"
|
|
},
|
|
"base": {
|
|
"size": 1536,
|
|
"relocation_count": 76,
|
|
"normalized_sha256": "f586255e6af97eacfd630c01c08aaa2ff43060eea09eaf9fe4257f2d00ecb94b"
|
|
},
|
|
"objdiff_percent": 82.027954
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/physics/collision_usage",
|
|
"function": "_collision_log_get_current_user",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule with the complete private user-selection helper retained in ordinary typed C and its semantic name recovered from historical Xbox donor source. The retained stack-top access is global_current_collision_users[global_current_collision_user_depth - 1], as independently proved by January's collision_usage_current+2974 relocation resolving two bytes before global_current_collision_users. Target and candidate share the 256-byte padded envelope and 23 relocations. After resolving that csplit alias, their instruction streams align for every instruction except the final successful return: January emits mov ax,si while VC7 emits movsx eax,si. Restoring the target assertion punctuation recovered the authentic owned strings. The independent PC machine-code lifts infer a short return, but neither has source or PDB type provenance; compiling that signature collapses January's separate NONE exits and shrinks the function to 240 bytes, so the Xbox donor's natural long-return topology is retained. Prior declaration, local-result, and return-shape experiments are documented as exhausted. No barrier, volatile or register forcing, pragma, assembly, fake dependency, undefined behavior, or nonsensical branch is retained. The fail-closed classifier returns UNKNOWN. Reopen only for authoritative January prototype/local-lifetime evidence or a natural same-compiler donor that explains the narrow AX return without changing the rest of the function.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 256,
|
|
"relocation_count": 23,
|
|
"normalized_sha256": "fc370d7e130011908802a1d09d62cadaccb97dac976f7c5705341b7eb44d1cb3"
|
|
},
|
|
"base": {
|
|
"size": 256,
|
|
"relocation_count": 23,
|
|
"normalized_sha256": "0f1289b9c2652df52cbd35e38ba0778b3d2ada82a9dd87a9528fb5928c017bf3"
|
|
},
|
|
"objdiff_percent": 99.14286
|
|
}
|
|
},
|
|
{
|
|
"unit": "libs/libcmt/x10fout",
|
|
"function": "_$I10_OUTPUT",
|
|
"class": "tu-context-optimization",
|
|
"evidence": "Fuzzy-parked with the complete first-party Microsoft CRT implementation retained in ordinary C. XDK 3911 CodeView names d:\\xbox-finalfre\\private\\sdktools\\crt\\fpw32\\conv\\x10fout.c, and the matching Microsoft source in xerohour/xbox_leak_may_2020 commit fd00b4b3b2abb1ea6ef9ac64b755419741a3af00 blob 7e9106227dc9543ac5bca9a216e0fdf1b0b486cc explicitly defines STRCPY as strcpy and uses it for all four special-value outputs. Under the unchanged /O1 /Gy policy, VC7 leaves two shared tail calls out of line, producing 638 bytes and 14 relocations instead of January's 631 bytes and 12. A previously reported strict-exact form replaced those calls with invented fixed-size aggregate types and assignments solely to steer code generation; it is rejected under the anti-fake rule because authoritative source proves those constructs were absent. /Oi, optimizer pragmas, forced inline, aggregate copy substitutes, assembly, volatile/register forcing, undefined behavior, fake dependencies, and nonsensical control flow are not retained. Reopen only with authenticated evidence for January's CRT intrinsic configuration or original compiler/header context that naturally lowers the four strcpy calls to the target copies.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 631,
|
|
"relocation_count": 12,
|
|
"normalized_sha256": "680a37145127a3fc46fe86768557819c28826e310a95b69f9b5133f108d03a6d"
|
|
},
|
|
"base": {
|
|
"size": 638,
|
|
"relocation_count": 14,
|
|
"normalized_sha256": "b290f40fcd9212e3550eaf60c6943489f6564c4e73756d0d2450ff79ca920c12"
|
|
},
|
|
"objdiff_percent": 96.4574
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/units/bipeds",
|
|
"function": "_biped_find_nearby_support_surface",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after restoring the complete typed support-surface search from January disassembly and relocation topology, the later HCEA semantic implementation, and the earlier e02971dfd campaign reconstruction. The same-build Halo CE symbol atlas independently recovers the private name biped_find_nearby_support_surface. The retained ordinary C obtains the biped physics pill, brackets the collision query with the semantic collision-user stack, tests the structure BSP with the breakable-surface flags, corrects back-facing planes through named fields and LONG_MAX, selects the closest support plane, and updates the biped's support surface, ground plane, and up vector. Target and candidate have the same 544-byte padded envelope, all 23 relocation identities, and 175 decoded instructions; the report records 99.976746 percent similarity. Their sole machine-code difference is the order of the first two independent x87 multiply/add terms inside the inlined plane3d_distance_to_point expression. The source-authentic project helper is retained rather than expanding and reordering its dot-product terms solely to steer code generation. The fail-closed classifier returns UNKNOWN. No forced inline/noinline, barrier, volatile access, pragma, assembly, fake dependency, raw offset, undefined behavior, manual bitwise plane mask, or nonsensical branch is retained. Reopen only for authoritative January source/local records, a proven January inline-schedule correction, or a natural compatible-compiler donor that explains the x87 evaluation order.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 544,
|
|
"relocation_count": 23,
|
|
"normalized_sha256": "d2fe0224f5db1253a04cdd2a4749291078f65eb5c0b9a9f21e7de2b2b31e6b4b"
|
|
},
|
|
"base": {
|
|
"size": 544,
|
|
"relocation_count": 23,
|
|
"normalized_sha256": "7264f6ba522f1b4dab0f59e9a1e725bfed9363c869e1727e0b69f94b1e1212b0"
|
|
},
|
|
"objdiff_percent": 99.976746
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_group",
|
|
"function": "_bitmap_group_add_bitmap",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after restoring the complete typed bitmap insertion routine from January disassembly, relocation topology, assertion and diagnostic strings, the later HCEA semantic implementation, and the independent PC machine-code lift. The retained ordinary C builds the 48-byte bitmap descriptor through semantic fields, validates interface, power-of-two, cube-map, compressed, and palettized cases, grows the bitmap block and pixel blob, repoints every existing bitmap through TAG_BLOCK_GET_ELEMENT, verifies the relocated ranges, preserves the original tight-packing warning, copies the new descriptor, and zero-fills its pixels. Its five sibling functions remain strict exact. January is 995 meaningful bytes in a 1008-byte padded envelope; the candidate is 989 meaningful bytes in a 992-byte envelope, preserves the 0x34 frame and all 59 semantically corresponding relocations, and reports 60.99099 percent similarity. The first divergence is VC7's allocation of the 16-bit type/depth/group-type lifetimes, followed by a different but equivalent diagnostic-block layout; the fail-closed classifier returns UNKNOWN. The earlier object ledger exhausted explicit-clear, flags-local, entry-live-range, return-type, declaration-order, signature-store, predicate, and branch-layout families, including a historical 1008/59 candidate that was still nonexact and whose source artifact was not retained. A fresh dangling-blob and worktree audit recovered only the later HCEA reconstruction, not that disposable source. Adding the public owner-header prototype was also rejected after a full verdict bisect proved that its header-position sensitivity regressed the exact bitmap_2d_uncompress_from_mipmap; the function definition remains its authoritative declaration until a consumer requires an owner-header API. No barrier, volatile or register forcing, pragma, assembly, fake dependency, raw offset, undefined behavior, codegen carrier, or nonsensical branch is retained. Reopen only for authoritative January source or local-variable records, recovery of the historical readable candidate, a strict same-topology donor, or a compatible VC7/QFE that naturally explains the register and cold-block schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1008,
|
|
"relocation_count": 59,
|
|
"normalized_sha256": "b5fee4632a47ed183bb1aec903552bd1b140a591e64d42625900c8b7bf8a7e69"
|
|
},
|
|
"base": {
|
|
"size": 992,
|
|
"relocation_count": 59,
|
|
"normalized_sha256": "2e0bbd84c45f240758cc76a2d4df8c78be689cfe9bc21af6a52e017f218e7ca0"
|
|
},
|
|
"objdiff_percent": 60.99099
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/widgets/lightning",
|
|
"function": "_lightning_offset_marker_position",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete private marker-offset helper in ordinary typed C from January disassembly and assertion/relocation evidence, then corroborating its semantic name and algorithm against the later HCEA implementation and the independent Stian/Pastudan lifts. The helper is a same-TU static owner naturally emitted by the complete lightning_submit caller and receives position, matrix, and random_position_bounds in January's ESI/EBX/EDI private register convention. Target and candidate share the 240-byte padded envelope and all 22 relocation identities; the fail-closed classifier returns a PROVEN independent-instruction-scheduling STOP. After relocation normalization, the sole instruction difference is an adjacent transposition of the post-transform stack cleanup and first independent x87 addition. The retained source performs all three authenticated assertions, three local random draws, component remapping, in-place matrix transform, and position accumulation. No register hint, volatile access, barrier, pragma, assembly, fake dependency, undefined behavior, forced inline/noinline, or nonsensical control flow is present. Reopen only for authoritative January source/local records or a natural compatible-compiler context that explains that independent schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 240,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "2fe97798519acba821968a88f76c5a3ac64a62c86a9919327b6ed89c8599f17d"
|
|
},
|
|
"base": {
|
|
"size": 240,
|
|
"relocation_count": 22,
|
|
"normalized_sha256": "18303a5b66698933663dbbd26cebba03fb0487eb8154f80ec6a8bfadd6d7c7f3"
|
|
},
|
|
"objdiff_percent": 97.402596
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/objects/widgets/lightning",
|
|
"function": "_lightning_submit",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconciling the strongest preserved Fable reconstruction with January control flow, frame, calls, relocation topology, and owned assertions. Its marker/subdivision/render semantics are independently corroborated by the later HCEA source, HCEA type records, and the Stian/Pastudan lifts. The retained function uses lightning_definition_get, lightning_get, bitmap_group_get, and TAG_BLOCK_GET_ELEMENT typed access; semantic enums and cseries flag/index macros; TU-private target-proven tag and vertex layouts; and the color-packing prototype declared in its hud_draw owner header. It reproduces January's 0x24144 stack frame and 0x24024-byte clear for 4,097 typed 0x24-byte points, resolves object markers, applies endpoint and midpoint jitter, preserves point-valid assertions, billboards the path into typed dynamic-unlit vertices, computes its bounds centroid, selects the semantic shader, submits, and releases the buffer. January and the retained VC7 candidate now share the 2,576-byte padded envelope, all 80 relocation identities, and 756 decoded instructions; objdiff reports 99.35952 percent. The raw Fable endpoint-axis aggregate cast left only one additional scheduling transposition but was rejected as representation punning; the retained component-wise copy is ordinary typed C and leaves a small register-allocation packet plus that independent x87-store transposition. The fail-closed classifier therefore remains UNKNOWN and grants no strict credit. No point_from_line3d helper/COMDAT, register hint, volatile access, barrier, pragma, assembly, fake dependency, raw address, undefined behavior, forced inline/noinline, manual color packing, or nonsensical exact-only branch is present. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining the remaining allocation and scheduling packet.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 2576,
|
|
"relocation_count": 80,
|
|
"normalized_sha256": "fb46c25559e11027286d7f9192b0cbceef54b7e56aece731f83c6d0c298c5377"
|
|
},
|
|
"base": {
|
|
"size": 2576,
|
|
"relocation_count": 80,
|
|
"normalized_sha256": "4b830e4a539a01c46bae3b186cd66658f81b4285953455a907518a348b9b7cc0"
|
|
},
|
|
"objdiff_percent": 99.35952
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/interface/hud",
|
|
"function": "_hud_show_action_response",
|
|
"class": "private-register-convention",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete action-response dispatcher as ordinary typed C from January disassembly and relocation topology plus the later HCEA semantic recovery at commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c. The retained function handles all named respawn failures and player action-result enums, typed object/unit/control/weapon access, weapon-HUD messaging icons, custom game-engine text, driver/gunner suppression, and the target-attested odd inventory loop. Its 1024-wide-character state buffer recovers January's 0x82c frame, and its instruction count is 626 against January's 631. The remaining boundary is January's private EAX argument convention and common-tail selection: the public C spelling compiles with a stack argument and one extra relocation, while an explicit __fastcall experiment used the stack plus ret 4 and materially worsened the function. Register hints, duplicated fallbacks, declaration/order variants, and alternate icon/seat access shapes did not close the residual. No forced convention shim, naked wrapper, assembly, volatile access, optimizer carrier, raw offset, fake dependency, undefined behavior, or nonsensical branch is retained. Reopen only for authoritative January source/local records or natural same-compiler evidence explaining the private EAX convention and fallback tail sharing.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1744,
|
|
"relocation_count": 120,
|
|
"normalized_sha256": "bfe1022d2e8f59dc3220b33c497fed91681596b485f4cb2b9339454fe27ec317"
|
|
},
|
|
"base": {
|
|
"size": 1728,
|
|
"relocation_count": 121,
|
|
"normalized_sha256": "853cffc36136054ae6e51f2bb4012315c6f5b991c2950c0783d7b0f4fc9cafa9"
|
|
},
|
|
"objdiff_percent": 71.032104
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/interface/hud",
|
|
"function": "_temporary_hud_draw_reticle",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule with a complete ordinary-C reticle renderer recovered from January disassembly: it constructs sixteen typed world-space points from sine/cosine and the render view transform, then closes the ring through rasterizer_debug_line. January and the retained candidate have the same six relocation identities. The residual is limited to two compiler choices: January schedules the pi/8 x87 add before call-stack cleanup, and retains the generic signed remainder-by-16 sequence, whereas VC7 proves the reconstructed index nonnegative and emits an and 0xf. Natural for-loop, increment-placement, signed long-index, pointer-loop, and declaration-order variants were tested; they either return to this fixed point or perturb more code. No volatile or register forcing, artificial signedness carrier, inline assembly, barrier, raw offset, fake dependency, undefined behavior, or nonsensical control flow is retained. Reopen only for authoritative January source/local-lifetime evidence or a natural same-compiler donor explaining both the x87 and remainder schedules.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 208,
|
|
"relocation_count": 6,
|
|
"normalized_sha256": "34a33fe789d2858840e360558ebc1d2674a329e6a14d59572a3dfb9c1bc2255c"
|
|
},
|
|
"base": {
|
|
"size": 192,
|
|
"relocation_count": 6,
|
|
"normalized_sha256": "676b43cbdb66de19263a32f71a6c895b867d638c75f5fcd404e031b808e47afa"
|
|
},
|
|
"objdiff_percent": 90.676926
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/interface/hud",
|
|
"function": "_hud_draw_screen",
|
|
"class": "private-register-convention",
|
|
"evidence": "Fuzzy-parked with the complete top-level HUD draw dispatcher retained in ordinary typed C and corroborated by HCEA commit 570c83fd9c365dad6f2a3e7041705d5b84c7847c. Target and candidate have all 33 relocation identities and the same semantic call sequence: rasterizer HUD bracketing, teammate indicators, primary-local-player motion-sensor tick, perspective and unit gating, weapon/action/sound/unit/nav/damage rendering, messaging, and the temporary HUD tail. The 16-byte envelope gap and downstream register/cleanup schedule are consequences of the adjacent private hud_show_action_response call: January passes its player index in EAX, while the honest source-level candidate pushes a normal stack argument. All unrelated calls remain cdecl and the streams realign at the rasterizer end/temporary-HUD tail. Explicit __fastcall on the private callee was rejected because this compiler emitted a stack argument plus ret 4 and worsened both functions. No ABI shim, naked wrapper, forced convention, assembly, volatile access, optimizer carrier, fake dependency, or nonsensical control flow is retained. Reopen with authoritative January declaration/context evidence or a natural same-compiler mechanism for the private EAX call.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 320,
|
|
"relocation_count": 33,
|
|
"normalized_sha256": "4c1bd54b1e9c6c99e27b86fe5281fca35482e7f2b16be9a9d808a4110b77dffb"
|
|
},
|
|
"base": {
|
|
"size": 304,
|
|
"relocation_count": 33,
|
|
"normalized_sha256": "b1b1215ac7f29cbcd63a6070eb063e95473ffdde8caf4a744719cf62850343f7"
|
|
},
|
|
"objdiff_percent": 94.97959
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_utilities",
|
|
"function": "_bitmap_2d_smooth",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete in-place separable 2D smoothing algorithm in ordinary typed C from January disassembly, relocation and diagnostic evidence, cross-checked against the later HaloCEA implementation. The retained body verifies the 2D bitmap and filter, rejects an oversized filter with the target-proven warning and unused newline vararg, allocates the full pixel-data scratch buffer with the January source line, performs horizontal and vertical toroidal convolution over all four channels with the evidenced binomial normalization, reports allocation failure, and frees the scratch buffer at the target line. January is 1,136 padded bytes and the candidate is 1,120; both have 27 relocations and the report records 79.08777 percent similarity. The fail-closed classifier returns UNKNOWN; the remaining difference is broad C2 frame/register/address scheduling, not missing logic. No forced inline/noinline, barrier, volatile or register forcing, pragma, assembly, fake dependency, undefined behavior, invented helper, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the remaining schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1136,
|
|
"relocation_count": 27,
|
|
"normalized_sha256": "90b742207acc12d7ffc61ded1c7a346f26f7076d550c0011ad2e78990182b4a1"
|
|
},
|
|
"base": {
|
|
"size": 1120,
|
|
"relocation_count": 27,
|
|
"normalized_sha256": "50140a12ed87f6078950e90a3752af637be8fd1a6de063538023c3cac5447871"
|
|
},
|
|
"objdiff_percent": 79.08777
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_utilities",
|
|
"function": "_bitmap_3d_smooth",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete 3D separable smoothing algorithm in ordinary typed C from January disassembly, relocation and diagnostic evidence, cross-checked against the later HaloCEA implementation. The retained body verifies the 3D bitmap and filter, preserves the target's oversized-filter warning and unused newline vararg, allocates the full pixel-data scratch buffer, performs toroidally wrapped X, Y, and Z convolution passes over every channel, copies the full scratch buffer back as January does, reports allocation failure, and frees at source line 0x33E. January is 1,824 padded bytes and the candidate is 1,792; both have 28 relocations and the report records 78.04 percent similarity. The fail-closed classifier returns UNKNOWN; the remaining difference is broad C2 frame/register/address scheduling, not missing logic. No forced inline/noinline, barrier, volatile or register forcing, pragma, assembly, fake dependency, undefined behavior, invented helper, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the remaining schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1824,
|
|
"relocation_count": 28,
|
|
"normalized_sha256": "747a45c66bf64a1173294daa196597534368e72d120f3715e324e42c4fbd717a"
|
|
},
|
|
"base": {
|
|
"size": 1792,
|
|
"relocation_count": 28,
|
|
"normalized_sha256": "dbdbd0bafa0bb62473ea8f137a0d3075e194123bf8705d26834b8f27fea5a5e0"
|
|
},
|
|
"objdiff_percent": 78.04
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_utilities",
|
|
"function": "_bitmap_2d_sharpen",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete toroidally wrapped 3x3 2D sharpen filter in ordinary typed C from January disassembly and table relocations, cross-checked against the later HaloCEA algorithm while retaining January's x86 parameter order. The retained body verifies the bitmap and signed positive/negative lookup tables, skips images smaller than 3x3, allocates a full scratch bitmap, processes each ARGB byte with the positive center term and eight negative neighbor terms using the cseries PIN macro, copies the result back, reports allocation failure, and frees at source line 0x3D1. January is 1,152 padded bytes and the candidate is 1,184; both have 29 relocations and the report records 60.921833 percent similarity. The fail-closed classifier returns UNKNOWN; the remaining difference is broad C2 frame/register/pointer scheduling, not missing logic. The PPC HaloCEA float-last ABI was deliberately not transplanted. No forced inline/noinline, barrier, volatile or register forcing, pragma, assembly, fake dependency, undefined behavior, raw offset, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the remaining schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1152,
|
|
"relocation_count": 29,
|
|
"normalized_sha256": "38d28fa8cc7ad1141ae0e3eeee9cefd225f50d30675345ae64f826e6aa5cf042"
|
|
},
|
|
"base": {
|
|
"size": 1184,
|
|
"relocation_count": 29,
|
|
"normalized_sha256": "8a988645f8b5734c6607564d032d20a39c294dde3a2ba0b5107c766da700dcc2"
|
|
},
|
|
"objdiff_percent": 60.921833
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_utilities",
|
|
"function": "_bitmap_sharpen",
|
|
"class": "csplit-relocation-alias",
|
|
"evidence": "The natural typed dispatcher and lookup-table builder is byte-identical to January after correcting the semantic BSS ownership proved by table construction and use: bitmap_sharpen_negative_table begins at 3260160 and bitmap_sharpen_positive_table at 3260672. Ordinary COFF comparison differs only at two strength-reduced loop relocations because csplit anchors positive_table-2 as negative_table+510 and negative_table-2 as the preceding _bss_0031bed4+42. The fail-closed resolved-address scan proves both pairs resolve respectively to 3260670 and 3260158; all other bytes and all 23 relocations agree. The source retains direct semantic array indexing and MAX/PIN cseries macros rather than introducing an out-of-bounds alias or raw address merely to copy csplit's spelling.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 352,
|
|
"relocation_count": 23,
|
|
"normalized_sha256": "999f3191aca8d9e3ec7721de890a470569586b58b32cd1b8432b2be68fa1f750"
|
|
},
|
|
"base": {
|
|
"size": 352,
|
|
"relocation_count": 23,
|
|
"normalized_sha256": "999f3191aca8d9e3ec7721de890a470569586b58b32cd1b8432b2be68fa1f750"
|
|
},
|
|
"objdiff_percent": 100.0
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_engine",
|
|
"function": "_find_closest_player_index",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete closest-player target search in ordinary typed C from January disassembly and independent HaloCEA source. The retained body iterates the target-proven object sweep, resolves each candidate through unit_get, applies the active-camouflage/requesting-player exception, calls the typed autoaim_compute_target interface owned by aim_assist.h, and retains each qualifying sweep result exactly as January does. The consecutive comparisons of the same squared-distance local against 400.0f and 900.0f are mathematically redundant but evidence-backed rather than a match trick: January emits both loads/comparisons and the independent reconstruction records the same pair. January and the candidate are both 448 padded bytes with 18 relocations, and the report records 94.2638 percent similarity. Their instruction streams remain identical through the final selection tail; January keeps the successful candidate in EAX and schedules the failure assignment separately, while C2's natural source lowering merges the terminal conversions and chooses a different temporary register. Declaration order, initialization placement, and natural equivalent control-flow forms did not alter that tail. No forced inline/noinline, barrier, volatile or register forcing, pragma, assembly, fake dependency, raw object cast, invented address name, or unsupported nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the remaining tail schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 448,
|
|
"relocation_count": 18,
|
|
"normalized_sha256": "4c90ec184c403112ccdd4b254be7841546362efefda25464c37fe8c16c767639"
|
|
},
|
|
"base": {
|
|
"size": 448,
|
|
"relocation_count": 18,
|
|
"normalized_sha256": "542e7ea46ce27458a815781758141536442e685e6172e9bab9c41d0dd26e4e9a"
|
|
},
|
|
"objdiff_percent": 94.2638
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_engine",
|
|
"function": "_game_engine_should_spawn_player",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete multiplayer spawn eligibility decision in ordinary typed C from January disassembly and independent HaloCEA source. The retained body blocks spawning while the game is in a terminal postgame state, asks the active engine whether the player may spawn, applies the target-proven respawn-timer decrement and final countdown sound selection, and reports the remaining delay through the out parameter using semantic game-engine and multiplayer-sound enum constants. January and the candidate are both 256 padded bytes with 9 relocations, and the report records 99.71265 percent similarity. The residual is the target's register choice: January pins integer one in EBX and later compares EAX against EBX, whereas C2's natural lowering uses an immediate/byte form and a different countdown temporary. Equivalent declarations and source-level branch forms did not recover that allocation. No forced inline/noinline, barrier, volatile or register forcing, pragma, assembly, fake dependency, raw numeric enum, invented address name, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the register allocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 256,
|
|
"relocation_count": 9,
|
|
"normalized_sha256": "8259180402f726ea65aa4d62461f38a4138acc21fc1d8fe1c19e9d246b5ff0ef"
|
|
},
|
|
"base": {
|
|
"size": 256,
|
|
"relocation_count": 9,
|
|
"normalized_sha256": "031050d5b5fa8b5697cbd4a43d34c01f3d0d3f7b6cc40ab3856f55f8d6b86142"
|
|
},
|
|
"objdiff_percent": 99.71265
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_engine",
|
|
"function": "_game_engine_get_place",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete place/rank calculation in ordinary typed C from January disassembly, the game-engine callback ABI, and independent HaloCEA source. The retained body queries the active engine with the semantic _get_score_team enum, compares the requested score against every opposing team, tracks tied and all-tied state as booleans, and returns the semantic place flags with the correct rank. January and the candidate are both 368 padded bytes with 12 relocations, and the report records 94.49254 percent similarity. The residual is confined to C2's byte-local allocation and boolean combine: January assigns the two byte locals to the opposite stack slots and emits an early AND through DL/CL, while natural declarations emit TEST or swap those registers; explicitly materializing the same operation grows the function by 16 bytes. The retained boolean bitwise AND is meaningful for normalized boolean values and preserves January's size and relocation shape. No forced inline/noinline, barrier, volatile or register forcing, pragma, assembly, fake dependency, raw numeric score/flag constant, invented address name, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the byte-register allocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 368,
|
|
"relocation_count": 12,
|
|
"normalized_sha256": "91161c382c55b5a853880db9762c078496b19779acec4a23fb5ae6837afd3323"
|
|
},
|
|
"base": {
|
|
"size": 368,
|
|
"relocation_count": 12,
|
|
"normalized_sha256": "bcf2be6ca02eb7a0bbb9ddfbc12fffef603d6e539e68d79ec02aecdaf172f185"
|
|
},
|
|
"objdiff_percent": 94.49254
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_frame_statistics",
|
|
"function": "_eat_my_shorts",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after retaining the ordinary unsigned-word comparator required by the exact dynamic-vertex counter. The semantic private name eat_my_shorts is authenticated by the imported January/Halo CE symbol evidence, and January's jbe branch proves the strict first > second predicate used by qsort_2byte. The source preserves that early-return structure directly: return TRUE when first is greater, otherwise return FALSE. VC7 collapses the natural source to seta and one return in 16 padded bytes, while January preserves two explicit returns in 32 padded bytes; the fail-closed classifier identifies only its R5 control-flow-return-shape signature and grants no match credit. A same-size result-variable spelling was rejected because it changes the source topology solely to steer code generation. No volatile/register forcing, barrier, pragma, assembly, undefined behavior, fake dependency, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural same-compiler context that preserves both source-authentic early exits.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 32,
|
|
"relocation_count": 0,
|
|
"normalized_sha256": "272173574597a002350643c155ed196ad630c283059b477e0743dbf755f77f6e"
|
|
},
|
|
"base": {
|
|
"size": 16,
|
|
"relocation_count": 0,
|
|
"normalized_sha256": "824636ceaea1b9fd752c3bd2d2e627269d300d2dbc33b596caea74e2aeaa9d0c"
|
|
},
|
|
"objdiff_percent": 58.18182
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/rasterizer_frame_statistics",
|
|
"function": "_rasterizer_frame_statistics_count_static_vertices",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after restoring the complete ordinary typed static-vertex counter from January's instruction stream and the target-authenticated triangle_buffer and vertex_buffer layouts. It returns zero for either null buffer or an unsupported type, triangle_buffer->count + 2 for _triangle_buffer_type_precompiled_strip, and vertex_buffer->count for _triangle_buffer_type_triangles. January and the candidate share the 64-byte padded envelope, zero relocations, and the complete semantic branch/value topology; objdiff reports 87.8 percent similarity. The residual is a VC7 callee-save/epilogue schedule: January delays push esi until after the first null test and places an alignment nop between pop esi and pop ebp, while the natural typed source saves ESI before that branch. Combined and nested null guards compile to the same fixed point, and the fail-closed classifier returns UNKNOWN. No forced inline/noinline, volatile/register forcing, barrier, pragma, assembly, fake dependency, raw offset, undefined behavior, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler context that explains the delayed ESI save.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 64,
|
|
"relocation_count": 0,
|
|
"normalized_sha256": "abb0cdbbf190c800ba8155c28e0a784c40db9fd088fd6ff879704b736ecce18c"
|
|
},
|
|
"base": {
|
|
"size": 64,
|
|
"relocation_count": 0,
|
|
"normalized_sha256": "df987f2500b4f059b29f638e8a3c6bc588dbbaf1410573fbac13cff295c3a60d"
|
|
},
|
|
"objdiff_percent": 87.8
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/player_control",
|
|
"function": "_player_control_initialize_for_new_map",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete map-reset body in ordinary typed C from January disassembly and the independent HaloCEA implementation. The retained body clears the four semantic player-control flag fields, iterates MAXIMUM_NUMBER_OF_LOCAL_PLAYERS, obtains the typed player-control constants through TAG_BLOCK_GET_ELEMENT, resets each local unit through player_control_new_unit, and initializes only zero pitch/yaw rates from the tag defaults. January and the candidate are both 144 padded bytes with the same 10 relocation identities; objdiff reports 92.888885 percent similarity. Their instruction streams are exact from +0x0F through the epilogue. The sole residual is the opening schedule: January stores action_test_flags and action_flags before saving EDI, while VC7 hoists the EDI save before those stores and reverses the two independent stores. Ordinary declaration, initialization, nested-scope, direct-member, chained-zero, and reordered natural-C spellings were measured without recovering that schedule. The fail-closed classifier returns UNKNOWN, so no compiler recipe is claimed. No forced inline/noinline, barrier, volatile or register forcing, pragma, assembly, fake dependency, raw offset, invented address name, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the prologue schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 144,
|
|
"relocation_count": 10,
|
|
"normalized_sha256": "adb32edd759e2bbcf07d7c5b87f8a11099d2f03e8e93e465605bcbc3512994e7"
|
|
},
|
|
"base": {
|
|
"size": 144,
|
|
"relocation_count": 10,
|
|
"normalized_sha256": "782be32752d680a0aa319f1f3fe2eec2e01fed6eee342801b2fb2b66e01d9ebd"
|
|
},
|
|
"objdiff_percent": 92.888885
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/player_control",
|
|
"function": "_player_control_modify_desired_angles",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete desired-look update in ordinary typed C from January disassembly, PDB-authenticated private ownership, and the independent HaloCEA implementation. The retained body uses player_control_get, unit_get, unit_definition_get, and TAG_BLOCK_GET_ELEMENT; applies the seat-marker yaw arc, wraps yaw, derives and clamps camera pitch limits, autolevels against typed translational velocity, eases the persistent limits, and applies the requested pitch delta. The source uses real values and cseries PIN/angle helpers; the target-proven 2/pi scalar is expressed as the natural real literal 0.63661975f, eliminating the donor's wrong full-precision relocation. January and the candidate are both 1,584 padded bytes with the same 83 relocation identities; objdiff reports 99.59677 percent similarity. The fail-closed classifier proves independent-instruction-scheduling: the residual is one dependency-free else-arm schedule in which January materializes constants and the frame pointer between a velocity load and its x87 multiply while VC7 emits the multiply first. Six natural declaration/expression shapes were measured without changing that tie. No forced inline/noinline, barrier, volatile or register forcing, pragma, assembly, fake dependency, raw object/tag cast, invented address name, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the remaining schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1584,
|
|
"relocation_count": 83,
|
|
"normalized_sha256": "6e468bddb00f141c0c0018648fc4965e97ac383f6e688247adeab58281c6d4fb"
|
|
},
|
|
"base": {
|
|
"size": 1584,
|
|
"relocation_count": 83,
|
|
"normalized_sha256": "c61e9a2f2f5674737556d0890676ed566e69473ec0fe9f051738a4e9c1560afc"
|
|
},
|
|
"objdiff_percent": 99.59677
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/interface/virtual_keyboard",
|
|
"function": "_virtual_keyboard_select",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete virtual-key selection dispatcher in ordinary typed C from January disassembly and the independent HaloCEA implementation. The retained body handles done/save validation, shift/caps/symbol modes, backspace, cursor motion, space insertion, configurable character insertion, the .fortune easter egg, feedback sounds, and one-shot shift reset through semantic enums and owner-header prototypes. January and the candidate are both 1,088 padded bytes with 123 relocations, and objdiff reports 93.7518 percent similarity. The fail-closed blocker classifier returns UNKNOWN: the remaining differences are distributed source-order, branch-layout, and register-scheduling choices rather than missing behavior, and prior natural HaloCEA adaptation had a worse 1,120-byte envelope. No forced inline/noinline, barrier, volatile/register forcing, pragma, assembly, raw address, invented dependency, fake branch, or nonsensical matching construct is retained. Reopen only for authenticated January source/local records or a natural compatible-compiler donor that explains the residual schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1088,
|
|
"relocation_count": 123,
|
|
"normalized_sha256": "28fa08bf4fb555466006d076f32c672ca72ddd07a165e4c51e1cb54f02a0e141"
|
|
},
|
|
"base": {
|
|
"size": 1088,
|
|
"relocation_count": 123,
|
|
"normalized_sha256": "025bd53f5f2169bb649702adf79e4603dd2a13ac0b5967aca9297e7e983565d9"
|
|
},
|
|
"objdiff_percent": 93.7518
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_engine_king",
|
|
"function": "_find_hill",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete January hill scan in ordinary typed C and checking it against the independent later-Xbox HaloCEA reconstruction. The retained body uses TAG_BLOCK_GET_ELEMENT, cseries real/point types and MIN/MAX macros, expands a single flag into the target-proven four-corner square, computes the convex hull, and derives the semantic king_globals bounds and center. Target and candidate share the 848-byte padded envelope and 35 relocations; objdiff reports 97.94042 percent similarity. Alignment-aware disassembly confines the substantive residual to C2's choice of the z-component rather than the y-component as the induction base for the six-component bounding-box update. The independently corroborated scalar-if form was also compiled and did not improve the exact class. The fail-closed classifier returns UNKNOWN, so the honest class is unclassified rather than an invented compiler recipe. No raw offset, one-use alias, volatile/register forcing, barrier, pragma, assembly, fake dependency, forced inline, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor explaining the component-base selection.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 848,
|
|
"relocation_count": 35,
|
|
"normalized_sha256": "a05fb3507d2417e3408ce6b7c3b810e537c4b60803458e52ca97a42bde4c1bf4"
|
|
},
|
|
"base": {
|
|
"size": 848,
|
|
"relocation_count": 35,
|
|
"normalized_sha256": "3df0c47f4a6bdfebee82d3384005fb9078878ec08e2f383ce175208066a85a01"
|
|
},
|
|
"objdiff_percent": 97.94042
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_engine_king",
|
|
"function": "_king_calculate_hill_state",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete team and free-for-all hill-control state machine in ordinary typed C from January disassembly and independent HaloCEA behavior. The retained function iterates player_data through the normal data iterator, uses the authenticated king_hill_state and multiplayer-sound enums, preserves the previous-controller rule, and updates the control timer without optimizer-only carriers. Target and candidate share the 448-byte padded envelope; target has 32 relocations and the candidate 30, while objdiff reports 81.507355 percent similarity. Fable's bounded experiments covered count declaration scope, local state consolidation, early-return and shared-tail forms; none produced a lawful easy closure, and alignment-aware disassembly still shows broad control-flow and register-allocation differences. The fail-closed classifier returns UNKNOWN, so the honest class is unclassified. No volatile/register forcing, barrier, pragma, assembly, fake dependency, raw datum cast, invented address name, forced inline, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the two missing relocation sites and branch schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 448,
|
|
"relocation_count": 32,
|
|
"normalized_sha256": "9c852f781c6a691a41f7c445091bea59a0738ebd49fd6ec16add6961cedb8817"
|
|
},
|
|
"base": {
|
|
"size": 448,
|
|
"relocation_count": 30,
|
|
"normalized_sha256": "e9d7a30d3245b8ffd0d72b1271a341f0dd5b20ddd94e9029876f4676c5ed9ae3"
|
|
},
|
|
"objdiff_percent": 81.507355
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_engine_race",
|
|
"function": "_race_engine_get_score",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete typed Race score getter from January disassembly and the independent later-Xbox HaloCEA implementation. The retained ordinary C returns the semantic team score for _get_score_team and otherwise combines the player's completed laps with the exact count_bits_32 population count of touched flags. January and the candidate are both 224 padded bytes with four relocations and objdiff reports 84.46 percent similarity. January keeps the lap bit vector in EDX, the lap count in EDI, and the inlined population count in ESI; VC7 selects an equivalent register permutation. Natural assignment-order and direct-expression probes reproduce the permutation, while a scoped bit-vector local prevents the target's helper unroll and shrinks the function to 96 bytes. The fail-closed classifier returns UNKNOWN, so no compiler recipe is claimed. No forced inline/noinline, volatile/register forcing, barrier, pragma, assembly, fake dependency, raw address, undefined behavior, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the inlined-helper register allocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 224,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "d4de45e4555836b0b784b385c6fe1a16eb949a3b107f3a16331d2c300d667db1"
|
|
},
|
|
"base": {
|
|
"size": 224,
|
|
"relocation_count": 4,
|
|
"normalized_sha256": "4f2137667212ade01aa3926e67a3ad0b3d726bec432a345a596e2e03a5948ce8"
|
|
},
|
|
"objdiff_percent": 84.45783
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/game/game_engine_ctf",
|
|
"function": "_ctf_engine_weapon_update",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked under the current house rule after reconstructing the complete CTF objective-weapon tick in ordinary typed C from January disassembly and assertions, the January engine-table role, and the independent HaloCEA implementation. The retained body handles single-flag swapping, unattended connected-flag return, warning and score messaging, carrier discovery, and both world/carrier goal markers through named cseries flags and typed weapon access. January and the candidate both occupy 576 padded bytes and contain the same 40-relocation behavior set; objdiff reports 77.044945 percent similarity. Their remaining differences are broad but coherent compiler choices: January preserves the weapon index in EDI while VC7 selects EBX, lowers the connected-map TEST_FLAG through shr/test instead of test ah, computes the opposite team before the handled-flag branch, and places the carrier/no-carrier goal blocks in the opposite fallthrough order. The fail-closed blocker classifier returns UNKNOWN, so this is honestly unclassified rather than assigned an invented recipe. Fable's bounded W3/W4 block-local team-index, W5 connected-flag local, W6 goal-polarity, Vw2 manual-bitshift, and combined variants did not close the residual and were rejected. No forced inline/noinline, barrier, volatile/register forcing, pragma, assembly, manual replacement for the retained cseries flag macros, raw address, fake dependency, representation pun, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor that explains the whole register/control-flow schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 576,
|
|
"relocation_count": 40,
|
|
"normalized_sha256": "0c8e2649895a583167f4b4c8d53d9d29c7e4c0edbad2488e717d4517ce66d20b"
|
|
},
|
|
"base": {
|
|
"size": 576,
|
|
"relocation_count": 40,
|
|
"normalized_sha256": "ca4f3e8d94db6ebd18708ad5263816b8e2542424d9fcbbe35cbd33701e1f2a56"
|
|
},
|
|
"objdiff_percent": 77.044945
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/ai_communication",
|
|
"function": "_ai_communication_update_speech_timers",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked under the current house rule after restoring the complete typed speech-timer update through its genuine ai_communication_started caller. Independent HCEA source authenticates the semantic ai_communication_update_speech_timers and actor_reset_idle_vocalization_timer names; the retained implementation uses unit_get and actor_get, named speech-priority constants, the typed AI communication globals, and the established dialogue/reply table structures. Target and candidate are both 672 padded bytes with all 43 relocation identities, and objdiff reports 97.76382 percent similarity. The remaining gap is the previously documented C2 register/lifetime schedule: January retains the unit in EDI and time in ESI while the natural candidate selects the inverse allocation, with a small associated two-load ordering tie. Prior bounded declaration, initialization, and expression-order probes did not close it naturally. No register hint, volatile access, barrier, pragma, assembly, fake dependency, false alias, raw offset, forced inline/noinline, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining the register lifetimes.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 672,
|
|
"relocation_count": 43,
|
|
"normalized_sha256": "91999fda75815c6638478824f3efa53ee6717572f365530362cbec00e78a50ac"
|
|
},
|
|
"base": {
|
|
"size": 672,
|
|
"relocation_count": 43,
|
|
"normalized_sha256": "7db4861a5adf519e0457a0ffe785ff4d47e878fda47cc0a06206a529776ac91c"
|
|
},
|
|
"objdiff_percent": 97.76382
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_extract",
|
|
"function": "_bitmaps_extract",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked after reconstructing the complete public bitmap extraction entry point in ordinary typed C from January's instruction, relocation, assertion, and cleanup topology, cross-checked against independent later Halo sources. The retained body validates the group, allocates and decompresses the imported plate, dispatches sequence and group-type extraction, reports January's target-proven double error on allocation failure, and releases temporary state. The 720-byte candidate versus 736-byte target and 66 versus 68 relocations reflect cold cleanup layout and still-unwritten private callees; bounded natural control-flow variants did not expose a semantic defect. No register forcing, volatile carrier, pragma, assembly, fake dependency, invented branch, or undefined behavior is retained. Reopen for authoritative January source/local records or when the remaining private extraction callees are reconstructed naturally.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 736,
|
|
"relocation_count": 68,
|
|
"normalized_sha256": "537d98f8a8adf6da9a4651ec215d5cf13225263ecefe5cb3562c8e932eb718ed"
|
|
},
|
|
"base": {
|
|
"size": 720,
|
|
"relocation_count": 66,
|
|
"normalized_sha256": "51cadcd34bfde4712f54de3e6857f3ca096f6b623352a90454c4ae53c260e337"
|
|
},
|
|
"objdiff_percent": 76.950676
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_extract",
|
|
"function": "_extract_warn_about_horizontal_border",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked after recovering the target-proven horizontal-border warning loop in natural typed C. Target and candidate share the 128-byte envelope and all nine relocation identities; objdiff reports 99.48718 percent similarity. Four normalized bytes differ only because VC7 selects different temporary registers for two vararg integer extensions. Natural declaration and expression shapes did not reveal missing behavior. No register hint, volatile access, barrier, pragma, inline assembly, fake dependency, or nonsensical control flow is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining the temporary-register choice.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 128,
|
|
"relocation_count": 9,
|
|
"normalized_sha256": "12713fbd52519b45853b962d44c886bc14bc020e2b80b044cfe0bc174fdeb8db"
|
|
},
|
|
"base": {
|
|
"size": 128,
|
|
"relocation_count": 9,
|
|
"normalized_sha256": "17f7087e59c4a476db19d9896873393f95f891dd2997971eb2d4946439c3f6bc"
|
|
},
|
|
"objdiff_percent": 99.48718
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/bitmaps/bitmap_extract",
|
|
"function": "_extract_bitmap",
|
|
"class": "private-register-convention",
|
|
"evidence": "Fuzzy-parked after reconstructing the complete private bitmap extractor from January's control-flow, relocations, assertions, marker rules, and independent later-source semantics. The retained typed body covers bounds, registration points, marker filtering, alpha and DXT1 color-key warnings, interface-format validation, pending entries, sprites, plateless cubes, and direct bitmaps. Candidate and target have all 66 relocations; the candidate is 1,152 padded bytes versus 1,168. The remaining gap is C2 register/cold-block allocation and the unresolved private extract_add_bitmap call: January uses a TU-private EAX convention that cannot arise from an undefined ordinary declaration. No calling-convention lie, register forcing, volatile carrier, pragma, fake wrapper, assembly, or undefined behavior is retained. Reopen when extract_add_bitmap is naturally reconstructed in this TU or authoritative January source/local records appear.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 1168,
|
|
"relocation_count": 66,
|
|
"normalized_sha256": "051e1fae474dc6acd83587572aebfa8a0a9b8ab20dfafed770583e6ad046469c"
|
|
},
|
|
"base": {
|
|
"size": 1152,
|
|
"relocation_count": 66,
|
|
"normalized_sha256": "feaf057bd40ae57be6e00fd6b992917f505b252e13ee90219ae693a6be9a26ed"
|
|
},
|
|
"objdiff_percent": 80.3984
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/xbox/rasterizer_xbox_environment",
|
|
"function": "__rasterizer_environment_diffuse_light_begin",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked after reconstructing the full diffuse-light setup in ordinary typed C from January disassembly and Halo/Xbox renderer evidence. Target and candidate both occupy 928 padded bytes with all 58 relocation identities; objdiff reports 99.89695 percent similarity. The remaining normalized difference is C2's assignment of three coherent local basis vectors to different stack slots. Bounded declaration-scope and vector-shape probes did not produce a natural closure. No volatile or register steering, barrier, pragma, assembly, raw offset, fake dependency, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural compatible-compiler donor explaining those stack lifetimes.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 928,
|
|
"relocation_count": 58,
|
|
"normalized_sha256": "96f42a578f493250f9fb27beb69c6e4bbd03472de63c1e81e039ec7723dbfcf7"
|
|
},
|
|
"base": {
|
|
"size": 928,
|
|
"relocation_count": 58,
|
|
"normalized_sha256": "6b3b2693e14dabc8837d8ae5f0c01d349f16ed4f347f60a7be6d226baee60252"
|
|
},
|
|
"objdiff_percent": 99.89695
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/rasterizer/xbox/rasterizer_xbox_environment",
|
|
"function": "_rasterizer_environment_specular_spot_light_begin",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked after retaining the complete HCEA-backed spot-light vector and cross-product implementation in ordinary C. January is 960 padded bytes and the candidate 944, with all 64 relocations shared and objdiff at 82.64557 percent. The remaining difference is compiler vector/local allocation and scheduling, not absent renderer behavior; bounded helper and declaration-shape probes did not close it. The source uses project real/vector types and existing math helpers and preserves the January inline schedule without emitting point_from_line3d. No forced inline/noinline, volatile steering, barrier, pragma, assembly, fake arithmetic, raw address, or undefined behavior is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor that explains the vector lifetime schedule.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 960,
|
|
"relocation_count": 64,
|
|
"normalized_sha256": "e0331f6b94a74f9c4b4cc2fbed6d8a0cf3d0e3b8d65c487daeac0b7a0e4ab7af"
|
|
},
|
|
"base": {
|
|
"size": 944,
|
|
"relocation_count": 64,
|
|
"normalized_sha256": "2a707c5cccc4f0c2d87cf05ca1a6b07fcb1f9bae48ee0271f2043aa4ae01f5a9"
|
|
},
|
|
"objdiff_percent": 82.64557
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actors",
|
|
"function": "_actor_swarm_attach_unit",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked after reconstructing the complete typed swarm attachment path from January's instruction, relocation, assertion, and error topology. The retained ordinary C creates the optional swarm component, detaches prior actor ownership, links the unit into the doubly-linked swarm list, initializes the component cache, inherits encounter/team ownership, controls activation, and marks the unit actively controlled. Target and candidate share the 656-byte padded envelope and all 43 relocation identities; objdiff reports 94.25247 percent similarity. Bounded declaration and branch forms leave a VC7 register/scheduling tie. No register hint, volatile access, barrier, pragma, forced inline, assembly, raw offset, fake dependency, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining the remaining allocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 656,
|
|
"relocation_count": 43,
|
|
"normalized_sha256": "d3153578bbc9c66ae43435a4b417c54675d0925fdffaa3501f03c90011b171e9"
|
|
},
|
|
"base": {
|
|
"size": 656,
|
|
"relocation_count": 43,
|
|
"normalized_sha256": "6eeef871c34cb94714939d7af4e52d1d8c91b7a74ddc5830a84e4b3b6fbefdc6"
|
|
},
|
|
"objdiff_percent": 94.25247
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actors",
|
|
"function": "_actor_customize_unit",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked after reconstructing the complete typed actor-variant customization path from January disassembly and independent HCEA behavior. The retained ordinary C applies vitality overrides, forced shader permutations, tag-block change colors, default weapon replacement, grenade inventory, validated powerup equipment, and active/super camouflage. It uses semantic actor-variant flags, typed tag/object accessors, and January's exact equipment diagnostic. Target is 640 padded bytes and the candidate 672, with all 26 relocation identities preserved; objdiff reports 65.71359 percent. Straightforward condition, declaration, and lifetime forms did not isolate a missing behavior, so the fail-closed class remains unclassified. No false field, register or volatile steering, barrier, pragma, assembly, forced inline, fake dependency, or undefined behavior is retained. Reopen for authoritative January source/local records or a natural same-compiler donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 640,
|
|
"relocation_count": 26,
|
|
"normalized_sha256": "940083a9f9c438a46008f10ccd707110659c75bfabdc759f04b3ac94dde73f6d"
|
|
},
|
|
"base": {
|
|
"size": 672,
|
|
"relocation_count": 26,
|
|
"normalized_sha256": "0a9c42b8a04f30f959817cd50c482b9c1b88524b16e36dd8cff695ce3202d759"
|
|
},
|
|
"objdiff_percent": 65.71359
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actors",
|
|
"function": "_actor_create_for_unit",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked after reconstructing actor creation and attachment in complete typed ordinary C. The function validates individual bipeds, reuses a compatible swarm actor, allocates and attaches new actors to encounters or the encounterless pool, initializes brain/default/command-list state, validates swarm type compatibility with January's exact diagnostic, attaches the unit, and verifies activation. Target and candidate share the 624-byte padded envelope and all 29 relocation identities; objdiff reports 93.40611 percent. Nearly the entire body is instruction-identical after the prologue; the residual is VC7 callee-saved register allocation and shrink wrapping around the early exits. Plausible declaration, comparison, and outer-block forms did not close it naturally. No register hint, volatile access, barrier, pragma, assembly, forced inline, fake dependency, or false alias is retained. Reopen only for authoritative January source/local records or a natural same-compiler allocation donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 624,
|
|
"relocation_count": 29,
|
|
"normalized_sha256": "c57ee9f93e814f9fea670c9d0dbecc8f169bca56e8927152831246b0937c49f4"
|
|
},
|
|
"base": {
|
|
"size": 624,
|
|
"relocation_count": 29,
|
|
"normalized_sha256": "2671b840674c236181fee91624f136dfc81e1798a2789e58af203aee9e0cd7e6"
|
|
},
|
|
"objdiff_percent": 93.40611
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actors",
|
|
"function": "_actors_spawn_from_unit",
|
|
"class": "instruction-scheduling",
|
|
"evidence": "Fuzzy-parked after reconstructing the full typed spawn loop from January disassembly and independent HCEA semantics. The retained ordinary C inherits encounter/squad ownership, resolves actor tags through subsystem macros, creates each unit at the source origin with randomized facing and offset, settles bipeds, customizes and creates actors, emits January's exact failure warning and cleanup, verifies activation, and applies the randomized outward launch. Target and candidate share the 672-byte padded envelope and all 29 relocation identities. Objdiff reports 54.82266 percent because an early register-allocation shift makes its index-aligned score pessimistic; the major call, constant, placement, cleanup, activation, launch, and loop topology remains aligned. Bounded early-return, single-exit, loop, declaration, and vector-expression forms only traded VC7 callee-save/register and x87-stack schedules. No register hint, volatile access, barrier, pragma, forced inline, assembly, raw offset, fake dependency, or nonsensical control flow is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining those schedules.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 672,
|
|
"relocation_count": 29,
|
|
"normalized_sha256": "38d0b2f1fcd5109d57fab7a261e7d8abe3bf5d4b8c1d44e26feccf0941ded7e1"
|
|
},
|
|
"base": {
|
|
"size": 672,
|
|
"relocation_count": 29,
|
|
"normalized_sha256": "8c163f7b091727361868c65de3aaf62f4e8b4ac9d495435b3e00f45adeb68eba"
|
|
},
|
|
"objdiff_percent": 54.82266
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actors",
|
|
"function": "_actor_place",
|
|
"class": "register-allocation",
|
|
"evidence": "Fuzzy-parked after reconstructing the complete typed actor-placement path from January disassembly and independent HCEA behavior. The retained ordinary C validates and optionally upgrades the actor variant, builds the unit placement, reports January's exact unit/actor creation diagnostics, reads squad starting state, customizes and creates the actor, cleans up on failure, and verifies activation. Target is 800 padded bytes and the candidate 816, with all 41 relocation identities preserved; objdiff reports 90.887215 percent similarity. The common prefix and call topology are close, while the residual begins with VC7's choice of callee-saved registers and a four-byte frame-size difference. Bounded natural declaration-lifetime, branch, and local-placement forms did not close that allocation tie. No register hint, volatile access, barrier, pragma, forced inline, assembly, raw offset, fake dependency, or nonsensical branch is retained. Reopen only for authoritative January source/local records or a natural same-compiler donor explaining the remaining allocation.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 800,
|
|
"relocation_count": 41,
|
|
"normalized_sha256": "a4258acc637a3ae90493b151b147e75fea1243d941bcc699f9ec7463542ec5fb"
|
|
},
|
|
"base": {
|
|
"size": 816,
|
|
"relocation_count": 41,
|
|
"normalized_sha256": "ff120b98736b6eb6c41f5c41c8c5e33f6a4e15a5179d42a938b8c320f1ec6a2f"
|
|
},
|
|
"objdiff_percent": 90.887215
|
|
}
|
|
},
|
|
{
|
|
"unit": "source/ai/actors",
|
|
"function": "_actor_input_update",
|
|
"class": "unclassified",
|
|
"evidence": "Fuzzy-parked after reconstructing the full typed actor-input refresh from January disassembly, January relocation/assert/string topology, independent HCEA behavior, and the recovered Claude draft as secondary evidence. The retained ordinary C updates swarm centers and members, samples individual or parent-vehicle state, handles vehicle roles and encounter migration, diagnoses flying/3D-position mismatches, scans attached melee/projectile threats, refreshes biped path state and orientation vectors, validates every resulting normal, and records vitality. Target is 2384 padded bytes and the candidate 2400, with all 89 relocation identities preserved; objdiff reports 94.84425 percent similarity. The residual spans several VC7 allocation and instruction-scheduling choices rather than one isolated source construct, so it remains fail-closed as unclassified. Bounded natural condition, declaration-lifetime, encounter-migration, and vector-expression forms did not close it; an earlier equal-size form was rejected because it expressed January's behavior less faithfully. No register hint, volatile access, barrier, pragma, forced inline, assembly, raw offset, fake dependency, or nonsensical control flow is retained. Reopen for authoritative January source/local records or a natural same-compiler donor.",
|
|
"measurements": {
|
|
"target": {
|
|
"size": 2384,
|
|
"relocation_count": 89,
|
|
"normalized_sha256": "bf2e87448623ee925aa42e94ee93f1e1ebc439fd58971dba93e1a2b993c0d9b8"
|
|
},
|
|
"base": {
|
|
"size": 2400,
|
|
"relocation_count": 89,
|
|
"normalized_sha256": "7820324643af007011e488b773988db634efcf67378be6c4a78ff5ee20a1bb54"
|
|
},
|
|
"objdiff_percent": 94.84425
|
|
}
|
|
}
|
|
]
|
|
}
|