qvm: pre-firing return chains

docs/ASSET_PIPELINE_TODO.md

@@ -427,3 +427,6 @@ Research progress: RE-578 [report](research/QVM_RELOAD_COMPLETE.md); remaining n
 
 
 Research progress: RE-579 [report](research/QVM_WEAPON_PHASES.md); remaining native/content/runtime/platform scope stays open.
+
+
+Research progress: RE-580 [report](research/QVM_WEAPON_RETURN_CHAINS.md); remaining native/content/runtime/platform scope stays open.

docs/FINDINGS.md

@@ -785,3 +785,6 @@ Bounded qagame paths recover bomb-plant/inactivity correction requests, direct f
 
 
 **RE-579 — Weapon lowering raising and frame gates:** 51633..51801 completes state2 via49028, resets state1 to0 and selects a separate class-based torso table, then gates other states on FRAME232 and FRAME36 before firing entry51802. [Evidence](research/QVM_WEAPON_PHASES.md).
+
+
+**RE-580 — Pre-firing weapon return chains and actual main suffix handoff:** Recovered50746 branches now compose through51801, preserving the pre-switch mode local; actual53046 returns resume main torso/locomotion/water calls while51802 paths keep the caller suspended. [Evidence](research/QVM_WEAPON_RETURN_CHAINS.md).

docs/PROVISIONAL_TODO.md

@@ -741,3 +741,8 @@ Research progress: RE-578 [report](research/QVM_RELOAD_COMPLETE.md); remaining n
 
 
 Research progress: RE-579 [report](research/QVM_WEAPON_PHASES.md); remaining native/content/runtime/platform scope stays open.
+
+The [RE-571–580 weapon batch](research/QVM_WEAPON_BATCH.md) closes bounded lookup, selection/completion, helper50525 and pre-firing return branches. Its next ten tasks prioritize51802+ firing/availability and complete main/reference validation. Rust/Bevy/Solari macOS/Linux runtime, native/content/rendering and whole-game scope remain open.
+
+
+Research progress: RE-580 [report](research/QVM_WEAPON_RETURN_CHAINS.md); remaining native/content/runtime/platform scope stays open.

docs/RESEARCH_LEDGER.md

@@ -591,3 +591,10 @@ Actual54444 reload/interaction order exposes timer interference before the weapo
 ## 2026-10-20 — RE-579 Weapon lowering raising and frame gates (separate task commit)
 
 51633..51801 completes state2 via49028, resets state1 to0 and selects a separate class-based torso table, then gates other states on FRAME232 and FRAME36 before firing entry51802. 87 fixtures independently check completion fallback and state handoff, all classes−1..8, button priority, animation timer/type guards and both frame gates. Full suite: 835 tests pass. Report regenerates byte-identically (796730 bytes). Storage/filter, links and whitespace checks pass. No assets/Rust runtime/shared VM evaluator changed; native/reference/legal/full platform scope remains open.
+
+
+## 2026-10-20 — RE-580 Pre-firing weapon return chains and actual main suffix handoff (separate task commit)
+
+Recovered50746 branches now compose through51801, preserving the pre-switch mode local; actual53046 returns resume main torso/locomotion/water calls while51802 paths keep the caller suspended. 16 independent source-order scenarios check every reload/interaction/prefix/selection/guard/ready/ammo/phase handoff, full final state, suspension versus resume and old-mode-local preservation. Full suite: 839 tests pass. Report regenerates byte-identically (1198369 bytes). Storage/filter, links and whitespace checks pass. No assets/Rust runtime/shared VM evaluator changed; native/reference/legal/full platform scope remains open.
+
+RE-580 additional regression: all19 reports from RE-560–569 and RE-571–579 regenerate byte-identically after the explicit-byte-input and optional caller-memory/local-preservation additions. The new composition keeps the parent suspended at51802 rather than assuming a firing-body return.

