kc3-lang/libffi/src/arm/trampoline.S

Branch : - branch - android master - tag - v3.0.10 v3.0.11 v3.0.12 v3.0.13 v3.0.9 v3.1 v3.2 v3.2.1 v3.3 v3.3-rc0 v3.3-rc1 v3.3-rc2 v3.4-rc1 v3.4.0 v3.4.0-rc2 v3.4.1 v3.4.2 v3.4.3 v3.4.4

• Show log

  Commit

• Author : Landon Fuller
  Date : 2010-10-27 19:34:51
  Hash : f6ab3edc
  Message : Include the license header in the generated output.

• src/arm/trampoline.S

• # GENERATED CODE - DO NOT EDIT
  # This file was generated by ./gentramp.sh
  
  #  Copyright (c) 2010, Plausible Labs Cooperative, Inc.
  #  
  #  Permission is hereby granted, free of charge, to any person obtaining
  #  a copy of this software and associated documentation files (the
  #  Software''), to deal in the Software without restriction, including
  #  without limitation the rights to use, copy, modify, merge, publish,
  #  distribute, sublicense, and/or sell copies of the Software, and to
  #  permit persons to whom the Software is furnished to do so, subject to
  #  the following conditions:
  #
  #  The above copyright notice and this permission notice shall be included
  #  in all copies or substantial portions of the Software.
  #
  #  THE SOFTWARE IS PROVIDED AS IS'', WITHOUT WARRANTY OF ANY KIND,
  #  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  #  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  #  NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  #  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  #  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  #  DEALINGS IN THE SOFTWARE.
  #  -----------------------------------------------------------------------
  
  .text
  .align 12
  .globl _ffi_closure_trampoline_table_page
  _ffi_closure_trampoline_table_page:
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]
  
  
      // 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.
      ldr r0, [pc, #-4092]
  
      // Load the jump address from the config page.
      ldr pc, [pc, #-4092]