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

• Show log

  Commit

• Hash : 39e6a586
  Author :
  Date : 2012-04-11T22:39:46
  

  More mac/ios build improvements

Download

• src/arm/trampoline.S

• # GENERATED CODE - DO NOT EDIT
  # This file was generated by src/arm/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]
  
  

Download