docs/REVERSE_ENGINEERING_TODO.md

@@ -750,7 +750,7 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 - [x] RE-568 Complete locomotion gait bob and footstep consumer ([report](research/QVM_LOCOMOTION.md)).
 
-- [ ] RE-570 Recover48798/49028 weapon selection/completion,50525 helper and50872..53045 firing/reload continuation; connect availability/resource writers and main final vector snap. Validate full source-order ticks against original execution before claiming runtime parity. Map numeric animation/audio IDs to assets and continue Rust/Bevy/Solari macOS/Linux implementation. See [consumer batch scope and next work](research/QVM_CONSUMER_BATCH.md).
+- [ ] RE-570 Partially closed by RE-571–580:48798/49028 selection/completion,50525 and pre-firing continuation through51801 are recovered. Remaining51802..53045 firing/availability, resource writers, main final vector snap, original reference ticks, asset-ID mapping and Rust/Bevy/Solari macOS/Linux runtime stay open. See [weapon batch](research/QVM_WEAPON_BATCH.md).
 
 
 - [x] RE-569 Main request and independently bounded animation consumer chains ([report](research/QVM_MAIN_CONSUMERS.md)).
@@ -781,3 +781,9 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-579 Weapon lowering raising and frame gates ([report](research/QVM_WEAPON_PHASES.md)).
+
+
+- [ ] RE-581 Recover51802+ charge/hold/release, availability failure, ammunition decrement and remaining firing children; finish50746 and main final native snap before full-tick composition. Validate legal multi-tick behavior against original execution and continue full native/content/rendering/platform implementation. See the [next ten tasks](research/QVM_WEAPON_BATCH.md#next-ten-concrete-tasks).
+
+
+- [x] RE-580 Pre-firing weapon return chains and actual main suffix handoff ([report](research/QVM_WEAPON_RETURN_CHAINS.md)).

docs/research/QVM_CONSUMER_BATCH.md

@@ -44,3 +44,5 @@ RE-569 does **not** complete a main tick. It evaluates54444..54451 (reload and i
 8. Map numeric animation and event IDs to actual skeletal/audio assets, preserving variants and provenance.
 9. Continue native/DLL/network/protocol/rendering/material and whole-content coverage from the broader todo-list.
 10. Establish the first Rust/Bevy/Solari runtime slice and macOS/Linux validation; these bounded research tasks do not count as a playable game or platform completion.
+
+The subsequent [RE-571–580 weapon batch](QVM_WEAPON_BATCH.md) recovers selection/completion and pre-firing continuation through51801, including actual early-return main handoffs. The missing-body boundary above describes this earlier batch; the new report records the narrower remaining51802+ scope.

docs/research/QVM_WEAPON_BATCH.md

@@ -0,0 +1,48 @@
+# Weapon-state research batch: RE-571–580
+
+Ten separately committed tasks extend the previous [consumer batch](QVM_CONSUMER_BATCH.md). They recover weapon lookup, selection, transition completion, a native-query contract and the pre-firing50746 branches through51801. Source identity, bounded instruction traces, independent state oracles and synthetic/native response limits accompany each report.
+
+| Task | Recovered scope | Evidence |
+| --- | --- | --- |
+| RE-571 | Complete31691 first16-slot weapon lookup | [Lookup](QVM_WEAPON_LOOKUP.md) |
+| RE-572 | Complete48798 selection request and transition effects | [Selection](QVM_WEAPON_SELECT.md) |
+| RE-573 | Complete49028 selected/fallback lookup and raising transition | [Completion](QVM_WEAPON_COMPLETE.md) |
+| RE-574 | Complete50525 ordered input gates and native trace/event contract | [Special query](QVM_SPECIAL_QUERY.md) |
+| RE-575 | Actual50746 prefix through selection handoff50922 | [Caller](QVM_WEAPON_SELECTION_CALLER.md) |
+| RE-576 |50923..51206 guards, timer floors and state512 cancellation | [Guards](QVM_WEAPON_GUARDS.md) |
+| RE-577 |51207..51364 ID27 refill, cadence and interaction re-entry | [Ready consumer](QVM_WEAPON_READY.md) |
+| RE-578 |51365..51632 ammo transfer and actual reload re-entry | [Reload completion](QVM_RELOAD_COMPLETE.md) |
+| RE-579 |51633..51801 lowering/raising completion and frame gates | [Phases](QVM_WEAPON_PHASES.md) |
+| RE-580 | Source-ordered pre-firing weapon paths and main suffix resumed only after actual return | [Return chains](QVM_WEAPON_RETURN_CHAINS.md) |
+
+## Findings that affect the port
+
+- Weapon lookup and item lookup use different16-slot arrays, at PS312 and PS376 respectively. Weapon records match low-byte ID to the full requested argument.
+- Selection starts state2 and does not change the active slot. Completion changes the slot, sets state1 and adds250 to the timer. Missing command ID falls back to1; a missing fallback is not checked before storing−1. Checked Rust handling requires an explicit policy backed by runtime evidence.
+- Two continuation guards literally assign localID12 on fallback branches. The shipped instruction behavior is documented without guessing intended C logic.
+- Incremental reload adds one modulo256 to the magazine; replacement reload writes configured capacity. Both subtract one modulo256 from reserve. The reserve unit is not established by that arithmetic alone.
+- Reload completion clears its flag before calling reload request with argument0. Held input can restart a reload under the actual child gates, without the extra reload timer component.
+- Phase completion uses a different torso table from idle selection: class4 always requests72 here, with no tag22 exception.
+- The parent keeps the mode local decoded before49327 even if packed mode changes afterward. Composition must preserve the local instead of reconstructing it from the new packed word. An explicitly supplied zero switch timer lets a fixture reach this otherwise gated boundary.
+- Helper50525 consumes trace reply contents+48 and event parameter+52, but native geometry and the gameplay identity of that parameter remain unverified.
+
+## Integration boundary
+
+RE-580 executes54444..54451 reload/interaction, then composes50747..51801 in the same parent local frame. Paths reaching the actual void epilogue53046 can resume54455..54463 torso/locomotion/water consumers. Paths reaching51802 keep the parent suspended. This replaces the previous blanket weapon-prefix gap for the recovered return paths; it does not invent a return from the still-unrecovered firing body.
+
+The void epilogue/parent POP are explicit source boundary bridges; this is not a full VM interpreter. Earlier main setup, clock, timer, movement and environment effects are supplied rather than composed here. The final native vector snap54471 is omitted. Successive standalone calls are not claimed as complete game ticks. Native trace records and animation durations remain supplied fixtures. No original game executable or native library runs, and no Rust gameplay/rendering/platform work is counted as completed by this batch.
+
+The baseline799 tests gains40 independent checks. Every report is reproducible below the2MiB normal-Git cap. The asset filters remain in force and originals remain outside normal Git.
+
+## Next ten concrete tasks
+
+1. Recover51802..52084 mode-flag8 charge/hold/release and cancellation, including50309 availability handoff and requested-weapon exceptions.
+2. Recover52085..52153 state/availability failure, ID27 exception, event29 and timer+500.
+3. Recover52154+ ammunition decrement and mode-flag4 exception, retaining packed ID/mode/reserve and byte boundaries.
+4. Partition the remaining52253..53045 firing branches by return/callee boundaries and inventory every child/native request before interpreting them.
+5. Recover mode delays, burst counters and state writes after firing without presuming projectile/hitscan outcomes.
+6. Recover remaining firing-event parameters, recoil/spread/aim effects and native ABI consumers; compare legal configuration writers with initialized image records.
+7. Compose complete50746 calls only when all reached firing children are recovered; add real multi-tick selection/reload/firing scenarios with actual timer/environment consumers.
+8. Recover final main native vector snapping54471 and compose the complete main tick, preserving byte inputs, locals and all event/animation order.
+9. Capture original-execution references and collision-consistent responses; map numeric weapon/animation/event identities to actual assets and validate legal input domains.
+10. Continue the broader native/DLL/protocol/rendering/content work and first Rust/Bevy/Solari runtime slice on macOS/Linux. Bounded research coverage is not playable-game completion.

docs/research/QVM_WEAPON_RETURN_CHAINS.md

@@ -0,0 +1,11 @@
+# Pre-firing weapon return chains and actual main suffix handoff
+
+RE-580. Reproduce with `python3 scripts/analyze_qvm_weapon_return_chains.py`; check with `python3 scripts/test_qvm_weapon_return_chains.py`. The [machine report](qvm-weapon-return-chains.json) retains source identity and bounded fixtures.
+
+The pre-firing composer starts with actual50747 prefix/selection, then carries the same parent locals through50923 guards,51207 ready handling,51365 reload completion and51633 phase completion. It stops only at51802 or the actual void epilogue53046. Ready handling can opt into preserving existing locals; defaults for standalone reports remain unchanged. A synthetic zero switch timer fixture proves that local mode1 survives when packed mode becomes0. Reconstructing locals from packed state would change source behavior.
+
+Actual main54444..54451 first runs reload(argument1) and interaction. Its resulting state feeds this weapon composer. Only proven53046 returns bridge the source void epilogue/POP and resume54455..54463 torso/locomotion/water consumers. Paths reaching51802 do not resume.16 scenarios cover lowering wait/completion, raising, reload and held reload, action re-entry, early flags/death, frame gate, ID27, mode switching and a new selection request. Exact state is compared at every child and stage boundary.
+
+The earlier animation-chain helper now optionally returns its memory for actual handoff; default reports are unchanged. This is still a bounded staged interpretation: no51802..53045 firing body, final native snap54471, earlier main setup/clock/timer/environment/movement or original execution is composed. Therefore no full tick/gameplay claim is made. See the [ten-task batch and next work](QVM_WEAPON_BATCH.md).
+
+No original executable/full QVM/native collision/physics/rendering executes. Native responses and legal input domains are supplied or unverified where stated; full runtime/macOS/Linux Rust/Bevy/Solari gameplay remains open.

docs/research/README.md

@@ -342,3 +342,8 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-579: Weapon lowering raising and frame gates](QVM_WEAPON_PHASES.md). Reproduce with `python3 scripts/analyze_qvm_weapon_phases.py`; check with `python3 scripts/test_qvm_weapon_phases.py`.
+
+[RE-571–580 weapon batch and next ten tasks](QVM_WEAPON_BATCH.md): source-ordered transition/reload return paths and the explicit remaining firing/main boundary.
+
+
+[RE-580: Pre-firing weapon return chains and actual main suffix handoff](QVM_WEAPON_RETURN_CHAINS.md). Reproduce with `python3 scripts/analyze_qvm_weapon_return_chains.py`; check with `python3 scripts/test_qvm_weapon_return_chains.py`.

scripts/analyze_qvm_main_consumers.py

@@ -23,13 +23,14 @@ def entry_chain(ins,m,contents,cmd=(0,0,0)):
     m,w=weapon_prefix(ins,m,c)
     return {'initial':initial,'main_execution':r,'before_weapon':before,'weapon_prefix':w,'final':state(m),'main_stopped_before':54452,'pending_call_instruction':54453,'parent_resumed':False}
 
-def animation_chain(ins,m,cmd):
+def animation_chain(ins,m,cmd,return_memory=False):
     initial=state(m)
     def child(fn):
         def apply(i,m,a,c):m,r=fn(i,m,c);return m,c,0,r
         return apply
     m,c,r=execute(ins,54455,54464,m,cmd,LOCAL+0x1000,{49117:child(torso),47884:child(locomotion),48716:child(water_events)})
-    return {'initial':initial,'supplied_post_weapon_state':True,'execution':r,'final':state(m),'stop_before':54464}
+    report={'initial':initial,'supplied_post_weapon_state':True,'execution':r,'final':state(m),'stop_before':54464}
+    return (m,report) if return_memory else report
 
 def main():
     q,raw,h,ins=source();entries=[];animations=[]

scripts/analyze_qvm_weapon_ready.py

@@ -9,11 +9,13 @@ from analyze_qvm_interaction_request import interaction
 from analyze_qvm_acceleration import PS,FRAME
 from analyze_qvm import write_json
 
-def ready(ins,m,cmd=(0,0,0),contents=33554432):
-    initial=weapon_state(m);ident=initial['packed']&255;mode=(initial['packed']>>16)&255;m[LOCAL+12]=ident;m[LOCAL+16]=mode;cfg={'capacity':m[4052+432*ident],'mode_flags':m[4244+432*ident+52*mode+4]}
+def ready(ins,m,cmd=(0,0,0),contents=33554432,preserve_locals=False):
+    initial=weapon_state(m)
+    if not preserve_locals:m[LOCAL+12]=initial['packed']&255;m[LOCAL+16]=(initial['packed']>>16)&255
+    ident=m[LOCAL+12];mode=m[LOCAL+16];cfg={'capacity':m[4052+432*ident],'mode_flags':m[4244+432*ident+52*mode+4]}
     def action(i,m,a,c):m,r=interaction(i,m,contents,c);return m,c,0,r
     m,c,r=execute(ins,51207,53046,m,cmd,LOCAL,{49918:action},boundaries=[51365])
-    return m,{'initial':initial,'buttons':m[FRAME+20],'config':cfg,'contents':contents,'execution':r,'final':weapon_state(m)}
+    return m,{**({'preserved_parent_locals':{'id':ident,'mode':mode}} if preserve_locals else {}),'initial':initial,'buttons':m[FRAME+20],'config':cfg,'contents':contents,'execution':r,'final':weapon_state(m)}
 
 def main():
     q,raw,h,ins=source();rows=[]

scripts/analyze_qvm_weapon_return_chains.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Source-ordered pre-fire weapon paths and main suffix only after real returns."""
+from pathlib import Path
+from qvm_research_support import source,execute
+from qvm_weapon_support import weapon_seed,weapon_state
+from analyze_qvm_weapon_selection_caller import selection_caller
+from analyze_qvm_weapon_guards import guards
+from analyze_qvm_weapon_ready import ready
+from analyze_qvm_reload_complete import reload_complete
+from analyze_qvm_weapon_phases import phases
+from analyze_qvm_reload_request import reload
+from analyze_qvm_interaction_request import interaction
+from analyze_qvm_main_consumers import animation_chain
+from analyze_qvm_acceleration import PS,FRAME
+from analyze_qvm import write_json
+LOCAL=0x77000000
+
+def pre_fire(ins,m,cmd=(0,0,0),contents=33554432):
+    initial=weapon_state(m);m,r=selection_caller(ins,m,cmd);stages=[{'name':'selection','probe':r}];stop=r['stop']
+    for name,at,fn in [('guards',50923,guards),('ready',51207,lambda i,m,c:ready(i,m,c,contents,preserve_locals=True)),('reload',51365,reload_complete),('phases',51633,phases)]:
+        if stop!=at:break
+        m,r=fn(ins,m,cmd);stages.append({'name':name,'probe':r});stop=r['execution']['stop']
+    assert stop in [51802,53046]
+    return m,{'initial':initial,'stages':stages,'stop':stop,'returned':stop==53046,'final':weapon_state(m)}
+
+def main_chain(ins,m,cmd=(0,0,0),contents=33554432):
+    initial=weapon_state(m)
+    def reload_child(i,m,a,c):m,r=reload(i,m,a[8],c);return m,c,0,r
+    def interaction_child(i,m,a,c):m,r=interaction(i,m,contents,c);return m,c,0,r
+    m,c,entry=execute(ins,54444,54452,m,cmd,LOCAL,{49652:reload_child,49918:interaction_child});before=weapon_state(m)
+    assert ins[54452]['operand']==50746 and ins[54453]['opcode']=='CALL'
+    m,w=pre_fire(ins,m,c,contents);tail=None
+    if w['returned']:
+        m,tail=animation_chain(ins,m,c,return_memory=True)
+        tail['supplied_post_weapon_state']=False;tail['resumed_after_actual_return']=True
+    return {'initial':initial,'entry_execution':entry,'before_weapon':before,'weapon':w,'tail':tail,'final':weapon_state(m),'main_stop':54464 if tail else 54453}
+
+def main():
+    q,raw,h,ins=source();rows=[]
+    cases=[('ready',{}),('lowering-wait',{PS+148:2,PS+44:200}),('lowering-complete',{PS+148:2,PS+44:16}),('raising-complete',{PS+148:1,PS+44:16}),('reload-complete',{PS+220:8,PS+44:16}),('held-reload',{PS+220:8,PS+44:16,FRAME+20:32}),('action-reentry',{PS+220:1,FRAME+20:64}),('blocked-action',{PS+220:512|128}),('disabled',{PS+12:256}),('dead',{PS+208:0}),('special-mode',{PS+220:1024}),('frame-gate',{FRAME+232:1}),('id27',{PS+312:27|(1<<8),FRAME+24:27}),('mode-local',{PS+312:1|(1<<8)|(1<<16),FRAME+24:1,4244+432+12:0}),('incremental-reload',{PS+312:1|(1<<8)|(3<<24),PS+220:8,PS+44:16,FRAME+20:32,FRAME+24:1,4028+432:16}),('new-request',{PS+312:1|(2<<8),FRAME+24:22})]
+    for name,changes in cases:
+        m=weapon_seed(raw,h,desired=22);m.update({PS+312:22|(2<<8)|(3<<24),PS+316:1,PS+320:22|(5<<8)|(3<<24),FRAME+20:0,PS+68:8,FRAME+212:3,35024028:0,35023932:16,FRAME+36:0});m.update(changes);p=main_chain(ins,m);p['name']=name;p['supplied_changes']={str(k):v for k,v in changes.items()};rows.append(p)
+    write_json(Path('docs/research/qvm-weapon-return-chains.json'),{'source':q['source'],'sha256':q['sha256'],'probes':rows,'limits':'Actual main54444..54451 then weapon50747..51801 staged in shared parent locals. Actual exit53046 permits resumed54455..54463;51802 suspends caller. Void epilogue/POP are boundary bridges, not full VM execution. No firing51802..53045, final native snap54471 or earlier main tick; no full tick/reference runtime claim.'})
+if __name__=='__main__':main()

scripts/test_qvm_weapon_return_chains.py

@@ -0,0 +1,49 @@
+import json,unittest,copy
+from pathlib import Path
+from test_qvm_main_consumers import reload_state,interaction_state,weapon_state as prefix_state
+from test_qvm_weapon_select import select_state
+from test_qvm_weapon_guards import guard_state
+from test_qvm_weapon_ready import ready_state
+from test_qvm_reload_complete import reload_complete_state
+from test_qvm_weapon_phases import phase_state
+from test_qvm_torso_selector import request
+from test_qvm_locomotion_prefix import animation
+from test_qvm_locomotion import locomotion_state
+from test_qvm_water_events import enqueue,expected
+
+def selection_state(test,p):
+    a=copy.deepcopy(p['initial']);test.assertEqual(p['prefix']['initial'],{k:a[k] for k in p['prefix']['initial']});a.update(prefix_state(p['prefix']));a['weapons'][a['slot']]=a['packed'];test.assertEqual(a,p['before_selection'])
+    if p['selection_execution'] and p['selection_execution']['children']:
+        child=p['selection_execution']['children'][0]['effect'];test.assertEqual(child['initial'],a);a=select_state(child)
+    test.assertEqual(p['final'],a);return a,p['stop']
+class WeaponReturnChainTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/qvm-weapon-return-chains.json').read_text())
+    def test_main_entry_live_children_and_exact_weapon_handoff(self):
+        self.assertEqual(len(self.r['probes']),16)
+        for p in self.r['probes']:
+            a=copy.deepcopy(p['initial']);self.assertEqual([c['instruction'] for c in p['entry_execution']['calls']],[54447,54450])
+            for child,oracle in zip(p['entry_execution']['children'],[reload_state,interaction_state]):
+                q=child['effect'];self.assertEqual(q['initial'],{k:a[k] for k in q['initial']});a.update(oracle(q));self.assertEqual(q['final'],{k:a[k] for k in q['final']})
+            self.assertEqual(a,p['before_weapon']);self.assertEqual(a,p['weapon']['initial'])
+    def test_every_weapon_stage_exact_state_and_stop(self):
+        oracles={'guards':guard_state,'ready':ready_state,'reload':reload_complete_state,'phases':phase_state};entries={'guards':50923,'ready':51207,'reload':51365,'phases':51633}
+        for p in self.r['probes']:
+            a=copy.deepcopy(p['weapon']['initial']);stop=None
+            for stage in p['weapon']['stages']:
+                name,q=stage['name'],stage['probe'];self.assertEqual(q['initial'],a)
+                if name=='selection':a,stop=selection_state(self,q)
+                else:
+                    self.assertEqual(stop,entries[name]);result=oracles[name](q);a,stop=result[:2];self.assertEqual(q['execution']['stop'],stop);self.assertEqual(q['final'],a)
+            self.assertEqual(p['weapon']['final'],a);self.assertEqual(p['weapon']['stop'],stop)
+    def test_actual_returns_resume_exact_main_tail_other_paths_suspend(self):
+        for p in self.r['probes']:
+            w=p['weapon'];a=copy.deepcopy(w['final']);self.assertEqual(w['returned'],w['stop']==53046);self.assertEqual(p['tail'] is not None,w['returned'])
+            if p['tail']:
+                tail=p['tail'];self.assertFalse(tail['supplied_post_weapon_state']);self.assertTrue(tail['resumed_after_actual_return']);self.assertEqual([c['instruction'] for c in tail['execution']['calls']],[54456,54459,54462]);self.assertEqual(tail['initial'],{k:a[k] for k in tail['initial']});torso,loco,water=[x['effect'] for x in tail['execution']['children']];r=request(torso)
+                if r is not None:animation(a,39482,r,0)
+                self.assertEqual(torso['final'],{k:a[k] for k in torso['final']});self.assertEqual(loco['initial'],{k:a[k] for k in loco['initial']});a.update(locomotion_state(loco)[0]);self.assertEqual(water['initial'],{k:a[k] for k in water['initial']});a['queue']=enqueue(a['queue'],expected(water));self.assertEqual(tail['final'],{k:a[k] for k in tail['final']})
+            self.assertEqual(p['final'],a);self.assertEqual(p['main_stop'],54464 if w['returned'] else 54453)
+    def test_pre_switch_mode_local_is_preserved_after_packed_mode_change(self):
+        p=next(p for p in self.r['probes'] if p['name']=='mode-local');stage=next(s['probe'] for s in p['weapon']['stages'] if s['name']=='ready');self.assertEqual(stage['preserved_parent_locals'],{'id':1,'mode':1});self.assertEqual(stage['initial']['packed']>>16&255,0);self.assertEqual(p['weapon']['stop'],51802)
+if __name__=='__main__':unittest.main()