From 36849e7716b77aa25e4175d1f4be1b93dbf47aac Mon Sep 17 00:00:00 2001 From: Landon Fuller Date: Sun, 19 Sep 2010 09:35:04 -0700 Subject: [PATCH] Whitespace/comment fixes. --- src/arm/gentramp.sh | 5 + src/arm/trampoline.S | 3060 ++++++++++++++++++++++++++++++++---------- 2 files changed, 2385 insertions(+), 680 deletions(-) diff --git a/src/arm/gentramp.sh b/src/arm/gentramp.sh index 5eb20335..7d5eca42 100755 --- a/src/arm/gentramp.sh +++ b/src/arm/gentramp.sh @@ -34,7 +34,11 @@ header () { # WARNING - Don't modify the trampoline code size without also updating the relevent libffi code trampoline () { cat << END + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. // This places the first usable config value at _ffi_closure_trampoline_table-4080 // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. @@ -42,6 +46,7 @@ trampoline () { // Load the jump address from the config page. ldr pc, [pc, #-4092] + END } diff --git a/src/arm/trampoline.S b/src/arm/trampoline.S index 2de1b37c..9f5891ed 100644 --- a/src/arm/trampoline.S +++ b/src/arm/trampoline.S @@ -5,2723 +5,4423 @@ .align 12 .globl _ffi_closure_trampoline_table _ffi_closure_trampoline_table: + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] + + + // trampoline + // Save to stack stmfd sp!, {r0-r3} + // Load the context argument from the config page. - // This places the first config value at _ffi_closure_trampoline_table-4080 - // This accounts for the above, 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. + // This places the first usable config value at _ffi_closure_trampoline_table-4080 + // This accounts for the above 4-byte stmfd instruction, plus 8 bytes constant when loading from pc. ldr r0, [pc, #-4092] // Load the jump address from the config page. ldr pc, [pc, #-4092] +