Index: trunk/firmware_bootloader/SES/Output/Release/Exe/bootloader.htm =================================================================== --- trunk/firmware_bootloader/SES/Output/Release/Exe/bootloader.htm (revision 2) +++ trunk/firmware_bootloader/SES/Output/Release/Exe/bootloader.htm (revision 2) @@ -0,0 +1,12976 @@ + + + + +

LINK INFORMATION +
- Linker version
- Command line
+
LINKER SCRIPT +
- Linker script 'D:/Projekte/ecs_greenSmartSwitch/trunk/firmware_bootloader/SES/STM32G0xx_Flash.icf'
+
PLACEMENT SUMMARY +
+
MODULE SUMMARY +
+
MODULE DETAIL +
+
SECTION DETAIL +
- Sections by address
+
UNUSED MEMORY SUMMARY +
- Detail
+
INITIALIZATION TABLE +
+
LINKER-CREATED VENEERS +
+
SYMBOL LIST +
+
REGION LIST +
- Regions by name
- Analysis
+
BLOCK LIST +
- Blocks by name
- Blocks by address
+
STACK SIZES +
- Functions by stack size
- Functions without stack size information
+
UNUSED INPUTS +
- Unused object files
+
ABSOLUTE LISTING +
+
LINK SUMMARY +
- Memory breakdown
- Region summary
- Diagnostic summary
+

LINK INFORMATION

Linker version

+SEGGER ARM Linker 4.38.2 compiled Mar 14 2023 20:07:24
+Copyright (c) 2017-2022 SEGGER Microcontroller GmbH    www.segger.com
+

Command line

+--add-region:FLASH1=0x00003000@0x08000000
+--add-region:RAM1=0x00008000@0x20000000
+--defsym=__STACKSIZE__=4096
+--defsym=__STACKSIZE_PROCESS__=0
+--defsym=__HEAPSIZE__=0
+--full-section-headers
+--merge-sections
+--merge-strings
+-eReset_Handler
+-EL
+-mcpu=6-M
+--defsym=__SEGGER_RTL_vfprintf=__SEGGER_RTL_vfprintf_int_nwp
+--defsym=__SEGGER_RTL_vfscanf=__SEGGER_RTL_vfscanf_int
+--silent
+--list-all-undefineds
+-TD:/Projekte/ecs_greenSmartSwitch/trunk/firmware_bootloader/SES/STM32G0xx_Flash.icf
+--map-html
+--map-file=Output/Release/Exe/bootloader.htm
+--map-full
+-u_vectors
+-uFW_VERSION
+-o
+D:/Projekte/ecs_greenSmartSwitch/trunk/firmware_bootloader/SES/Output/Release/Exe/bootloader.elf
+Output/Release/Obj/system_stm32g0xx.o
+Output/Release/Obj/aes.o
+Output/Release/Obj/main.o
+Output/Release/Obj/SEGGER_THUMB_Startup.o
+Output/Release/Obj/STM32G07x_Vectors.o
+Output/Release/Obj/STM32G0xx_Startup.o
+C:/Program Files/SEGGER/SEGGER Embedded Studio for ARM 7.12a/lib/libc_v6m_t_le_eabi_small.a
+C:/Program Files/SEGGER/SEGGER Embedded Studio for ARM 7.12a/lib/SEGGER_crtinit_v6m_t_le_eabi_small.a
+C:/Program Files/SEGGER/SEGGER Embedded Studio for ARM 7.12a/lib/prinops_rtt_v6m_t_le_eabi_small.a
+C:/Program Files/SEGGER/SEGGER Embedded Studio for ARM 7.12a/lib/heapops_basic_v6m_t_le_eabi_small.a
+C:/Program Files/SEGGER/SEGGER Embedded Studio for ARM 7.12a/lib/heapops_disable_interrupts_locking_v6m_t_le_eabi_small.a
+

LINKER SCRIPT

Linker script 'D:/Projekte/ecs_greenSmartSwitch/trunk/firmware_bootloader/SES/STM32G0xx_Flash.icf'

+// **********************************************************************
+// *                    SEGGER Microcontroller GmbH                     *
+// *                        The Embedded Experts                        *
+// **********************************************************************
+// *                                                                    *
+// *            (c) 2014 - 2019 SEGGER Microcontroller GmbH             *
+// *            (c) 2001 - 2019 Rowley Associates Limited               *
+// *                                                                    *
+// *           www.segger.com     Support: support@segger.com           *
+// *                                                                    *
+// **********************************************************************
+// *                                                                    *
+// * All rights reserved.                                               *
+// *                                                                    *
+// * Redistribution and use in source and binary forms, with or         *
+// * without modification, are permitted provided that the following    *
+// * conditions are met:                                                *
+// *                                                                    *
+// * - Redistributions of source code must retain the above copyright   *
+// *   notice, this list of conditions and the following disclaimer.    *
+// *                                                                    *
+// * - Neither the name of SEGGER Microcontroller GmbH                  *
+// *   nor the names of its contributors may be used to endorse or      *
+// *   promote products derived from this software without specific     *
+// *   prior written permission.                                        *
+// *                                                                    *
+// * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+// * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+// * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+// * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+// * DISCLAIMED.                                                        *
+// * IN NO EVENT SHALL SEGGER Microcontroller GmbH BE LIABLE FOR        *
+// * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+// * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+// * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+// * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+// * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+// * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+// * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+// * DAMAGE.                                                            *
+// *                                                                    *
+// **********************************************************************
+
+define memory with size = 4G;
+
+//
+// Combined regions per memory type
+//
+define region FLASH = FLASH1;
+define region RAM   = RAM1;
+
+//
+// Block definitions
+//
+define block vectors                        { section .vectors };                         // Vector table section
+define block vectors_ram                    { section .vectors_ram };                     // Vector table section
+define block ctors                          { section .ctors,     section .ctors.*, block with         alphabetical order { init_array } };
+define block dtors                          { section .dtors,     section .dtors.*, block with reverse alphabetical order { fini_array } };
+define block exidx                          { section .ARM.exidx, section .ARM.exidx.* };
+define block tbss                           { section .tbss,      section .tbss.*  };
+define block tdata                          { section .tdata,     section .tdata.* };
+define block tls                            { block tbss, block tdata };
+define block tdata_load                     { copy of block tdata };
+define block heap  with size = __HEAPSIZE__,  alignment = 8, /* fill =0x00, */ readwrite access { };
+define block stack with size = __STACKSIZE__, alignment = 8, /* fill =0xCD, */ readwrite access { };
+//
+// Explicit initialization settings for sections
+//
+do not initialize                           { section .non_init, section .non_init.*, section .*.non_init, section .*.non_init.* };
+initialize by copy /* with packing=auto */  { section .data, section .data.*, section .*.data, section .*.data.* };
+initialize by copy /* with packing=auto */  { section .fast, section .fast.* };
+
+//
+// FLASH Placement
+//
+place at start of FLASH                     { block vectors };                         // Vector table section
+place in FLASH with minimum size order      { section .init,   section .init.*,        // Init code section
+                                              section .init_rodata, section .init_rodata.*, // Init read-only section
+                                              section .text,   section .text.*,        // Code section
+                                              section .rodata, section .rodata.*,      // Read-only data section
+                                              section .segger.*,                       // Auto-generated initialization
+                                              block exidx,                             // ARM exception unwinding block
+                                              block ctors,                             // Constructors block
+                                              block dtors };                           // Destructors block
+place in FLASH                              { block tdata_load };                      // Thread-local-storage load image
+//
+// Explicit placement in FLASHn
+//
+place in FLASH1                             { section .FLASH1, section .FLASH1.* };
+
+//
+// RAM Placement
+//
+place at start of RAM                       { block vectors_ram };
+place in RAM                                { section .non_init, section .non_init.*,  // No initialization section
+                                              block tls };                             // Thread-local-storage block
+place in RAM with auto order                { section .fast, section .fast.*,          // "ramfunc" section
+                                              section .data, section .data.*,          // Initialized data section
+                                              section .bss, section .bss.*
+                                            };          // Static data section
+place in RAM                                { block heap };           // Heap reserved block
+place at end of RAM                         { block stack };          // Stack reserved block at the end
+
+//
+// Explicit placement in RAMn
+//
+place in RAM1                               { section .RAM1, section .RAM1.* };
+
+

PLACEMENT SUMMARY

place at 0x08000000

+ + + + + + + + + + + + + + + + + +

Symbol or [section] name	Type	Address	Size	Align	Object File
`_vectors`	`Code`	`0x08000000`	`192`	`512`	`STM32G07x_Vectors.o`

place at 0x20008000

+ + + + + + + + + + + + + + + + + +

Symbol or [section] name	Type	Address	Size	Align	Object File
`[.bss.block.stack]`	`None`	`0x20007000`	`4 096`	`8`	`[ Linker created ]`

at line 77, col 45": place in [0x08000000 to 0x08002fff] with maximum packing">"<#4> at line 77, col 45": place in [0x08000000 to 0x08002fff] with maximum packing

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Type	Address	Size	Align	Object File
`FW_VERSION`	`Cnst`	`0x080000C0`	`16`	`16`	`main.o`
`SystemInit`	`Code`	`0x080000D0`	`16`	`4`	`system_stm32g0xx.o`
`SystemCoreClockUpdate`	`Code`	`0x080000E0`	`140`	`4`	`system_stm32g0xx.o`
`AHBPrescTable`	`Cnst`	`0x0800016C`	`64`	`4`	`system_stm32g0xx.o`
`AES128_ECB_decrypt`	`Code`	`0x080001AC`	`692`	`4`	`aes.o`
`AddRoundKey`	`Code`	`0x08000460`	`56`	`4`	`aes.o`
`main`	`Code`	`0x08000498`	`1 136`	`4`	`main.o`
`Init`	`Code`	`0x08000908`	`512`	`4`	`main.o`
`WaitForByte`	`Code`	`0x08000B08`	`140`	`4`	`main.o`
`JumpToApplication`	`Code`	`0x08000B94`	`152`	`4`	`main.o`
`Transmit`	`Code`	`0x08000C2C`	`32`	`4`	`main.o`
`TurnErrorLEDOn`	`Code`	`0x08000C4C`	`68`	`4`	`main.o`
`Delay`	`Code`	`0x08000C90`	`28`	`4`	`main.o`
`SysTick_Handler`	`Code`	`0x08000CAC`	`16`	`4`	`main.o`
`_start`	`Code`	`0x08000CBC`	`20`	`4`	`SEGGER_THUMB_Startup.o`
`SVC_Handler`	`Code`	`0x08000CD0`	`2`	`2`	`STM32G07x_Vectors.o`
`PendSV_Handler`	`Code`	`0x08000CD2`	`2`	`2`	`STM32G07x_Vectors.o`
`WWDG_IRQHandler`	`Code`	`0x08000CD4`	`2`	`2`	`STM32G07x_Vectors.o`
`PVD_IRQHandler`	`Code`	`0x08000CD6`	`2`	`2`	`STM32G07x_Vectors.o`
`RTC_STAMP_IRQHandler`	`Code`	`0x08000CD8`	`2`	`2`	`STM32G07x_Vectors.o`
`FLASH_IRQHandler`	`Code`	`0x08000CDA`	`2`	`2`	`STM32G07x_Vectors.o`
`RCC_IRQHandler`	`Code`	`0x08000CDC`	`2`	`2`	`STM32G07x_Vectors.o`
`EXTI0_1_IRQHandler`	`Code`	`0x08000CDE`	`2`	`2`	`STM32G07x_Vectors.o`
`EXTI2_3_IRQHandler`	`Code`	`0x08000CE0`	`2`	`2`	`STM32G07x_Vectors.o`
`EXTI4_15_IRQHandler`	`Code`	`0x08000CE2`	`2`	`2`	`STM32G07x_Vectors.o`
`UCPD1_UCPD2_IRQHandler`	`Code`	`0x08000CE4`	`2`	`2`	`STM32G07x_Vectors.o`
`DMA_Channel1_IRQHandler`	`Code`	`0x08000CE6`	`2`	`2`	`STM32G07x_Vectors.o`
`DMA_Channel2_3_IRQHandler`	`Code`	`0x08000CE8`	`2`	`2`	`STM32G07x_Vectors.o`
`DMA_Channel4_5_6_7_IRQHandler`	`Code`	`0x08000CEA`	`2`	`2`	`STM32G07x_Vectors.o`
`ADC_COMP_IRQHandler`	`Code`	`0x08000CEC`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM1_BRK_UP_TRG_COMP_IRQHandler`	`Code`	`0x08000CEE`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM1_CC_IRQHandler`	`Code`	`0x08000CF0`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM2_IRQHandler`	`Code`	`0x08000CF2`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM3_IRQHandler`	`Code`	`0x08000CF4`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM6_DAC_LPTIM1_IRQHandler`	`Code`	`0x08000CF6`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM7_LPTIM2_IRQHandler`	`Code`	`0x08000CF8`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM14_IRQHandler`	`Code`	`0x08000CFA`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM15_IRQHandler`	`Code`	`0x08000CFC`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM16_IRQHandler`	`Code`	`0x08000CFE`	`2`	`2`	`STM32G07x_Vectors.o`
`TIM17_IRQHandler`	`Code`	`0x08000D00`	`2`	`2`	`STM32G07x_Vectors.o`
`I2C1_IRQHandler`	`Code`	`0x08000D02`	`2`	`2`	`STM32G07x_Vectors.o`
`I2C2_IRQHandler`	`Code`	`0x08000D04`	`2`	`2`	`STM32G07x_Vectors.o`
`SPI1_IRQHandler`	`Code`	`0x08000D06`	`2`	`2`	`STM32G07x_Vectors.o`
`SPI2_IRQHandler`	`Code`	`0x08000D08`	`2`	`2`	`STM32G07x_Vectors.o`
`USART1_IRQHandler`	`Code`	`0x08000D0A`	`2`	`2`	`STM32G07x_Vectors.o`
`USART2_IRQHandler`	`Code`	`0x08000D0C`	`2`	`2`	`STM32G07x_Vectors.o`
`USART3_USART4_LPUART1_IRQHandler`	`Code`	`0x08000D0E`	`2`	`2`	`STM32G07x_Vectors.o`
`CEC_IRQHandler`	`Code`	`0x08000D10`	`2`	`2`	`STM32G07x_Vectors.o`
`AES_RNG_IRQHandler`	`Code`	`0x08000D12`	`2`	`2`	`STM32G07x_Vectors.o`
`reset_handler`	`Code`	`0x08000D14`	`6`	`2`	`STM32G0xx_Startup.o`
`NMI_Handler`	`Code`	`0x08000D1A`	`14`	`2`	`main.o`
`__aeabi_idiv0`	`Code`	`0x08000D28`	`6`	`2`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`TransmitACK`	`Code`	`0x08000D2E`	`20`	`2`	`main.o`
`TransmitNACK`	`Code`	`0x08000D42`	`20`	`2`	`main.o`
`HardFault_Handler`	`Code`	`0x08000D56`	`16`	`2`	`main.o`
`__aeabi_uidiv`	`Code`	`0x08000D66`	`56`	`2`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memclr`	`Code`	`0x08000D9E`	`20`	`2`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`Rcon`	`Cnst`	`0x08000DB2`	`255`	`1`	`aes.o`
`[.rodata.block.tdata.copy]`	`Cnst`	`0x08000EB1`		`1`	`[ Linker created ]`
`[.init_array]`	`----`	`0x08000EB4`	`4`	`4`	`STM32G0xx_Startup.o`
`sbox`	`Cnst`	`0x08000EB8`	`256`	`1`	`aes.o`
`rsbox`	`Cnst`	`0x08000FB8`	`256`	`1`	`aes.o`
`AES_KEY`	`Cnst`	`0x080010B8`	`16`	`1`	`main.o`
`__SEGGER_init_table__`	`Cnst`	`0x080010C8`	`44`	`4`	`[ Linker created ]`
`__SEGGER_init_data__`	`Cnst`	`0x080010F4`	`4`	`4`	`[ Linker created ]`
`__SEGGER_init_zero`	`Code`	`0x080010F8`	`18`	`2`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`
`__SEGGER_init_copy`	`Code`	`0x0800110A`	`20`	`2`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`

at line 97, col 45": place in [0x20000000 to 0x20007fff] with auto order">"<#9> at line 97, col 45": place in [0x20000000 to 0x20007fff] with auto order

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Type	Address	Size	Align	Object File
`SystemCoreClock`	`Init`	`0x20000000`	`4`	`4`	`system_stm32g0xx.o`
`u`	`Zero`	`0x20000004`	`5`	`4`	`main.o`
`state`	`Zero`	`0x2000000C`	`4`	`4`	`aes.o`
`msCounter`	`Zero`	`0x20000010`	`4`	`4`	`main.o`
`[.bss.block.heap]`	`None`	`0x20000010`		`8`	`[ Linker created ]`
`Key`	`Zero`	`0x20000014`	`4`	`4`	`aes.o`
`RoundKey`	`Zero`	`0x20000018`	`176`	`1`	`aes.o`
`[.bss.block.stack]`	`None`	`0x20007000`	`4 096`	`8`	`[ Linker created ]`

at line 101, col 45": place in [0x20000000 to 0x20007fff] with auto order">"<#10> at line 101, col 45": place in [0x20000000 to 0x20007fff] with auto order

+ + + + + + + + + + + + + + + + + +

Symbol or [section] name	Type	Address	Size	Align	Object File
`[.bss.block.heap]`	`None`	`0x20000010`		`8`	`[ Linker created ]`

MODULE SUMMARY

Memory use by input file

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Object File	RX Code	RO Data	RW Data	ZI Data
`aes.o`	`748`	`767`		`184`
`main.o`	`2 154`	`32`		`9`
`SEGGER_THUMB_Startup.o`	`20`
`STM32G07x_Vectors.o`	`260`
`STM32G0xx_Startup.o`	`6`
`system_stm32g0xx.o`	`156`	`64`	`4`
`Subtotal (6 objects)`	`3 344`	`863`	`4`	`193`
`libc_v6m_t_le_eabi_small.a`	`82`
`SEGGER_crtinit_v6m_t_le_eabi_small.a`	`38`
`Subtotal (2 archives)`	`120`
`Linker created (shared data, fills, blocks):`		`48`		`4 096`
`Total:`	`3 464`	`911`	`4`	`4 289`

Memory use by archive member

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Archive member	RX Code	RO Data	RW Data	ZI Data
`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`	`62`
`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`	`38`
`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`	`20`
`Subtotal (3 members from 2 archives)`	`120`
`Objects (6 files)`	`3 344`	`863`	`4`	`193`
`Linker created (shared data, fills, blocks):`		`48`		`4 096`
`Total:`	`3 464`	`911`	`4`	`4 289`

Memory use by linker

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Description	RX Code	RO Data	RW Data	ZI Data
`Initialization table`		`48`
`Memory for block 'stack'`				`4 096`
`Subtotal (linker created):`		`48`		`4 096`
`Objects (6 files)`	`3 344`	`863`	`4`	`193`
`Archives (2 files)`	`120`
`Total:`	`3 464`	`911`	`4`	`4 289`

MODULE DETAIL

Module system_stm32g0xx.o

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Code	RO Data	RW Data
`SystemCoreClockUpdate`	`140`
`SystemInit`	`16`
`AHBPrescTable`		`64`
`SystemCoreClock`			`4`
`Total:`	`156`	`64`	`4`

Module aes.o

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Code	RO Data	ZI Data
`AES128_ECB_decrypt`	`692`
`AddRoundKey`	`56`
`sbox`		`256`
`rsbox`		`256`
`Rcon`		`255`
`RoundKey`			`176`
`state`			`4`
`Key`			`4`
`Total:`	`748`	`767`	`184`

Module main.o

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Code	RO Data	ZI Data
`main`	`1 136`
`Init`	`512`
`JumpToApplication`	`152`
`WaitForByte`	`140`
`TurnErrorLEDOn`	`68`
`Transmit`	`32`
`Delay`	`28`
`TransmitACK`	`20`
`TransmitNACK`	`20`
`SysTick_Handler`	`16`
`HardFault_Handler`	`16`
`NMI_Handler`	`14`
`FW_VERSION`		`16`
`AES_KEY`		`16`
`u`			`5`
`msCounter`			`4`
`Total:`	`2 154`	`32`	`9`

Module SEGGER_THUMB_Startup.o

+ + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Code	RO Data	RW Data	ZI Data
`_start`	`20`
`Total:`	`20`

Module STM32G07x_Vectors.o

Symbol or [section] name	Code	RO Data	RW Data	ZI Data
`_vectors`	`192`
`SVC_Handler`	`2`
`PendSV_Handler`	`2`
`WWDG_IRQHandler`	`2`
`PVD_IRQHandler`	`2`
`RTC_STAMP_IRQHandler`	`2`
`FLASH_IRQHandler`	`2`
`RCC_IRQHandler`	`2`
`EXTI0_1_IRQHandler`	`2`
`EXTI2_3_IRQHandler`	`2`
`EXTI4_15_IRQHandler`	`2`
`UCPD1_UCPD2_IRQHandler`	`2`
`DMA_Channel1_IRQHandler`	`2`
`DMA_Channel2_3_IRQHandler`	`2`
`DMA_Channel4_5_6_7_IRQHandler`	`2`
`ADC_COMP_IRQHandler`	`2`
`TIM1_BRK_UP_TRG_COMP_IRQHandler`	`2`
`TIM1_CC_IRQHandler`	`2`
`TIM2_IRQHandler`	`2`
`TIM3_IRQHandler`	`2`
`TIM6_DAC_LPTIM1_IRQHandler`	`2`
`TIM7_LPTIM2_IRQHandler`	`2`
`TIM14_IRQHandler`	`2`
`TIM15_IRQHandler`	`2`
`TIM16_IRQHandler`	`2`
`TIM17_IRQHandler`	`2`
`I2C1_IRQHandler`	`2`
`I2C2_IRQHandler`	`2`
`SPI1_IRQHandler`	`2`
`SPI2_IRQHandler`	`2`
`USART1_IRQHandler`	`2`
`USART2_IRQHandler`	`2`
`USART3_USART4_LPUART1_IRQHandler`	`2`
`CEC_IRQHandler`	`2`
`AES_RNG_IRQHandler`	`2`
`Total:`	`260`

Module STM32G0xx_Startup.o

+ + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Code	RO Data	RW Data	ZI Data
`reset_handler`	`6`
`Total:`	`6`

Module intasmops_arm.o (libc_v6m_t_le_eabi_small.a)

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Code	RO Data	RW Data	ZI Data
`__aeabi_uidiv`	`56`
`__aeabi_idiv0`	`6`
`Total:`	`62`

Module strasmops_arm.o (libc_v6m_t_le_eabi_small.a)

+ + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Code	RO Data	RW Data	ZI Data
`__aeabi_memclr`	`20`
`Total:`	`20`

Module SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol or [section] name	Code	RO Data	RW Data	ZI Data
`__SEGGER_init_copy`	`20`
`__SEGGER_init_zero`	`18`
`Total:`	`38`

All modules

+ + + + + + + + + + + + + + + +

	Code	RO Data	RW Data	ZI Data
`Grand total:`	`3 464`	`863`	`4`	`193`

SECTION DETAIL

Sections by address

Range	Symbol or [section] Name	Size	Al	Init	Ac	Object File
`08000000-080000bf`	`_vectors`	`192`	`512`	`Code`	`RX`	`STM32G07x_Vectors.o`
`080000c0-080000cf`	`FW_VERSION`	`16`	`16`	`Cnst`	`RO`	`main.o`
`080000d0-080000df`	`SystemInit`	`16`	`4`	`Code`	`RX`	`system_stm32g0xx.o`
`080000e0-0800016b`	`SystemCoreClockUpdate`	`140`	`4`	`Code`	`RX`	`system_stm32g0xx.o`
`0800016c-080001ab`	`AHBPrescTable`	`64`	`4`	`Cnst`	`RO`	`system_stm32g0xx.o`
`080001ac-0800045f`	`AES128_ECB_decrypt`	`692`	`4`	`Code`	`RX`	`aes.o`
`08000460-08000497`	`AddRoundKey`	`56`	`4`	`Code`	`RX`	`aes.o`
`08000498-08000907`	`main`	`1 136`	`4`	`Code`	`RX`	`main.o`
`08000908-08000b07`	`Init`	`512`	`4`	`Code`	`RX`	`main.o`
`08000b08-08000b93`	`WaitForByte`	`140`	`4`	`Code`	`RX`	`main.o`
`08000b94-08000c2b`	`JumpToApplication`	`152`	`4`	`Code`	`RX`	`main.o`
`08000c2c-08000c4b`	`Transmit`	`32`	`4`	`Code`	`RX`	`main.o`
`08000c4c-08000c8f`	`TurnErrorLEDOn`	`68`	`4`	`Code`	`RX`	`main.o`
`08000c90-08000cab`	`Delay`	`28`	`4`	`Code`	`RX`	`main.o`
`08000cac-08000cbb`	`SysTick_Handler`	`16`	`4`	`Code`	`RX`	`main.o`
`08000cbc-08000ccf`	`_start`	`20`	`4`	`Code`	`RX`	`SEGGER_THUMB_Startup.o`
`08000cd0-08000cd1`	`SVC_Handler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cd2-08000cd3`	`PendSV_Handler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cd4-08000cd5`	`WWDG_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cd6-08000cd7`	`PVD_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cd8-08000cd9`	`RTC_STAMP_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cda-08000cdb`	`FLASH_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cdc-08000cdd`	`RCC_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cde-08000cdf`	`EXTI0_1_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000ce0-08000ce1`	`EXTI2_3_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000ce2-08000ce3`	`EXTI4_15_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000ce4-08000ce5`	`UCPD1_UCPD2_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000ce6-08000ce7`	`DMA_Channel1_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000ce8-08000ce9`	`DMA_Channel2_3_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cea-08000ceb`	`DMA_Channel4_5_6_7_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cec-08000ced`	`ADC_COMP_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cee-08000cef`	`TIM1_BRK_UP_TRG_COMP_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cf0-08000cf1`	`TIM1_CC_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cf2-08000cf3`	`TIM2_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cf4-08000cf5`	`TIM3_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cf6-08000cf7`	`TIM6_DAC_LPTIM1_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cf8-08000cf9`	`TIM7_LPTIM2_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cfa-08000cfb`	`TIM14_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cfc-08000cfd`	`TIM15_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000cfe-08000cff`	`TIM16_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d00-08000d01`	`TIM17_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d02-08000d03`	`I2C1_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d04-08000d05`	`I2C2_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d06-08000d07`	`SPI1_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d08-08000d09`	`SPI2_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d0a-08000d0b`	`USART1_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d0c-08000d0d`	`USART2_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d0e-08000d0f`	`USART3_USART4_LPUART1_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d10-08000d11`	`CEC_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d12-08000d13`	`AES_RNG_IRQHandler`	`2`	`2`	`Code`	`RX`	`STM32G07x_Vectors.o`
`08000d14-08000d19`	`reset_handler`	`6`	`2`	`Code`	`RX`	`STM32G0xx_Startup.o`
`08000d1a-08000d27`	`NMI_Handler`	`14`	`2`	`Code`	`RX`	`main.o`
`08000d28-08000d2d`	`__aeabi_idiv0`	`6`	`2`	`Code`	`RX`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`08000d2e-08000d41`	`TransmitACK`	`20`	`2`	`Code`	`RX`	`main.o`
`08000d42-08000d55`	`TransmitNACK`	`20`	`2`	`Code`	`RX`	`main.o`
`08000d56-08000d65`	`HardFault_Handler`	`16`	`2`	`Code`	`RX`	`main.o`
`08000d66-08000d9d`	`__aeabi_uidiv`	`56`	`2`	`Code`	`RX`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`08000d9e-08000db1`	`__aeabi_memclr`	`20`	`2`	`Code`	`RX`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`08000db2-08000eb0`	`Rcon`	`255`	`1`	`Cnst`	`RO`	`aes.o`
`08000eb1-08000eb3`	`( UNUSED .=.+3 )`	`3`	`-`	`----`	`-`	`-`
`08000eb4-08000eb7`	`[.init_array]`	`4`	`4`	`----`	`--`	`STM32G0xx_Startup.o`
`08000eb8-08000fb7`	`sbox`	`256`	`1`	`Cnst`	`RO`	`aes.o`
`08000fb8-080010b7`	`rsbox`	`256`	`1`	`Cnst`	`RO`	`aes.o`
`080010b8-080010c7`	`AES_KEY`	`16`	`1`	`Cnst`	`RO`	`main.o`
`080010c8-080010f3`	`__SEGGER_init_table__`	`44`	`4`	`Cnst`	`RO`	`[ Linker created ]`
`080010f4-080010f7`	`__SEGGER_init_data__`	`4`	`4`	`Cnst`	`RO`	`[ Linker created ]`
`080010f8-08001109`	`__SEGGER_init_zero`	`18`	`2`	`Code`	`RX`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`
`0800110a-0800111d`	`__SEGGER_init_copy`	`20`	`2`	`Code`	`RX`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`
`0800111e-1fffffff`	`( UNUSED .=.+402648802 )`	`402 648 802`	`-`	`----`	`-`	`-`
`20000000-20000003`	`SystemCoreClock`	`4`	`4`	`Init`	`RW`	`system_stm32g0xx.o`
`20000004-20000008`	`u`	`5`	`4`	`Zero`	`ZI`	`main.o`
`20000009-2000000b`	`( ALIGN .=.+3 )`	`3`	`-`	`----`	`-`	`-`
`2000000c-2000000f`	`state`	`4`	`4`	`Zero`	`ZI`	`aes.o`
`20000010-20000013`	`msCounter`	`4`	`4`	`Zero`	`ZI`	`main.o`
`20000014-20000017`	`Key`	`4`	`4`	`Zero`	`ZI`	`aes.o`
`20000018-200000c7`	`RoundKey`	`176`	`1`	`Zero`	`ZI`	`aes.o`
`200000c8-20006fff`	`( UNUSED .=.+28472 )`	`28 472`	`-`	`----`	`-`	`-`
`20007000-20007fff`	`[.bss.block.stack]`	`4 096`	`8`	`None`	`ZI`	`[ Linker created ]`

UNUSED MEMORY SUMMARY

Detail

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Range	Size	Reason
`08000eb1-08000eb3`	`3`	`Unused memory between sections '.rodata.Rcon' and '.init_array'`
`0800111e-1fffffff`	`402 648 802`	`Unused memory between sections '.segger.init.__SEGGER_init_copy' and '.data.SystemCoreClock'`
`20000009-2000000b`	`3`	`Filler between sections '.bss.u' and '.bss.state' as align=4`
		`NOTE: section '.bss.u' has size 5 that is not a multiple of its alignment 4`
`200000c8-20006fff`	`28 472`	`Unused memory between sections '.bss.RoundKey' and '.bss.block.stack'`

INITIALIZATION TABLE

Constructor list

+ + + + + + + + + + + +

Table Address	Called Address	Called Symbol or [section] name
`0x08000EB4`	`0x080000E1`	`SystemCoreClockUpdate`

Initialize by zero

+ + + + + + + + + + + + + + + + +

Initialize by zero

Range	Size	Symbol or [section] name
`20000004-20000008`	`5`	`u`
`20000004-20000008`	`5`	`Total (1 sections)`

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Initialize by copy with packing=none

Range	Size	Symbol or [section] name
`2000000c-2000000f`	`4`	`state`
`20000010-20000013`	`4`	`msCounter`
`20000014-20000017`	`4`	`Key`
`20000018-200000c7`	`176`	`RoundKey`
`2000000c-200000c7`	`188`	`Total (4 sections)`

+ + + + + + + + + + + + + + + + +

Summary

Range	Size	Symbol or [section] name
`20000000-20000003`	`4`	`SystemCoreClock`
`20000000-20000003`	`4`	`Total (1 sections)`

+ + + + + + + + + + + + + + + + + + + + +

Description	Size
Initialization table	`44 bytes`
Source image	`4 bytes`
Destination image	`197 bytes`
Saving	`149 bytes`

LINKER-CREATED VENEERS

Arm-Arm range extension veneers

+ + + + + + + + + + + +

Veneer Size	Target	Source
`0`	`Total`

Thumb-Thumb range extension veneers

+ + + + + + + + + + + +

Veneer Size	Target	Source
`0`	`Total`

Arm-Thumb mode switch veneers

+ + + + + + + + + + + +

Veneer Size	Target	Source
`0`	`Total`

Thumb-Arm mode switch veneers

+ + + + + + + + + + + +

Veneer Size	Target	Source
`0`	`Total`

Summary

+ + + + + + + + + + + + + + + + + + + + + + + + + +

Veneer Type	Size
Thumb-Arm mode switch	0
Arm-Thumb mode switch	0
Thumb-Thumb range extension	0
Arm-Arm range extension	0
Total:	0

SYMBOL LIST

Function symbols by name

Symbol name	Address	Size	Align	Type	Bd	Object File
`ADC_COMP_IRQHandler`	`0x08000CED`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`AES128_ECB_decrypt`	`0x080001AD`	`692`	`4`	`Code`	`Gb`	`aes.o`
`AES_RNG_IRQHandler`	`0x08000D13`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`AddRoundKey`	`0x08000461`	`56`	`4`	`Code`	`Lc`	`aes.o`
`CEC_IRQHandler`	`0x08000D11`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`DMA_Channel1_IRQHandler`	`0x08000CE7`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`DMA_Channel2_3_IRQHandler`	`0x08000CE9`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`DMA_Channel4_5_6_7_IRQHandler`	`0x08000CEB`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`Delay`	`0x08000C91`	`28`	`4`	`Code`	`Gb`	`main.o`
`EXTI0_1_IRQHandler`	`0x08000CDF`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`EXTI2_3_IRQHandler`	`0x08000CE1`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`EXTI4_15_IRQHandler`	`0x08000CE3`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`FLASH_IRQHandler`	`0x08000CDB`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`HardFault_Handler`	`0x08000D57`	`16`	`2`	`Code`	`Gb`	`main.o`
`I2C1_IRQHandler`	`0x08000D03`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`I2C2_IRQHandler`	`0x08000D05`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`Init`	`0x08000909`	`512`	`4`	`Code`	`Gb`	`main.o`
`JumpToApplication`	`0x08000B95`	`152`	`4`	`Code`	`Gb`	`main.o`
`NMI_Handler`	`0x08000D1B`	`14`	`2`	`Code`	`Gb`	`main.o`
`PVD_IRQHandler`	`0x08000CD7`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`PendSV_Handler`	`0x08000CD3`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`RCC_IRQHandler`	`0x08000CDD`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`RTC_STAMP_IRQHandler`	`0x08000CD9`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`Reset_Handler`	`0x08000D15`		`2`	`Code`	`Gb`	`STM32G0xx_Startup.o`
`SPI1_IRQHandler`	`0x08000D07`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`SPI2_IRQHandler`	`0x08000D09`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`SVC_Handler`	`0x08000CD1`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`SysTick_Handler`	`0x08000CAD`	`16`	`4`	`Code`	`Gb`	`main.o`
`SystemCoreClockUpdate`	`0x080000E1`	`140`	`4`	`Code`	`Gb`	`system_stm32g0xx.o`
`SystemInit`	`0x080000D1`	`16`	`4`	`Code`	`Gb`	`system_stm32g0xx.o`
`TIM14_IRQHandler`	`0x08000CFB`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM15_IRQHandler`	`0x08000CFD`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM16_IRQHandler`	`0x08000CFF`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM17_IRQHandler`	`0x08000D01`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM1_BRK_UP_TRG_COMP_IRQHandler`	`0x08000CEF`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM1_CC_IRQHandler`	`0x08000CF1`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM2_IRQHandler`	`0x08000CF3`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM3_IRQHandler`	`0x08000CF5`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM6_DAC_LPTIM1_IRQHandler`	`0x08000CF7`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM7_LPTIM2_IRQHandler`	`0x08000CF9`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`Transmit`	`0x08000C2D`	`32`	`4`	`Code`	`Gb`	`main.o`
`TransmitACK`	`0x08000D2F`	`20`	`2`	`Code`	`Gb`	`main.o`
`TransmitNACK`	`0x08000D43`	`20`	`2`	`Code`	`Gb`	`main.o`
`TurnErrorLEDOn`	`0x08000C4D`	`68`	`4`	`Code`	`Gb`	`main.o`
`UCPD1_UCPD2_IRQHandler`	`0x08000CE5`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`USART1_IRQHandler`	`0x08000D0B`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`USART2_IRQHandler`	`0x08000D0D`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`USART3_USART4_LPUART1_IRQHandler`	`0x08000D0F`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`WWDG_IRQHandler`	`0x08000CD5`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`WaitForByte`	`0x08000B09`	`140`	`4`	`Code`	`Gb`	`main.o`
`__SEGGER_init_copy`	`0x0800110B`	`20`	`2`	`Code`	`Wk`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`
`__SEGGER_init_done`	`0x08000CC7`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`__SEGGER_init_zero`	`0x080010F9`	`18`	`2`	`Code`	`Wk`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`
`__aeabi_idiv0`	`0x08000D29`	`6`	`2`	`Code`	`Wk`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memclr`	`0x08000D9F`	`20`	`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memclr4`	`0x08000D9F`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memclr8`	`0x08000D9F`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memset`	`0x08000DA1`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memset4`	`0x08000DA1`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memset8`	`0x08000DA1`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_uidiv`	`0x08000D67`	`56`	`2`	`Code`	`Wk`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`_start`	`0x08000CBD`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`exit`	`0x08000CCB`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`main`	`0x08000499`	`1 136`	`4`	`Code`	`Gb`	`main.o`
`memset`	`0x08000DA7`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`reset_handler`	`0x08000D15`		`2`	`Code`	`Gb`	`STM32G0xx_Startup.o`

Function symbols by address

Address	Symbol name	Size	Align	Type	Bd	Object File
`0x080000D1`	`SystemInit`	`16`	`4`	`Code`	`Gb`	`system_stm32g0xx.o`
`0x080000E1`	`SystemCoreClockUpdate`	`140`	`4`	`Code`	`Gb`	`system_stm32g0xx.o`
`0x080001AD`	`AES128_ECB_decrypt`	`692`	`4`	`Code`	`Gb`	`aes.o`
`0x08000461`	`AddRoundKey`	`56`	`4`	`Code`	`Lc`	`aes.o`
`0x08000499`	`main`	`1 136`	`4`	`Code`	`Gb`	`main.o`
`0x08000909`	`Init`	`512`	`4`	`Code`	`Gb`	`main.o`
`0x08000B09`	`WaitForByte`	`140`	`4`	`Code`	`Gb`	`main.o`
`0x08000B95`	`JumpToApplication`	`152`	`4`	`Code`	`Gb`	`main.o`
`0x08000C2D`	`Transmit`	`32`	`4`	`Code`	`Gb`	`main.o`
`0x08000C4D`	`TurnErrorLEDOn`	`68`	`4`	`Code`	`Gb`	`main.o`
`0x08000C91`	`Delay`	`28`	`4`	`Code`	`Gb`	`main.o`
`0x08000CAD`	`SysTick_Handler`	`16`	`4`	`Code`	`Gb`	`main.o`
`0x08000CBD`	`_start`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`0x08000CC7`	`__SEGGER_init_done`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`0x08000CCB`	`exit`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`0x08000CD1`	`SVC_Handler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CD3`	`PendSV_Handler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CD5`	`WWDG_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CD7`	`PVD_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CD9`	`RTC_STAMP_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CDB`	`FLASH_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CDD`	`RCC_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CDF`	`EXTI0_1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CE1`	`EXTI2_3_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CE3`	`EXTI4_15_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CE5`	`UCPD1_UCPD2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CE7`	`DMA_Channel1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CE9`	`DMA_Channel2_3_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CEB`	`DMA_Channel4_5_6_7_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CED`	`ADC_COMP_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CEF`	`TIM1_BRK_UP_TRG_COMP_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CF1`	`TIM1_CC_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CF3`	`TIM2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CF5`	`TIM3_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CF7`	`TIM6_DAC_LPTIM1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CF9`	`TIM7_LPTIM2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CFB`	`TIM14_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CFD`	`TIM15_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000CFF`	`TIM16_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D01`	`TIM17_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D03`	`I2C1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D05`	`I2C2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D07`	`SPI1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D09`	`SPI2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D0B`	`USART1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D0D`	`USART2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D0F`	`USART3_USART4_LPUART1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D11`	`CEC_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D13`	`AES_RNG_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`0x08000D15`	`reset_handler`		`2`	`Code`	`Gb`	`STM32G0xx_Startup.o`
`0x08000D15`	`Reset_Handler`		`2`	`Code`	`Gb`	`STM32G0xx_Startup.o`
`0x08000D1B`	`NMI_Handler`	`14`	`2`	`Code`	`Gb`	`main.o`
`0x08000D29`	`__aeabi_idiv0`	`6`	`2`	`Code`	`Wk`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x08000D2F`	`TransmitACK`	`20`	`2`	`Code`	`Gb`	`main.o`
`0x08000D43`	`TransmitNACK`	`20`	`2`	`Code`	`Gb`	`main.o`
`0x08000D57`	`HardFault_Handler`	`16`	`2`	`Code`	`Gb`	`main.o`
`0x08000D67`	`__aeabi_uidiv`	`56`	`2`	`Code`	`Wk`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x08000D9F`	`__aeabi_memclr8`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x08000D9F`	`__aeabi_memclr4`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x08000D9F`	`__aeabi_memclr`	`20`	`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x08000DA1`	`__aeabi_memset8`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x08000DA1`	`__aeabi_memset4`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x08000DA1`	`__aeabi_memset`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x08000DA7`	`memset`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`0x080010F9`	`__SEGGER_init_zero`	`18`	`2`	`Code`	`Wk`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`
`0x0800110B`	`__SEGGER_init_copy`	`20`	`2`	`Code`	`Wk`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`

Function symbols by descending size

Symbol name	Size	Align	Type	Bd	Object File
`main`	`1 136`	`4`	`Code`	`Gb`	`main.o`
`AES128_ECB_decrypt`	`692`	`4`	`Code`	`Gb`	`aes.o`
`Init`	`512`	`4`	`Code`	`Gb`	`main.o`
`JumpToApplication`	`152`	`4`	`Code`	`Gb`	`main.o`
`SystemCoreClockUpdate`	`140`	`4`	`Code`	`Gb`	`system_stm32g0xx.o`
`WaitForByte`	`140`	`4`	`Code`	`Gb`	`main.o`
`TurnErrorLEDOn`	`68`	`4`	`Code`	`Gb`	`main.o`
`AddRoundKey`	`56`	`4`	`Code`	`Lc`	`aes.o`
`__aeabi_uidiv`	`56`	`2`	`Code`	`Wk`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`Transmit`	`32`	`4`	`Code`	`Gb`	`main.o`
`Delay`	`28`	`4`	`Code`	`Gb`	`main.o`
`TransmitACK`	`20`	`2`	`Code`	`Gb`	`main.o`
`TransmitNACK`	`20`	`2`	`Code`	`Gb`	`main.o`
`__SEGGER_init_copy`	`20`	`2`	`Code`	`Wk`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`
`__aeabi_memclr`	`20`	`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__SEGGER_init_zero`	`18`	`2`	`Code`	`Wk`	`SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)`
`HardFault_Handler`	`16`	`2`	`Code`	`Gb`	`main.o`
`SysTick_Handler`	`16`	`4`	`Code`	`Gb`	`main.o`
`SystemInit`	`16`	`4`	`Code`	`Gb`	`system_stm32g0xx.o`
`NMI_Handler`	`14`	`2`	`Code`	`Gb`	`main.o`
`__aeabi_idiv0`	`6`	`2`	`Code`	`Wk`	`intasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`ADC_COMP_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`AES_RNG_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`CEC_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`DMA_Channel1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`DMA_Channel2_3_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`DMA_Channel4_5_6_7_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`EXTI0_1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`EXTI2_3_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`EXTI4_15_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`FLASH_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`I2C1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`I2C2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`PVD_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`PendSV_Handler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`RCC_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`RTC_STAMP_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`Reset_Handler`		`2`	`Code`	`Gb`	`STM32G0xx_Startup.o`
`SPI1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`SPI2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`SVC_Handler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM14_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM15_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM16_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM17_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM1_BRK_UP_TRG_COMP_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM1_CC_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM3_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM6_DAC_LPTIM1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`TIM7_LPTIM2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`UCPD1_UCPD2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`USART1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`USART2_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`USART3_USART4_LPUART1_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`WWDG_IRQHandler`		`2`	`Code`	`Wk`	`STM32G07x_Vectors.o`
`__SEGGER_init_done`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`__aeabi_memclr4`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memclr8`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memset`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memset4`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`__aeabi_memset8`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`_start`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`exit`		`4`	`Code`	`Gb`	`SEGGER_THUMB_Startup.o`
`memset`		`2`	`Code`	`Wk`	`strasmops_arm.o (libc_v6m_t_le_eabi_small.a)`
`reset_handler`		`2`	`Code`	`Gb`	`STM32G0xx_Startup.o`

Read-write data symbols by name

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol name	Address	Size	Align	Type	Bd	Object File
`Key`	`0x20000014`	`4`	`4`	`Zero`	`Lc`	`aes.o`
`RoundKey`	`0x20000018`	`176`		`Zero`	`Lc`	`aes.o`
`SystemCoreClock`	`0x20000000`	`4`	`4`	`Init`	`Gb`	`system_stm32g0xx.o`
`msCounter`	`0x20000010`	`4`	`4`	`Zero`	`Gb`	`main.o`
`state`	`0x2000000C`	`4`	`4`	`Zero`	`Lc`	`aes.o`
`u`	`0x20000004`	`5`	`4`	`Zero`	`Gb`	`main.o`

Read-write data symbols by address

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Address	Symbol name	Size	Align	Type	Bd	Object File
`0x20000000`	`SystemCoreClock`	`4`	`4`	`Init`	`Gb`	`system_stm32g0xx.o`
`0x20000004`	`u`	`5`	`4`	`Zero`	`Gb`	`main.o`
`0x2000000C`	`state`	`4`	`4`	`Zero`	`Lc`	`aes.o`
`0x20000010`	`msCounter`	`4`	`4`	`Zero`	`Gb`	`main.o`
`0x20000014`	`Key`	`4`	`4`	`Zero`	`Lc`	`aes.o`
`0x20000018`	`RoundKey`	`176`		`Zero`	`Lc`	`aes.o`

Read-write data symbols by descending size

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol name	Size	Align	Type	Bd	Object File
`RoundKey`	`176`		`Zero`	`Lc`	`aes.o`
`u`	`5`	`4`	`Zero`	`Gb`	`main.o`
`Key`	`4`	`4`	`Zero`	`Lc`	`aes.o`
`SystemCoreClock`	`4`	`4`	`Init`	`Gb`	`system_stm32g0xx.o`
`msCounter`	`4`	`4`	`Zero`	`Gb`	`main.o`
`state`	`4`	`4`	`Zero`	`Lc`	`aes.o`

Read-only data symbols by name

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Symbol name	Address	Size	Align	Type	Bd	Object File
`AES_KEY`	`0x080010B8`	`16`		`Cnst`	`Gb`	`main.o`
`AHBPrescTable`	`0x0800016C`	`64`	`4`	`Cnst`	`Gb`	`system_stm32g0xx.o`
`FW_VERSION`	`0x080000C0`	`16`	`16`	`Cnst`	`Gb`	`main.o`
`Rcon`	`0x08000DB2`	`255`		`Cnst`	`Lc`	`aes.o`
`__SEGGER_init_data__`	`0x080010F4`	`[4]`	`4`	`Cnst`	`Lc`	`[ Linker created ]`
`__SEGGER_init_table__`	`0x080010C8`	`[44]`	`4`	`Cnst`	`Lc`	`[ Linker created ]`
`rsbox`	`0x08000FB8`	`256`		`Cnst`	`Lc`	`aes.o`
`sbox`	`0x08000EB8`	`256`		`Cnst`	`Lc`	`aes.o`

Read-only data symbols by address

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Address	Symbol name	Size	Align	Type	Bd	Object File
`0x080000C0`	`FW_VERSION`	`16`	`16`	`Cnst`	`Gb`	`main.o`
`0x0800016C`	`AHBPrescTable`	`64`	`4`	`Cnst`	`Gb`	`system_stm32g0xx.o`
`0x08000DB2`	`Rcon`	`255`		`Cnst`	`Lc`	`aes.o`
`0x08000EB8`	`sbox`	`256`		`Cnst`	`Lc`	`aes.o`
`0x08000FB8`	`rsbox`	`256`		`Cnst`	`Lc`	`aes.o`
`0x080010B8`	`AES_KEY`	`16`		`Cnst`	`Gb`	`main.o`
`0x080010C8`	`__SEGGER_init_table__`	`[44]`	`4`	`Cnst`	`Lc`	`[ Linker created ]`
`0x080010F4`	`__SEGGER_init_data__`	`[4]`	`4`	`Cnst`	`Lc`	`[ Linker created ]`

Untyped symbols by name

Symbol name	Value	Size	Align	Type	Bd	Object File
`__FLASH1_segment_end__`	`0x08003000`			`----`	`Gb`	`[ Linker created ]`
`__FLASH1_segment_size__`	`0x00003000`			`----`	`Gb`	`[ Linker created ]`
`__FLASH1_segment_start__`	`0x08000000`			`----`	`Gb`	`[ Linker created ]`
`__FLASH1_segment_used_end__`	`0x0800111E`			`----`	`Gb`	`[ Linker created ]`
`__FLASH1_segment_used_size__`	`0x0000111E`			`----`	`Gb`	`[ Linker created ]`
`__FLASH1_segment_used_start__`	`0x08000000`			`----`	`Gb`	`[ Linker created ]`
`__FLASH_segment_end__`	`0x08003000`			`----`	`Gb`	`[ Linker created ]`
`__FLASH_segment_size__`	`0x00003000`			`----`	`Gb`	`[ Linker created ]`
`__FLASH_segment_start__`	`0x08000000`			`----`	`Gb`	`[ Linker created ]`
`__FLASH_segment_used_end__`	`0x0800111E`			`----`	`Gb`	`[ Linker created ]`
`__FLASH_segment_used_size__`	`0x0000111E`			`----`	`Gb`	`[ Linker created ]`
`__FLASH_segment_used_start__`	`0x08000000`			`----`	`Gb`	`[ Linker created ]`
`__HEAPSIZE__`	`0x00000000`			`----`	`Gb`	`[ Linker created ]`
`__RAM1_segment_end__`	`0x20008000`			`----`	`Gb`	`[ Linker created ]`
`__RAM1_segment_size__`	`0x00008000`			`----`	`Gb`	`[ Linker created ]`
`__RAM1_segment_start__`	`0x20000000`			`----`	`Gb`	`[ Linker created ]`
`__RAM1_segment_used_end__`	`0x20008000`			`----`	`Gb`	`[ Linker created ]`
`__RAM1_segment_used_size__`	`0x00008000`			`----`	`Gb`	`[ Linker created ]`
`__RAM1_segment_used_start__`	`0x20000000`			`----`	`Gb`	`[ Linker created ]`
`__RAM_segment_end__`	`0x20008000`			`----`	`Gb`	`[ Linker created ]`
`__RAM_segment_size__`	`0x00008000`			`----`	`Gb`	`[ Linker created ]`
`__RAM_segment_start__`	`0x20000000`			`----`	`Gb`	`[ Linker created ]`
`__RAM_segment_used_end__`	`0x20008000`			`----`	`Gb`	`[ Linker created ]`
`__RAM_segment_used_size__`	`0x00008000`			`----`	`Gb`	`[ Linker created ]`
`__RAM_segment_used_start__`	`0x20000000`			`----`	`Gb`	`[ Linker created ]`
`__SEGGER_init_run_loop`	`0x08000CBE`		`4`	`Code`	`Lc`	`SEGGER_THUMB_Startup.o`
`__STACKSIZE_PROCESS__`	`0x00000000`			`----`	`Gb`	`[ Linker created ]`
`__STACKSIZE__`	`0x00001000`			`----`	`Gb`	`[ Linker created ]`
`__stack_end__`	`0x20008000`			`----`	`Gb`	`[ Linker created ]`
`__thread_pointer$`	`0x00000000`			`----`	`Gb`	`[ Linker created ]`
`_vectors`	`0x08000000`	`[192]`	`512`	`Code`	`Gb`	`STM32G07x_Vectors.o`
`_vectors_end`	`0x080000C0`		`512`	`Code`	`Lc`	`STM32G07x_Vectors.o`

Untyped symbols by address

Value	Symbol name	Size	Align	Type	Bd	Object File
`0x00000000`	`__thread_pointer$`			`----`	`Gb`	`[ Linker created ]`
`0x00000000`	`__STACKSIZE_PROCESS__`			`----`	`Gb`	`[ Linker created ]`
`0x00000000`	`__HEAPSIZE__`			`----`	`Gb`	`[ Linker created ]`
`0x00001000`	`__STACKSIZE__`			`----`	`Gb`	`[ Linker created ]`
`0x0000111E`	`__FLASH_segment_used_size__`			`----`	`Gb`	`[ Linker created ]`
`0x0000111E`	`__FLASH1_segment_used_size__`			`----`	`Gb`	`[ Linker created ]`
`0x00003000`	`__FLASH_segment_size__`			`----`	`Gb`	`[ Linker created ]`
`0x00003000`	`__FLASH1_segment_size__`			`----`	`Gb`	`[ Linker created ]`
`0x00008000`	`__RAM_segment_used_size__`			`----`	`Gb`	`[ Linker created ]`
`0x00008000`	`__RAM_segment_size__`			`----`	`Gb`	`[ Linker created ]`
`0x00008000`	`__RAM1_segment_used_size__`			`----`	`Gb`	`[ Linker created ]`
`0x00008000`	`__RAM1_segment_size__`			`----`	`Gb`	`[ Linker created ]`
`0x08000000`	`_vectors`	`[192]`	`512`	`Code`	`Gb`	`STM32G07x_Vectors.o`
`0x08000000`	`__FLASH_segment_used_start__`			`----`	`Gb`	`[ Linker created ]`
`0x08000000`	`__FLASH_segment_start__`			`----`	`Gb`	`[ Linker created ]`
`0x08000000`	`__FLASH1_segment_used_start__`			`----`	`Gb`	`[ Linker created ]`
`0x08000000`	`__FLASH1_segment_start__`			`----`	`Gb`	`[ Linker created ]`
`0x080000C0`	`_vectors_end`		`512`	`Code`	`Lc`	`STM32G07x_Vectors.o`
`0x08000CBE`	`__SEGGER_init_run_loop`		`4`	`Code`	`Lc`	`SEGGER_THUMB_Startup.o`
`0x0800111E`	`__FLASH_segment_used_end__`			`----`	`Gb`	`[ Linker created ]`
`0x0800111E`	`__FLASH1_segment_used_end__`			`----`	`Gb`	`[ Linker created ]`
`0x08003000`	`__FLASH_segment_end__`			`----`	`Gb`	`[ Linker created ]`
`0x08003000`	`__FLASH1_segment_end__`			`----`	`Gb`	`[ Linker created ]`
`0x20000000`	`__RAM_segment_used_start__`			`----`	`Gb`	`[ Linker created ]`
`0x20000000`	`__RAM_segment_start__`			`----`	`Gb`	`[ Linker created ]`
`0x20000000`	`__RAM1_segment_used_start__`			`----`	`Gb`	`[ Linker created ]`
`0x20000000`	`__RAM1_segment_start__`			`----`	`Gb`	`[ Linker created ]`
`0x20008000`	`__stack_end__`			`----`	`Gb`	`[ Linker created ]`
`0x20008000`	`__RAM_segment_used_end__`			`----`	`Gb`	`[ Linker created ]`
`0x20008000`	`__RAM_segment_end__`			`----`	`Gb`	`[ Linker created ]`
`0x20008000`	`__RAM1_segment_used_end__`			`----`	`Gb`	`[ Linker created ]`
`0x20008000`	`__RAM1_segment_end__`			`----`	`Gb`	`[ Linker created ]`

REGION LIST

Regions by name

+ + + + + + + + + + + + + + + + + + + + + + + + + + +

Name	Range	Size
`FLASH`	`08000000-08002fff`	`12 288`
`FLASH1`	`08000000-08002fff`	`12 288`
`RAM`	`20000000-20007fff`	`32 768`
`RAM1`	`20000000-20007fff`	`32 768`

Analysis

+FLASH: + Identical to region FLASH1 + +FLASH1: + Identical to region FLASH + +RAM: + Identical to region RAM1 + +RAM1: + Identical to region RAM +

BLOCK LIST

Blocks by name

+ + + + + + + + + + + + + + + + + + + + + +

Name	Range	Size
`ctors`	`08000eb4-08000eb7`	`4`
`stack`	`20007000-20007fff`	`4 096`
`vectors`	`08000000-080000bf`	`192`

Blocks by address

+ + + + + + + + + + + + + + + + + + + + + +

Range	Size	Name
`08000000-080000bf`	`192`	`vectors`
`08000eb4-08000eb7`	`4`	`ctors`
`20007000-20007fff`	`4 096`	`stack`

STACK SIZES

Functions by stack size

+ + + + + + +

Function name	Stack	Object File

Functions without stack size information

+ SystemInit + SystemCoreClockUpdate + AddRoundKey + AES128_ECB_decrypt + main + Init + WaitForByte + TransmitACK + Transmit + TransmitNACK + JumpToApplication + TurnErrorLEDOn + Delay + SysTick_Handler + HardFault_Handler + NMI_Handler + _start + __SEGGER_init_done + exit + SVC_Handler + PendSV_Handler + WWDG_IRQHandler + PVD_IRQHandler + RTC_STAMP_IRQHandler + FLASH_IRQHandler + RCC_IRQHandler + EXTI0_1_IRQHandler + EXTI2_3_IRQHandler + EXTI4_15_IRQHandler + UCPD1_UCPD2_IRQHandler + DMA_Channel1_IRQHandler + DMA_Channel2_3_IRQHandler + DMA_Channel4_5_6_7_IRQHandler + ADC_COMP_IRQHandler + TIM1_BRK_UP_TRG_COMP_IRQHandler + TIM1_CC_IRQHandler + TIM2_IRQHandler + TIM3_IRQHandler + TIM6_DAC_LPTIM1_IRQHandler + TIM7_LPTIM2_IRQHandler + TIM14_IRQHandler + TIM15_IRQHandler + TIM16_IRQHandler + TIM17_IRQHandler + I2C1_IRQHandler + I2C2_IRQHandler + SPI1_IRQHandler + SPI2_IRQHandler + USART1_IRQHandler + USART2_IRQHandler + USART3_USART4_LPUART1_IRQHandler + CEC_IRQHandler + AES_RNG_IRQHandler + reset_handler + Reset_Handler + __aeabi_idiv0 + __aeabi_uidiv + __aeabi_memclr + __aeabi_memclr8 + __aeabi_memclr4 + __aeabi_memset8 + __aeabi_memset4 + __aeabi_memset + memset + __SEGGER_init_zero + __SEGGER_init_copy +

UNUSED INPUTS

Unused object files

+No unused object files +

ABSOLUTE LISTING

Section .vectors from STM32G07x_Vectors.o, size=192, align=512

+
_vectors:
+  0x08000000:  20008000     DC.W       0x20008000
+  0x08000004:  08000D15     DC.W       reset_handler
+  0x08000008:  08000D1B     DC.W       NMI_Handler
+  0x0800000C:  08000D57     DC.W       HardFault_Handler
+  0x08000010:  00           DC.B       0x00                     ; '\0'
+  0x08000011:  00           DC.B       0x00                     ; '\0'
+  0x08000012:  00           DC.B       0x00                     ; '\0'
+  0x08000013:  00           DC.B       0x00                     ; '\0'
+  0x08000014:  00           DC.B       0x00                     ; '\0'
+  0x08000015:  00           DC.B       0x00                     ; '\0'
+  0x08000016:  00           DC.B       0x00                     ; '\0'
+  0x08000017:  00           DC.B       0x00                     ; '\0'
+  0x08000018:  00           DC.B       0x00                     ; '\0'
+  0x08000019:  00           DC.B       0x00                     ; '\0'
+  0x0800001A:  00           DC.B       0x00                     ; '\0'
+  0x0800001B:  00           DC.B       0x00                     ; '\0'
+  0x0800001C:  00           DC.B       0x00                     ; '\0'
+  0x0800001D:  00           DC.B       0x00                     ; '\0'
+  0x0800001E:  00           DC.B       0x00                     ; '\0'
+  0x0800001F:  00           DC.B       0x00                     ; '\0'
+  0x08000020:  00           DC.B       0x00                     ; '\0'
+  0x08000021:  00           DC.B       0x00                     ; '\0'
+  0x08000022:  00           DC.B       0x00                     ; '\0'
+  0x08000023:  00           DC.B       0x00                     ; '\0'
+  0x08000024:  00           DC.B       0x00                     ; '\0'
+  0x08000025:  00           DC.B       0x00                     ; '\0'
+  0x08000026:  00           DC.B       0x00                     ; '\0'
+  0x08000027:  00           DC.B       0x00                     ; '\0'
+  0x08000028:  00           DC.B       0x00                     ; '\0'
+  0x08000029:  00           DC.B       0x00                     ; '\0'
+  0x0800002A:  00           DC.B       0x00                     ; '\0'
+  0x0800002B:  00           DC.B       0x00                     ; '\0'
+  0x0800002C:  08000CD1     DC.W       SVC_Handler
+  0x08000030:  00           DC.B       0x00                     ; '\0'
+  0x08000031:  00           DC.B       0x00                     ; '\0'
+  0x08000032:  00           DC.B       0x00                     ; '\0'
+  0x08000033:  00           DC.B       0x00                     ; '\0'
+  0x08000034:  00           DC.B       0x00                     ; '\0'
+  0x08000035:  00           DC.B       0x00                     ; '\0'
+  0x08000036:  00           DC.B       0x00                     ; '\0'
+  0x08000037:  00           DC.B       0x00                     ; '\0'
+  0x08000038:  08000CD3     DC.W       PendSV_Handler
+  0x0800003C:  08000CAD     DC.W       SysTick_Handler
+  0x08000040:  08000CD5     DC.W       WWDG_IRQHandler
+  0x08000044:  08000CD7     DC.W       PVD_IRQHandler
+  0x08000048:  08000CD9     DC.W       RTC_STAMP_IRQHandler
+  0x0800004C:  08000CDB     DC.W       FLASH_IRQHandler
+  0x08000050:  08000CDD     DC.W       RCC_IRQHandler
+  0x08000054:  08000CDF     DC.W       EXTI0_1_IRQHandler
+  0x08000058:  08000CE1     DC.W       EXTI2_3_IRQHandler
+  0x0800005C:  08000CE3     DC.W       EXTI4_15_IRQHandler
+  0x08000060:  08000CE5     DC.W       UCPD1_UCPD2_IRQHandler
+  0x08000064:  08000CE7     DC.W       DMA_Channel1_IRQHandler
+  0x08000068:  08000CE9     DC.W       DMA_Channel2_3_IRQHandler
+  0x0800006C:  08000CEB     DC.W       DMA_Channel4_5_6_7_IRQHandler
+  0x08000070:  08000CED     DC.W       ADC_COMP_IRQHandler
+  0x08000074:  08000CEF     DC.W       TIM1_BRK_UP_TRG_COMP_IRQHandler
+  0x08000078:  08000CF1     DC.W       TIM1_CC_IRQHandler
+  0x0800007C:  08000CF3     DC.W       TIM2_IRQHandler
+  0x08000080:  08000CF5     DC.W       TIM3_IRQHandler
+  0x08000084:  08000CF7     DC.W       TIM6_DAC_LPTIM1_IRQHandler
+  0x08000088:  08000CF9     DC.W       TIM7_LPTIM2_IRQHandler
+  0x0800008C:  08000CFB     DC.W       TIM14_IRQHandler
+  0x08000090:  08000CFD     DC.W       TIM15_IRQHandler
+  0x08000094:  08000CFF     DC.W       TIM16_IRQHandler
+  0x08000098:  08000D01     DC.W       TIM17_IRQHandler
+  0x0800009C:  08000D03     DC.W       I2C1_IRQHandler
+  0x080000A0:  08000D05     DC.W       I2C2_IRQHandler
+  0x080000A4:  08000D07     DC.W       SPI1_IRQHandler
+  0x080000A8:  08000D09     DC.W       SPI2_IRQHandler
+  0x080000AC:  08000D0B     DC.W       USART1_IRQHandler
+  0x080000B0:  08000D0D     DC.W       USART2_IRQHandler
+  0x080000B4:  08000D0F     DC.W       USART3_USART4_LPUART1_IRQHandler
+  0x080000B8:  08000D11     DC.W       CEC_IRQHandler
+  0x080000BC:  08000D13     DC.W       AES_RNG_IRQHandler
+

Section .rodata.FW_VERSION from main.o, size=16, align=16

+
FW_VERSION:
+_vectors_end:
+  0x080000C0:  45           DC.B       0x45                     ; 'E'
+  0x080000C1:  43           DC.B       0x43                     ; 'C'
+  0x080000C2:  53           DC.B       0x53                     ; 'S'
+  0x080000C3:  2E           DC.B       0x2E                     ; '.'
+  0x080000C4:  46           DC.B       0x46                     ; 'F'
+  0x080000C5:  57           DC.B       0x57                     ; 'W'
+  0x080000C6:  3A           DC.B       0x3A                     ; ':'
+  0x080000C7:  30           DC.B       0x30                     ; '0'
+  0x080000C8:  31           DC.B       0x31                     ; '1'
+  0x080000C9:  2E           DC.B       0x2E                     ; '.'
+  0x080000CA:  30           DC.B       0x30                     ; '0'
+  0x080000CB:  30           DC.B       0x30                     ; '0'
+  0x080000CC:  2E           DC.B       0x2E                     ; '.'
+  0x080000CD:  30           DC.B       0x30                     ; '0'
+  0x080000CE:  31           DC.B       0x31                     ; '1'
+  0x080000CF:  00           DC.B       0x00                     ; '\0'
+

Section .init.SystemInit from system_stm32g0xx.o, size=16, align=4

+
SystemInit:
+  0x080000D0:  2001         MOVS       R0, #1
+  0x080000D2:  06C0         LSLS       R0, R0, #27
+  0x080000D4:  4901         LDR        R1, =0xE000ED08          ; [PC, #4] [0x080000DC]
+  0x080000D6:  6008         STR        R0, [R1]
+  0x080000D8:  4770         BX         LR
+  0x080000DA:  46C0         NOP
+  0x080000DC:  E000ED08     DC.W       0xE000ED08
+

Section .init.SystemCoreClockUpdate from system_stm32g0xx.o, size=140, align=4

+
SystemCoreClockUpdate:
+  0x080000E0:  B510         PUSH       {R4, LR}
+  0x080000E2:  4C1D         LDR        R4, =0x40021000          ; [PC, #116] [0x08000158]
+  0x080000E4:  68A0         LDR        R0, [R4, #8]
+  0x080000E6:  0680         LSLS       R0, R0, #26
+  0x080000E8:  0F40         LSRS       R0, R0, #29
+  0x080000EA:  1E41         SUBS       R1, R0, #1
+  0x080000EC:  2903         CMP        R1, #3
+  0x080000EE:  D823         BHI        .L2                      ; 0x08000138
+  0x080000F0:  481A         LDR        R0, =0x007A1200          ; [PC, #104] [0x0800015C]
+  0x080000F2:  46C0         NOP
+  0x080000F4:  4479         ADD        R1, PC
+  0x080000F6:  7909         LDRB       R1, [R1, #4]
+  0x080000F8:  0049         LSLS       R1, R1, #1
+  0x080000FA:  448F         ADD        PC, R1
+  0x080000FC:  22           DC.B       0x22                     ; '\"'
+  0x080000FD:  01           DC.B       0x01                     ; '\x01'
+  0x080000FE:  17           DC.B       0x17                     ; '\x17'
+  0x080000FF:  1A           DC.B       0x1A                     ; '\x1A'
+  0x08000100:  68E1         LDR        R1, [R4, #12]
+  0x08000102:  2203         MOVS       R2, #3
+  0x08000104:  400A         ANDS       R2, R1
+  0x08000106:  2A03         CMP        R2, #3
+  0x08000108:  D000         BEQ        .L1                      ; 0x0800010C
+  0x0800010A:  4815         LDR        R0, =0x00F42400          ; [PC, #84] [0x08000160]
+
.L1:
+  0x0800010C:  68E1         LDR        R1, [R4, #12]
+  0x0800010E:  0649         LSLS       R1, R1, #25
+  0x08000110:  0F49         LSRS       R1, R1, #29
+  0x08000112:  1C49         ADDS       R1, R1, #1
+  0x08000114:  F000 FE27    BL         __aeabi_uidiv            ; 0x08000D66
+  0x08000118:  68E1         LDR        R1, [R4, #12]
+  0x0800011A:  0449         LSLS       R1, R1, #17
+  0x0800011C:  0E49         LSRS       R1, R1, #25
+  0x0800011E:  4348         MULS       R0, R1, R0
+  0x08000120:  68E1         LDR        R1, [R4, #12]
+  0x08000122:  0F49         LSRS       R1, R1, #29
+  0x08000124:  1C49         ADDS       R1, R1, #1
+  0x08000126:  F000 FE1E    BL         __aeabi_uidiv            ; 0x08000D66
+  0x0800012A:  E00A         B          .L3                      ; 0x08000142
+  0x0800012C:  207D         MOVS       R0, #125
+  0x0800012E:  0200         LSLS       R0, R0, #8
+  0x08000130:  E007         B          .L3                      ; 0x08000142
+  0x08000132:  2001         MOVS       R0, #1
+  0x08000134:  03C0         LSLS       R0, R0, #15
+  0x08000136:  E004         B          .L3                      ; 0x08000142
+
.L2:
+  0x08000138:  6820         LDR        R0, [R4]
+  0x0800013A:  0480         LSLS       R0, R0, #18
+  0x0800013C:  0F41         LSRS       R1, R0, #29
+  0x0800013E:  4808         LDR        R0, =0x00F42400          ; [PC, #32] [0x08000160]
+  0x08000140:  40C8         LSRS       R0, R1
+
.L3:
+  0x08000142:  4908         LDR        R1, =SystemCoreClock     ; [PC, #32] [0x08000164] =0x20000000
+  0x08000144:  6008         STR        R0, [R1]
+  0x08000146:  68A2         LDR        R2, [R4, #8]
+  0x08000148:  0992         LSRS       R2, R2, #6
+  0x0800014A:  233C         MOVS       R3, #60
+  0x0800014C:  4013         ANDS       R3, R2
+  0x0800014E:  4A06         LDR        R2, =AHBPrescTable       ; [PC, #24] [0x08000168] =0x0800016C
+  0x08000150:  58D2         LDR        R2, [R2, R3]
+  0x08000152:  40D0         LSRS       R0, R2
+  0x08000154:  6008         STR        R0, [R1]
+  0x08000156:  BD10         POP        {R4, PC}
+  0x08000158:  40021000     DC.W       0x40021000
+  0x0800015C:  007A1200     DC.W       0x007A1200
+  0x08000160:  00F42400     DC.W       0x00F42400
+  0x08000164:  20000000     DC.W       SystemCoreClock
+  0x08000168:  0800016C     DC.W       AHBPrescTable
+

Section .init_rodata.AHBPrescTable from system_stm32g0xx.o, size=64, align=4

+
AHBPrescTable:
+  0x0800016C:  00           DC.B       0x00                     ; '\0'
+  0x0800016D:  00           DC.B       0x00                     ; '\0'
+  0x0800016E:  00           DC.B       0x00                     ; '\0'
+  0x0800016F:  00           DC.B       0x00                     ; '\0'
+  0x08000170:  00           DC.B       0x00                     ; '\0'
+  0x08000171:  00           DC.B       0x00                     ; '\0'
+  0x08000172:  00           DC.B       0x00                     ; '\0'
+  0x08000173:  00           DC.B       0x00                     ; '\0'
+  0x08000174:  00           DC.B       0x00                     ; '\0'
+  0x08000175:  00           DC.B       0x00                     ; '\0'
+  0x08000176:  00           DC.B       0x00                     ; '\0'
+  0x08000177:  00           DC.B       0x00                     ; '\0'
+  0x08000178:  00           DC.B       0x00                     ; '\0'
+  0x08000179:  00           DC.B       0x00                     ; '\0'
+  0x0800017A:  00           DC.B       0x00                     ; '\0'
+  0x0800017B:  00           DC.B       0x00                     ; '\0'
+  0x0800017C:  00           DC.B       0x00                     ; '\0'
+  0x0800017D:  00           DC.B       0x00                     ; '\0'
+  0x0800017E:  00           DC.B       0x00                     ; '\0'
+  0x0800017F:  00           DC.B       0x00                     ; '\0'
+  0x08000180:  00           DC.B       0x00                     ; '\0'
+  0x08000181:  00           DC.B       0x00                     ; '\0'
+  0x08000182:  00           DC.B       0x00                     ; '\0'
+  0x08000183:  00           DC.B       0x00                     ; '\0'
+  0x08000184:  00           DC.B       0x00                     ; '\0'
+  0x08000185:  00           DC.B       0x00                     ; '\0'
+  0x08000186:  00           DC.B       0x00                     ; '\0'
+  0x08000187:  00           DC.B       0x00                     ; '\0'
+  0x08000188:  00           DC.B       0x00                     ; '\0'
+  0x08000189:  00           DC.B       0x00                     ; '\0'
+  0x0800018A:  00           DC.B       0x00                     ; '\0'
+  0x0800018B:  00           DC.B       0x00                     ; '\0'
+  0x0800018C:  01           DC.B       0x01                     ; '\x01'
+  0x0800018D:  00           DC.B       0x00                     ; '\0'
+  0x0800018E:  00           DC.B       0x00                     ; '\0'
+  0x0800018F:  00           DC.B       0x00                     ; '\0'
+  0x08000190:  02           DC.B       0x02                     ; '\x02'
+  0x08000191:  00           DC.B       0x00                     ; '\0'
+  0x08000192:  00           DC.B       0x00                     ; '\0'
+  0x08000193:  00           DC.B       0x00                     ; '\0'
+  0x08000194:  03           DC.B       0x03                     ; '\x03'
+  0x08000195:  00           DC.B       0x00                     ; '\0'
+  0x08000196:  00           DC.B       0x00                     ; '\0'
+  0x08000197:  00           DC.B       0x00                     ; '\0'
+  0x08000198:  04           DC.B       0x04                     ; '\x04'
+  0x08000199:  00           DC.B       0x00                     ; '\0'
+  0x0800019A:  00           DC.B       0x00                     ; '\0'
+  0x0800019B:  00           DC.B       0x00                     ; '\0'
+  0x0800019C:  06           DC.B       0x06                     ; '\x06'
+  0x0800019D:  00           DC.B       0x00                     ; '\0'
+  0x0800019E:  00           DC.B       0x00                     ; '\0'
+  0x0800019F:  00           DC.B       0x00                     ; '\0'
+  0x080001A0:  07           DC.B       0x07                     ; '\x07'
+  0x080001A1:  00           DC.B       0x00                     ; '\0'
+  0x080001A2:  00           DC.B       0x00                     ; '\0'
+  0x080001A3:  00           DC.B       0x00                     ; '\0'
+  0x080001A4:  08           DC.B       0x08                     ; '\x08'
+  0x080001A5:  00           DC.B       0x00                     ; '\0'
+  0x080001A6:  00           DC.B       0x00                     ; '\0'
+  0x080001A7:  00           DC.B       0x00                     ; '\0'
+  0x080001A8:  09           DC.B       0x09                     ; '\t'
+  0x080001A9:  00           DC.B       0x00                     ; '\0'
+  0x080001AA:  00           DC.B       0x00                     ; '\0'
+  0x080001AB:  00           DC.B       0x00                     ; '\0'
+

Section .text.AES128_ECB_decrypt from aes.o, size=692, align=4

+
AES128_ECB_decrypt:
+  0x080001AC:  B5F0         PUSH       {R4-R7, LR}
+  0x080001AE:  B091         SUB        SP, SP, #68
+  0x080001B0:  2300         MOVS       R3, #0
+
.L1:
+  0x080001B2:  2B10         CMP        R3, #16
+  0x080001B4:  D003         BEQ        .L2                      ; 0x080001BE
+  0x080001B6:  5CC4         LDRB       R4, [R0, R3]
+  0x080001B8:  54D4         STRB       R4, [R2, R3]
+  0x080001BA:  1C5B         ADDS       R3, R3, #1
+  0x080001BC:  E7F9         B          .L1                      ; 0x080001B2
+
.L2:
+  0x080001BE:  48A2         LDR        R0, =Key                 ; [PC, #0x0288] [0x08000448] =0x20000014
+  0x080001C0:  6001         STR        R1, [R0]
+  0x080001C2:  48A2         LDR        R0, =state               ; [PC, #0x0288] [0x0800044C] =0x2000000C
+  0x080001C4:  6002         STR        R2, [R0]
+  0x080001C6:  2200         MOVS       R2, #0
+  0x080001C8:  48A1         LDR        R0, =RoundKey            ; [PC, #0x0284] [0x08000450] =0x20000018
+
.L3:
+  0x080001CA:  2A10         CMP        R2, #16
+  0x080001CC:  D00B         BEQ        .L4                      ; 0x080001E6
+  0x080001CE:  5C8B         LDRB       R3, [R1, R2]
+  0x080001D0:  5483         STRB       R3, [R0, R2]
+  0x080001D2:  1883         ADDS       R3, R0, R2
+  0x080001D4:  188C         ADDS       R4, R1, R2
+  0x080001D6:  7865         LDRB       R5, [R4, #1]
+  0x080001D8:  705D         STRB       R5, [R3, #1]
+  0x080001DA:  78A5         LDRB       R5, [R4, #2]
+  0x080001DC:  709D         STRB       R5, [R3, #2]
+  0x080001DE:  78E4         LDRB       R4, [R4, #3]
+  0x080001E0:  70DC         STRB       R4, [R3, #3]
+  0x080001E2:  1D12         ADDS       R2, R2, #4
+  0x080001E4:  E7F1         B          .L3                      ; 0x080001CA
+
.L4:
+  0x080001E6:  2104         MOVS       R1, #4
+  0x080001E8:  4C99         LDR        R4, =RoundKey            ; [PC, #0x0264] [0x08000450] =0x20000018
+
.L5:
+  0x080001EA:  292C         CMP        R1, #44
+  0x080001EC:  D048         BEQ        .L10                     ; 0x08000280
+  0x080001EE:  008D         LSLS       R5, R1, #2
+  0x080001F0:  220C         MOVS       R2, #12
+
.L6:
+  0x080001F2:  2A10         CMP        R2, #16
+  0x080001F4:  D006         BEQ        .L7                      ; 0x08000204
+  0x080001F6:  5CA3         LDRB       R3, [R4, R2]
+  0x080001F8:  AE10         ADD        R6, SP, #64
+  0x080001FA:  18B6         ADDS       R6, R6, R2
+  0x080001FC:  3E0C         SUBS       R6, #12
+  0x080001FE:  7033         STRB       R3, [R6]
+  0x08000200:  1C52         ADDS       R2, R2, #1
+  0x08000202:  E7F6         B          .L6                      ; 0x080001F2
+
.L7:
+  0x08000204:  AE10         ADD        R6, SP, #64
+  0x08000206:  78F7         LDRB       R7, [R6, #3]
+  0x08000208:  78B3         LDRB       R3, [R6, #2]
+  0x0800020A:  7872         LDRB       R2, [R6, #1]
+  0x0800020C:  7836         LDRB       R6, [R6]
+  0x0800020E:  0788         LSLS       R0, R1, #30
+  0x08000210:  D003         BEQ        .L8                      ; 0x0800021A
+  0x08000212:  970F         STR        R7, [SP, #60]
+  0x08000214:  930E         STR        R3, [SP, #56]
+  0x08000216:  4613         MOV        R3, R2
+  0x08000218:  E012         B          .L9                      ; 0x08000240
+
.L8:
+  0x0800021A:  488E         LDR        R0, =sbox                ; [PC, #0x0238] [0x08000454] =0x08000EB8
+  0x0800021C:  910D         STR        R1, [SP, #52]
+  0x0800021E:  4601         MOV        R1, R0
+  0x08000220:  5D86         LDRB       R6, [R0, R6]
+  0x08000222:  A810         ADD        R0, SP, #64
+  0x08000224:  960F         STR        R6, [SP, #60]
+  0x08000226:  70C6         STRB       R6, [R0, #3]
+  0x08000228:  5DCE         LDRB       R6, [R1, R7]
+  0x0800022A:  960E         STR        R6, [SP, #56]
+  0x0800022C:  7086         STRB       R6, [R0, #2]
+  0x0800022E:  5CCB         LDRB       R3, [R1, R3]
+  0x08000230:  7043         STRB       R3, [R0, #1]
+  0x08000232:  5C8A         LDRB       R2, [R1, R2]
+  0x08000234:  990D         LDR        R1, [SP, #52]
+  0x08000236:  088E         LSRS       R6, R1, #2
+  0x08000238:  4F87         LDR        R7, =Rcon                ; [PC, #0x021C] [0x08000458] =0x08000DB2
+  0x0800023A:  5DBE         LDRB       R6, [R7, R6]
+  0x0800023C:  4056         EORS       R6, R2
+  0x0800023E:  7006         STRB       R6, [R0]
+
.L9:
+  0x08000240:  4F83         LDR        R7, =RoundKey            ; [PC, #0x020C] [0x08000450] =0x20000018
+  0x08000242:  197A         ADDS       R2, R7, R5
+  0x08000244:  4610         MOV        R0, R2
+  0x08000246:  3810         SUBS       R0, #16
+  0x08000248:  7800         LDRB       R0, [R0]
+  0x0800024A:  4070         EORS       R0, R6
+  0x0800024C:  5578         STRB       R0, [R7, R5]
+  0x0800024E:  2001         MOVS       R0, #1
+  0x08000250:  4328         ORRS       R0, R5
+  0x08000252:  4616         MOV        R6, R2
+  0x08000254:  3E0F         SUBS       R6, #15
+  0x08000256:  7836         LDRB       R6, [R6]
+  0x08000258:  405E         EORS       R6, R3
+  0x0800025A:  543E         STRB       R6, [R7, R0]
+  0x0800025C:  2002         MOVS       R0, #2
+  0x0800025E:  4328         ORRS       R0, R5
+  0x08000260:  4613         MOV        R3, R2
+  0x08000262:  3B0E         SUBS       R3, #14
+  0x08000264:  781B         LDRB       R3, [R3]
+  0x08000266:  9E0E         LDR        R6, [SP, #56]
+  0x08000268:  4073         EORS       R3, R6
+  0x0800026A:  543B         STRB       R3, [R7, R0]
+  0x0800026C:  2003         MOVS       R0, #3
+  0x0800026E:  4328         ORRS       R0, R5
+  0x08000270:  3A0D         SUBS       R2, #13
+  0x08000272:  7812         LDRB       R2, [R2]
+  0x08000274:  9B0F         LDR        R3, [SP, #60]
+  0x08000276:  405A         EORS       R2, R3
+  0x08000278:  543A         STRB       R2, [R7, R0]
+  0x0800027A:  1D24         ADDS       R4, R4, #4
+  0x0800027C:  1C49         ADDS       R1, R1, #1
+  0x0800027E:  E7B4         B          .L5                      ; 0x080001EA
+
.L10:
+  0x08000280:  200A         MOVS       R0, #10
+  0x08000282:  F000 F8ED    BL         AddRoundKey              ; 0x08000460
+  0x08000286:  2009         MOVS       R0, #9
+  0x08000288:  4C74         LDR        R4, =rsbox               ; [PC, #0x01D0] [0x0800045C] =0x08000FB8
+
.L11:
+  0x0800028A:  9000         STR        R0, [SP, #0]
+  0x0800028C:  486F         LDR        R0, =state               ; [PC, #0x01BC] [0x0800044C] =0x2000000C
+  0x0800028E:  6800         LDR        R0, [R0]
+  0x08000290:  7B41         LDRB       R1, [R0, #13]
+  0x08000292:  7A42         LDRB       R2, [R0, #9]
+  0x08000294:  7342         STRB       R2, [R0, #13]
+  0x08000296:  7942         LDRB       R2, [R0, #5]
+  0x08000298:  7843         LDRB       R3, [R0, #1]
+  0x0800029A:  7143         STRB       R3, [R0, #5]
+  0x0800029C:  7242         STRB       R2, [R0, #9]
+  0x0800029E:  7041         STRB       R1, [R0, #1]
+  0x080002A0:  7881         LDRB       R1, [R0, #2]
+  0x080002A2:  7A82         LDRB       R2, [R0, #10]
+  0x080002A4:  7082         STRB       R2, [R0, #2]
+  0x080002A6:  7281         STRB       R1, [R0, #10]
+  0x080002A8:  7981         LDRB       R1, [R0, #6]
+  0x080002AA:  7B82         LDRB       R2, [R0, #14]
+  0x080002AC:  7182         STRB       R2, [R0, #6]
+  0x080002AE:  7381         STRB       R1, [R0, #14]
+  0x080002B0:  78C1         LDRB       R1, [R0, #3]
+  0x080002B2:  79C2         LDRB       R2, [R0, #7]
+  0x080002B4:  70C2         STRB       R2, [R0, #3]
+  0x080002B6:  7AC2         LDRB       R2, [R0, #11]
+  0x080002B8:  71C2         STRB       R2, [R0, #7]
+  0x080002BA:  7BC2         LDRB       R2, [R0, #15]
+  0x080002BC:  73C1         STRB       R1, [R0, #15]
+  0x080002BE:  72C2         STRB       R2, [R0, #11]
+  0x080002C0:  2100         MOVS       R1, #0
+
.L12:
+  0x080002C2:  2904         CMP        R1, #4
+  0x080002C4:  D00A         BEQ        .L15                     ; 0x080002DC
+  0x080002C6:  2200         MOVS       R2, #0
+
.L13:
+  0x080002C8:  2A10         CMP        R2, #16
+  0x080002CA:  D004         BEQ        .L14                     ; 0x080002D6
+  0x080002CC:  5C83         LDRB       R3, [R0, R2]
+  0x080002CE:  5CE3         LDRB       R3, [R4, R3]
+  0x080002D0:  5483         STRB       R3, [R0, R2]
+  0x080002D2:  1D12         ADDS       R2, R2, #4
+  0x080002D4:  E7F8         B          .L13                     ; 0x080002C8
+
.L14:
+  0x080002D6:  1C40         ADDS       R0, R0, #1
+  0x080002D8:  1C49         ADDS       R1, R1, #1
+  0x080002DA:  E7F2         B          .L12                     ; 0x080002C2
+
.L15:
+  0x080002DC:  9900         LDR        R1, [SP, #0]
+  0x080002DE:  0608         LSLS       R0, R1, #24
+  0x080002E0:  D100         BNE        .L16                     ; 0x080002E4
+  0x080002E2:  E0AD         B          .L20                     ; 0x08000440
+
.L16:
+  0x080002E4:  B2C8         UXTB       R0, R1
+  0x080002E6:  F000 F8BB    BL         AddRoundKey              ; 0x08000460
+  0x080002EA:  4858         LDR        R0, =state               ; [PC, #0x0160] [0x0800044C] =0x2000000C
+  0x080002EC:  6800         LDR        R0, [R0]
+  0x080002EE:  9007         STR        R0, [SP, #28]
+  0x080002F0:  2000         MOVS       R0, #0
+
.L17:
+  0x080002F2:  2810         CMP        R0, #16
+  0x080002F4:  D100         BNE        .L18                     ; 0x080002F8
+  0x080002F6:  E0A0         B          .L19                     ; 0x0800043A
+
.L18:
+  0x080002F8:  9F07         LDR        R7, [SP, #28]
+  0x080002FA:  563A         LDRSB      R2, [R7, R0]
+  0x080002FC:  09D1         LSRS       R1, R2, #7
+  0x080002FE:  4614         MOV        R4, R2
+  0x08000300:  9204         STR        R2, [SP, #16]
+  0x08000302:  221B         MOVS       R2, #27
+  0x08000304:  4011         ANDS       R1, R2
+  0x08000306:  460B         MOV        R3, R1
+  0x08000308:  900F         STR        R0, [SP, #60]
+  0x0800030A:  0060         LSLS       R0, R4, #1
+  0x0800030C:  4043         EORS       R3, R0
+  0x0800030E:  0059         LSLS       R1, R3, #1
+  0x08000310:  461E         MOV        R6, R3
+  0x08000312:  9305         STR        R3, [SP, #20]
+  0x08000314:  B24B         SXTB       R3, R1
+  0x08000316:  09DB         LSRS       R3, R3, #7
+  0x08000318:  4013         ANDS       R3, R2
+  0x0800031A:  B240         SXTB       R0, R0
+  0x0800031C:  09C0         LSRS       R0, R0, #7
+  0x0800031E:  4010         ANDS       R0, R2
+  0x08000320:  4048         EORS       R0, R1
+  0x08000322:  0041         LSLS       R1, R0, #1
+  0x08000324:  4605         MOV        R5, R0
+  0x08000326:  9006         STR        R0, [SP, #24]
+  0x08000328:  4059         EORS       R1, R3
+  0x0800032A:  910E         STR        R1, [SP, #56]
+  0x0800032C:  980F         LDR        R0, [SP, #60]
+  0x0800032E:  1839         ADDS       R1, R7, R0
+  0x08000330:  2001         MOVS       R0, #1
+  0x08000332:  560F         LDRSB      R7, [R1, R0]
+  0x08000334:  460B         MOV        R3, R1
+  0x08000336:  2002         MOVS       R0, #2
+  0x08000338:  5609         LDRSB      R1, [R1, R0]
+  0x0800033A:  461C         MOV        R4, R3
+  0x0800033C:  9303         STR        R3, [SP, #12]
+  0x0800033E:  4608         MOV        R0, R1
+  0x08000340:  4078         EORS       R0, R7
+  0x08000342:  4070         EORS       R0, R6
+  0x08000344:  2303         MOVS       R3, #3
+  0x08000346:  56E3         LDRSB      R3, [R4, R3]
+  0x08000348:  930C         STR        R3, [SP, #48]
+  0x0800034A:  4058         EORS       R0, R3
+  0x0800034C:  09FB         LSRS       R3, R7, #7
+  0x0800034E:  4013         ANDS       R3, R2
+  0x08000350:  007C         LSLS       R4, R7, #1
+  0x08000352:  940D         STR        R4, [SP, #52]
+  0x08000354:  4063         EORS       R3, R4
+  0x08000356:  930A         STR        R3, [SP, #40]
+  0x08000358:  4058         EORS       R0, R3
+  0x0800035A:  4068         EORS       R0, R5
+  0x0800035C:  09CB         LSRS       R3, R1, #7
+  0x0800035E:  4013         ANDS       R3, R2
+  0x08000360:  004D         LSLS       R5, R1, #1
+  0x08000362:  406B         EORS       R3, R5
+  0x08000364:  930B         STR        R3, [SP, #44]
+  0x08000366:  005C         LSLS       R4, R3, #1
+  0x08000368:  9401         STR        R4, [SP, #4]
+  0x0800036A:  B26D         SXTB       R5, R5
+  0x0800036C:  09EE         LSRS       R6, R5, #7
+  0x0800036E:  4016         ANDS       R6, R2
+  0x08000370:  4066         EORS       R6, R4
+  0x08000372:  4070         EORS       R0, R6
+  0x08000374:  9602         STR        R6, [SP, #8]
+  0x08000376:  9B0E         LDR        R3, [SP, #56]
+  0x08000378:  4058         EORS       R0, R3
+  0x0800037A:  9B0A         LDR        R3, [SP, #40]
+  0x0800037C:  005C         LSLS       R4, R3, #1
+  0x0800037E:  B265         SXTB       R5, R4
+  0x08000380:  09EB         LSRS       R3, R5, #7
+  0x08000382:  4013         ANDS       R3, R2
+  0x08000384:  9D0D         LDR        R5, [SP, #52]
+  0x08000386:  B26D         SXTB       R5, R5
+  0x08000388:  09ED         LSRS       R5, R5, #7
+  0x0800038A:  4015         ANDS       R5, R2
+  0x0800038C:  4065         EORS       R5, R4
+  0x0800038E:  9509         STR        R5, [SP, #36]
+  0x08000390:  006C         LSLS       R4, R5, #1
+  0x08000392:  405C         EORS       R4, R3
+  0x08000394:  9408         STR        R4, [SP, #32]
+  0x08000396:  4060         EORS       R0, R4
+  0x08000398:  9B01         LDR        R3, [SP, #4]
+  0x0800039A:  B25B         SXTB       R3, R3
+  0x0800039C:  09DB         LSRS       R3, R3, #7
+  0x0800039E:  4013         ANDS       R3, R2
+  0x080003A0:  0074         LSLS       R4, R6, #1
+  0x080003A2:  405C         EORS       R4, R3
+  0x080003A4:  940D         STR        R4, [SP, #52]
+  0x080003A6:  4060         EORS       R0, R4
+  0x080003A8:  9B0C         LDR        R3, [SP, #48]
+  0x080003AA:  09DC         LSRS       R4, R3, #7
+  0x080003AC:  4014         ANDS       R4, R2
+  0x080003AE:  005B         LSLS       R3, R3, #1
+  0x080003B0:  405C         EORS       R4, R3
+  0x080003B2:  0065         LSLS       R5, R4, #1
+  0x080003B4:  B26E         SXTB       R6, R5
+  0x080003B6:  09F6         LSRS       R6, R6, #7
+  0x080003B8:  4016         ANDS       R6, R2
+  0x080003BA:  B25B         SXTB       R3, R3
+  0x080003BC:  09DB         LSRS       R3, R3, #7
+  0x080003BE:  4013         ANDS       R3, R2
+  0x080003C0:  406B         EORS       R3, R5
+  0x080003C2:  005A         LSLS       R2, R3, #1
+  0x080003C4:  4072         EORS       R2, R6
+  0x080003C6:  4050         EORS       R0, R2
+  0x080003C8:  9D0F         LDR        R5, [SP, #60]
+  0x080003CA:  9E07         LDR        R6, [SP, #28]
+  0x080003CC:  5570         STRB       R0, [R6, R5]
+  0x080003CE:  4608         MOV        R0, R1
+  0x080003D0:  9D04         LDR        R5, [SP, #16]
+  0x080003D2:  4068         EORS       R0, R5
+  0x080003D4:  9E0C         LDR        R6, [SP, #48]
+  0x080003D6:  4070         EORS       R0, R6
+  0x080003D8:  9E0A         LDR        R6, [SP, #40]
+  0x080003DA:  4070         EORS       R0, R6
+  0x080003DC:  9E0B         LDR        R6, [SP, #44]
+  0x080003DE:  4070         EORS       R0, R6
+  0x080003E0:  9E09         LDR        R6, [SP, #36]
+  0x080003E2:  4070         EORS       R0, R6
+  0x080003E4:  9E0E         LDR        R6, [SP, #56]
+  0x080003E6:  4070         EORS       R0, R6
+  0x080003E8:  4058         EORS       R0, R3
+  0x080003EA:  9E08         LDR        R6, [SP, #32]
+  0x080003EC:  4070         EORS       R0, R6
+  0x080003EE:  9E0D         LDR        R6, [SP, #52]
+  0x080003F0:  4070         EORS       R0, R6
+  0x080003F2:  4050         EORS       R0, R2
+  0x080003F4:  9E03         LDR        R6, [SP, #12]
+  0x080003F6:  7070         STRB       R0, [R6, #1]
+  0x080003F8:  980F         LDR        R0, [SP, #60]
+  0x080003FA:  406F         EORS       R7, R5
+  0x080003FC:  4067         EORS       R7, R4
+  0x080003FE:  4C17         LDR        R4, =rsbox               ; [PC, #92] [0x0800045C] =0x08000FB8
+  0x08000400:  9D0E         LDR        R5, [SP, #56]
+  0x08000402:  406F         EORS       R7, R5
+  0x08000404:  4079         EORS       R1, R7
+  0x08000406:  9D05         LDR        R5, [SP, #20]
+  0x08000408:  4069         EORS       R1, R5
+  0x0800040A:  9D09         LDR        R5, [SP, #36]
+  0x0800040C:  4069         EORS       R1, R5
+  0x0800040E:  4059         EORS       R1, R3
+  0x08000410:  9D08         LDR        R5, [SP, #32]
+  0x08000412:  4069         EORS       R1, R5
+  0x08000414:  9B0D         LDR        R3, [SP, #52]
+  0x08000416:  4059         EORS       R1, R3
+  0x08000418:  4051         EORS       R1, R2
+  0x0800041A:  70F1         STRB       R1, [R6, #3]
+  0x0800041C:  990C         LDR        R1, [SP, #48]
+  0x0800041E:  404F         EORS       R7, R1
+  0x08000420:  990B         LDR        R1, [SP, #44]
+  0x08000422:  404F         EORS       R7, R1
+  0x08000424:  9906         LDR        R1, [SP, #24]
+  0x08000426:  404F         EORS       R7, R1
+  0x08000428:  9902         LDR        R1, [SP, #8]
+  0x0800042A:  404F         EORS       R7, R1
+  0x0800042C:  406F         EORS       R7, R5
+  0x0800042E:  990D         LDR        R1, [SP, #52]
+  0x08000430:  404F         EORS       R7, R1
+  0x08000432:  4057         EORS       R7, R2
+  0x08000434:  70B7         STRB       R7, [R6, #2]
+  0x08000436:  1D00         ADDS       R0, R0, #4
+  0x08000438:  E75B         B          .L17                     ; 0x080002F2
+
.L19:
+  0x0800043A:  9800         LDR        R0, [SP, #0]
+  0x0800043C:  1E40         SUBS       R0, R0, #1
+  0x0800043E:  E724         B          .L11                     ; 0x0800028A
+
.L20:
+  0x08000440:  F000 F80E    BL         AddRoundKey              ; 0x08000460
+  0x08000444:  B011         ADD        SP, SP, #68
+  0x08000446:  BDF0         POP        {R4-R7, PC}
+  0x08000448:  20000014     DC.W       Key
+  0x0800044C:  2000000C     DC.W       state
+  0x08000450:  20000018     DC.W       RoundKey
+  0x08000454:  08000EB8     DC.W       sbox
+  0x08000458:  08000DB2     DC.W       Rcon
+  0x0800045C:  08000FB8     DC.W       rsbox
+

Section .text.AddRoundKey from aes.o, size=56, align=4

+
AddRoundKey:
+  0x08000460:  B530         PUSH       {R4-R5, LR}
+  0x08000462:  0100         LSLS       R0, R0, #4
+  0x08000464:  490A         LDR        R1, =RoundKey            ; [PC, #40] [0x08000490] =0x20000018
+  0x08000466:  1808         ADDS       R0, R1, R0
+  0x08000468:  490A         LDR        R1, =state               ; [PC, #40] [0x08000494] =0x2000000C
+  0x0800046A:  6809         LDR        R1, [R1]
+  0x0800046C:  2200         MOVS       R2, #0
+
.L1:
+  0x0800046E:  2A04         CMP        R2, #4
+  0x08000470:  D00C         BEQ        .L4                      ; 0x0800048C
+  0x08000472:  2300         MOVS       R3, #0
+
.L2:
+  0x08000474:  2B04         CMP        R3, #4
+  0x08000476:  D005         BEQ        .L3                      ; 0x08000484
+  0x08000478:  5CC4         LDRB       R4, [R0, R3]
+  0x0800047A:  5CCD         LDRB       R5, [R1, R3]
+  0x0800047C:  4065         EORS       R5, R4
+  0x0800047E:  54CD         STRB       R5, [R1, R3]
+  0x08000480:  1C5B         ADDS       R3, R3, #1
+  0x08000482:  E7F7         B          .L2                      ; 0x08000474
+
.L3:
+  0x08000484:  1D09         ADDS       R1, R1, #4
+  0x08000486:  1D00         ADDS       R0, R0, #4
+  0x08000488:  1C52         ADDS       R2, R2, #1
+  0x0800048A:  E7F0         B          .L1                      ; 0x0800046E
+
.L4:
+  0x0800048C:  BD30         POP        {R4-R5, PC}
+  0x0800048E:  46C0         NOP
+  0x08000490:  20000018     DC.W       RoundKey
+  0x08000494:  2000000C     DC.W       state
+

Section .text.main from main.o, size=1136, align=4

+
main:
+  0x08000498:  B5D0         PUSH       {R4, R6-R7, LR}
+  0x0800049A:  AF02         ADD        R7, SP, #8
+  0x0800049C:  B0FF         SUB        SP, SP, #0x01FC
+  0x0800049E:  B089         SUB        SP, SP, #36
+  0x080004A0:  466E         MOV        R6, SP
+  0x080004A2:  F000 FA31    BL         Init                     ; 0x08000908
+  0x080004A6:  2001         MOVS       R0, #1
+  0x080004A8:  0401         LSLS       R1, R0, #16
+  0x080004AA:  60B1         STR        R1, [R6, #8]
+  0x080004AC:  61F0         STR        R0, [R6, #28]
+  0x080004AE:  07C0         LSLS       R0, R0, #31
+  0x080004B0:  6070         STR        R0, [R6, #4]
+
.L1:
+  0x080004B2:  48E6         LDR        R0, =msCounter           ; [PC, #0x0398] [0x0800084C] =0x20000010
+  0x080004B4:  6800         LDR        R0, [R0]
+  0x080004B6:  6130         STR        R0, [R6, #16]
+
.L2:
+  0x080004B8:  48E5         LDR        R0, =0x00001388          ; [PC, #0x0394] [0x08000850]
+  0x080004BA:  F000 FB25    BL         WaitForByte              ; 0x08000B08
+  0x080004BE:  287F         CMP        R0, #127
+  0x080004C0:  D00F         BEQ        .L4                      ; 0x080004E2
+  0x080004C2:  B280         UXTH       R0, R0
+  0x080004C4:  49E3         LDR        R1, =0x0000FFFF          ; [PC, #0x038C] [0x08000854]
+  0x080004C6:  4288         CMP        R0, R1
+  0x080004C8:  D003         BEQ        .L3                      ; 0x080004D2
+  0x080004CA:  49E3         LDR        R1, =0x0000FFFE          ; [PC, #0x038C] [0x08000858]
+  0x080004CC:  4288         CMP        R0, R1
+  0x080004CE:  D100         BNE        .L3                      ; 0x080004D2
+  0x080004D0:  E1FF         B          .L57                     ; 0x080008D2
+
.L3:
+  0x080004D2:  48DE         LDR        R0, =msCounter           ; [PC, #0x0378] [0x0800084C] =0x20000010
+  0x080004D4:  6800         LDR        R0, [R0]
+  0x080004D6:  6931         LDR        R1, [R6, #16]
+  0x080004D8:  1A40         SUBS       R0, R0, R1
+  0x080004DA:  49DD         LDR        R1, =0x00001388          ; [PC, #0x0374] [0x08000850]
+  0x080004DC:  4288         CMP        R0, R1
+  0x080004DE:  D9EB         BLS        .L2                      ; 0x080004B8
+  0x080004E0:  E1F7         B          .L57                     ; 0x080008D2
+
.L4:
+  0x080004E2:  F000 FC24    BL         TransmitACK              ; 0x08000D2E
+
.L5:
+  0x080004E6:  48FC         LDR        R0, =0x00001388          ; [PC, #0x03F0] [0x080008D8]
+  0x080004E8:  F000 FB0E    BL         WaitForByte              ; 0x08000B08
+  0x080004EC:  4605         MOV        R5, R0
+  0x080004EE:  1C40         ADDS       R0, R0, #1
+  0x080004F0:  D0F9         BEQ        .L5                      ; 0x080004E6
+  0x080004F2:  B2A8         UXTH       R0, R5
+  0x080004F4:  49D8         LDR        R1, =0x0000FFFE          ; [PC, #0x0360] [0x08000858]
+  0x080004F6:  4288         CMP        R0, R1
+  0x080004F8:  D0DE         BEQ        .L2                      ; 0x080004B8
+  0x080004FA:  48F7         LDR        R0, =0x00001388          ; [PC, #0x03DC] [0x080008D8]
+  0x080004FC:  F000 FB04    BL         WaitForByte              ; 0x08000B08
+  0x08000500:  2800         CMP        R0, #0
+  0x08000502:  D4F0         BMI        .L5                      ; 0x080004E6
+  0x08000504:  21FF         MOVS       R1, #255
+  0x08000506:  4381         BICS       R1, R0
+  0x08000508:  B2E8         UXTB       R0, R5
+  0x0800050A:  2802         CMP        R0, #2
+  0x0800050C:  D113         BNE        .L7                      ; 0x08000536
+  0x0800050E:  2902         CMP        R1, #2
+  0x08000510:  D111         BNE        .L7                      ; 0x08000536
+  0x08000512:  48FC         LDR        R0, =0x00000120          ; [PC, #0x03F0] [0x08000904]
+  0x08000514:  1980         ADDS       R0, R0, R6
+  0x08000516:  69F1         LDR        R1, [R6, #28]
+  0x08000518:  7041         STRB       R1, [R0, #1]
+  0x0800051A:  2179         MOVS       R1, #121
+  0x0800051C:  7001         STRB       R1, [R0]
+  0x0800051E:  7101         STRB       R1, [R0, #4]
+  0x08000520:  4AEE         LDR        R2, =0x40015800          ; [PC, #0x03B8] [0x080008DC]
+  0x08000522:  7811         LDRB       R1, [R2]
+  0x08000524:  70C1         STRB       R1, [R0, #3]
+  0x08000526:  7851         LDRB       R1, [R2, #1]
+  0x08000528:  220F         MOVS       R2, #15
+  0x0800052A:  400A         ANDS       R2, R1
+  0x0800052C:  7082         STRB       R2, [R0, #2]
+
.L6:
+  0x0800052E:  2105         MOVS       R1, #5
+  0x08000530:  F000 FB7C    BL         Transmit                 ; 0x08000C2C
+  0x08000534:  E7D7         B          .L5                      ; 0x080004E6
+
.L7:
+  0x08000536:  4602         MOV        R2, R0
+  0x08000538:  430A         ORRS       R2, R1
+  0x0800053A:  D121         BNE        .L8                      ; 0x08000580
+  0x0800053C:  48F1         LDR        R0, =0x00000120          ; [PC, #0x03C4] [0x08000904]
+  0x0800053E:  1980         ADDS       R0, R0, R6
+  0x08000540:  2179         MOVS       R1, #121
+  0x08000542:  7381         STRB       R1, [R0, #14]
+  0x08000544:  2292         MOVS       R2, #146
+  0x08000546:  7342         STRB       R2, [R0, #13]
+  0x08000548:  2282         MOVS       R2, #130
+  0x0800054A:  7302         STRB       R2, [R0, #12]
+  0x0800054C:  2273         MOVS       R2, #115
+  0x0800054E:  72C2         STRB       R2, [R0, #11]
+  0x08000550:  2263         MOVS       R2, #99
+  0x08000552:  7282         STRB       R2, [R0, #10]
+  0x08000554:  2243         MOVS       R2, #67
+  0x08000556:  7242         STRB       R2, [R0, #9]
+  0x08000558:  2231         MOVS       R2, #49
+  0x0800055A:  7202         STRB       R2, [R0, #8]
+  0x0800055C:  2221         MOVS       R2, #33
+  0x0800055E:  71C2         STRB       R2, [R0, #7]
+  0x08000560:  2211         MOVS       R2, #17
+  0x08000562:  7182         STRB       R2, [R0, #6]
+  0x08000564:  2302         MOVS       R3, #2
+  0x08000566:  7143         STRB       R3, [R0, #5]
+  0x08000568:  69F3         LDR        R3, [R6, #28]
+  0x0800056A:  7103         STRB       R3, [R0, #4]
+  0x0800056C:  2300         MOVS       R3, #0
+  0x0800056E:  70C3         STRB       R3, [R0, #3]
+  0x08000570:  7082         STRB       R2, [R0, #2]
+  0x08000572:  220B         MOVS       R2, #11
+  0x08000574:  7042         STRB       R2, [R0, #1]
+  0x08000576:  7001         STRB       R1, [R0]
+  0x08000578:  210F         MOVS       R1, #15
+  0x0800057A:  F000 FB57    BL         Transmit                 ; 0x08000C2C
+  0x0800057E:  E7B2         B          .L5                      ; 0x080004E6
+
.L8:
+  0x08000580:  2811         CMP        R0, #17
+  0x08000582:  D113         BNE        .L10                     ; 0x080005AC
+  0x08000584:  2911         CMP        R1, #17
+  0x08000586:  D111         BNE        .L10                     ; 0x080005AC
+  0x08000588:  25FF         MOVS       R5, #255
+  0x0800058A:  F000 FBD0    BL         TransmitACK              ; 0x08000D2E
+  0x0800058E:  2400         MOVS       R4, #0
+  0x08000590:  48D8         LDR        R0, =u                   ; [PC, #0x0360] [0x080008F4] =0x20000004
+  0x08000592:  7104         STRB       R4, [R0, #4]
+  0x08000594:  6004         STR        R4, [R0]
+
.L9:
+  0x08000596:  2C05         CMP        R4, #5
+  0x08000598:  D017         BEQ        .L11                     ; 0x080005CA
+  0x0800059A:  48CF         LDR        R0, =0x00001388          ; [PC, #0x033C] [0x080008D8]
+  0x0800059C:  F000 FAB4    BL         WaitForByte              ; 0x08000B08
+  0x080005A0:  2800         CMP        R0, #0
+  0x080005A2:  D4A0         BMI        .L5                      ; 0x080004E6
+  0x080005A4:  49D3         LDR        R1, =u                   ; [PC, #0x034C] [0x080008F4] =0x20000004
+  0x080005A6:  5508         STRB       R0, [R1, R4]
+  0x080005A8:  1C64         ADDS       R4, R4, #1
+  0x080005AA:  E7F4         B          .L9                      ; 0x08000596
+
.L10:
+  0x080005AC:  2801         CMP        R0, #1
+  0x080005AE:  D12B         BNE        .L15                     ; 0x08000608
+  0x080005B0:  2901         CMP        R1, #1
+  0x080005B2:  D129         BNE        .L15                     ; 0x08000608
+  0x080005B4:  48D3         LDR        R0, =0x00000120          ; [PC, #0x034C] [0x08000904]
+  0x080005B6:  1980         ADDS       R0, R0, R6
+  0x080005B8:  2179         MOVS       R1, #121
+  0x080005BA:  7101         STRB       R1, [R0, #4]
+  0x080005BC:  2200         MOVS       R2, #0
+  0x080005BE:  70C2         STRB       R2, [R0, #3]
+  0x080005C0:  7082         STRB       R2, [R0, #2]
+  0x080005C2:  2211         MOVS       R2, #17
+  0x080005C4:  7042         STRB       R2, [R0, #1]
+  0x080005C6:  7001         STRB       R1, [R0]
+  0x080005C8:  E7B1         B          .L6                      ; 0x0800052E
+
.L11:
+  0x080005CA:  4CCA         LDR        R4, =u                   ; [PC, #0x0328] [0x080008F4] =0x20000004
+  0x080005CC:  78E0         LDRB       R0, [R4, #3]
+  0x080005CE:  78A1         LDRB       R1, [R4, #2]
+  0x080005D0:  7862         LDRB       R2, [R4, #1]
+  0x080005D2:  7823         LDRB       R3, [R4]
+  0x080005D4:  4053         EORS       R3, R2
+  0x080005D6:  404B         EORS       R3, R1
+  0x080005D8:  4043         EORS       R3, R0
+  0x080005DA:  6820         LDR        R0, [R4]
+  0x080005DC:  BA00         REV        R0, R0
+  0x080005DE:  6020         STR        R0, [R4]
+  0x080005E0:  7920         LDRB       R0, [R4, #4]
+  0x080005E2:  4283         CMP        R3, R0
+  0x080005E4:  D000         BEQ        .L12                     ; 0x080005E8
+  0x080005E6:  E0C8         B          .L35                     ; 0x0800077A
+
.L12:
+  0x080005E8:  F000 FBA1    BL         TransmitACK              ; 0x08000D2E
+  0x080005EC:  2400         MOVS       R4, #0
+
.L13:
+  0x080005EE:  2C02         CMP        R4, #2
+  0x080005F0:  D046         BEQ        .L22                     ; 0x08000680
+  0x080005F2:  48B9         LDR        R0, =0x00001388          ; [PC, #0x02E4] [0x080008D8]
+  0x080005F4:  F000 FA88    BL         WaitForByte              ; 0x08000B08
+  0x080005F8:  2800         CMP        R0, #0
+  0x080005FA:  D500         BPL        .L14                     ; 0x080005FE
+  0x080005FC:  E773         B          .L5                      ; 0x080004E6
+
.L14:
+  0x080005FE:  49C1         LDR        R1, =0x00000120          ; [PC, #0x0304] [0x08000904]
+  0x08000600:  1989         ADDS       R1, R1, R6
+  0x08000602:  5508         STRB       R0, [R1, R4]
+  0x08000604:  1C64         ADDS       R4, R4, #1
+  0x08000606:  E7F2         B          .L13                     ; 0x080005EE
+
.L15:
+  0x08000608:  2843         CMP        R0, #67
+  0x0800060A:  D123         BNE        .L19                     ; 0x08000654
+  0x0800060C:  2943         CMP        R1, #67
+  0x0800060E:  D121         BNE        .L19                     ; 0x08000654
+  0x08000610:  F000 FB8D    BL         TransmitACK              ; 0x08000D2E
+  0x08000614:  48B0         LDR        R0, =0x00001388          ; [PC, #0x02C0] [0x080008D8]
+  0x08000616:  F000 FA77    BL         WaitForByte              ; 0x08000B08
+  0x0800061A:  2800         CMP        R0, #0
+  0x0800061C:  D500         BPL        .L16                     ; 0x08000620
+  0x0800061E:  E762         B          .L5                      ; 0x080004E6
+
.L16:
+  0x08000620:  4602         MOV        R2, R0
+  0x08000622:  3209         ADDS       R2, #9
+  0x08000624:  2107         MOVS       R1, #7
+  0x08000626:  438A         BICS       R2, R1
+  0x08000628:  4669         MOV        R1, SP
+  0x0800062A:  60F1         STR        R1, [R6, #12]
+  0x0800062C:  4669         MOV        R1, SP
+  0x0800062E:  1A8A         SUBS       R2, R1, R2
+  0x08000630:  4695         MOV        SP, R2
+  0x08000632:  6170         STR        R0, [R6, #20]
+  0x08000634:  1C85         ADDS       R5, R0, #2
+  0x08000636:  4614         MOV        R4, R2
+  0x08000638:  61B2         STR        R2, [R6, #24]
+
.L17:
+  0x0800063A:  2D00         CMP        R5, #0
+  0x0800063C:  D04A         BEQ        .L25                     ; 0x080006D4
+  0x0800063E:  48A6         LDR        R0, =0x00001388          ; [PC, #0x0298] [0x080008D8]
+  0x08000640:  F000 FA62    BL         WaitForByte              ; 0x08000B08
+  0x08000644:  2800         CMP        R0, #0
+  0x08000646:  D500         BPL        .L18                     ; 0x0800064A
+  0x08000648:  E0A3         B          .L38                     ; 0x08000792
+
.L18:
+  0x0800064A:  7020         STRB       R0, [R4]
+  0x0800064C:  1C64         ADDS       R4, R4, #1
+  0x0800064E:  1E6D         SUBS       R5, R5, #1
+  0x08000650:  69B2         LDR        R2, [R6, #24]
+  0x08000652:  E7F2         B          .L17                     ; 0x0800063A
+
.L19:
+  0x08000654:  2831         CMP        R0, #49
+  0x08000656:  D132         BNE        .L23                     ; 0x080006BE
+  0x08000658:  2931         CMP        R1, #49
+  0x0800065A:  D130         BNE        .L23                     ; 0x080006BE
+  0x0800065C:  F000 FB67    BL         TransmitACK              ; 0x08000D2E
+  0x08000660:  2400         MOVS       R4, #0
+  0x08000662:  48A4         LDR        R0, =u                   ; [PC, #0x0290] [0x080008F4] =0x20000004
+  0x08000664:  7104         STRB       R4, [R0, #4]
+  0x08000666:  6004         STR        R4, [R0]
+
.L20:
+  0x08000668:  2C05         CMP        R4, #5
+  0x0800066A:  D070         BEQ        .L33                     ; 0x0800074E
+  0x0800066C:  489A         LDR        R0, =0x00001388          ; [PC, #0x0268] [0x080008D8]
+  0x0800066E:  F000 FA4B    BL         WaitForByte              ; 0x08000B08
+  0x08000672:  2800         CMP        R0, #0
+  0x08000674:  D500         BPL        .L21                     ; 0x08000678
+  0x08000676:  E736         B          .L5                      ; 0x080004E6
+
.L21:
+  0x08000678:  499E         LDR        R1, =u                   ; [PC, #0x0278] [0x080008F4] =0x20000004
+  0x0800067A:  5508         STRB       R0, [R1, R4]
+  0x0800067C:  1C64         ADDS       R4, R4, #1
+  0x0800067E:  E7F3         B          .L20                     ; 0x08000668
+
.L22:
+  0x08000680:  48A0         LDR        R0, =0x00000120          ; [PC, #0x0280] [0x08000904]
+  0x08000682:  1980         ADDS       R0, R0, R6
+  0x08000684:  7844         LDRB       R4, [R0, #1]
+  0x08000686:  406C         EORS       R4, R5
+  0x08000688:  7800         LDRB       R0, [R0]
+  0x0800068A:  42A0         CMP        R0, R4
+  0x0800068C:  D175         BNE        .L35                     ; 0x0800077A
+  0x0800068E:  4625         MOV        R5, R4
+  0x08000690:  3508         ADDS       R5, #8
+  0x08000692:  2007         MOVS       R0, #7
+  0x08000694:  4385         BICS       R5, R0
+  0x08000696:  F000 FB4A    BL         TransmitACK              ; 0x08000D2E
+  0x0800069A:  4668         MOV        R0, SP
+  0x0800069C:  61B0         STR        R0, [R6, #24]
+  0x0800069E:  4668         MOV        R0, SP
+  0x080006A0:  1B45         SUBS       R5, R0, R5
+  0x080006A2:  46AD         MOV        SP, R5
+  0x080006A4:  1C64         ADDS       R4, R4, #1
+  0x080006A6:  22EC         MOVS       R2, #236
+  0x080006A8:  4628         MOV        R0, R5
+  0x080006AA:  4621         MOV        R1, R4
+  0x080006AC:  F000 FB78    BL         __aeabi_memset8          ; 0x08000DA0
+  0x080006B0:  4628         MOV        R0, R5
+  0x080006B2:  4621         MOV        R1, R4
+  0x080006B4:  F000 FABA    BL         Transmit                 ; 0x08000C2C
+  0x080006B8:  69B0         LDR        R0, [R6, #24]
+  0x080006BA:  4685         MOV        SP, R0
+  0x080006BC:  E713         B          .L5                      ; 0x080004E6
+
.L23:
+  0x080006BE:  F000 FB40    BL         TransmitNACK             ; 0x08000D42
+  0x080006C2:  488B         LDR        R0, =msCounter           ; [PC, #0x022C] [0x080008F0] =0x20000010
+  0x080006C4:  6800         LDR        R0, [R0]
+  0x080006C6:  6931         LDR        R1, [R6, #16]
+  0x080006C8:  1A40         SUBS       R0, R0, R1
+  0x080006CA:  4983         LDR        R1, =0x00001388          ; [PC, #0x020C] [0x080008D8]
+  0x080006CC:  4288         CMP        R0, R1
+  0x080006CE:  D800         BHI        .L24                     ; 0x080006D2
+  0x080006D0:  E709         B          .L5                      ; 0x080004E6
+
.L24:
+  0x080006D2:  E0FE         B          .L57                     ; 0x080008D2
+
.L25:
+  0x080006D4:  6971         LDR        R1, [R6, #20]
+  0x080006D6:  1C48         ADDS       R0, R1, #1
+  0x080006D8:  B2C9         UXTB       R1, R1
+  0x080006DA:  4603         MOV        R3, R0
+  0x080006DC:  4D80         LDR        R5, =0x40022008          ; [PC, #0x0200] [0x080008E0]
+
.L26:
+  0x080006DE:  2B00         CMP        R3, #0
+  0x080006E0:  D004         BEQ        .L27                     ; 0x080006EC
+  0x080006E2:  7814         LDRB       R4, [R2]
+  0x080006E4:  4061         EORS       R1, R4
+  0x080006E6:  1C52         ADDS       R2, R2, #1
+  0x080006E8:  1E5B         SUBS       R3, R3, #1
+  0x080006EA:  E7F8         B          .L26                     ; 0x080006DE
+
.L27:
+  0x080006EC:  69B2         LDR        R2, [R6, #24]
+  0x080006EE:  5C10         LDRB       R0, [R2, R0]
+  0x080006F0:  4281         CMP        R1, R0
+  0x080006F2:  D145         BNE        .L36                     ; 0x08000780
+  0x080006F4:  68E8         LDR        R0, [R5, #12]
+  0x080006F6:  2800         CMP        R0, #0
+  0x080006F8:  D503         BPL        .L28                     ; 0x08000702
+  0x080006FA:  487A         LDR        R0, =0x45670123          ; [PC, #0x01E8] [0x080008E4]
+  0x080006FC:  6028         STR        R0, [R5]
+  0x080006FE:  487B         LDR        R0, =0xCDEF89AB          ; [PC, #0x01EC] [0x080008EC]
+  0x08000700:  6028         STR        R0, [R5]
+
.L28:
+  0x08000702:  2000         MOVS       R0, #0
+  0x08000704:  68B4         LDR        R4, [R6, #8]
+
.L29:
+  0x08000706:  6971         LDR        R1, [R6, #20]
+  0x08000708:  4288         CMP        R0, R1
+  0x0800070A:  DC3C         BGT        .L37                     ; 0x08000786
+  0x0800070C:  5C11         LDRB       R1, [R2, R0]
+  0x0800070E:  2906         CMP        R1, #6
+  0x08000710:  D31B         BCC        .L32                     ; 0x0800074A
+
.L30:
+  0x08000712:  68AA         LDR        R2, [R5, #8]
+  0x08000714:  4222         TST        R2, R4
+  0x08000716:  D1FC         BNE        .L30                     ; 0x08000712
+  0x08000718:  68AA         LDR        R2, [R5, #8]
+  0x0800071A:  60AA         STR        R2, [R5, #8]
+  0x0800071C:  223F         MOVS       R2, #63
+  0x0800071E:  00D2         LSLS       R2, R2, #3
+  0x08000720:  68EB         LDR        R3, [R5, #12]
+  0x08000722:  4393         BICS       R3, R2
+  0x08000724:  60EB         STR        R3, [R5, #12]
+  0x08000726:  00C9         LSLS       R1, R1, #3
+  0x08000728:  68EA         LDR        R2, [R5, #12]
+  0x0800072A:  430A         ORRS       R2, R1
+  0x0800072C:  60EA         STR        R2, [R5, #12]
+  0x0800072E:  68EA         LDR        R2, [R5, #12]
+  0x08000730:  2102         MOVS       R1, #2
+  0x08000732:  430A         ORRS       R2, R1
+  0x08000734:  60EA         STR        R2, [R5, #12]
+  0x08000736:  68EA         LDR        R2, [R5, #12]
+  0x08000738:  4322         ORRS       R2, R4
+  0x0800073A:  60EA         STR        R2, [R5, #12]
+
.L31:
+  0x0800073C:  68AA         LDR        R2, [R5, #8]
+  0x0800073E:  4222         TST        R2, R4
+  0x08000740:  D1FC         BNE        .L31                     ; 0x0800073C
+  0x08000742:  68EA         LDR        R2, [R5, #12]
+  0x08000744:  438A         BICS       R2, R1
+  0x08000746:  60EA         STR        R2, [R5, #12]
+  0x08000748:  69B2         LDR        R2, [R6, #24]
+
.L32:
+  0x0800074A:  1C40         ADDS       R0, R0, #1
+  0x0800074C:  E7DB         B          .L29                     ; 0x08000706
+
.L33:
+  0x0800074E:  4A69         LDR        R2, =u                   ; [PC, #0x01A4] [0x080008F4] =0x20000004
+  0x08000750:  7810         LDRB       R0, [R2]
+  0x08000752:  7851         LDRB       R1, [R2, #1]
+  0x08000754:  4041         EORS       R1, R0
+  0x08000756:  7890         LDRB       R0, [R2, #2]
+  0x08000758:  4048         EORS       R0, R1
+  0x0800075A:  78D1         LDRB       R1, [R2, #3]
+  0x0800075C:  4041         EORS       R1, R0
+  0x0800075E:  7910         LDRB       R0, [R2, #4]
+  0x08000760:  4281         CMP        R1, R0
+  0x08000762:  D10A         BNE        .L35                     ; 0x0800077A
+  0x08000764:  F000 FAE3    BL         TransmitACK              ; 0x08000D2E
+  0x08000768:  485B         LDR        R0, =0x00001388          ; [PC, #0x016C] [0x080008D8]
+  0x0800076A:  F000 F9CD    BL         WaitForByte              ; 0x08000B08
+  0x0800076E:  2800         CMP        R0, #0
+  0x08000770:  D500         BPL        .L34                     ; 0x08000774
+  0x08000772:  E6B8         B          .L5                      ; 0x080004E6
+
.L34:
+  0x08000774:  1C41         ADDS       R1, R0, #1
+  0x08000776:  078A         LSLS       R2, R1, #30
+  0x08000778:  D00E         BEQ        .L39                     ; 0x08000798
+
.L35:
+  0x0800077A:  F000 FAE2    BL         TransmitNACK             ; 0x08000D42
+  0x0800077E:  E6B2         B          .L5                      ; 0x080004E6
+
.L36:
+  0x08000780:  F000 FADF    BL         TransmitNACK             ; 0x08000D42
+  0x08000784:  E005         B          .L38                     ; 0x08000792
+
.L37:
+  0x08000786:  68E8         LDR        R0, [R5, #12]
+  0x08000788:  6871         LDR        R1, [R6, #4]
+  0x0800078A:  4308         ORRS       R0, R1
+  0x0800078C:  60E8         STR        R0, [R5, #12]
+  0x0800078E:  F000 FACE    BL         TransmitACK              ; 0x08000D2E
+
.L38:
+  0x08000792:  68F0         LDR        R0, [R6, #12]
+  0x08000794:  4685         MOV        SP, R0
+  0x08000796:  E6A6         B          .L5                      ; 0x080004E6
+
.L39:
+  0x08000798:  6170         STR        R0, [R6, #20]
+  0x0800079A:  61B1         STR        R1, [R6, #24]
+  0x0800079C:  69F0         LDR        R0, [R6, #28]
+  0x0800079E:  0201         LSLS       R1, R0, #8
+  0x080007A0:  4858         LDR        R0, =0x00000120          ; [PC, #0x0160] [0x08000904]
+  0x080007A2:  1980         ADDS       R0, R0, R6
+  0x080007A4:  22FF         MOVS       R2, #255
+  0x080007A6:  60F1         STR        R1, [R6, #12]
+  0x080007A8:  F000 FAFA    BL         __aeabi_memset8          ; 0x08000DA0
+  0x080007AC:  2500         MOVS       R5, #0
+  0x080007AE:  4C4E         LDR        R4, =0x50000414          ; [PC, #0x0138] [0x080008E8]
+
.L40:
+  0x080007B0:  69B0         LDR        R0, [R6, #24]
+  0x080007B2:  42A8         CMP        R0, R5
+  0x080007B4:  D009         BEQ        .L41                     ; 0x080007CA
+  0x080007B6:  4848         LDR        R0, =0x00001388          ; [PC, #0x0120] [0x080008D8]
+  0x080007B8:  F000 F9A6    BL         WaitForByte              ; 0x08000B08
+  0x080007BC:  2800         CMP        R0, #0
+  0x080007BE:  D404         BMI        .L41                     ; 0x080007CA
+  0x080007C0:  4950         LDR        R1, =0x00000120          ; [PC, #0x0140] [0x08000904]
+  0x080007C2:  1989         ADDS       R1, R1, R6
+  0x080007C4:  5548         STRB       R0, [R1, R5]
+  0x080007C6:  1C6D         ADDS       R5, R5, #1
+  0x080007C8:  E7F2         B          .L40                     ; 0x080007B0
+
.L41:
+  0x080007CA:  6820         LDR        R0, [R4]
+  0x080007CC:  07C0         LSLS       R0, R0, #31
+  0x080007CE:  D001         BEQ        .L42                     ; 0x080007D4
+  0x080007D0:  2014         MOVS       R0, #20
+  0x080007D2:  E000         B          .L43                     ; 0x080007D6
+
.L42:
+  0x080007D4:  2004         MOVS       R0, #4
+
.L43:
+  0x080007D6:  69F1         LDR        R1, [R6, #28]
+  0x080007D8:  5021         STR        R1, [R4, R0]
+  0x080007DA:  6974         LDR        R4, [R6, #20]
+  0x080007DC:  42A5         CMP        R5, R4
+  0x080007DE:  DC00         BGT        .L44                     ; 0x080007E2
+  0x080007E0:  E681         B          .L5                      ; 0x080004E6
+
.L44:
+  0x080007E2:  483D         LDR        R0, =0x00001388          ; [PC, #244] [0x080008D8]
+  0x080007E4:  F000 F990    BL         WaitForByte              ; 0x08000B08
+  0x080007E8:  2800         CMP        R0, #0
+  0x080007EA:  D500         BPL        .L45                     ; 0x080007EE
+  0x080007EC:  E67B         B          .L5                      ; 0x080004E6
+
.L45:
+  0x080007EE:  2100         MOVS       R1, #0
+  0x080007F0:  4622         MOV        R2, R4
+
.L46:
+  0x080007F2:  42A1         CMP        R1, R4
+  0x080007F4:  DC05         BGT        .L47                     ; 0x08000802
+  0x080007F6:  4B43         LDR        R3, =0x00000120          ; [PC, #0x010C] [0x08000904]
+  0x080007F8:  199B         ADDS       R3, R3, R6
+  0x080007FA:  5C5B         LDRB       R3, [R3, R1]
+  0x080007FC:  405A         EORS       R2, R3
+  0x080007FE:  1C49         ADDS       R1, R1, #1
+  0x08000800:  E7F7         B          .L46                     ; 0x080007F2
+
.L47:
+  0x08000802:  B2D1         UXTB       R1, R2
+  0x08000804:  4281         CMP        R1, R0
+  0x08000806:  D1B8         BNE        .L35                     ; 0x0800077A
+  0x08000808:  493A         LDR        R1, =u                   ; [PC, #232] [0x080008F4] =0x20000004
+  0x0800080A:  6808         LDR        R0, [R1]
+  0x0800080C:  BA00         REV        R0, R0
+  0x0800080E:  6008         STR        R0, [R1]
+  0x08000810:  4939         LDR        R1, =0x08003000          ; [PC, #228] [0x080008F8]
+  0x08000812:  4288         CMP        R0, R1
+  0x08000814:  D200         BCS        .L48                     ; 0x08000818
+  0x08000816:  E664         B          .L4                      ; 0x080004E2
+
.L48:
+  0x08000818:  1900         ADDS       R0, R0, R4
+  0x0800081A:  4938         LDR        R1, =0x0801EFFF          ; [PC, #224] [0x080008FC]
+  0x0800081C:  4288         CMP        R0, R1
+  0x0800081E:  D900         BLS        .L49                     ; 0x08000822
+  0x08000820:  E65F         B          .L4                      ; 0x080004E2
+
.L49:
+  0x08000822:  1DF0         ADDS       R0, R6, #7
+  0x08000824:  3019         ADDS       R0, #25
+  0x08000826:  68F1         LDR        R1, [R6, #12]
+  0x08000828:  F000 FAB9    BL         __aeabi_memclr           ; 0x08000D9E
+  0x0800082C:  2400         MOVS       R4, #0
+  0x0800082E:  4D2C         LDR        R5, =0x40022008          ; [PC, #176] [0x080008E0]
+
.L50:
+  0x08000830:  6970         LDR        R0, [R6, #20]
+  0x08000832:  4284         CMP        R4, R0
+  0x08000834:  DC12         BGT        .L51                     ; 0x0800085C
+  0x08000836:  4833         LDR        R0, =0x00000120          ; [PC, #204] [0x08000904]
+  0x08000838:  1980         ADDS       R0, R0, R6
+  0x0800083A:  1900         ADDS       R0, R0, R4
+  0x0800083C:  1DF1         ADDS       R1, R6, #7
+  0x0800083E:  3119         ADDS       R1, #25
+  0x08000840:  190A         ADDS       R2, R1, R4
+  0x08000842:  492F         LDR        R1, =AES_KEY             ; [PC, #188] [0x08000900] =0x080010B8
+  0x08000844:  F7FF FCB2    BL         AES128_ECB_decrypt       ; 0x080001AC
+  0x08000848:  3410         ADDS       R4, #16
+  0x0800084A:  E7F1         B          .L50                     ; 0x08000830
+  0x0800084C:  20000010     DC.W       msCounter
+  0x08000850:  00001388     DC.W       0x00001388
+  0x08000854:  0000FFFF     DC.W       0x0000FFFF
+  0x08000858:  0000FFFE     DC.W       0x0000FFFE
+
.L51:
+  0x0800085C:  68E8         LDR        R0, [R5, #12]
+  0x0800085E:  2800         CMP        R0, #0
+  0x08000860:  D503         BPL        .L52                     ; 0x0800086A
+  0x08000862:  4820         LDR        R0, =0x45670123          ; [PC, #128] [0x080008E4]
+  0x08000864:  6028         STR        R0, [R5]
+  0x08000866:  4821         LDR        R0, =0xCDEF89AB          ; [PC, #132] [0x080008EC]
+  0x08000868:  6028         STR        R0, [R5]
+
.L52:
+  0x0800086A:  69B0         LDR        R0, [R6, #24]
+  0x0800086C:  10C0         ASRS       R0, R0, #3
+  0x0800086E:  60F0         STR        R0, [R6, #12]
+  0x08000870:  2100         MOVS       R1, #0
+  0x08000872:  68B4         LDR        R4, [R6, #8]
+
.L53:
+  0x08000874:  68F0         LDR        R0, [R6, #12]
+  0x08000876:  4281         CMP        R1, R0
+  0x08000878:  DA22         BGE        .L56                     ; 0x080008C0
+
.L54:
+  0x0800087A:  68AA         LDR        R2, [R5, #8]
+  0x0800087C:  4222         TST        R2, R4
+  0x0800087E:  D1FC         BNE        .L54                     ; 0x0800087A
+  0x08000880:  68AA         LDR        R2, [R5, #8]
+  0x08000882:  60AA         STR        R2, [R5, #8]
+  0x08000884:  61B1         STR        R1, [R6, #24]
+  0x08000886:  00CA         LSLS       R2, R1, #3
+  0x08000888:  1DF3         ADDS       R3, R6, #7
+  0x0800088A:  3319         ADDS       R3, #25
+  0x0800088C:  189C         ADDS       R4, R3, R2
+  0x0800088E:  6860         LDR        R0, [R4, #4]
+  0x08000890:  6170         STR        R0, [R6, #20]
+  0x08000892:  589B         LDR        R3, [R3, R2]
+  0x08000894:  4817         LDR        R0, =u                   ; [PC, #92] [0x080008F4] =0x20000004
+  0x08000896:  6805         LDR        R5, [R0]
+  0x08000898:  4811         LDR        R0, =0x40022008          ; [PC, #68] [0x080008E0]
+  0x0800089A:  68C0         LDR        R0, [R0, #12]
+  0x0800089C:  69F4         LDR        R4, [R6, #28]
+  0x0800089E:  4320         ORRS       R0, R4
+  0x080008A0:  68B4         LDR        R4, [R6, #8]
+  0x080008A2:  490F         LDR        R1, =0x40022008          ; [PC, #60] [0x080008E0]
+  0x080008A4:  60C8         STR        R0, [R1, #12]
+  0x080008A6:  50AB         STR        R3, [R5, R2]
+  0x080008A8:  18A8         ADDS       R0, R5, R2
+  0x080008AA:  460D         MOV        R5, R1
+  0x080008AC:  F3BF 8F6F    ISB        SY
+  0x080008B0:  6971         LDR        R1, [R6, #20]
+  0x080008B2:  6041         STR        R1, [R0, #4]
+
.L55:
+  0x080008B4:  68A8         LDR        R0, [R5, #8]
+  0x080008B6:  4220         TST        R0, R4
+  0x080008B8:  D1FC         BNE        .L55                     ; 0x080008B4
+  0x080008BA:  69B1         LDR        R1, [R6, #24]
+  0x080008BC:  1C49         ADDS       R1, R1, #1
+  0x080008BE:  E7D9         B          .L53                     ; 0x08000874
+
.L56:
+  0x080008C0:  68E8         LDR        R0, [R5, #12]
+  0x080008C2:  69F1         LDR        R1, [R6, #28]
+  0x080008C4:  4388         BICS       R0, R1
+  0x080008C6:  60E8         STR        R0, [R5, #12]
+  0x080008C8:  68E8         LDR        R0, [R5, #12]
+  0x080008CA:  6871         LDR        R1, [R6, #4]
+  0x080008CC:  4308         ORRS       R0, R1
+  0x080008CE:  60E8         STR        R0, [R5, #12]
+  0x080008D0:  E607         B          .L4                      ; 0x080004E2
+
.L57:
+  0x080008D2:  F000 F95F    BL         JumpToApplication        ; 0x08000B94
+  0x080008D6:  E5EC         B          .L1                      ; 0x080004B2
+  0x080008D8:  00001388     DC.W       0x00001388
+  0x080008DC:  40015800     DC.W       0x40015800
+  0x080008E0:  40022008     DC.W       0x40022008
+  0x080008E4:  45670123     DC.W       0x45670123
+  0x080008E8:  50000414     DC.W       0x50000414
+  0x080008EC:  CDEF89AB     DC.W       0xCDEF89AB
+  0x080008F0:  20000010     DC.W       msCounter
+  0x080008F4:  20000004     DC.W       u
+  0x080008F8:  08003000     DC.W       0x08003000
+  0x080008FC:  0801EFFF     DC.W       0x0801EFFF
+  0x08000900:  080010B8     DC.W       AES_KEY
+  0x08000904:  00000120     DC.W       0x00000120
+

Section .text.Init from main.o, size=512, align=4

+
Init:
+  0x08000908:  B5F0         PUSH       {R4-R7, LR}
+  0x0800090A:  B083         SUB        SP, SP, #12
+  0x0800090C:  486E         LDR        R0, =SystemCoreClock     ; [PC, #0x01B8] [0x08000AC8] =0x20000000
+  0x0800090E:  6800         LDR        R0, [R0]
+  0x08000910:  217D         MOVS       R1, #125
+  0x08000912:  00C9         LSLS       R1, R1, #3
+  0x08000914:  F000 FA27    BL         __aeabi_uidiv            ; 0x08000D66
+  0x08000918:  1E40         SUBS       R0, R0, #1
+  0x0800091A:  0E01         LSRS       R1, R0, #24
+  0x0800091C:  D10D         BNE        .L1                      ; 0x0800093A
+  0x0800091E:  496B         LDR        R1, =0x00FFFFFF          ; [PC, #0x01AC] [0x08000ACC]
+  0x08000920:  4A6B         LDR        R2, =0xE000E010          ; [PC, #0x01AC] [0x08000AD0]
+  0x08000922:  6050         STR        R0, [R2, #4]
+  0x08000924:  486B         LDR        R0, =0xE000ED20          ; [PC, #0x01AC] [0x08000AD4]
+  0x08000926:  6803         LDR        R3, [R0]
+  0x08000928:  400B         ANDS       R3, R1
+  0x0800092A:  2103         MOVS       R1, #3
+  0x0800092C:  0789         LSLS       R1, R1, #30
+  0x0800092E:  1859         ADDS       R1, R3, R1
+  0x08000930:  6001         STR        R1, [R0]
+  0x08000932:  2000         MOVS       R0, #0
+  0x08000934:  6090         STR        R0, [R2, #8]
+  0x08000936:  2007         MOVS       R0, #7
+  0x08000938:  6010         STR        R0, [R2]
+
.L1:
+  0x0800093A:  4D67         LDR        R5, =msCounter           ; [PC, #0x019C] [0x08000AD8] =0x20000010
+  0x0800093C:  682E         LDR        R6, [R5]
+  0x0800093E:  2000         MOVS       R0, #0
+  0x08000940:  43C0         MVNS       R0, R0
+  0x08000942:  9001         STR        R0, [SP, #4]
+  0x08000944:  4965         LDR        R1, =0x00000341          ; [PC, #0x0194] [0x08000ADC]
+  0x08000946:  4A66         LDR        R2, =0x40021000          ; [PC, #0x0198] [0x08000AE0]
+  0x08000948:  4F6E         LDR        R7, =0x00001389          ; [PC, #0x01B8] [0x08000B04]
+
.L2:
+  0x0800094A:  460C         MOV        R4, R1
+  0x0800094C:  34BF         ADDS       R4, #191
+  0x0800094E:  6810         LDR        R0, [R2]
+  0x08000950:  4220         TST        R0, R4
+  0x08000952:  D10A         BNE        .L3                      ; 0x0800096A
+  0x08000954:  6828         LDR        R0, [R5]
+  0x08000956:  1B80         SUBS       R0, R0, R6
+  0x08000958:  42B8         CMP        R0, R7
+  0x0800095A:  D3F6         BCC        .L2                      ; 0x0800094A
+  0x0800095C:  2032         MOVS       R0, #50
+  0x0800095E:  9901         LDR        R1, [SP, #4]
+  0x08000960:  F000 F974    BL         TurnErrorLEDOn           ; 0x08000C4C
+  0x08000964:  4A5E         LDR        R2, =0x40021000          ; [PC, #0x0178] [0x08000AE0]
+  0x08000966:  495D         LDR        R1, =0x00000341          ; [PC, #0x0174] [0x08000ADC]
+  0x08000968:  E7EF         B          .L2                      ; 0x0800094A
+
.L3:
+  0x0800096A:  6B50         LDR        R0, [R2, #52]
+  0x0800096C:  2703         MOVS       R7, #3
+  0x0800096E:  4338         ORRS       R0, R7
+  0x08000970:  6350         STR        R0, [R2, #52]
+  0x08000972:  4A5C         LDR        R2, =0x50000400          ; [PC, #0x0170] [0x08000AE4]
+  0x08000974:  6810         LDR        R0, [R2]
+  0x08000976:  43B8         BICS       R0, R7
+  0x08000978:  6010         STR        R0, [R2]
+  0x0800097A:  6810         LDR        R0, [R2]
+  0x0800097C:  210C         MOVS       R1, #12
+  0x0800097E:  9100         STR        R1, [SP, #0]
+  0x08000980:  4388         BICS       R0, R1
+  0x08000982:  6010         STR        R0, [R2]
+  0x08000984:  6810         LDR        R0, [R2]
+  0x08000986:  2301         MOVS       R3, #1
+  0x08000988:  4318         ORRS       R0, R3
+  0x0800098A:  6010         STR        R0, [R2]
+  0x0800098C:  6810         LDR        R0, [R2]
+  0x0800098E:  2104         MOVS       R1, #4
+  0x08000990:  4301         ORRS       R1, R0
+  0x08000992:  6011         STR        R1, [R2]
+  0x08000994:  9302         STR        R3, [SP, #8]
+  0x08000996:  041D         LSLS       R5, R3, #16
+  0x08000998:  4853         LDR        R0, =0x40022008          ; [PC, #0x014C] [0x08000AE8]
+  0x0800099A:  6981         LDR        R1, [R0, #24]
+  0x0800099C:  B2C9         UXTB       R1, R1
+  0x0800099E:  29AA         CMP        R1, #170
+  0x080009A0:  D003         BEQ        .L4                      ; 0x080009AA
+  0x080009A2:  6981         LDR        R1, [R0, #24]
+  0x080009A4:  B2C9         UXTB       R1, R1
+  0x080009A6:  29CC         CMP        R1, #204
+  0x080009A8:  D129         BNE        .L9                      ; 0x080009FE
+
.L4:
+  0x080009AA:  68C1         LDR        R1, [R0, #12]
+  0x080009AC:  2900         CMP        R1, #0
+  0x080009AE:  D503         BPL        .L5                      ; 0x080009B8
+  0x080009B0:  494E         LDR        R1, =0x45670123          ; [PC, #0x0138] [0x08000AEC]
+  0x080009B2:  6001         STR        R1, [R0]
+  0x080009B4:  494E         LDR        R1, =0xCDEF89AB          ; [PC, #0x0138] [0x08000AF0]
+  0x080009B6:  6001         STR        R1, [R0]
+
.L5:
+  0x080009B8:  68C1         LDR        R1, [R0, #12]
+  0x080009BA:  0049         LSLS       R1, R1, #1
+  0x080009BC:  D503         BPL        .L6                      ; 0x080009C6
+  0x080009BE:  494D         LDR        R1, =0x08192A3B          ; [PC, #0x0134] [0x08000AF4]
+  0x080009C0:  6041         STR        R1, [R0, #4]
+  0x080009C2:  494D         LDR        R1, =0x4C5D6E7F          ; [PC, #0x0134] [0x08000AF8]
+  0x080009C4:  6041         STR        R1, [R0, #4]
+
.L6:
+  0x080009C6:  6981         LDR        R1, [R0, #24]
+  0x080009C8:  22FF         MOVS       R2, #255
+  0x080009CA:  4391         BICS       R1, R2
+  0x080009CC:  6181         STR        R1, [R0, #24]
+  0x080009CE:  6981         LDR        R1, [R0, #24]
+  0x080009D0:  22EC         MOVS       R2, #236
+  0x080009D2:  430A         ORRS       R2, R1
+  0x080009D4:  6182         STR        R2, [R0, #24]
+
.L7:
+  0x080009D6:  6881         LDR        R1, [R0, #8]
+  0x080009D8:  4229         TST        R1, R5
+  0x080009DA:  D1FC         BNE        .L7                      ; 0x080009D6
+  0x080009DC:  9902         LDR        R1, [SP, #8]
+  0x080009DE:  0449         LSLS       R1, R1, #17
+  0x080009E0:  68C2         LDR        R2, [R0, #12]
+  0x080009E2:  430A         ORRS       R2, R1
+  0x080009E4:  60C2         STR        R2, [R0, #12]
+
.L8:
+  0x080009E6:  6881         LDR        R1, [R0, #8]
+  0x080009E8:  4229         TST        R1, R5
+  0x080009EA:  D1FC         BNE        .L8                      ; 0x080009E6
+  0x080009EC:  9902         LDR        R1, [SP, #8]
+  0x080009EE:  06C9         LSLS       R1, R1, #27
+  0x080009F0:  68C2         LDR        R2, [R0, #12]
+  0x080009F2:  430A         ORRS       R2, R1
+  0x080009F4:  60C2         STR        R2, [R0, #12]
+  0x080009F6:  2064         MOVS       R0, #100
+  0x080009F8:  9901         LDR        R1, [SP, #4]
+  0x080009FA:  F000 F927    BL         TurnErrorLEDOn           ; 0x08000C4C
+
.L9:
+  0x080009FE:  20CF         MOVS       R0, #207
+  0x08000A00:  0481         LSLS       R1, R0, #18
+  0x08000A02:  2605         MOVS       R6, #5
+  0x08000A04:  0730         LSLS       R0, R6, #28
+  0x08000A06:  6802         LDR        R2, [R0]
+  0x08000A08:  438A         BICS       R2, R1
+  0x08000A0A:  6002         STR        R2, [R0]
+  0x08000A0C:  2145         MOVS       R1, #69
+  0x08000A0E:  04C9         LSLS       R1, R1, #19
+  0x08000A10:  6802         LDR        R2, [R0]
+  0x08000A12:  430A         ORRS       R2, R1
+  0x08000A14:  6002         STR        R2, [R0]
+  0x08000A16:  0539         LSLS       R1, R7, #20
+  0x08000A18:  68C2         LDR        R2, [R0, #12]
+  0x08000A1A:  438A         BICS       R2, R1
+  0x08000A1C:  60C2         STR        R2, [R0, #12]
+  0x08000A1E:  9F02         LDR        R7, [SP, #8]
+  0x08000A20:  0539         LSLS       R1, R7, #20
+  0x08000A22:  68C2         LDR        R2, [R0, #12]
+  0x08000A24:  430A         ORRS       R2, R1
+  0x08000A26:  60C2         STR        R2, [R0, #12]
+  0x08000A28:  210F         MOVS       R1, #15
+  0x08000A2A:  020A         LSLS       R2, R1, #8
+  0x08000A2C:  6A43         LDR        R3, [R0, #36]
+  0x08000A2E:  4393         BICS       R3, R2
+  0x08000A30:  6243         STR        R3, [R0, #36]
+  0x08000A32:  023A         LSLS       R2, R7, #8
+  0x08000A34:  6A43         LDR        R3, [R0, #36]
+  0x08000A36:  4313         ORRS       R3, R2
+  0x08000A38:  6243         STR        R3, [R0, #36]
+  0x08000A3A:  6A42         LDR        R2, [R0, #36]
+  0x08000A3C:  23F0         MOVS       R3, #240
+  0x08000A3E:  439A         BICS       R2, R3
+  0x08000A40:  6242         STR        R2, [R0, #36]
+  0x08000A42:  6A42         LDR        R2, [R0, #36]
+  0x08000A44:  2310         MOVS       R3, #16
+  0x08000A46:  4313         ORRS       R3, R2
+  0x08000A48:  6243         STR        R3, [R0, #36]
+  0x08000A4A:  0409         LSLS       R1, R1, #16
+  0x08000A4C:  6A42         LDR        R2, [R0, #36]
+  0x08000A4E:  438A         BICS       R2, R1
+  0x08000A50:  6242         STR        R2, [R0, #36]
+  0x08000A52:  6A41         LDR        R1, [R0, #36]
+  0x08000A54:  4329         ORRS       R1, R5
+  0x08000A56:  6241         STR        R1, [R0, #36]
+  0x08000A58:  03B9         LSLS       R1, R7, #14
+  0x08000A5A:  4A21         LDR        R2, =0x40021000          ; [PC, #132] [0x08000AE0]
+  0x08000A5C:  6C10         LDR        R0, [R2, #64]
+  0x08000A5E:  4308         ORRS       R0, R1
+  0x08000A60:  6410         STR        R0, [R2, #64]
+  0x08000A62:  4826         LDR        R0, =0x40013800          ; [PC, #152] [0x08000AFC]
+  0x08000A64:  6802         LDR        R2, [R0]
+  0x08000A66:  43BA         BICS       R2, R7
+  0x08000A68:  6002         STR        R2, [R0]
+  0x08000A6A:  073A         LSLS       R2, R7, #28
+  0x08000A6C:  6803         LDR        R3, [R0]
+  0x08000A6E:  4393         BICS       R3, R2
+  0x08000A70:  6003         STR        R3, [R0]
+  0x08000A72:  033A         LSLS       R2, R7, #12
+  0x08000A74:  6803         LDR        R3, [R0]
+  0x08000A76:  4313         ORRS       R3, R2
+  0x08000A78:  6003         STR        R3, [R0]
+  0x08000A7A:  03FA         LSLS       R2, R7, #15
+  0x08000A7C:  6803         LDR        R3, [R0]
+  0x08000A7E:  4393         BICS       R3, R2
+  0x08000A80:  6003         STR        R3, [R0]
+  0x08000A82:  6802         LDR        R2, [R0]
+  0x08000A84:  4322         ORRS       R2, R4
+  0x08000A86:  6002         STR        R2, [R0]
+  0x08000A88:  6802         LDR        R2, [R0]
+  0x08000A8A:  9B00         LDR        R3, [SP, #0]
+  0x08000A8C:  431A         ORRS       R2, R3
+  0x08000A8E:  6002         STR        R2, [R0]
+  0x08000A90:  6802         LDR        R2, [R0]
+  0x08000A92:  4B1B         LDR        R3, =0x03FF0000          ; [PC, #108] [0x08000B00]
+  0x08000A94:  4313         ORRS       R3, R2
+  0x08000A96:  6003         STR        R3, [R0]
+  0x08000A98:  6882         LDR        R2, [R0, #8]
+  0x08000A9A:  430A         ORRS       R2, R1
+  0x08000A9C:  6082         STR        R2, [R0, #8]
+  0x08000A9E:  490F         LDR        R1, =0x00000341          ; [PC, #60] [0x08000ADC]
+  0x08000AA0:  60C1         STR        R1, [R0, #12]
+  0x08000AA2:  6801         LDR        R1, [R0]
+  0x08000AA4:  4339         ORRS       R1, R7
+  0x08000AA6:  6001         STR        R1, [R0]
+  0x08000AA8:  4F0E         LDR        R7, =0x50000400          ; [PC, #56] [0x08000AE4]
+
.L10:
+  0x08000AAA:  2E00         CMP        R6, #0
+  0x08000AAC:  D00A         BEQ        .L11                     ; 0x08000AC4
+  0x08000AAE:  9802         LDR        R0, [SP, #8]
+  0x08000AB0:  61B8         STR        R0, [R7, #24]
+  0x08000AB2:  2096         MOVS       R0, #150
+  0x08000AB4:  F000 F8EC    BL         Delay                    ; 0x08000C90
+  0x08000AB8:  61BD         STR        R5, [R7, #24]
+  0x08000ABA:  2096         MOVS       R0, #150
+  0x08000ABC:  F000 F8E8    BL         Delay                    ; 0x08000C90
+  0x08000AC0:  1E76         SUBS       R6, R6, #1
+  0x08000AC2:  E7F2         B          .L10                     ; 0x08000AAA
+
.L11:
+  0x08000AC4:  B003         ADD        SP, SP, #12
+  0x08000AC6:  BDF0         POP        {R4-R7, PC}
+  0x08000AC8:  20000000     DC.W       SystemCoreClock
+  0x08000ACC:  00FFFFFF     DC.W       0x00FFFFFF
+  0x08000AD0:  E000E010     DC.W       0xE000E010
+  0x08000AD4:  E000ED20     DC.W       0xE000ED20
+  0x08000AD8:  20000010     DC.W       msCounter
+  0x08000ADC:  00000341     DC.W       0x00000341
+  0x08000AE0:  40021000     DC.W       0x40021000
+  0x08000AE4:  50000400     DC.W       0x50000400
+  0x08000AE8:  40022008     DC.W       0x40022008
+  0x08000AEC:  45670123     DC.W       0x45670123
+  0x08000AF0:  CDEF89AB     DC.W       0xCDEF89AB
+  0x08000AF4:  08192A3B     DC.W       0x08192A3B
+  0x08000AF8:  4C5D6E7F     DC.W       0x4C5D6E7F
+  0x08000AFC:  40013800     DC.W       0x40013800
+  0x08000B00:  03FF0000     DC.W       0x03FF0000
+  0x08000B04:  00001389     DC.W       0x00001389
+

Section .text.WaitForByte from main.o, size=140, align=4

+
WaitForByte:
+  0x08000B08:  B5F0         PUSH       {R4-R7, LR}
+  0x08000B0A:  4A1E         LDR        R2, =msCounter           ; [PC, #120] [0x08000B84] =0x20000010
+  0x08000B0C:  6814         LDR        R4, [R2]
+  0x08000B0E:  6813         LDR        R3, [R2]
+  0x08000B10:  491D         LDR        R1, =0x4001381C          ; [PC, #116] [0x08000B88]
+  0x08000B12:  4D1F         LDR        R5, =0x50000414          ; [PC, #124] [0x08000B90]
+
.L1:
+  0x08000B14:  680E         LDR        R6, [R1]
+  0x08000B16:  06B6         LSLS       R6, R6, #26
+  0x08000B18:  D411         BMI        .L4                      ; 0x08000B3E
+  0x08000B1A:  6816         LDR        R6, [R2]
+  0x08000B1C:  1AF6         SUBS       R6, R6, R3
+  0x08000B1E:  4286         CMP        R6, R0
+  0x08000B20:  D20D         BCS        .L4                      ; 0x08000B3E
+  0x08000B22:  6816         LDR        R6, [R2]
+  0x08000B24:  1B36         SUBS       R6, R6, R4
+  0x08000B26:  2E4B         CMP        R6, #75
+  0x08000B28:  D3F4         BCC        .L1                      ; 0x08000B14
+  0x08000B2A:  6814         LDR        R4, [R2]
+  0x08000B2C:  682E         LDR        R6, [R5]
+  0x08000B2E:  07F6         LSLS       R6, R6, #31
+  0x08000B30:  D001         BEQ        .L2                      ; 0x08000B36
+  0x08000B32:  2614         MOVS       R6, #20
+  0x08000B34:  E000         B          .L3                      ; 0x08000B38
+
.L2:
+  0x08000B36:  2604         MOVS       R6, #4
+
.L3:
+  0x08000B38:  2701         MOVS       R7, #1
+  0x08000B3A:  5177         STR        R7, [R6, R5]
+  0x08000B3C:  E7EA         B          .L1                      ; 0x08000B14
+
.L4:
+  0x08000B3E:  6812         LDR        R2, [R2]
+  0x08000B40:  1AD2         SUBS       R2, R2, R3
+  0x08000B42:  4282         CMP        R2, R0
+  0x08000B44:  D20F         BCS        .L5                      ; 0x08000B66
+  0x08000B46:  4811         LDR        R0, =0x0000FFFF          ; [PC, #68] [0x08000B8C]
+  0x08000B48:  680A         LDR        R2, [R1]
+  0x08000B4A:  0712         LSLS       R2, R2, #28
+  0x08000B4C:  D40F         BMI        .L6                      ; 0x08000B6E
+  0x08000B4E:  680A         LDR        R2, [R1]
+  0x08000B50:  0752         LSLS       R2, R2, #29
+  0x08000B52:  D40E         BMI        .L7                      ; 0x08000B72
+  0x08000B54:  680A         LDR        R2, [R1]
+  0x08000B56:  0792         LSLS       R2, R2, #30
+  0x08000B58:  D40D         BMI        .L8                      ; 0x08000B76
+  0x08000B5A:  680A         LDR        R2, [R1]
+  0x08000B5C:  07D2         LSLS       R2, R2, #31
+  0x08000B5E:  D10C         BNE        .L9                      ; 0x08000B7A
+  0x08000B60:  6888         LDR        R0, [R1, #8]
+  0x08000B62:  B2C0         UXTB       R0, R0
+  0x08000B64:  E00B         B          .L11                     ; 0x08000B7E
+
.L5:
+  0x08000B66:  2000         MOVS       R0, #0
+  0x08000B68:  43C0         MVNS       R0, R0
+  0x08000B6A:  1E40         SUBS       R0, R0, #1
+  0x08000B6C:  E007         B          .L11                     ; 0x08000B7E
+
.L6:
+  0x08000B6E:  2208         MOVS       R2, #8
+  0x08000B70:  E004         B          .L10                     ; 0x08000B7C
+
.L7:
+  0x08000B72:  2204         MOVS       R2, #4
+  0x08000B74:  E002         B          .L10                     ; 0x08000B7C
+
.L8:
+  0x08000B76:  2202         MOVS       R2, #2
+  0x08000B78:  E000         B          .L10                     ; 0x08000B7C
+
.L9:
+  0x08000B7A:  2201         MOVS       R2, #1
+
.L10:
+  0x08000B7C:  604A         STR        R2, [R1, #4]
+
.L11:
+  0x08000B7E:  B200         SXTH       R0, R0
+  0x08000B80:  BDF0         POP        {R4-R7, PC}
+  0x08000B82:  46C0         NOP
+  0x08000B84:  20000010     DC.W       msCounter
+  0x08000B88:  4001381C     DC.W       0x4001381C
+  0x08000B8C:  0000FFFF     DC.W       0x0000FFFF
+  0x08000B90:  50000414     DC.W       0x50000414
+

Section .text.JumpToApplication from main.o, size=152, align=4

+
JumpToApplication:
+  0x08000B94:  B5F0         PUSH       {R4-R7, LR}
+  0x08000B96:  B081         SUB        SP, SP, #4
+  0x08000B98:  2001         MOVS       R0, #1
+  0x08000B9A:  0302         LSLS       R2, R0, #12
+  0x08000B9C:  491A         LDR        R1, =0x40021038          ; [PC, #104] [0x08000C08]
+  0x08000B9E:  680B         LDR        R3, [R1]
+  0x08000BA0:  4313         ORRS       R3, R2
+  0x08000BA2:  600B         STR        R3, [R1]
+  0x08000BA4:  4B19         LDR        R3, =0x40023000          ; [PC, #100] [0x08000C0C]
+  0x08000BA6:  689C         LDR        R4, [R3, #8]
+  0x08000BA8:  4304         ORRS       R4, R0
+  0x08000BAA:  609C         STR        R4, [R3, #8]
+  0x08000BAC:  2400         MOVS       R4, #0
+  0x08000BAE:  4818         LDR        R0, =0x08003000          ; [PC, #96] [0x08000C10]
+  0x08000BB0:  4D18         LDR        R5, =0x0001BFFC          ; [PC, #96] [0x08000C14]
+  0x08000BB2:  4E1D         LDR        R6, =0xF7FFD004          ; [PC, #116] [0x08000C28]
+
.L1:
+  0x08000BB4:  42AC         CMP        R4, R5
+  0x08000BB6:  D205         BCS        .L2                      ; 0x08000BC4
+  0x08000BB8:  5827         LDR        R7, [R4, R0]
+  0x08000BBA:  BA3F         REV        R7, R7
+  0x08000BBC:  601F         STR        R7, [R3]
+  0x08000BBE:  1824         ADDS       R4, R4, R0
+  0x08000BC0:  19A4         ADDS       R4, R4, R6
+  0x08000BC2:  E7F7         B          .L1                      ; 0x08000BB4
+
.L2:
+  0x08000BC4:  4C14         LDR        R4, =0x0801EFFC          ; [PC, #80] [0x08000C18]
+  0x08000BC6:  6824         LDR        R4, [R4]
+  0x08000BC8:  681B         LDR        R3, [R3]
+  0x08000BCA:  42A3         CMP        R3, R4
+  0x08000BCC:  D115         BNE        .L4                      ; 0x08000BFA
+  0x08000BCE:  680B         LDR        R3, [R1]
+  0x08000BD0:  4393         BICS       R3, R2
+  0x08000BD2:  600B         STR        R3, [R1]
+  0x08000BD4:  4912         LDR        R1, =0xE000E010          ; [PC, #72] [0x08000C20]
+  0x08000BD6:  2400         MOVS       R4, #0
+  0x08000BD8:  608C         STR        R4, [R1, #8]
+  0x08000BDA:  604C         STR        R4, [R1, #4]
+  0x08000BDC:  600C         STR        R4, [R1]
+  0x08000BDE:  B672         CPSID      i
+  0x08000BE0:  4910         LDR        R1, =0xE000ED08          ; [PC, #64] [0x08000C24]
+  0x08000BE2:  6008         STR        R0, [R1]
+  0x08000BE4:  6801         LDR        R1, [R0]
+  0x08000BE6:  F381 8808    MSR        MSP, R1
+  0x08000BEA:  B662         CPSIE      i
+  0x08000BEC:  6840         LDR        R0, [R0, #4]
+  0x08000BEE:  4780         BLX        R0
+
.L3:
+  0x08000BF0:  43E1         MVNS       R1, R4
+  0x08000BF2:  207D         MOVS       R0, #125
+  0x08000BF4:  F000 F82A    BL         TurnErrorLEDOn           ; 0x08000C4C
+  0x08000BF8:  E7FA         B          .L3                      ; 0x08000BF0
+
.L4:
+  0x08000BFA:  20FA         MOVS       R0, #250
+  0x08000BFC:  4907         LDR        R1, =0x00001388          ; [PC, #28] [0x08000C1C]
+  0x08000BFE:  F000 F825    BL         TurnErrorLEDOn           ; 0x08000C4C
+  0x08000C02:  B001         ADD        SP, SP, #4
+  0x08000C04:  BDF0         POP        {R4-R7, PC}
+  0x08000C06:  46C0         NOP
+  0x08000C08:  40021038     DC.W       0x40021038
+  0x08000C0C:  40023000     DC.W       0x40023000
+  0x08000C10:  08003000     DC.W       0x08003000
+  0x08000C14:  0001BFFC     DC.W       0x0001BFFC
+  0x08000C18:  0801EFFC     DC.W       0x0801EFFC
+  0x08000C1C:  00001388     DC.W       0x00001388
+  0x08000C20:  E000E010     DC.W       0xE000E010
+  0x08000C24:  E000ED08     DC.W       0xE000ED08
+  0x08000C28:  F7FFD004     DC.W       0xF7FFD004
+

Section .text.Transmit from main.o, size=32, align=4

+
Transmit:
+  0x08000C2C:  B510         PUSH       {R4, LR}
+  0x08000C2E:  2200         MOVS       R2, #0
+  0x08000C30:  4B05         LDR        R3, =0x4001381C          ; [PC, #20] [0x08000C48]
+
.L1:
+  0x08000C32:  428A         CMP        R2, R1
+  0x08000C34:  DA06         BGE        .L3                      ; 0x08000C44
+
.L2:
+  0x08000C36:  681C         LDR        R4, [R3]
+  0x08000C38:  0624         LSLS       R4, R4, #24
+  0x08000C3A:  D5FC         BPL        .L2                      ; 0x08000C36
+  0x08000C3C:  5C84         LDRB       R4, [R0, R2]
+  0x08000C3E:  60DC         STR        R4, [R3, #12]
+  0x08000C40:  1C52         ADDS       R2, R2, #1
+  0x08000C42:  E7F6         B          .L1                      ; 0x08000C32
+
.L3:
+  0x08000C44:  BD10         POP        {R4, PC}
+  0x08000C46:  46C0         NOP
+  0x08000C48:  4001381C     DC.W       0x4001381C
+

Section .text.TurnErrorLEDOn from main.o, size=68, align=4

+
TurnErrorLEDOn:
+  0x08000C4C:  B5F0         PUSH       {R4-R7, LR}
+  0x08000C4E:  B081         SUB        SP, SP, #4
+  0x08000C50:  9100         STR        R1, [SP, #0]
+  0x08000C52:  4605         MOV        R5, R0
+  0x08000C54:  2601         MOVS       R6, #1
+  0x08000C56:  0430         LSLS       R0, R6, #16
+  0x08000C58:  4F0B         LDR        R7, =0x50000418          ; [PC, #44] [0x08000C88]
+  0x08000C5A:  6038         STR        R0, [R7]
+  0x08000C5C:  480B         LDR        R0, =msCounter           ; [PC, #44] [0x08000C8C] =0x20000010
+  0x08000C5E:  6804         LDR        R4, [R0]
+
.L1:
+  0x08000C60:  480A         LDR        R0, =msCounter           ; [PC, #40] [0x08000C8C] =0x20000010
+  0x08000C62:  6800         LDR        R0, [R0]
+  0x08000C64:  1B00         SUBS       R0, R0, R4
+  0x08000C66:  9900         LDR        R1, [SP, #0]
+  0x08000C68:  4288         CMP        R0, R1
+  0x08000C6A:  D20A         BCS        .L2                      ; 0x08000C82
+  0x08000C6C:  2002         MOVS       R0, #2
+  0x08000C6E:  6038         STR        R0, [R7]
+  0x08000C70:  4628         MOV        R0, R5
+  0x08000C72:  F000 F80D    BL         Delay                    ; 0x08000C90
+  0x08000C76:  0470         LSLS       R0, R6, #17
+  0x08000C78:  6038         STR        R0, [R7]
+  0x08000C7A:  4628         MOV        R0, R5
+  0x08000C7C:  F000 F808    BL         Delay                    ; 0x08000C90
+  0x08000C80:  E7EE         B          .L1                      ; 0x08000C60
+
.L2:
+  0x08000C82:  B001         ADD        SP, SP, #4
+  0x08000C84:  BDF0         POP        {R4-R7, PC}
+  0x08000C86:  46C0         NOP
+  0x08000C88:  50000418     DC.W       0x50000418
+  0x08000C8C:  20000010     DC.W       msCounter
+

Section .text.Delay from main.o, size=28, align=4

+
Delay:
+  0x08000C90:  B081         SUB        SP, SP, #4
+  0x08000C92:  4905         LDR        R1, =msCounter           ; [PC, #20] [0x08000CA8] =0x20000010
+  0x08000C94:  680A         LDR        R2, [R1]
+  0x08000C96:  9200         STR        R2, [SP, #0]
+
.L1:
+  0x08000C98:  680A         LDR        R2, [R1]
+  0x08000C9A:  9B00         LDR        R3, [SP, #0]
+  0x08000C9C:  1AD2         SUBS       R2, R2, R3
+  0x08000C9E:  4282         CMP        R2, R0
+  0x08000CA0:  D3FA         BCC        .L1                      ; 0x08000C98
+  0x08000CA2:  B001         ADD        SP, SP, #4
+  0x08000CA4:  4770         BX         LR
+  0x08000CA6:  46C0         NOP
+  0x08000CA8:  20000010     DC.W       msCounter
+

Section .text.SysTick_Handler from main.o, size=16, align=4

+
SysTick_Handler:
+  0x08000CAC:  4802         LDR        R0, =msCounter           ; [PC, #8] [0x08000CB8] =0x20000010
+  0x08000CAE:  6801         LDR        R1, [R0]
+  0x08000CB0:  1C49         ADDS       R1, R1, #1
+  0x08000CB2:  6001         STR        R1, [R0]
+  0x08000CB4:  4770         BX         LR
+  0x08000CB6:  46C0         NOP
+  0x08000CB8:  20000010     DC.W       msCounter
+

Section .init from SEGGER_THUMB_Startup.o, size=20, align=4

+
_start:
+  0x08000CBC:  4C03         LDR        R4, =0x080010C8          ; [PC, #12] [0x08000CCC]
+
__SEGGER_init_run_loop:
+  0x08000CBE:  6820         LDR        R0, [R4]
+  0x08000CC0:  3404         ADDS       R4, #4
+  0x08000CC2:  4780         BLX        R0
+  0x08000CC4:  E7FB         B          __SEGGER_init_run_loop   ; 0x08000CBE
+
__SEGGER_init_done:
+  0x08000CC6:  F7FF FBE7    BL         main                     ; 0x08000498
+
exit:
+  0x08000CCA:  E7FE         B          exit                     ; 0x08000CCA
+  0x08000CCC:  080010C8     DC.W       0x080010C8
+

Section .init.SVC_Handler from STM32G07x_Vectors.o, size=2, align=2

+
SVC_Handler:
+  0x08000CD0:  E7FE         B          SVC_Handler              ; 0x08000CD0
+

Section .init.PendSV_Handler from STM32G07x_Vectors.o, size=2, align=2

+
PendSV_Handler:
+  0x08000CD2:  E7FE         B          PendSV_Handler           ; 0x08000CD2
+

Section .init.WWDG_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
WWDG_IRQHandler:
+  0x08000CD4:  E7FE         B          WWDG_IRQHandler          ; 0x08000CD4
+

Section .init.PVD_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
PVD_IRQHandler:
+  0x08000CD6:  E7FE         B          PVD_IRQHandler           ; 0x08000CD6
+

Section .init.RTC_STAMP_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
RTC_STAMP_IRQHandler:
+  0x08000CD8:  E7FE         B          RTC_STAMP_IRQHandler     ; 0x08000CD8
+

Section .init.FLASH_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
FLASH_IRQHandler:
+  0x08000CDA:  E7FE         B          FLASH_IRQHandler         ; 0x08000CDA
+

Section .init.RCC_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
RCC_IRQHandler:
+  0x08000CDC:  E7FE         B          RCC_IRQHandler           ; 0x08000CDC
+

Section .init.EXTI0_1_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
EXTI0_1_IRQHandler:
+  0x08000CDE:  E7FE         B          EXTI0_1_IRQHandler       ; 0x08000CDE
+

Section .init.EXTI2_3_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
EXTI2_3_IRQHandler:
+  0x08000CE0:  E7FE         B          EXTI2_3_IRQHandler       ; 0x08000CE0
+

Section .init.EXTI4_15_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
EXTI4_15_IRQHandler:
+  0x08000CE2:  E7FE         B          EXTI4_15_IRQHandler      ; 0x08000CE2
+

Section .init.UCPD1_UCPD2_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
UCPD1_UCPD2_IRQHandler:
+  0x08000CE4:  E7FE         B          UCPD1_UCPD2_IRQHandler   ; 0x08000CE4
+

Section .init.DMA_Channel1_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
DMA_Channel1_IRQHandler:
+  0x08000CE6:  E7FE         B          DMA_Channel1_IRQHandler  ; 0x08000CE6
+

Section .init.DMA_Channel2_3_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
DMA_Channel2_3_IRQHandler:
+  0x08000CE8:  E7FE         B          DMA_Channel2_3_IRQHandler ; 0x08000CE8
+

Section .init.DMA_Channel4_5_6_7_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
DMA_Channel4_5_6_7_IRQHandler:
+  0x08000CEA:  E7FE         B          DMA_Channel4_5_6_7_IRQHandler ; 0x08000CEA
+

Section .init.ADC_COMP_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
ADC_COMP_IRQHandler:
+  0x08000CEC:  E7FE         B          ADC_COMP_IRQHandler      ; 0x08000CEC
+

Section .init.TIM1_BRK_UP_TRG_COMP_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM1_BRK_UP_TRG_COMP_IRQHandler:
+  0x08000CEE:  E7FE         B          TIM1_BRK_UP_TRG_COMP_IRQHandler ; 0x08000CEE
+

Section .init.TIM1_CC_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM1_CC_IRQHandler:
+  0x08000CF0:  E7FE         B          TIM1_CC_IRQHandler       ; 0x08000CF0
+

Section .init.TIM2_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM2_IRQHandler:
+  0x08000CF2:  E7FE         B          TIM2_IRQHandler          ; 0x08000CF2
+

Section .init.TIM3_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM3_IRQHandler:
+  0x08000CF4:  E7FE         B          TIM3_IRQHandler          ; 0x08000CF4
+

Section .init.TIM6_DAC_LPTIM1_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM6_DAC_LPTIM1_IRQHandler:
+  0x08000CF6:  E7FE         B          TIM6_DAC_LPTIM1_IRQHandler ; 0x08000CF6
+

Section .init.TIM7_LPTIM2_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM7_LPTIM2_IRQHandler:
+  0x08000CF8:  E7FE         B          TIM7_LPTIM2_IRQHandler   ; 0x08000CF8
+

Section .init.TIM14_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM14_IRQHandler:
+  0x08000CFA:  E7FE         B          TIM14_IRQHandler         ; 0x08000CFA
+

Section .init.TIM15_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM15_IRQHandler:
+  0x08000CFC:  E7FE         B          TIM15_IRQHandler         ; 0x08000CFC
+

Section .init.TIM16_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM16_IRQHandler:
+  0x08000CFE:  E7FE         B          TIM16_IRQHandler         ; 0x08000CFE
+

Section .init.TIM17_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
TIM17_IRQHandler:
+  0x08000D00:  E7FE         B          TIM17_IRQHandler         ; 0x08000D00
+

Section .init.I2C1_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
I2C1_IRQHandler:
+  0x08000D02:  E7FE         B          I2C1_IRQHandler          ; 0x08000D02
+

Section .init.I2C2_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
I2C2_IRQHandler:
+  0x08000D04:  E7FE         B          I2C2_IRQHandler          ; 0x08000D04
+

Section .init.SPI1_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
SPI1_IRQHandler:
+  0x08000D06:  E7FE         B          SPI1_IRQHandler          ; 0x08000D06
+

Section .init.SPI2_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
SPI2_IRQHandler:
+  0x08000D08:  E7FE         B          SPI2_IRQHandler          ; 0x08000D08
+

Section .init.USART1_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
USART1_IRQHandler:
+  0x08000D0A:  E7FE         B          USART1_IRQHandler        ; 0x08000D0A
+

Section .init.USART2_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
USART2_IRQHandler:
+  0x08000D0C:  E7FE         B          USART2_IRQHandler        ; 0x08000D0C
+

Section .init.USART3_USART4_LPUART1_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
USART3_USART4_LPUART1_IRQHandler:
+  0x08000D0E:  E7FE         B          USART3_USART4_LPUART1_IRQHandler ; 0x08000D0E
+

Section .init.CEC_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
CEC_IRQHandler:
+  0x08000D10:  E7FE         B          CEC_IRQHandler           ; 0x08000D10
+

Section .init.AES_RNG_IRQHandler from STM32G07x_Vectors.o, size=2, align=2

+
AES_RNG_IRQHandler:
+  0x08000D12:  E7FE         B          AES_RNG_IRQHandler       ; 0x08000D12
+

Section .init.Reset_Handler from STM32G0xx_Startup.o, size=6, align=2

+
reset_handler:
+Reset_Handler:
+  0x08000D14:  F7FF F9DC    BL         SystemInit               ; 0x080000D0
+  0x08000D18:  E7D0         B          _start                   ; 0x08000CBC
+

Section .text.NMI_Handler from main.o, size=14, align=2

+
NMI_Handler:
+  0x08000D1A:  B580         PUSH       {R7, LR}
+  0x08000D1C:  2000         MOVS       R0, #0
+  0x08000D1E:  43C1         MVNS       R1, R0
+  0x08000D20:  20FA         MOVS       R0, #250
+  0x08000D22:  F7FF FF93    BL         TurnErrorLEDOn           ; 0x08000C4C
+  0x08000D26:  BD80         POP        {R7, PC}
+

Section .text.libc.__aeabi_idiv0 from intasmops_arm.o (libc_v6m_t_le_eabi_small.a), size=6, align=2

+
__aeabi_idiv0:
+  0x08000D28:  2000         MOVS       R0, #0
+  0x08000D2A:  2100         MOVS       R1, #0
+  0x08000D2C:  4770         BX         LR
+

Section .text.TransmitACK from main.o, size=20, align=2

+
TransmitACK:
+  0x08000D2E:  B500         PUSH       {LR}
+  0x08000D30:  B081         SUB        SP, SP, #4
+  0x08000D32:  4668         MOV        R0, SP
+  0x08000D34:  2179         MOVS       R1, #121
+  0x08000D36:  7001         STRB       R1, [R0]
+  0x08000D38:  2101         MOVS       R1, #1
+  0x08000D3A:  F7FF FF77    BL         Transmit                 ; 0x08000C2C
+  0x08000D3E:  B001         ADD        SP, SP, #4
+  0x08000D40:  BD00         POP        {PC}
+

Section .text.TransmitNACK from main.o, size=20, align=2

+
TransmitNACK:
+  0x08000D42:  B500         PUSH       {LR}
+  0x08000D44:  B081         SUB        SP, SP, #4
+  0x08000D46:  4668         MOV        R0, SP
+  0x08000D48:  211F         MOVS       R1, #31
+  0x08000D4A:  7001         STRB       R1, [R0]
+  0x08000D4C:  2101         MOVS       R1, #1
+  0x08000D4E:  F7FF FF6D    BL         Transmit                 ; 0x08000C2C
+  0x08000D52:  B001         ADD        SP, SP, #4
+  0x08000D54:  BD00         POP        {PC}
+

Section .text.HardFault_Handler from main.o, size=16, align=2

+
HardFault_Handler:
+  0x08000D56:  B580         PUSH       {R7, LR}
+  0x08000D58:  207D         MOVS       R0, #125
+  0x08000D5A:  0080         LSLS       R0, R0, #2
+  0x08000D5C:  2100         MOVS       R1, #0
+  0x08000D5E:  43C9         MVNS       R1, R1
+  0x08000D60:  F7FF FF74    BL         TurnErrorLEDOn           ; 0x08000C4C
+  0x08000D64:  BD80         POP        {R7, PC}
+

Section .text.libc.__aeabi_uidiv from intasmops_arm.o (libc_v6m_t_le_eabi_small.a), size=56, align=2

+
__aeabi_uidiv:
+  0x08000D66:  000A         MOVS       R2, R1
+  0x08000D68:  D015         BEQ        .L8                      ; 0x08000D96
+  0x08000D6A:  0003         MOVS       R3, R0
+  0x08000D6C:  0840         LSRS       R0, R0, #1
+  0x08000D6E:  E000         B          .L2                      ; 0x08000D72
+
.L1:
+  0x08000D70:  0052         LSLS       R2, R2, #1
+
.L2:
+  0x08000D72:  4282         CMP        R2, R0
+  0x08000D74:  D9FC         BLS        .L1                      ; 0x08000D70
+  0x08000D76:  2000         MOVS       R0, #0
+  0x08000D78:  E000         B          .L4                      ; 0x08000D7C
+
.L3:
+  0x08000D7A:  0852         LSRS       R2, R2, #1
+
.L4:
+  0x08000D7C:  1A9B         SUBS       R3, R3, R2
+  0x08000D7E:  D306         BCC        .L7                      ; 0x08000D8E
+
.L5:
+  0x08000D80:  4140         ADCS       R0, R0
+  0x08000D82:  428A         CMP        R2, R1
+  0x08000D84:  D1F9         BNE        .L3                      ; 0x08000D7A
+  0x08000D86:  4770         BX         LR
+
.L6:
+  0x08000D88:  0852         LSRS       R2, R2, #1
+  0x08000D8A:  189B         ADDS       R3, R3, R2
+  0x08000D8C:  D2F8         BCS        .L5                      ; 0x08000D80
+
.L7:
+  0x08000D8E:  1800         ADDS       R0, R0, R0
+  0x08000D90:  428A         CMP        R2, R1
+  0x08000D92:  D1F9         BNE        .L6                      ; 0x08000D88
+  0x08000D94:  4770         BX         LR
+
.L8:
+  0x08000D96:  B510         PUSH       {R4, LR}
+  0x08000D98:  F7FF FFC6    BL         __aeabi_idiv0            ; 0x08000D28
+  0x08000D9C:  BD10         POP        {R4, PC}
+

Section .text.libc.__aeabi_memclr from strasmops_arm.o (libc_v6m_t_le_eabi_small.a), size=20, align=2

+
__aeabi_memclr:
+__aeabi_memclr8:
+__aeabi_memclr4:
+  0x08000D9E:  2200         MOVS       R2, #0
+
__aeabi_memset8:
+__aeabi_memset4:
+__aeabi_memset:
+  0x08000DA0:  000B         MOVS       R3, R1
+  0x08000DA2:  0011         MOVS       R1, R2
+  0x08000DA4:  001A         MOVS       R2, R3
+
memset:
+  0x08000DA6:  2A00         CMP        R2, #0
+  0x08000DA8:  D002         BEQ        .L2                      ; 0x08000DB0
+
.L1:
+  0x08000DAA:  3A01         SUBS       R2, #1
+  0x08000DAC:  5481         STRB       R1, [R0, R2]
+  0x08000DAE:  D1FC         BNE        .L1                      ; 0x08000DAA
+
.L2:
+  0x08000DB0:  4770         BX         LR
+

Section .rodata.Rcon from aes.o, size=255, align=1

+
Rcon:
+  0x08000DB2:  8D           DC.B       0x8D                     ; '\x8D'
+  0x08000DB3:  01           DC.B       0x01                     ; '\x01'
+  0x08000DB4:  02           DC.B       0x02                     ; '\x02'
+  0x08000DB5:  04           DC.B       0x04                     ; '\x04'
+  0x08000DB6:  08           DC.B       0x08                     ; '\x08'
+  0x08000DB7:  10           DC.B       0x10                     ; '\x10'
+  0x08000DB8:  20           DC.B       0x20                     ; ' '
+  0x08000DB9:  40           DC.B       0x40                     ; '@'
+  0x08000DBA:  80           DC.B       0x80                     ; '\x80'
+  0x08000DBB:  1B           DC.B       0x1B                     ; '\x1B'
+  0x08000DBC:  36           DC.B       0x36                     ; '6'
+  0x08000DBD:  6C           DC.B       0x6C                     ; 'l'
+  0x08000DBE:  D8           DC.B       0xD8                     ; '\xD8'
+  0x08000DBF:  AB           DC.B       0xAB                     ; '\xAB'
+  0x08000DC0:  4D           DC.B       0x4D                     ; 'M'
+  0x08000DC1:  9A           DC.B       0x9A                     ; '\x9A'
+  0x08000DC2:  2F           DC.B       0x2F                     ; '/'
+  0x08000DC3:  5E           DC.B       0x5E                     ; '^'
+  0x08000DC4:  BC           DC.B       0xBC                     ; '\xBC'
+  0x08000DC5:  63           DC.B       0x63                     ; 'c'
+  0x08000DC6:  C6           DC.B       0xC6                     ; '\xC6'
+  0x08000DC7:  97           DC.B       0x97                     ; '\x97'
+  0x08000DC8:  35           DC.B       0x35                     ; '5'
+  0x08000DC9:  6A           DC.B       0x6A                     ; 'j'
+  0x08000DCA:  D4           DC.B       0xD4                     ; '\xD4'
+  0x08000DCB:  B3           DC.B       0xB3                     ; '\xB3'
+  0x08000DCC:  7D           DC.B       0x7D                     ; '}'
+  0x08000DCD:  FA           DC.B       0xFA                     ; '\xFA'
+  0x08000DCE:  EF           DC.B       0xEF                     ; '\xEF'
+  0x08000DCF:  C5           DC.B       0xC5                     ; '\xC5'
+  0x08000DD0:  91           DC.B       0x91                     ; '\x91'
+  0x08000DD1:  39           DC.B       0x39                     ; '9'
+  0x08000DD2:  72           DC.B       0x72                     ; 'r'
+  0x08000DD3:  E4           DC.B       0xE4                     ; '\xE4'
+  0x08000DD4:  D3           DC.B       0xD3                     ; '\xD3'
+  0x08000DD5:  BD           DC.B       0xBD                     ; '\xBD'
+  0x08000DD6:  61           DC.B       0x61                     ; 'a'
+  0x08000DD7:  C2           DC.B       0xC2                     ; '\xC2'
+  0x08000DD8:  9F           DC.B       0x9F                     ; '\x9F'
+  0x08000DD9:  25           DC.B       0x25                     ; '%'
+  0x08000DDA:  4A           DC.B       0x4A                     ; 'J'
+  0x08000DDB:  94           DC.B       0x94                     ; '\x94'
+  0x08000DDC:  33           DC.B       0x33                     ; '3'
+  0x08000DDD:  66           DC.B       0x66                     ; 'f'
+  0x08000DDE:  CC           DC.B       0xCC                     ; '\xCC'
+  0x08000DDF:  83           DC.B       0x83                     ; '\x83'
+  0x08000DE0:  1D           DC.B       0x1D                     ; '\x1D'
+  0x08000DE1:  3A           DC.B       0x3A                     ; ':'
+  0x08000DE2:  74           DC.B       0x74                     ; 't'
+  0x08000DE3:  E8           DC.B       0xE8                     ; '\xE8'
+  0x08000DE4:  CB           DC.B       0xCB                     ; '\xCB'
+  0x08000DE5:  8D           DC.B       0x8D                     ; '\x8D'
+  0x08000DE6:  01           DC.B       0x01                     ; '\x01'
+  0x08000DE7:  02           DC.B       0x02                     ; '\x02'
+  0x08000DE8:  04           DC.B       0x04                     ; '\x04'
+  0x08000DE9:  08           DC.B       0x08                     ; '\x08'
+  0x08000DEA:  10           DC.B       0x10                     ; '\x10'
+  0x08000DEB:  20           DC.B       0x20                     ; ' '
+  0x08000DEC:  40           DC.B       0x40                     ; '@'
+  0x08000DED:  80           DC.B       0x80                     ; '\x80'
+  0x08000DEE:  1B           DC.B       0x1B                     ; '\x1B'
+  0x08000DEF:  36           DC.B       0x36                     ; '6'
+  0x08000DF0:  6C           DC.B       0x6C                     ; 'l'
+  0x08000DF1:  D8           DC.B       0xD8                     ; '\xD8'
+  0x08000DF2:  AB           DC.B       0xAB                     ; '\xAB'
+  0x08000DF3:  4D           DC.B       0x4D                     ; 'M'
+  0x08000DF4:  9A           DC.B       0x9A                     ; '\x9A'
+  0x08000DF5:  2F           DC.B       0x2F                     ; '/'
+  0x08000DF6:  5E           DC.B       0x5E                     ; '^'
+  0x08000DF7:  BC           DC.B       0xBC                     ; '\xBC'
+  0x08000DF8:  63           DC.B       0x63                     ; 'c'
+  0x08000DF9:  C6           DC.B       0xC6                     ; '\xC6'
+  0x08000DFA:  97           DC.B       0x97                     ; '\x97'
+  0x08000DFB:  35           DC.B       0x35                     ; '5'
+  0x08000DFC:  6A           DC.B       0x6A                     ; 'j'
+  0x08000DFD:  D4           DC.B       0xD4                     ; '\xD4'
+  0x08000DFE:  B3           DC.B       0xB3                     ; '\xB3'
+  0x08000DFF:  7D           DC.B       0x7D                     ; '}'
+  0x08000E00:  FA           DC.B       0xFA                     ; '\xFA'
+  0x08000E01:  EF           DC.B       0xEF                     ; '\xEF'
+  0x08000E02:  C5           DC.B       0xC5                     ; '\xC5'
+  0x08000E03:  91           DC.B       0x91                     ; '\x91'
+  0x08000E04:  39           DC.B       0x39                     ; '9'
+  0x08000E05:  72           DC.B       0x72                     ; 'r'
+  0x08000E06:  E4           DC.B       0xE4                     ; '\xE4'
+  0x08000E07:  D3           DC.B       0xD3                     ; '\xD3'
+  0x08000E08:  BD           DC.B       0xBD                     ; '\xBD'
+  0x08000E09:  61           DC.B       0x61                     ; 'a'
+  0x08000E0A:  C2           DC.B       0xC2                     ; '\xC2'
+  0x08000E0B:  9F           DC.B       0x9F                     ; '\x9F'
+  0x08000E0C:  25           DC.B       0x25                     ; '%'
+  0x08000E0D:  4A           DC.B       0x4A                     ; 'J'
+  0x08000E0E:  94           DC.B       0x94                     ; '\x94'
+  0x08000E0F:  33           DC.B       0x33                     ; '3'
+  0x08000E10:  66           DC.B       0x66                     ; 'f'
+  0x08000E11:  CC           DC.B       0xCC                     ; '\xCC'
+  0x08000E12:  83           DC.B       0x83                     ; '\x83'
+  0x08000E13:  1D           DC.B       0x1D                     ; '\x1D'
+  0x08000E14:  3A           DC.B       0x3A                     ; ':'
+  0x08000E15:  74           DC.B       0x74                     ; 't'
+  0x08000E16:  E8           DC.B       0xE8                     ; '\xE8'
+  0x08000E17:  CB           DC.B       0xCB                     ; '\xCB'
+  0x08000E18:  8D           DC.B       0x8D                     ; '\x8D'
+  0x08000E19:  01           DC.B       0x01                     ; '\x01'
+  0x08000E1A:  02           DC.B       0x02                     ; '\x02'
+  0x08000E1B:  04           DC.B       0x04                     ; '\x04'
+  0x08000E1C:  08           DC.B       0x08                     ; '\x08'
+  0x08000E1D:  10           DC.B       0x10                     ; '\x10'
+  0x08000E1E:  20           DC.B       0x20                     ; ' '
+  0x08000E1F:  40           DC.B       0x40                     ; '@'
+  0x08000E20:  80           DC.B       0x80                     ; '\x80'
+  0x08000E21:  1B           DC.B       0x1B                     ; '\x1B'
+  0x08000E22:  36           DC.B       0x36                     ; '6'
+  0x08000E23:  6C           DC.B       0x6C                     ; 'l'
+  0x08000E24:  D8           DC.B       0xD8                     ; '\xD8'
+  0x08000E25:  AB           DC.B       0xAB                     ; '\xAB'
+  0x08000E26:  4D           DC.B       0x4D                     ; 'M'
+  0x08000E27:  9A           DC.B       0x9A                     ; '\x9A'
+  0x08000E28:  2F           DC.B       0x2F                     ; '/'
+  0x08000E29:  5E           DC.B       0x5E                     ; '^'
+  0x08000E2A:  BC           DC.B       0xBC                     ; '\xBC'
+  0x08000E2B:  63           DC.B       0x63                     ; 'c'
+  0x08000E2C:  C6           DC.B       0xC6                     ; '\xC6'
+  0x08000E2D:  97           DC.B       0x97                     ; '\x97'
+  0x08000E2E:  35           DC.B       0x35                     ; '5'
+  0x08000E2F:  6A           DC.B       0x6A                     ; 'j'
+  0x08000E30:  D4           DC.B       0xD4                     ; '\xD4'
+  0x08000E31:  B3           DC.B       0xB3                     ; '\xB3'
+  0x08000E32:  7D           DC.B       0x7D                     ; '}'
+  0x08000E33:  FA           DC.B       0xFA                     ; '\xFA'
+  0x08000E34:  EF           DC.B       0xEF                     ; '\xEF'
+  0x08000E35:  C5           DC.B       0xC5                     ; '\xC5'
+  0x08000E36:  91           DC.B       0x91                     ; '\x91'
+  0x08000E37:  39           DC.B       0x39                     ; '9'
+  0x08000E38:  72           DC.B       0x72                     ; 'r'
+  0x08000E39:  E4           DC.B       0xE4                     ; '\xE4'
+  0x08000E3A:  D3           DC.B       0xD3                     ; '\xD3'
+  0x08000E3B:  BD           DC.B       0xBD                     ; '\xBD'
+  0x08000E3C:  61           DC.B       0x61                     ; 'a'
+  0x08000E3D:  C2           DC.B       0xC2                     ; '\xC2'
+  0x08000E3E:  9F           DC.B       0x9F                     ; '\x9F'
+  0x08000E3F:  25           DC.B       0x25                     ; '%'
+  0x08000E40:  4A           DC.B       0x4A                     ; 'J'
+  0x08000E41:  94           DC.B       0x94                     ; '\x94'
+  0x08000E42:  33           DC.B       0x33                     ; '3'
+  0x08000E43:  66           DC.B       0x66                     ; 'f'
+  0x08000E44:  CC           DC.B       0xCC                     ; '\xCC'
+  0x08000E45:  83           DC.B       0x83                     ; '\x83'
+  0x08000E46:  1D           DC.B       0x1D                     ; '\x1D'
+  0x08000E47:  3A           DC.B       0x3A                     ; ':'
+  0x08000E48:  74           DC.B       0x74                     ; 't'
+  0x08000E49:  E8           DC.B       0xE8                     ; '\xE8'
+  0x08000E4A:  CB           DC.B       0xCB                     ; '\xCB'
+  0x08000E4B:  8D           DC.B       0x8D                     ; '\x8D'
+  0x08000E4C:  01           DC.B       0x01                     ; '\x01'
+  0x08000E4D:  02           DC.B       0x02                     ; '\x02'
+  0x08000E4E:  04           DC.B       0x04                     ; '\x04'
+  0x08000E4F:  08           DC.B       0x08                     ; '\x08'
+  0x08000E50:  10           DC.B       0x10                     ; '\x10'
+  0x08000E51:  20           DC.B       0x20                     ; ' '
+  0x08000E52:  40           DC.B       0x40                     ; '@'
+  0x08000E53:  80           DC.B       0x80                     ; '\x80'
+  0x08000E54:  1B           DC.B       0x1B                     ; '\x1B'
+  0x08000E55:  36           DC.B       0x36                     ; '6'
+  0x08000E56:  6C           DC.B       0x6C                     ; 'l'
+  0x08000E57:  D8           DC.B       0xD8                     ; '\xD8'
+  0x08000E58:  AB           DC.B       0xAB                     ; '\xAB'
+  0x08000E59:  4D           DC.B       0x4D                     ; 'M'
+  0x08000E5A:  9A           DC.B       0x9A                     ; '\x9A'
+  0x08000E5B:  2F           DC.B       0x2F                     ; '/'
+  0x08000E5C:  5E           DC.B       0x5E                     ; '^'
+  0x08000E5D:  BC           DC.B       0xBC                     ; '\xBC'
+  0x08000E5E:  63           DC.B       0x63                     ; 'c'
+  0x08000E5F:  C6           DC.B       0xC6                     ; '\xC6'
+  0x08000E60:  97           DC.B       0x97                     ; '\x97'
+  0x08000E61:  35           DC.B       0x35                     ; '5'
+  0x08000E62:  6A           DC.B       0x6A                     ; 'j'
+  0x08000E63:  D4           DC.B       0xD4                     ; '\xD4'
+  0x08000E64:  B3           DC.B       0xB3                     ; '\xB3'
+  0x08000E65:  7D           DC.B       0x7D                     ; '}'
+  0x08000E66:  FA           DC.B       0xFA                     ; '\xFA'
+  0x08000E67:  EF           DC.B       0xEF                     ; '\xEF'
+  0x08000E68:  C5           DC.B       0xC5                     ; '\xC5'
+  0x08000E69:  91           DC.B       0x91                     ; '\x91'
+  0x08000E6A:  39           DC.B       0x39                     ; '9'
+  0x08000E6B:  72           DC.B       0x72                     ; 'r'
+  0x08000E6C:  E4           DC.B       0xE4                     ; '\xE4'
+  0x08000E6D:  D3           DC.B       0xD3                     ; '\xD3'
+  0x08000E6E:  BD           DC.B       0xBD                     ; '\xBD'
+  0x08000E6F:  61           DC.B       0x61                     ; 'a'
+  0x08000E70:  C2           DC.B       0xC2                     ; '\xC2'
+  0x08000E71:  9F           DC.B       0x9F                     ; '\x9F'
+  0x08000E72:  25           DC.B       0x25                     ; '%'
+  0x08000E73:  4A           DC.B       0x4A                     ; 'J'
+  0x08000E74:  94           DC.B       0x94                     ; '\x94'
+  0x08000E75:  33           DC.B       0x33                     ; '3'
+  0x08000E76:  66           DC.B       0x66                     ; 'f'
+  0x08000E77:  CC           DC.B       0xCC                     ; '\xCC'
+  0x08000E78:  83           DC.B       0x83                     ; '\x83'
+  0x08000E79:  1D           DC.B       0x1D                     ; '\x1D'
+  0x08000E7A:  3A           DC.B       0x3A                     ; ':'
+  0x08000E7B:  74           DC.B       0x74                     ; 't'
+  0x08000E7C:  E8           DC.B       0xE8                     ; '\xE8'
+  0x08000E7D:  CB           DC.B       0xCB                     ; '\xCB'
+  0x08000E7E:  8D           DC.B       0x8D                     ; '\x8D'
+  0x08000E7F:  01           DC.B       0x01                     ; '\x01'
+  0x08000E80:  02           DC.B       0x02                     ; '\x02'
+  0x08000E81:  04           DC.B       0x04                     ; '\x04'
+  0x08000E82:  08           DC.B       0x08                     ; '\x08'
+  0x08000E83:  10           DC.B       0x10                     ; '\x10'
+  0x08000E84:  20           DC.B       0x20                     ; ' '
+  0x08000E85:  40           DC.B       0x40                     ; '@'
+  0x08000E86:  80           DC.B       0x80                     ; '\x80'
+  0x08000E87:  1B           DC.B       0x1B                     ; '\x1B'
+  0x08000E88:  36           DC.B       0x36                     ; '6'
+  0x08000E89:  6C           DC.B       0x6C                     ; 'l'
+  0x08000E8A:  D8           DC.B       0xD8                     ; '\xD8'
+  0x08000E8B:  AB           DC.B       0xAB                     ; '\xAB'
+  0x08000E8C:  4D           DC.B       0x4D                     ; 'M'
+  0x08000E8D:  9A           DC.B       0x9A                     ; '\x9A'
+  0x08000E8E:  2F           DC.B       0x2F                     ; '/'
+  0x08000E8F:  5E           DC.B       0x5E                     ; '^'
+  0x08000E90:  BC           DC.B       0xBC                     ; '\xBC'
+  0x08000E91:  63           DC.B       0x63                     ; 'c'
+  0x08000E92:  C6           DC.B       0xC6                     ; '\xC6'
+  0x08000E93:  97           DC.B       0x97                     ; '\x97'
+  0x08000E94:  35           DC.B       0x35                     ; '5'
+  0x08000E95:  6A           DC.B       0x6A                     ; 'j'
+  0x08000E96:  D4           DC.B       0xD4                     ; '\xD4'
+  0x08000E97:  B3           DC.B       0xB3                     ; '\xB3'
+  0x08000E98:  7D           DC.B       0x7D                     ; '}'
+  0x08000E99:  FA           DC.B       0xFA                     ; '\xFA'
+  0x08000E9A:  EF           DC.B       0xEF                     ; '\xEF'
+  0x08000E9B:  C5           DC.B       0xC5                     ; '\xC5'
+  0x08000E9C:  91           DC.B       0x91                     ; '\x91'
+  0x08000E9D:  39           DC.B       0x39                     ; '9'
+  0x08000E9E:  72           DC.B       0x72                     ; 'r'
+  0x08000E9F:  E4           DC.B       0xE4                     ; '\xE4'
+  0x08000EA0:  D3           DC.B       0xD3                     ; '\xD3'
+  0x08000EA1:  BD           DC.B       0xBD                     ; '\xBD'
+  0x08000EA2:  61           DC.B       0x61                     ; 'a'
+  0x08000EA3:  C2           DC.B       0xC2                     ; '\xC2'
+  0x08000EA4:  9F           DC.B       0x9F                     ; '\x9F'
+  0x08000EA5:  25           DC.B       0x25                     ; '%'
+  0x08000EA6:  4A           DC.B       0x4A                     ; 'J'
+  0x08000EA7:  94           DC.B       0x94                     ; '\x94'
+  0x08000EA8:  33           DC.B       0x33                     ; '3'
+  0x08000EA9:  66           DC.B       0x66                     ; 'f'
+  0x08000EAA:  CC           DC.B       0xCC                     ; '\xCC'
+  0x08000EAB:  83           DC.B       0x83                     ; '\x83'
+  0x08000EAC:  1D           DC.B       0x1D                     ; '\x1D'
+  0x08000EAD:  3A           DC.B       0x3A                     ; ':'
+  0x08000EAE:  74           DC.B       0x74                     ; 't'
+  0x08000EAF:  E8           DC.B       0xE8                     ; '\xE8'
+  0x08000EB0:  CB           DC.B       0xCB                     ; '\xCB'
+

Section .init_array from STM32G0xx_Startup.o, size=4, align=4

+  0x08000EB4:  080000E1     DC.W       SystemCoreClockUpdate
+

Section .rodata.sbox from aes.o, size=256, align=1

+
sbox:
+  0x08000EB8:  63           DC.B       0x63                     ; 'c'
+  0x08000EB9:  7C           DC.B       0x7C                     ; '|'
+  0x08000EBA:  77           DC.B       0x77                     ; 'w'
+  0x08000EBB:  7B           DC.B       0x7B                     ; '{'
+  0x08000EBC:  F2           DC.B       0xF2                     ; '\xF2'
+  0x08000EBD:  6B           DC.B       0x6B                     ; 'k'
+  0x08000EBE:  6F           DC.B       0x6F                     ; 'o'
+  0x08000EBF:  C5           DC.B       0xC5                     ; '\xC5'
+  0x08000EC0:  30           DC.B       0x30                     ; '0'
+  0x08000EC1:  01           DC.B       0x01                     ; '\x01'
+  0x08000EC2:  67           DC.B       0x67                     ; 'g'
+  0x08000EC3:  2B           DC.B       0x2B                     ; '+'
+  0x08000EC4:  FE           DC.B       0xFE                     ; '\xFE'
+  0x08000EC5:  D7           DC.B       0xD7                     ; '\xD7'
+  0x08000EC6:  AB           DC.B       0xAB                     ; '\xAB'
+  0x08000EC7:  76           DC.B       0x76                     ; 'v'
+  0x08000EC8:  CA           DC.B       0xCA                     ; '\xCA'
+  0x08000EC9:  82           DC.B       0x82                     ; '\x82'
+  0x08000ECA:  C9           DC.B       0xC9                     ; '\xC9'
+  0x08000ECB:  7D           DC.B       0x7D                     ; '}'
+  0x08000ECC:  FA           DC.B       0xFA                     ; '\xFA'
+  0x08000ECD:  59           DC.B       0x59                     ; 'Y'
+  0x08000ECE:  47           DC.B       0x47                     ; 'G'
+  0x08000ECF:  F0           DC.B       0xF0                     ; '\xF0'
+  0x08000ED0:  AD           DC.B       0xAD                     ; '\xAD'
+  0x08000ED1:  D4           DC.B       0xD4                     ; '\xD4'
+  0x08000ED2:  A2           DC.B       0xA2                     ; '\xA2'
+  0x08000ED3:  AF           DC.B       0xAF                     ; '\xAF'
+  0x08000ED4:  9C           DC.B       0x9C                     ; '\x9C'
+  0x08000ED5:  A4           DC.B       0xA4                     ; '\xA4'
+  0x08000ED6:  72           DC.B       0x72                     ; 'r'
+  0x08000ED7:  C0           DC.B       0xC0                     ; '\xC0'
+  0x08000ED8:  B7           DC.B       0xB7                     ; '\xB7'
+  0x08000ED9:  FD           DC.B       0xFD                     ; '\xFD'
+  0x08000EDA:  93           DC.B       0x93                     ; '\x93'
+  0x08000EDB:  26           DC.B       0x26                     ; '&'
+  0x08000EDC:  36           DC.B       0x36                     ; '6'
+  0x08000EDD:  3F           DC.B       0x3F                     ; '?'
+  0x08000EDE:  F7           DC.B       0xF7                     ; '\xF7'
+  0x08000EDF:  CC           DC.B       0xCC                     ; '\xCC'
+  0x08000EE0:  34           DC.B       0x34                     ; '4'
+  0x08000EE1:  A5           DC.B       0xA5                     ; '\xA5'
+  0x08000EE2:  E5           DC.B       0xE5                     ; '\xE5'
+  0x08000EE3:  F1           DC.B       0xF1                     ; '\xF1'
+  0x08000EE4:  71           DC.B       0x71                     ; 'q'
+  0x08000EE5:  D8           DC.B       0xD8                     ; '\xD8'
+  0x08000EE6:  31           DC.B       0x31                     ; '1'
+  0x08000EE7:  15           DC.B       0x15                     ; '\x15'
+  0x08000EE8:  04           DC.B       0x04                     ; '\x04'
+  0x08000EE9:  C7           DC.B       0xC7                     ; '\xC7'
+  0x08000EEA:  23           DC.B       0x23                     ; '#'
+  0x08000EEB:  C3           DC.B       0xC3                     ; '\xC3'
+  0x08000EEC:  18           DC.B       0x18                     ; '\x18'
+  0x08000EED:  96           DC.B       0x96                     ; '\x96'
+  0x08000EEE:  05           DC.B       0x05                     ; '\x05'
+  0x08000EEF:  9A           DC.B       0x9A                     ; '\x9A'
+  0x08000EF0:  07           DC.B       0x07                     ; '\x07'
+  0x08000EF1:  12           DC.B       0x12                     ; '\x12'
+  0x08000EF2:  80           DC.B       0x80                     ; '\x80'
+  0x08000EF3:  E2           DC.B       0xE2                     ; '\xE2'
+  0x08000EF4:  EB           DC.B       0xEB                     ; '\xEB'
+  0x08000EF5:  27           DC.B       0x27                     ; '\\'
+  0x08000EF6:  B2           DC.B       0xB2                     ; '\xB2'
+  0x08000EF7:  75           DC.B       0x75                     ; 'u'
+  0x08000EF8:  09           DC.B       0x09                     ; '\t'
+  0x08000EF9:  83           DC.B       0x83                     ; '\x83'
+  0x08000EFA:  2C           DC.B       0x2C                     ; ','
+  0x08000EFB:  1A           DC.B       0x1A                     ; '\x1A'
+  0x08000EFC:  1B           DC.B       0x1B                     ; '\x1B'
+  0x08000EFD:  6E           DC.B       0x6E                     ; 'n'
+  0x08000EFE:  5A           DC.B       0x5A                     ; 'Z'
+  0x08000EFF:  A0           DC.B       0xA0                     ; '\xA0'
+  0x08000F00:  52           DC.B       0x52                     ; 'R'
+  0x08000F01:  3B           DC.B       0x3B                     ; ';'
+  0x08000F02:  D6           DC.B       0xD6                     ; '\xD6'
+  0x08000F03:  B3           DC.B       0xB3                     ; '\xB3'
+  0x08000F04:  29           DC.B       0x29                     ; ')'
+  0x08000F05:  E3           DC.B       0xE3                     ; '\xE3'
+  0x08000F06:  2F           DC.B       0x2F                     ; '/'
+  0x08000F07:  84           DC.B       0x84                     ; '\x84'
+  0x08000F08:  53           DC.B       0x53                     ; 'S'
+  0x08000F09:  D1           DC.B       0xD1                     ; '\xD1'
+  0x08000F0A:  00           DC.B       0x00                     ; '\0'
+  0x08000F0B:  ED           DC.B       0xED                     ; '\xED'
+  0x08000F0C:  20           DC.B       0x20                     ; ' '
+  0x08000F0D:  FC           DC.B       0xFC                     ; '\xFC'
+  0x08000F0E:  B1           DC.B       0xB1                     ; '\xB1'
+  0x08000F0F:  5B           DC.B       0x5B                     ; '['
+  0x08000F10:  6A           DC.B       0x6A                     ; 'j'
+  0x08000F11:  CB           DC.B       0xCB                     ; '\xCB'
+  0x08000F12:  BE           DC.B       0xBE                     ; '\xBE'
+  0x08000F13:  39           DC.B       0x39                     ; '9'
+  0x08000F14:  4A           DC.B       0x4A                     ; 'J'
+  0x08000F15:  4C           DC.B       0x4C                     ; 'L'
+  0x08000F16:  58           DC.B       0x58                     ; 'X'
+  0x08000F17:  CF           DC.B       0xCF                     ; '\xCF'
+  0x08000F18:  D0           DC.B       0xD0                     ; '\xD0'
+  0x08000F19:  EF           DC.B       0xEF                     ; '\xEF'
+  0x08000F1A:  AA           DC.B       0xAA                     ; '\xAA'
+  0x08000F1B:  FB           DC.B       0xFB                     ; '\xFB'
+  0x08000F1C:  43           DC.B       0x43                     ; 'C'
+  0x08000F1D:  4D           DC.B       0x4D                     ; 'M'
+  0x08000F1E:  33           DC.B       0x33                     ; '3'
+  0x08000F1F:  85           DC.B       0x85                     ; '\x85'
+  0x08000F20:  45           DC.B       0x45                     ; 'E'
+  0x08000F21:  F9           DC.B       0xF9                     ; '\xF9'
+  0x08000F22:  02           DC.B       0x02                     ; '\x02'
+  0x08000F23:  7F           DC.B       0x7F                     ; '\x7F'
+  0x08000F24:  50           DC.B       0x50                     ; 'P'
+  0x08000F25:  3C           DC.B       0x3C                     ; '<'
+  0x08000F26:  9F           DC.B       0x9F                     ; '\x9F'
+  0x08000F27:  A8           DC.B       0xA8                     ; '\xA8'
+  0x08000F28:  51           DC.B       0x51                     ; 'Q'
+  0x08000F29:  A3           DC.B       0xA3                     ; '\xA3'
+  0x08000F2A:  40           DC.B       0x40                     ; '@'
+  0x08000F2B:  8F           DC.B       0x8F                     ; '\x8F'
+  0x08000F2C:  92           DC.B       0x92                     ; '\x92'
+  0x08000F2D:  9D           DC.B       0x9D                     ; '\x9D'
+  0x08000F2E:  38           DC.B       0x38                     ; '8'
+  0x08000F2F:  F5           DC.B       0xF5                     ; '\xF5'
+  0x08000F30:  BC           DC.B       0xBC                     ; '\xBC'
+  0x08000F31:  B6           DC.B       0xB6                     ; '\xB6'
+  0x08000F32:  DA           DC.B       0xDA                     ; '\xDA'
+  0x08000F33:  21           DC.B       0x21                     ; '!'
+  0x08000F34:  10           DC.B       0x10                     ; '\x10'
+  0x08000F35:  FF           DC.B       0xFF                     ; '\xFF'
+  0x08000F36:  F3           DC.B       0xF3                     ; '\xF3'
+  0x08000F37:  D2           DC.B       0xD2                     ; '\xD2'
+  0x08000F38:  CD           DC.B       0xCD                     ; '\xCD'
+  0x08000F39:  0C           DC.B       0x0C                     ; '\x0C'
+  0x08000F3A:  13           DC.B       0x13                     ; '\x13'
+  0x08000F3B:  EC           DC.B       0xEC                     ; '\xEC'
+  0x08000F3C:  5F           DC.B       0x5F                     ; '_'
+  0x08000F3D:  97           DC.B       0x97                     ; '\x97'
+  0x08000F3E:  44           DC.B       0x44                     ; 'D'
+  0x08000F3F:  17           DC.B       0x17                     ; '\x17'
+  0x08000F40:  C4           DC.B       0xC4                     ; '\xC4'
+  0x08000F41:  A7           DC.B       0xA7                     ; '\xA7'
+  0x08000F42:  7E           DC.B       0x7E                     ; '~'
+  0x08000F43:  3D           DC.B       0x3D                     ; '='
+  0x08000F44:  64           DC.B       0x64                     ; 'd'
+  0x08000F45:  5D           DC.B       0x5D                     ; ']'
+  0x08000F46:  19           DC.B       0x19                     ; '\x19'
+  0x08000F47:  73           DC.B       0x73                     ; 's'
+  0x08000F48:  60           DC.B       0x60                     ; '`'
+  0x08000F49:  81           DC.B       0x81                     ; '\x81'
+  0x08000F4A:  4F           DC.B       0x4F                     ; 'O'
+  0x08000F4B:  DC           DC.B       0xDC                     ; '\xDC'
+  0x08000F4C:  22           DC.B       0x22                     ; '\"'
+  0x08000F4D:  2A           DC.B       0x2A                     ; '*'
+  0x08000F4E:  90           DC.B       0x90                     ; '\x90'
+  0x08000F4F:  88           DC.B       0x88                     ; '\x88'
+  0x08000F50:  46           DC.B       0x46                     ; 'F'
+  0x08000F51:  EE           DC.B       0xEE                     ; '\xEE'
+  0x08000F52:  B8           DC.B       0xB8                     ; '\xB8'
+  0x08000F53:  14           DC.B       0x14                     ; '\x14'
+  0x08000F54:  DE           DC.B       0xDE                     ; '\xDE'
+  0x08000F55:  5E           DC.B       0x5E                     ; '^'
+  0x08000F56:  0B           DC.B       0x0B                     ; '\x0B'
+  0x08000F57:  DB           DC.B       0xDB                     ; '\xDB'
+  0x08000F58:  E0           DC.B       0xE0                     ; '\xE0'
+  0x08000F59:  32           DC.B       0x32                     ; '2'
+  0x08000F5A:  3A           DC.B       0x3A                     ; ':'
+  0x08000F5B:  0A           DC.B       0x0A                     ; '\n'
+  0x08000F5C:  49           DC.B       0x49                     ; 'I'
+  0x08000F5D:  06           DC.B       0x06                     ; '\x06'
+  0x08000F5E:  24           DC.B       0x24                     ; '$'
+  0x08000F5F:  5C           DC.B       0x5C                     ; '\'
+  0x08000F60:  C2           DC.B       0xC2                     ; '\xC2'
+  0x08000F61:  D3           DC.B       0xD3                     ; '\xD3'
+  0x08000F62:  AC           DC.B       0xAC                     ; '\xAC'
+  0x08000F63:  62           DC.B       0x62                     ; 'b'
+  0x08000F64:  91           DC.B       0x91                     ; '\x91'
+  0x08000F65:  95           DC.B       0x95                     ; '\x95'
+  0x08000F66:  E4           DC.B       0xE4                     ; '\xE4'
+  0x08000F67:  79           DC.B       0x79                     ; 'y'
+  0x08000F68:  E7           DC.B       0xE7                     ; '\xE7'
+  0x08000F69:  C8           DC.B       0xC8                     ; '\xC8'
+  0x08000F6A:  37           DC.B       0x37                     ; '7'
+  0x08000F6B:  6D           DC.B       0x6D                     ; 'm'
+  0x08000F6C:  8D           DC.B       0x8D                     ; '\x8D'
+  0x08000F6D:  D5           DC.B       0xD5                     ; '\xD5'
+  0x08000F6E:  4E           DC.B       0x4E                     ; 'N'
+  0x08000F6F:  A9           DC.B       0xA9                     ; '\xA9'
+  0x08000F70:  6C           DC.B       0x6C                     ; 'l'
+  0x08000F71:  56           DC.B       0x56                     ; 'V'
+  0x08000F72:  F4           DC.B       0xF4                     ; '\xF4'
+  0x08000F73:  EA           DC.B       0xEA                     ; '\xEA'
+  0x08000F74:  65           DC.B       0x65                     ; 'e'
+  0x08000F75:  7A           DC.B       0x7A                     ; 'z'
+  0x08000F76:  AE           DC.B       0xAE                     ; '\xAE'
+  0x08000F77:  08           DC.B       0x08                     ; '\x08'
+  0x08000F78:  BA           DC.B       0xBA                     ; '\xBA'
+  0x08000F79:  78           DC.B       0x78                     ; 'x'
+  0x08000F7A:  25           DC.B       0x25                     ; '%'
+  0x08000F7B:  2E           DC.B       0x2E                     ; '.'
+  0x08000F7C:  1C           DC.B       0x1C                     ; '\x1C'
+  0x08000F7D:  A6           DC.B       0xA6                     ; '\xA6'
+  0x08000F7E:  B4           DC.B       0xB4                     ; '\xB4'
+  0x08000F7F:  C6           DC.B       0xC6                     ; '\xC6'
+  0x08000F80:  E8           DC.B       0xE8                     ; '\xE8'
+  0x08000F81:  DD           DC.B       0xDD                     ; '\xDD'
+  0x08000F82:  74           DC.B       0x74                     ; 't'
+  0x08000F83:  1F           DC.B       0x1F                     ; '\x1F'
+  0x08000F84:  4B           DC.B       0x4B                     ; 'K'
+  0x08000F85:  BD           DC.B       0xBD                     ; '\xBD'
+  0x08000F86:  8B           DC.B       0x8B                     ; '\x8B'
+  0x08000F87:  8A           DC.B       0x8A                     ; '\x8A'
+  0x08000F88:  70           DC.B       0x70                     ; 'p'
+  0x08000F89:  3E           DC.B       0x3E                     ; '>'
+  0x08000F8A:  B5           DC.B       0xB5                     ; '\xB5'
+  0x08000F8B:  66           DC.B       0x66                     ; 'f'
+  0x08000F8C:  48           DC.B       0x48                     ; 'H'
+  0x08000F8D:  03           DC.B       0x03                     ; '\x03'
+  0x08000F8E:  F6           DC.B       0xF6                     ; '\xF6'
+  0x08000F8F:  0E           DC.B       0x0E                     ; '\x0E'
+  0x08000F90:  61           DC.B       0x61                     ; 'a'
+  0x08000F91:  35           DC.B       0x35                     ; '5'
+  0x08000F92:  57           DC.B       0x57                     ; 'W'
+  0x08000F93:  B9           DC.B       0xB9                     ; '\xB9'
+  0x08000F94:  86           DC.B       0x86                     ; '\x86'
+  0x08000F95:  C1           DC.B       0xC1                     ; '\xC1'
+  0x08000F96:  1D           DC.B       0x1D                     ; '\x1D'
+  0x08000F97:  9E           DC.B       0x9E                     ; '\x9E'
+  0x08000F98:  E1           DC.B       0xE1                     ; '\xE1'
+  0x08000F99:  F8           DC.B       0xF8                     ; '\xF8'
+  0x08000F9A:  98           DC.B       0x98                     ; '\x98'
+  0x08000F9B:  11           DC.B       0x11                     ; '\x11'
+  0x08000F9C:  69           DC.B       0x69                     ; 'i'
+  0x08000F9D:  D9           DC.B       0xD9                     ; '\xD9'
+  0x08000F9E:  8E           DC.B       0x8E                     ; '\x8E'
+  0x08000F9F:  94           DC.B       0x94                     ; '\x94'
+  0x08000FA0:  9B           DC.B       0x9B                     ; '\x9B'
+  0x08000FA1:  1E           DC.B       0x1E                     ; '\x1E'
+  0x08000FA2:  87           DC.B       0x87                     ; '\x87'
+  0x08000FA3:  E9           DC.B       0xE9                     ; '\xE9'
+  0x08000FA4:  CE           DC.B       0xCE                     ; '\xCE'
+  0x08000FA5:  55           DC.B       0x55                     ; 'U'
+  0x08000FA6:  28           DC.B       0x28                     ; '('
+  0x08000FA7:  DF           DC.B       0xDF                     ; '\xDF'
+  0x08000FA8:  8C           DC.B       0x8C                     ; '\x8C'
+  0x08000FA9:  A1           DC.B       0xA1                     ; '\xA1'
+  0x08000FAA:  89           DC.B       0x89                     ; '\x89'
+  0x08000FAB:  0D           DC.B       0x0D                     ; '\r'
+  0x08000FAC:  BF           DC.B       0xBF                     ; '\xBF'
+  0x08000FAD:  E6           DC.B       0xE6                     ; '\xE6'
+  0x08000FAE:  42           DC.B       0x42                     ; 'B'
+  0x08000FAF:  68           DC.B       0x68                     ; 'h'
+  0x08000FB0:  41           DC.B       0x41                     ; 'A'
+  0x08000FB1:  99           DC.B       0x99                     ; '\x99'
+  0x08000FB2:  2D           DC.B       0x2D                     ; '-'
+  0x08000FB3:  0F           DC.B       0x0F                     ; '\x0F'
+  0x08000FB4:  B0           DC.B       0xB0                     ; '\xB0'
+  0x08000FB5:  54           DC.B       0x54                     ; 'T'
+  0x08000FB6:  BB           DC.B       0xBB                     ; '\xBB'
+  0x08000FB7:  16           DC.B       0x16                     ; '\x16'
+

Section .rodata.rsbox from aes.o, size=256, align=1

+
rsbox:
+  0x08000FB8:  52           DC.B       0x52                     ; 'R'
+  0x08000FB9:  09           DC.B       0x09                     ; '\t'
+  0x08000FBA:  6A           DC.B       0x6A                     ; 'j'
+  0x08000FBB:  D5           DC.B       0xD5                     ; '\xD5'
+  0x08000FBC:  30           DC.B       0x30                     ; '0'
+  0x08000FBD:  36           DC.B       0x36                     ; '6'
+  0x08000FBE:  A5           DC.B       0xA5                     ; '\xA5'
+  0x08000FBF:  38           DC.B       0x38                     ; '8'
+  0x08000FC0:  BF           DC.B       0xBF                     ; '\xBF'
+  0x08000FC1:  40           DC.B       0x40                     ; '@'
+  0x08000FC2:  A3           DC.B       0xA3                     ; '\xA3'
+  0x08000FC3:  9E           DC.B       0x9E                     ; '\x9E'
+  0x08000FC4:  81           DC.B       0x81                     ; '\x81'
+  0x08000FC5:  F3           DC.B       0xF3                     ; '\xF3'
+  0x08000FC6:  D7           DC.B       0xD7                     ; '\xD7'
+  0x08000FC7:  FB           DC.B       0xFB                     ; '\xFB'
+  0x08000FC8:  7C           DC.B       0x7C                     ; '|'
+  0x08000FC9:  E3           DC.B       0xE3                     ; '\xE3'
+  0x08000FCA:  39           DC.B       0x39                     ; '9'
+  0x08000FCB:  82           DC.B       0x82                     ; '\x82'
+  0x08000FCC:  9B           DC.B       0x9B                     ; '\x9B'
+  0x08000FCD:  2F           DC.B       0x2F                     ; '/'
+  0x08000FCE:  FF           DC.B       0xFF                     ; '\xFF'
+  0x08000FCF:  87           DC.B       0x87                     ; '\x87'
+  0x08000FD0:  34           DC.B       0x34                     ; '4'
+  0x08000FD1:  8E           DC.B       0x8E                     ; '\x8E'
+  0x08000FD2:  43           DC.B       0x43                     ; 'C'
+  0x08000FD3:  44           DC.B       0x44                     ; 'D'
+  0x08000FD4:  C4           DC.B       0xC4                     ; '\xC4'
+  0x08000FD5:  DE           DC.B       0xDE                     ; '\xDE'
+  0x08000FD6:  E9           DC.B       0xE9                     ; '\xE9'
+  0x08000FD7:  CB           DC.B       0xCB                     ; '\xCB'
+  0x08000FD8:  54           DC.B       0x54                     ; 'T'
+  0x08000FD9:  7B           DC.B       0x7B                     ; '{'
+  0x08000FDA:  94           DC.B       0x94                     ; '\x94'
+  0x08000FDB:  32           DC.B       0x32                     ; '2'
+  0x08000FDC:  A6           DC.B       0xA6                     ; '\xA6'
+  0x08000FDD:  C2           DC.B       0xC2                     ; '\xC2'
+  0x08000FDE:  23           DC.B       0x23                     ; '#'
+  0x08000FDF:  3D           DC.B       0x3D                     ; '='
+  0x08000FE0:  EE           DC.B       0xEE                     ; '\xEE'
+  0x08000FE1:  4C           DC.B       0x4C                     ; 'L'
+  0x08000FE2:  95           DC.B       0x95                     ; '\x95'
+  0x08000FE3:  0B           DC.B       0x0B                     ; '\x0B'
+  0x08000FE4:  42           DC.B       0x42                     ; 'B'
+  0x08000FE5:  FA           DC.B       0xFA                     ; '\xFA'
+  0x08000FE6:  C3           DC.B       0xC3                     ; '\xC3'
+  0x08000FE7:  4E           DC.B       0x4E                     ; 'N'
+  0x08000FE8:  08           DC.B       0x08                     ; '\x08'
+  0x08000FE9:  2E           DC.B       0x2E                     ; '.'
+  0x08000FEA:  A1           DC.B       0xA1                     ; '\xA1'
+  0x08000FEB:  66           DC.B       0x66                     ; 'f'
+  0x08000FEC:  28           DC.B       0x28                     ; '('
+  0x08000FED:  D9           DC.B       0xD9                     ; '\xD9'
+  0x08000FEE:  24           DC.B       0x24                     ; '$'
+  0x08000FEF:  B2           DC.B       0xB2                     ; '\xB2'
+  0x08000FF0:  76           DC.B       0x76                     ; 'v'
+  0x08000FF1:  5B           DC.B       0x5B                     ; '['
+  0x08000FF2:  A2           DC.B       0xA2                     ; '\xA2'
+  0x08000FF3:  49           DC.B       0x49                     ; 'I'
+  0x08000FF4:  6D           DC.B       0x6D                     ; 'm'
+  0x08000FF5:  8B           DC.B       0x8B                     ; '\x8B'
+  0x08000FF6:  D1           DC.B       0xD1                     ; '\xD1'
+  0x08000FF7:  25           DC.B       0x25                     ; '%'
+  0x08000FF8:  72           DC.B       0x72                     ; 'r'
+  0x08000FF9:  F8           DC.B       0xF8                     ; '\xF8'
+  0x08000FFA:  F6           DC.B       0xF6                     ; '\xF6'
+  0x08000FFB:  64           DC.B       0x64                     ; 'd'
+  0x08000FFC:  86           DC.B       0x86                     ; '\x86'
+  0x08000FFD:  68           DC.B       0x68                     ; 'h'
+  0x08000FFE:  98           DC.B       0x98                     ; '\x98'
+  0x08000FFF:  16           DC.B       0x16                     ; '\x16'
+  0x08001000:  D4           DC.B       0xD4                     ; '\xD4'
+  0x08001001:  A4           DC.B       0xA4                     ; '\xA4'
+  0x08001002:  5C           DC.B       0x5C                     ; '\'
+  0x08001003:  CC           DC.B       0xCC                     ; '\xCC'
+  0x08001004:  5D           DC.B       0x5D                     ; ']'
+  0x08001005:  65           DC.B       0x65                     ; 'e'
+  0x08001006:  B6           DC.B       0xB6                     ; '\xB6'
+  0x08001007:  92           DC.B       0x92                     ; '\x92'
+  0x08001008:  6C           DC.B       0x6C                     ; 'l'
+  0x08001009:  70           DC.B       0x70                     ; 'p'
+  0x0800100A:  48           DC.B       0x48                     ; 'H'
+  0x0800100B:  50           DC.B       0x50                     ; 'P'
+  0x0800100C:  FD           DC.B       0xFD                     ; '\xFD'
+  0x0800100D:  ED           DC.B       0xED                     ; '\xED'
+  0x0800100E:  B9           DC.B       0xB9                     ; '\xB9'
+  0x0800100F:  DA           DC.B       0xDA                     ; '\xDA'
+  0x08001010:  5E           DC.B       0x5E                     ; '^'
+  0x08001011:  15           DC.B       0x15                     ; '\x15'
+  0x08001012:  46           DC.B       0x46                     ; 'F'
+  0x08001013:  57           DC.B       0x57                     ; 'W'
+  0x08001014:  A7           DC.B       0xA7                     ; '\xA7'
+  0x08001015:  8D           DC.B       0x8D                     ; '\x8D'
+  0x08001016:  9D           DC.B       0x9D                     ; '\x9D'
+  0x08001017:  84           DC.B       0x84                     ; '\x84'
+  0x08001018:  90           DC.B       0x90                     ; '\x90'
+  0x08001019:  D8           DC.B       0xD8                     ; '\xD8'
+  0x0800101A:  AB           DC.B       0xAB                     ; '\xAB'
+  0x0800101B:  00           DC.B       0x00                     ; '\0'
+  0x0800101C:  8C           DC.B       0x8C                     ; '\x8C'
+  0x0800101D:  BC           DC.B       0xBC                     ; '\xBC'
+  0x0800101E:  D3           DC.B       0xD3                     ; '\xD3'
+  0x0800101F:  0A           DC.B       0x0A                     ; '\n'
+  0x08001020:  F7           DC.B       0xF7                     ; '\xF7'
+  0x08001021:  E4           DC.B       0xE4                     ; '\xE4'
+  0x08001022:  58           DC.B       0x58                     ; 'X'
+  0x08001023:  05           DC.B       0x05                     ; '\x05'
+  0x08001024:  B8           DC.B       0xB8                     ; '\xB8'
+  0x08001025:  B3           DC.B       0xB3                     ; '\xB3'
+  0x08001026:  45           DC.B       0x45                     ; 'E'
+  0x08001027:  06           DC.B       0x06                     ; '\x06'
+  0x08001028:  D0           DC.B       0xD0                     ; '\xD0'
+  0x08001029:  2C           DC.B       0x2C                     ; ','
+  0x0800102A:  1E           DC.B       0x1E                     ; '\x1E'
+  0x0800102B:  8F           DC.B       0x8F                     ; '\x8F'
+  0x0800102C:  CA           DC.B       0xCA                     ; '\xCA'
+  0x0800102D:  3F           DC.B       0x3F                     ; '?'
+  0x0800102E:  0F           DC.B       0x0F                     ; '\x0F'
+  0x0800102F:  02           DC.B       0x02                     ; '\x02'
+  0x08001030:  C1           DC.B       0xC1                     ; '\xC1'
+  0x08001031:  AF           DC.B       0xAF                     ; '\xAF'
+  0x08001032:  BD           DC.B       0xBD                     ; '\xBD'
+  0x08001033:  03           DC.B       0x03                     ; '\x03'
+  0x08001034:  01           DC.B       0x01                     ; '\x01'
+  0x08001035:  13           DC.B       0x13                     ; '\x13'
+  0x08001036:  8A           DC.B       0x8A                     ; '\x8A'
+  0x08001037:  6B           DC.B       0x6B                     ; 'k'
+  0x08001038:  3A           DC.B       0x3A                     ; ':'
+  0x08001039:  91           DC.B       0x91                     ; '\x91'
+  0x0800103A:  11           DC.B       0x11                     ; '\x11'
+  0x0800103B:  41           DC.B       0x41                     ; 'A'
+  0x0800103C:  4F           DC.B       0x4F                     ; 'O'
+  0x0800103D:  67           DC.B       0x67                     ; 'g'
+  0x0800103E:  DC           DC.B       0xDC                     ; '\xDC'
+  0x0800103F:  EA           DC.B       0xEA                     ; '\xEA'
+  0x08001040:  97           DC.B       0x97                     ; '\x97'
+  0x08001041:  F2           DC.B       0xF2                     ; '\xF2'
+  0x08001042:  CF           DC.B       0xCF                     ; '\xCF'
+  0x08001043:  CE           DC.B       0xCE                     ; '\xCE'
+  0x08001044:  F0           DC.B       0xF0                     ; '\xF0'
+  0x08001045:  B4           DC.B       0xB4                     ; '\xB4'
+  0x08001046:  E6           DC.B       0xE6                     ; '\xE6'
+  0x08001047:  73           DC.B       0x73                     ; 's'
+  0x08001048:  96           DC.B       0x96                     ; '\x96'
+  0x08001049:  AC           DC.B       0xAC                     ; '\xAC'
+  0x0800104A:  74           DC.B       0x74                     ; 't'
+  0x0800104B:  22           DC.B       0x22                     ; '\"'
+  0x0800104C:  E7           DC.B       0xE7                     ; '\xE7'
+  0x0800104D:  AD           DC.B       0xAD                     ; '\xAD'
+  0x0800104E:  35           DC.B       0x35                     ; '5'
+  0x0800104F:  85           DC.B       0x85                     ; '\x85'
+  0x08001050:  E2           DC.B       0xE2                     ; '\xE2'
+  0x08001051:  F9           DC.B       0xF9                     ; '\xF9'
+  0x08001052:  37           DC.B       0x37                     ; '7'
+  0x08001053:  E8           DC.B       0xE8                     ; '\xE8'
+  0x08001054:  1C           DC.B       0x1C                     ; '\x1C'
+  0x08001055:  75           DC.B       0x75                     ; 'u'
+  0x08001056:  DF           DC.B       0xDF                     ; '\xDF'
+  0x08001057:  6E           DC.B       0x6E                     ; 'n'
+  0x08001058:  47           DC.B       0x47                     ; 'G'
+  0x08001059:  F1           DC.B       0xF1                     ; '\xF1'
+  0x0800105A:  1A           DC.B       0x1A                     ; '\x1A'
+  0x0800105B:  71           DC.B       0x71                     ; 'q'
+  0x0800105C:  1D           DC.B       0x1D                     ; '\x1D'
+  0x0800105D:  29           DC.B       0x29                     ; ')'
+  0x0800105E:  C5           DC.B       0xC5                     ; '\xC5'
+  0x0800105F:  89           DC.B       0x89                     ; '\x89'
+  0x08001060:  6F           DC.B       0x6F                     ; 'o'
+  0x08001061:  B7           DC.B       0xB7                     ; '\xB7'
+  0x08001062:  62           DC.B       0x62                     ; 'b'
+  0x08001063:  0E           DC.B       0x0E                     ; '\x0E'
+  0x08001064:  AA           DC.B       0xAA                     ; '\xAA'
+  0x08001065:  18           DC.B       0x18                     ; '\x18'
+  0x08001066:  BE           DC.B       0xBE                     ; '\xBE'
+  0x08001067:  1B           DC.B       0x1B                     ; '\x1B'
+  0x08001068:  FC           DC.B       0xFC                     ; '\xFC'
+  0x08001069:  56           DC.B       0x56                     ; 'V'
+  0x0800106A:  3E           DC.B       0x3E                     ; '>'
+  0x0800106B:  4B           DC.B       0x4B                     ; 'K'
+  0x0800106C:  C6           DC.B       0xC6                     ; '\xC6'
+  0x0800106D:  D2           DC.B       0xD2                     ; '\xD2'
+  0x0800106E:  79           DC.B       0x79                     ; 'y'
+  0x0800106F:  20           DC.B       0x20                     ; ' '
+  0x08001070:  9A           DC.B       0x9A                     ; '\x9A'
+  0x08001071:  DB           DC.B       0xDB                     ; '\xDB'
+  0x08001072:  C0           DC.B       0xC0                     ; '\xC0'
+  0x08001073:  FE           DC.B       0xFE                     ; '\xFE'
+  0x08001074:  78           DC.B       0x78                     ; 'x'
+  0x08001075:  CD           DC.B       0xCD                     ; '\xCD'
+  0x08001076:  5A           DC.B       0x5A                     ; 'Z'
+  0x08001077:  F4           DC.B       0xF4                     ; '\xF4'
+  0x08001078:  1F           DC.B       0x1F                     ; '\x1F'
+  0x08001079:  DD           DC.B       0xDD                     ; '\xDD'
+  0x0800107A:  A8           DC.B       0xA8                     ; '\xA8'
+  0x0800107B:  33           DC.B       0x33                     ; '3'
+  0x0800107C:  88           DC.B       0x88                     ; '\x88'
+  0x0800107D:  07           DC.B       0x07                     ; '\x07'
+  0x0800107E:  C7           DC.B       0xC7                     ; '\xC7'
+  0x0800107F:  31           DC.B       0x31                     ; '1'
+  0x08001080:  B1           DC.B       0xB1                     ; '\xB1'
+  0x08001081:  12           DC.B       0x12                     ; '\x12'
+  0x08001082:  10           DC.B       0x10                     ; '\x10'
+  0x08001083:  59           DC.B       0x59                     ; 'Y'
+  0x08001084:  27           DC.B       0x27                     ; '\\'
+  0x08001085:  80           DC.B       0x80                     ; '\x80'
+  0x08001086:  EC           DC.B       0xEC                     ; '\xEC'
+  0x08001087:  5F           DC.B       0x5F                     ; '_'
+  0x08001088:  60           DC.B       0x60                     ; '`'
+  0x08001089:  51           DC.B       0x51                     ; 'Q'
+  0x0800108A:  7F           DC.B       0x7F                     ; '\x7F'
+  0x0800108B:  A9           DC.B       0xA9                     ; '\xA9'
+  0x0800108C:  19           DC.B       0x19                     ; '\x19'
+  0x0800108D:  B5           DC.B       0xB5                     ; '\xB5'
+  0x0800108E:  4A           DC.B       0x4A                     ; 'J'
+  0x0800108F:  0D           DC.B       0x0D                     ; '\r'
+  0x08001090:  2D           DC.B       0x2D                     ; '-'
+  0x08001091:  E5           DC.B       0xE5                     ; '\xE5'
+  0x08001092:  7A           DC.B       0x7A                     ; 'z'
+  0x08001093:  9F           DC.B       0x9F                     ; '\x9F'
+  0x08001094:  93           DC.B       0x93                     ; '\x93'
+  0x08001095:  C9           DC.B       0xC9                     ; '\xC9'
+  0x08001096:  9C           DC.B       0x9C                     ; '\x9C'
+  0x08001097:  EF           DC.B       0xEF                     ; '\xEF'
+  0x08001098:  A0           DC.B       0xA0                     ; '\xA0'
+  0x08001099:  E0           DC.B       0xE0                     ; '\xE0'
+  0x0800109A:  3B           DC.B       0x3B                     ; ';'
+  0x0800109B:  4D           DC.B       0x4D                     ; 'M'
+  0x0800109C:  AE           DC.B       0xAE                     ; '\xAE'
+  0x0800109D:  2A           DC.B       0x2A                     ; '*'
+  0x0800109E:  F5           DC.B       0xF5                     ; '\xF5'
+  0x0800109F:  B0           DC.B       0xB0                     ; '\xB0'
+  0x080010A0:  C8           DC.B       0xC8                     ; '\xC8'
+  0x080010A1:  EB           DC.B       0xEB                     ; '\xEB'
+  0x080010A2:  BB           DC.B       0xBB                     ; '\xBB'
+  0x080010A3:  3C           DC.B       0x3C                     ; '<'
+  0x080010A4:  83           DC.B       0x83                     ; '\x83'
+  0x080010A5:  53           DC.B       0x53                     ; 'S'
+  0x080010A6:  99           DC.B       0x99                     ; '\x99'
+  0x080010A7:  61           DC.B       0x61                     ; 'a'
+  0x080010A8:  17           DC.B       0x17                     ; '\x17'
+  0x080010A9:  2B           DC.B       0x2B                     ; '+'
+  0x080010AA:  04           DC.B       0x04                     ; '\x04'
+  0x080010AB:  7E           DC.B       0x7E                     ; '~'
+  0x080010AC:  BA           DC.B       0xBA                     ; '\xBA'
+  0x080010AD:  77           DC.B       0x77                     ; 'w'
+  0x080010AE:  D6           DC.B       0xD6                     ; '\xD6'
+  0x080010AF:  26           DC.B       0x26                     ; '&'
+  0x080010B0:  E1           DC.B       0xE1                     ; '\xE1'
+  0x080010B1:  69           DC.B       0x69                     ; 'i'
+  0x080010B2:  14           DC.B       0x14                     ; '\x14'
+  0x080010B3:  63           DC.B       0x63                     ; 'c'
+  0x080010B4:  55           DC.B       0x55                     ; 'U'
+  0x080010B5:  21           DC.B       0x21                     ; '!'
+  0x080010B6:  0C           DC.B       0x0C                     ; '\x0C'
+  0x080010B7:  7D           DC.B       0x7D                     ; '}'
+

Section .rodata.AES_KEY from main.o, size=16, align=1

+
AES_KEY:
+  0x080010B8:  04           DC.B       0x04                     ; '\x04'
+  0x080010B9:  60           DC.B       0x60                     ; '`'
+  0x080010BA:  62           DC.B       0x62                     ; 'b'
+  0x080010BB:  06           DC.B       0x06                     ; '\x06'
+  0x080010BC:  3E           DC.B       0x3E                     ; '>'
+  0x080010BD:  0B           DC.B       0x0B                     ; '\x0B'
+  0x080010BE:  5C           DC.B       0x5C                     ; '\'
+  0x080010BF:  4E           DC.B       0x4E                     ; 'N'
+  0x080010C0:  04           DC.B       0x04                     ; '\x04'
+  0x080010C1:  06           DC.B       0x06                     ; '\x06'
+  0x080010C2:  20           DC.B       0x20                     ; ' '
+  0x080010C3:  50           DC.B       0x50                     ; 'P'
+  0x080010C4:  4F           DC.B       0x4F                     ; 'O'
+  0x080010C5:  34           DC.B       0x34                     ; '4'
+  0x080010C6:  41           DC.B       0x41                     ; 'A'
+  0x080010C7:  4B           DC.B       0x4B                     ; 'K'
+

Section .segger.init.table from [ Linker created ], size=44, align=4

+  0x080010C8:  080010F9     DC.W       __SEGGER_init_zero
+  0x080010CC:  04           DC.B       0x04                     ; '\x04'
+  0x080010CD:  00           DC.B       0x00                     ; '\0'
+  0x080010CE:  00           DC.B       0x00                     ; '\0'
+  0x080010CF:  20           DC.B       0x20                     ; ' '
+  0x080010D0:  05           DC.B       0x05                     ; '\x05'
+  0x080010D1:  00           DC.B       0x00                     ; '\0'
+  0x080010D2:  00           DC.B       0x00                     ; '\0'
+  0x080010D3:  00           DC.B       0x00                     ; '\0'
+  0x080010D4:  080010F9     DC.W       __SEGGER_init_zero
+  0x080010D8:  0C           DC.B       0x0C                     ; '\x0C'
+  0x080010D9:  00           DC.B       0x00                     ; '\0'
+  0x080010DA:  00           DC.B       0x00                     ; '\0'
+  0x080010DB:  20           DC.B       0x20                     ; ' '
+  0x080010DC:  BC           DC.B       0xBC                     ; '\xBC'
+  0x080010DD:  00           DC.B       0x00                     ; '\0'
+  0x080010DE:  00           DC.B       0x00                     ; '\0'
+  0x080010DF:  00           DC.B       0x00                     ; '\0'
+  0x080010E0:  0800110B     DC.W       __SEGGER_init_copy
+  0x080010E4:  00           DC.B       0x00                     ; '\0'
+  0x080010E5:  00           DC.B       0x00                     ; '\0'
+  0x080010E6:  00           DC.B       0x00                     ; '\0'
+  0x080010E7:  20           DC.B       0x20                     ; ' '
+  0x080010E8:  080010F4     DC.W       0x080010F4
+  0x080010EC:  04           DC.B       0x04                     ; '\x04'
+  0x080010ED:  00           DC.B       0x00                     ; '\0'
+  0x080010EE:  00           DC.B       0x00                     ; '\0'
+  0x080010EF:  00           DC.B       0x00                     ; '\0'
+  0x080010F0:  08000CC7     DC.W       __SEGGER_init_done
+

Section .segger.init.data from [ Linker created ], size=4, align=4

+  0x080010F4:  00           DC.B       0x00                     ; '\0'
+  0x080010F5:  24           DC.B       0x24                     ; '$'
+  0x080010F6:  F4           DC.B       0xF4                     ; '\xF4'
+  0x080010F7:  00           DC.B       0x00                     ; '\0'
+

Section .segger.init.__SEGGER_init_zero from SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a), size=18, align=2

+
__SEGGER_init_zero:
+  0x080010F8:  6820         LDR        R0, [R4]
+  0x080010FA:  6861         LDR        R1, [R4, #4]
+  0x080010FC:  3408         ADDS       R4, #8
+  0x080010FE:  2200         MOVS       R2, #0
+  0x08001100:  E000         B          .L2                      ; 0x08001104
+
.L1:
+  0x08001102:  5442         STRB       R2, [R0, R1]
+
.L2:
+  0x08001104:  3901         SUBS       R1, #1
+  0x08001106:  D5FC         BPL        .L1                      ; 0x08001102
+  0x08001108:  4770         BX         LR
+

Section .segger.init.__SEGGER_init_copy from SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a), size=20, align=2

+
__SEGGER_init_copy:
+  0x0800110A:  6820         LDR        R0, [R4]
+  0x0800110C:  6861         LDR        R1, [R4, #4]
+  0x0800110E:  68A2         LDR        R2, [R4, #8]
+  0x08001110:  340C         ADDS       R4, #12
+  0x08001112:  E001         B          .L2                      ; 0x08001118
+
.L1:
+  0x08001114:  5C8B         LDRB       R3, [R1, R2]
+  0x08001116:  5483         STRB       R3, [R0, R2]
+
.L2:
+  0x08001118:  3A01         SUBS       R2, #1
+  0x0800111A:  D5FB         BPL        .L1                      ; 0x08001114
+  0x0800111C:  4770         BX         LR
+

Section .data.SystemCoreClock from system_stm32g0xx.o, size=4, align=4

+
SystemCoreClock:
+  0x20000000:  00           DC.B       0x00                     ; '\0'
+  0x20000001:  24           DC.B       0x24                     ; '$'
+  0x20000002:  F4           DC.B       0xF4                     ; '\xF4'
+  0x20000003:  00           DC.B       0x00                     ; '\0'
+

Section .bss.u from main.o, size=5, align=4

+
u:
+  0x20000004:  00           DC.B       0x00                     ; '\0'
+  0x20000005:  53           DC.B       0x53                     ; 'S'
+  0x20000006:  45           DC.B       0x45                     ; 'E'
+  0x20000007:  47           DC.B       0x47                     ; 'G'
+  0x20000008:  47           DC.B       0x47                     ; 'G'
+

Section .bss.state from aes.o, size=4, align=4

+
state:
+  0x2000000C:  8D           DC.B       0x8D                     ; '\x8D'
+  0x2000000D:  01           DC.B       0x01                     ; '\x01'
+  0x2000000E:  02           DC.B       0x02                     ; '\x02'
+  0x2000000F:  04           DC.B       0x04                     ; '\x04'
+

Section .bss.msCounter from main.o, size=4, align=4

+
msCounter:
+  0x20000010:  00           DC.B       0x00                     ; '\0'
+  0x20000011:  53           DC.B       0x53                     ; 'S'
+  0x20000012:  45           DC.B       0x45                     ; 'E'
+  0x20000013:  47           DC.B       0x47                     ; 'G'
+

Section .bss.Key from aes.o, size=4, align=4

+
Key:
+  0x20000014:  8D           DC.B       0x8D                     ; '\x8D'
+  0x20000015:  01           DC.B       0x01                     ; '\x01'
+  0x20000016:  02           DC.B       0x02                     ; '\x02'
+  0x20000017:  04           DC.B       0x04                     ; '\x04'
+

Section .bss.RoundKey from aes.o, size=176, align=1

+
RoundKey:
+  0x20000018:  8D           DC.B       0x8D                     ; '\x8D'
+  0x20000019:  01           DC.B       0x01                     ; '\x01'
+  0x2000001A:  02           DC.B       0x02                     ; '\x02'
+  0x2000001B:  04           DC.B       0x04                     ; '\x04'
+  0x2000001C:  08           DC.B       0x08                     ; '\x08'
+  0x2000001D:  10           DC.B       0x10                     ; '\x10'
+  0x2000001E:  20           DC.B       0x20                     ; ' '
+  0x2000001F:  40           DC.B       0x40                     ; '@'
+  0x20000020:  80           DC.B       0x80                     ; '\x80'
+  0x20000021:  1B           DC.B       0x1B                     ; '\x1B'
+  0x20000022:  36           DC.B       0x36                     ; '6'
+  0x20000023:  6C           DC.B       0x6C                     ; 'l'
+  0x20000024:  D8           DC.B       0xD8                     ; '\xD8'
+  0x20000025:  AB           DC.B       0xAB                     ; '\xAB'
+  0x20000026:  4D           DC.B       0x4D                     ; 'M'
+  0x20000027:  9A           DC.B       0x9A                     ; '\x9A'
+  0x20000028:  2F           DC.B       0x2F                     ; '/'
+  0x20000029:  5E           DC.B       0x5E                     ; '^'
+  0x2000002A:  BC           DC.B       0xBC                     ; '\xBC'
+  0x2000002B:  63           DC.B       0x63                     ; 'c'
+  0x2000002C:  C6           DC.B       0xC6                     ; '\xC6'
+  0x2000002D:  97           DC.B       0x97                     ; '\x97'
+  0x2000002E:  35           DC.B       0x35                     ; '5'
+  0x2000002F:  6A           DC.B       0x6A                     ; 'j'
+  0x20000030:  D4           DC.B       0xD4                     ; '\xD4'
+  0x20000031:  B3           DC.B       0xB3                     ; '\xB3'
+  0x20000032:  7D           DC.B       0x7D                     ; '}'
+  0x20000033:  FA           DC.B       0xFA                     ; '\xFA'
+  0x20000034:  EF           DC.B       0xEF                     ; '\xEF'
+  0x20000035:  C5           DC.B       0xC5                     ; '\xC5'
+  0x20000036:  91           DC.B       0x91                     ; '\x91'
+  0x20000037:  39           DC.B       0x39                     ; '9'
+  0x20000038:  72           DC.B       0x72                     ; 'r'
+  0x20000039:  E4           DC.B       0xE4                     ; '\xE4'
+  0x2000003A:  D3           DC.B       0xD3                     ; '\xD3'
+  0x2000003B:  BD           DC.B       0xBD                     ; '\xBD'
+  0x2000003C:  61           DC.B       0x61                     ; 'a'
+  0x2000003D:  C2           DC.B       0xC2                     ; '\xC2'
+  0x2000003E:  9F           DC.B       0x9F                     ; '\x9F'
+  0x2000003F:  25           DC.B       0x25                     ; '%'
+  0x20000040:  4A           DC.B       0x4A                     ; 'J'
+  0x20000041:  94           DC.B       0x94                     ; '\x94'
+  0x20000042:  33           DC.B       0x33                     ; '3'
+  0x20000043:  66           DC.B       0x66                     ; 'f'
+  0x20000044:  CC           DC.B       0xCC                     ; '\xCC'
+  0x20000045:  83           DC.B       0x83                     ; '\x83'
+  0x20000046:  1D           DC.B       0x1D                     ; '\x1D'
+  0x20000047:  3A           DC.B       0x3A                     ; ':'
+  0x20000048:  74           DC.B       0x74                     ; 't'
+  0x20000049:  E8           DC.B       0xE8                     ; '\xE8'
+  0x2000004A:  CB           DC.B       0xCB                     ; '\xCB'
+  0x2000004B:  8D           DC.B       0x8D                     ; '\x8D'
+  0x2000004C:  01           DC.B       0x01                     ; '\x01'
+  0x2000004D:  02           DC.B       0x02                     ; '\x02'
+  0x2000004E:  04           DC.B       0x04                     ; '\x04'
+  0x2000004F:  08           DC.B       0x08                     ; '\x08'
+  0x20000050:  10           DC.B       0x10                     ; '\x10'
+  0x20000051:  20           DC.B       0x20                     ; ' '
+  0x20000052:  40           DC.B       0x40                     ; '@'
+  0x20000053:  80           DC.B       0x80                     ; '\x80'
+  0x20000054:  1B           DC.B       0x1B                     ; '\x1B'
+  0x20000055:  36           DC.B       0x36                     ; '6'
+  0x20000056:  6C           DC.B       0x6C                     ; 'l'
+  0x20000057:  D8           DC.B       0xD8                     ; '\xD8'
+  0x20000058:  AB           DC.B       0xAB                     ; '\xAB'
+  0x20000059:  4D           DC.B       0x4D                     ; 'M'
+  0x2000005A:  9A           DC.B       0x9A                     ; '\x9A'
+  0x2000005B:  2F           DC.B       0x2F                     ; '/'
+  0x2000005C:  5E           DC.B       0x5E                     ; '^'
+  0x2000005D:  BC           DC.B       0xBC                     ; '\xBC'
+  0x2000005E:  63           DC.B       0x63                     ; 'c'
+  0x2000005F:  C6           DC.B       0xC6                     ; '\xC6'
+  0x20000060:  97           DC.B       0x97                     ; '\x97'
+  0x20000061:  35           DC.B       0x35                     ; '5'
+  0x20000062:  6A           DC.B       0x6A                     ; 'j'
+  0x20000063:  D4           DC.B       0xD4                     ; '\xD4'
+  0x20000064:  B3           DC.B       0xB3                     ; '\xB3'
+  0x20000065:  7D           DC.B       0x7D                     ; '}'
+  0x20000066:  FA           DC.B       0xFA                     ; '\xFA'
+  0x20000067:  EF           DC.B       0xEF                     ; '\xEF'
+  0x20000068:  C5           DC.B       0xC5                     ; '\xC5'
+  0x20000069:  91           DC.B       0x91                     ; '\x91'
+  0x2000006A:  39           DC.B       0x39                     ; '9'
+  0x2000006B:  72           DC.B       0x72                     ; 'r'
+  0x2000006C:  E4           DC.B       0xE4                     ; '\xE4'
+  0x2000006D:  D3           DC.B       0xD3                     ; '\xD3'
+  0x2000006E:  BD           DC.B       0xBD                     ; '\xBD'
+  0x2000006F:  61           DC.B       0x61                     ; 'a'
+  0x20000070:  C2           DC.B       0xC2                     ; '\xC2'
+  0x20000071:  9F           DC.B       0x9F                     ; '\x9F'
+  0x20000072:  25           DC.B       0x25                     ; '%'
+  0x20000073:  4A           DC.B       0x4A                     ; 'J'
+  0x20000074:  94           DC.B       0x94                     ; '\x94'
+  0x20000075:  33           DC.B       0x33                     ; '3'
+  0x20000076:  66           DC.B       0x66                     ; 'f'
+  0x20000077:  CC           DC.B       0xCC                     ; '\xCC'
+  0x20000078:  83           DC.B       0x83                     ; '\x83'
+  0x20000079:  1D           DC.B       0x1D                     ; '\x1D'
+  0x2000007A:  3A           DC.B       0x3A                     ; ':'
+  0x2000007B:  74           DC.B       0x74                     ; 't'
+  0x2000007C:  E8           DC.B       0xE8                     ; '\xE8'
+  0x2000007D:  CB           DC.B       0xCB                     ; '\xCB'
+  0x2000007E:  8D           DC.B       0x8D                     ; '\x8D'
+  0x2000007F:  01           DC.B       0x01                     ; '\x01'
+  0x20000080:  02           DC.B       0x02                     ; '\x02'
+  0x20000081:  04           DC.B       0x04                     ; '\x04'
+  0x20000082:  08           DC.B       0x08                     ; '\x08'
+  0x20000083:  10           DC.B       0x10                     ; '\x10'
+  0x20000084:  20           DC.B       0x20                     ; ' '
+  0x20000085:  40           DC.B       0x40                     ; '@'
+  0x20000086:  80           DC.B       0x80                     ; '\x80'
+  0x20000087:  1B           DC.B       0x1B                     ; '\x1B'
+  0x20000088:  36           DC.B       0x36                     ; '6'
+  0x20000089:  6C           DC.B       0x6C                     ; 'l'
+  0x2000008A:  D8           DC.B       0xD8                     ; '\xD8'
+  0x2000008B:  AB           DC.B       0xAB                     ; '\xAB'
+  0x2000008C:  4D           DC.B       0x4D                     ; 'M'
+  0x2000008D:  9A           DC.B       0x9A                     ; '\x9A'
+  0x2000008E:  2F           DC.B       0x2F                     ; '/'
+  0x2000008F:  5E           DC.B       0x5E                     ; '^'
+  0x20000090:  BC           DC.B       0xBC                     ; '\xBC'
+  0x20000091:  63           DC.B       0x63                     ; 'c'
+  0x20000092:  C6           DC.B       0xC6                     ; '\xC6'
+  0x20000093:  97           DC.B       0x97                     ; '\x97'
+  0x20000094:  35           DC.B       0x35                     ; '5'
+  0x20000095:  6A           DC.B       0x6A                     ; 'j'
+  0x20000096:  D4           DC.B       0xD4                     ; '\xD4'
+  0x20000097:  B3           DC.B       0xB3                     ; '\xB3'
+  0x20000098:  7D           DC.B       0x7D                     ; '}'
+  0x20000099:  FA           DC.B       0xFA                     ; '\xFA'
+  0x2000009A:  EF           DC.B       0xEF                     ; '\xEF'
+  0x2000009B:  C5           DC.B       0xC5                     ; '\xC5'
+  0x2000009C:  91           DC.B       0x91                     ; '\x91'
+  0x2000009D:  39           DC.B       0x39                     ; '9'
+  0x2000009E:  72           DC.B       0x72                     ; 'r'
+  0x2000009F:  E4           DC.B       0xE4                     ; '\xE4'
+  0x200000A0:  D3           DC.B       0xD3                     ; '\xD3'
+  0x200000A1:  BD           DC.B       0xBD                     ; '\xBD'
+  0x200000A2:  61           DC.B       0x61                     ; 'a'
+  0x200000A3:  C2           DC.B       0xC2                     ; '\xC2'
+  0x200000A4:  9F           DC.B       0x9F                     ; '\x9F'
+  0x200000A5:  25           DC.B       0x25                     ; '%'
+  0x200000A6:  4A           DC.B       0x4A                     ; 'J'
+  0x200000A7:  94           DC.B       0x94                     ; '\x94'
+  0x200000A8:  33           DC.B       0x33                     ; '3'
+  0x200000A9:  66           DC.B       0x66                     ; 'f'
+  0x200000AA:  CC           DC.B       0xCC                     ; '\xCC'
+  0x200000AB:  83           DC.B       0x83                     ; '\x83'
+  0x200000AC:  1D           DC.B       0x1D                     ; '\x1D'
+  0x200000AD:  3A           DC.B       0x3A                     ; ':'
+  0x200000AE:  74           DC.B       0x74                     ; 't'
+  0x200000AF:  E8           DC.B       0xE8                     ; '\xE8'
+  0x200000B0:  CB           DC.B       0xCB                     ; '\xCB'
+  0x200000B1:  8D           DC.B       0x8D                     ; '\x8D'
+  0x200000B2:  01           DC.B       0x01                     ; '\x01'
+  0x200000B3:  02           DC.B       0x02                     ; '\x02'
+  0x200000B4:  04           DC.B       0x04                     ; '\x04'
+  0x200000B5:  08           DC.B       0x08                     ; '\x08'
+  0x200000B6:  10           DC.B       0x10                     ; '\x10'
+  0x200000B7:  20           DC.B       0x20                     ; ' '
+  0x200000B8:  40           DC.B       0x40                     ; '@'
+  0x200000B9:  80           DC.B       0x80                     ; '\x80'
+  0x200000BA:  1B           DC.B       0x1B                     ; '\x1B'
+  0x200000BB:  36           DC.B       0x36                     ; '6'
+  0x200000BC:  6C           DC.B       0x6C                     ; 'l'
+  0x200000BD:  D8           DC.B       0xD8                     ; '\xD8'
+  0x200000BE:  AB           DC.B       0xAB                     ; '\xAB'
+  0x200000BF:  4D           DC.B       0x4D                     ; 'M'
+  0x200000C0:  9A           DC.B       0x9A                     ; '\x9A'
+  0x200000C1:  2F           DC.B       0x2F                     ; '/'
+  0x200000C2:  5E           DC.B       0x5E                     ; '^'
+  0x200000C3:  BC           DC.B       0xBC                     ; '\xBC'
+  0x200000C4:  63           DC.B       0x63                     ; 'c'
+  0x200000C5:  C6           DC.B       0xC6                     ; '\xC6'
+  0x200000C6:  97           DC.B       0x97                     ; '\x97'
+  0x200000C7:  35           DC.B       0x35                     ; '5'
+

Section .bss.block.stack from [ Linker created ], size=4096, align=8

+  0x20007000:  00           DC.B       0x00                     ; '\0'
+  0x20007001:  00           DC.B       0x00                     ; '\0'
+  0x20007002:  00           DC.B       0x00                     ; '\0'
+  0x20007003:  00           DC.B       0x00                     ; '\0'
+  0x20007004:  00           DC.B       0x00                     ; '\0'
+  0x20007005:  00           DC.B       0x00                     ; '\0'
+  0x20007006:  00           DC.B       0x00                     ; '\0'
+  0x20007007:  00           DC.B       0x00                     ; '\0'
+  0x20007008:  00           DC.B       0x00                     ; '\0'
+  0x20007009:  00           DC.B       0x00                     ; '\0'
+  0x2000700A:  00           DC.B       0x00                     ; '\0'
+  0x2000700B:  00           DC.B       0x00                     ; '\0'
+  0x2000700C:  00           DC.B       0x00                     ; '\0'
+  0x2000700D:  00           DC.B       0x00                     ; '\0'
+  0x2000700E:  00           DC.B       0x00                     ; '\0'
+  0x2000700F:  00           DC.B       0x00                     ; '\0'
+  0x20007010:  00           DC.B       0x00                     ; '\0'
+  0x20007011:  00           DC.B       0x00                     ; '\0'
+  0x20007012:  00           DC.B       0x00                     ; '\0'
+  0x20007013:  00           DC.B       0x00                     ; '\0'
+  0x20007014:  00           DC.B       0x00                     ; '\0'
+  0x20007015:  00           DC.B       0x00                     ; '\0'
+  0x20007016:  00           DC.B       0x00                     ; '\0'
+  0x20007017:  00           DC.B       0x00                     ; '\0'
+  0x20007018:  00           DC.B       0x00                     ; '\0'
+  0x20007019:  00           DC.B       0x00                     ; '\0'
+  0x2000701A:  00           DC.B       0x00                     ; '\0'
+  0x2000701B:  00           DC.B       0x00                     ; '\0'
+  0x2000701C:  00           DC.B       0x00                     ; '\0'
+  0x2000701D:  00           DC.B       0x00                     ; '\0'
+  0x2000701E:  00           DC.B       0x00                     ; '\0'
+  0x2000701F:  00           DC.B       0x00                     ; '\0'
+  0x20007020:  00           DC.B       0x00                     ; '\0'
+  0x20007021:  00           DC.B       0x00                     ; '\0'
+  0x20007022:  00           DC.B       0x00                     ; '\0'
+  0x20007023:  00           DC.B       0x00                     ; '\0'
+  0x20007024:  00           DC.B       0x00                     ; '\0'
+  0x20007025:  00           DC.B       0x00                     ; '\0'
+  0x20007026:  00           DC.B       0x00                     ; '\0'
+  0x20007027:  00           DC.B       0x00                     ; '\0'
+  0x20007028:  00           DC.B       0x00                     ; '\0'
+  0x20007029:  00           DC.B       0x00                     ; '\0'
+  0x2000702A:  00           DC.B       0x00                     ; '\0'
+  0x2000702B:  00           DC.B       0x00                     ; '\0'
+  0x2000702C:  00           DC.B       0x00                     ; '\0'
+  0x2000702D:  00           DC.B       0x00                     ; '\0'
+  0x2000702E:  00           DC.B       0x00                     ; '\0'
+  0x2000702F:  00           DC.B       0x00                     ; '\0'
+  0x20007030:  00           DC.B       0x00                     ; '\0'
+  0x20007031:  00           DC.B       0x00                     ; '\0'
+  0x20007032:  00           DC.B       0x00                     ; '\0'
+  0x20007033:  00           DC.B       0x00                     ; '\0'
+  0x20007034:  00           DC.B       0x00                     ; '\0'
+  0x20007035:  00           DC.B       0x00                     ; '\0'
+  0x20007036:  00           DC.B       0x00                     ; '\0'
+  0x20007037:  00           DC.B       0x00                     ; '\0'
+  0x20007038:  00           DC.B       0x00                     ; '\0'
+  0x20007039:  00           DC.B       0x00                     ; '\0'
+  0x2000703A:  00           DC.B       0x00                     ; '\0'
+  0x2000703B:  00           DC.B       0x00                     ; '\0'
+  0x2000703C:  00           DC.B       0x00                     ; '\0'
+  0x2000703D:  00           DC.B       0x00                     ; '\0'
+  0x2000703E:  00           DC.B       0x00                     ; '\0'
+  0x2000703F:  00           DC.B       0x00                     ; '\0'
+  0x20007040:  00           DC.B       0x00                     ; '\0'
+  0x20007041:  00           DC.B       0x00                     ; '\0'
+  0x20007042:  00           DC.B       0x00                     ; '\0'
+  0x20007043:  00           DC.B       0x00                     ; '\0'
+  0x20007044:  00           DC.B       0x00                     ; '\0'
+  0x20007045:  00           DC.B       0x00                     ; '\0'
+  0x20007046:  00           DC.B       0x00                     ; '\0'
+  0x20007047:  00           DC.B       0x00                     ; '\0'
+  0x20007048:  00           DC.B       0x00                     ; '\0'
+  0x20007049:  00           DC.B       0x00                     ; '\0'
+  0x2000704A:  00           DC.B       0x00                     ; '\0'
+  0x2000704B:  00           DC.B       0x00                     ; '\0'
+  0x2000704C:  00           DC.B       0x00                     ; '\0'
+  0x2000704D:  00           DC.B       0x00                     ; '\0'
+  0x2000704E:  00           DC.B       0x00                     ; '\0'
+  0x2000704F:  00           DC.B       0x00                     ; '\0'
+  0x20007050:  00           DC.B       0x00                     ; '\0'
+  0x20007051:  00           DC.B       0x00                     ; '\0'
+  0x20007052:  00           DC.B       0x00                     ; '\0'
+  0x20007053:  00           DC.B       0x00                     ; '\0'
+  0x20007054:  00           DC.B       0x00                     ; '\0'
+  0x20007055:  00           DC.B       0x00                     ; '\0'
+  0x20007056:  00           DC.B       0x00                     ; '\0'
+  0x20007057:  00           DC.B       0x00                     ; '\0'
+  0x20007058:  00           DC.B       0x00                     ; '\0'
+  0x20007059:  00           DC.B       0x00                     ; '\0'
+  0x2000705A:  00           DC.B       0x00                     ; '\0'
+  0x2000705B:  00           DC.B       0x00                     ; '\0'
+  0x2000705C:  00           DC.B       0x00                     ; '\0'
+  0x2000705D:  00           DC.B       0x00                     ; '\0'
+  0x2000705E:  00           DC.B       0x00                     ; '\0'
+  0x2000705F:  00           DC.B       0x00                     ; '\0'
+  0x20007060:  00           DC.B       0x00                     ; '\0'
+  0x20007061:  00           DC.B       0x00                     ; '\0'
+  0x20007062:  00           DC.B       0x00                     ; '\0'
+  0x20007063:  00           DC.B       0x00                     ; '\0'
+  0x20007064:  00           DC.B       0x00                     ; '\0'
+  0x20007065:  00           DC.B       0x00                     ; '\0'
+  0x20007066:  00           DC.B       0x00                     ; '\0'
+  0x20007067:  00           DC.B       0x00                     ; '\0'
+  0x20007068:  00           DC.B       0x00                     ; '\0'
+  0x20007069:  00           DC.B       0x00                     ; '\0'
+  0x2000706A:  00           DC.B       0x00                     ; '\0'
+  0x2000706B:  00           DC.B       0x00                     ; '\0'
+  0x2000706C:  00           DC.B       0x00                     ; '\0'
+  0x2000706D:  00           DC.B       0x00                     ; '\0'
+  0x2000706E:  00           DC.B       0x00                     ; '\0'
+  0x2000706F:  00           DC.B       0x00                     ; '\0'
+  0x20007070:  00           DC.B       0x00                     ; '\0'
+  0x20007071:  00           DC.B       0x00                     ; '\0'
+  0x20007072:  00           DC.B       0x00                     ; '\0'
+  0x20007073:  00           DC.B       0x00                     ; '\0'
+  0x20007074:  00           DC.B       0x00                     ; '\0'
+  0x20007075:  00           DC.B       0x00                     ; '\0'
+  0x20007076:  00           DC.B       0x00                     ; '\0'
+  0x20007077:  00           DC.B       0x00                     ; '\0'
+  0x20007078:  00           DC.B       0x00                     ; '\0'
+  0x20007079:  00           DC.B       0x00                     ; '\0'
+  0x2000707A:  00           DC.B       0x00                     ; '\0'
+  0x2000707B:  00           DC.B       0x00                     ; '\0'
+  0x2000707C:  00           DC.B       0x00                     ; '\0'
+  0x2000707D:  00           DC.B       0x00                     ; '\0'
+  0x2000707E:  00           DC.B       0x00                     ; '\0'
+  0x2000707F:  00           DC.B       0x00                     ; '\0'
+  0x20007080:  00           DC.B       0x00                     ; '\0'
+  0x20007081:  00           DC.B       0x00                     ; '\0'
+  0x20007082:  00           DC.B       0x00                     ; '\0'
+  0x20007083:  00           DC.B       0x00                     ; '\0'
+  0x20007084:  00           DC.B       0x00                     ; '\0'
+  0x20007085:  00           DC.B       0x00                     ; '\0'
+  0x20007086:  00           DC.B       0x00                     ; '\0'
+  0x20007087:  00           DC.B       0x00                     ; '\0'
+  0x20007088:  00           DC.B       0x00                     ; '\0'
+  0x20007089:  00           DC.B       0x00                     ; '\0'
+  0x2000708A:  00           DC.B       0x00                     ; '\0'
+  0x2000708B:  00           DC.B       0x00                     ; '\0'
+  0x2000708C:  00           DC.B       0x00                     ; '\0'
+  0x2000708D:  00           DC.B       0x00                     ; '\0'
+  0x2000708E:  00           DC.B       0x00                     ; '\0'
+  0x2000708F:  00           DC.B       0x00                     ; '\0'
+  0x20007090:  00           DC.B       0x00                     ; '\0'
+  0x20007091:  00           DC.B       0x00                     ; '\0'
+  0x20007092:  00           DC.B       0x00                     ; '\0'
+  0x20007093:  00           DC.B       0x00                     ; '\0'
+  0x20007094:  00           DC.B       0x00                     ; '\0'
+  0x20007095:  00           DC.B       0x00                     ; '\0'
+  0x20007096:  00           DC.B       0x00                     ; '\0'
+  0x20007097:  00           DC.B       0x00                     ; '\0'
+  0x20007098:  00           DC.B       0x00                     ; '\0'
+  0x20007099:  00           DC.B       0x00                     ; '\0'
+  0x2000709A:  00           DC.B       0x00                     ; '\0'
+  0x2000709B:  00           DC.B       0x00                     ; '\0'
+  0x2000709C:  00           DC.B       0x00                     ; '\0'
+  0x2000709D:  00           DC.B       0x00                     ; '\0'
+  0x2000709E:  00           DC.B       0x00                     ; '\0'
+  0x2000709F:  00           DC.B       0x00                     ; '\0'
+  0x200070A0:  00           DC.B       0x00                     ; '\0'
+  0x200070A1:  00           DC.B       0x00                     ; '\0'
+  0x200070A2:  00           DC.B       0x00                     ; '\0'
+  0x200070A3:  00           DC.B       0x00                     ; '\0'
+  0x200070A4:  00           DC.B       0x00                     ; '\0'
+  0x200070A5:  00           DC.B       0x00                     ; '\0'
+  0x200070A6:  00           DC.B       0x00                     ; '\0'
+  0x200070A7:  00           DC.B       0x00                     ; '\0'
+  0x200070A8:  00           DC.B       0x00                     ; '\0'
+  0x200070A9:  00           DC.B       0x00                     ; '\0'
+  0x200070AA:  00           DC.B       0x00                     ; '\0'
+  0x200070AB:  00           DC.B       0x00                     ; '\0'
+  0x200070AC:  00           DC.B       0x00                     ; '\0'
+  0x200070AD:  00           DC.B       0x00                     ; '\0'
+  0x200070AE:  00           DC.B       0x00                     ; '\0'
+  0x200070AF:  00           DC.B       0x00                     ; '\0'
+  0x200070B0:  00           DC.B       0x00                     ; '\0'
+  0x200070B1:  00           DC.B       0x00                     ; '\0'
+  0x200070B2:  00           DC.B       0x00                     ; '\0'
+  0x200070B3:  00           DC.B       0x00                     ; '\0'
+  0x200070B4:  00           DC.B       0x00                     ; '\0'
+  0x200070B5:  00           DC.B       0x00                     ; '\0'
+  0x200070B6:  00           DC.B       0x00                     ; '\0'
+  0x200070B7:  00           DC.B       0x00                     ; '\0'
+  0x200070B8:  00           DC.B       0x00                     ; '\0'
+  0x200070B9:  00           DC.B       0x00                     ; '\0'
+  0x200070BA:  00           DC.B       0x00                     ; '\0'
+  0x200070BB:  00           DC.B       0x00                     ; '\0'
+  0x200070BC:  00           DC.B       0x00                     ; '\0'
+  0x200070BD:  00           DC.B       0x00                     ; '\0'
+  0x200070BE:  00           DC.B       0x00                     ; '\0'
+  0x200070BF:  00           DC.B       0x00                     ; '\0'
+  0x200070C0:  00           DC.B       0x00                     ; '\0'
+  0x200070C1:  00           DC.B       0x00                     ; '\0'
+  0x200070C2:  00           DC.B       0x00                     ; '\0'
+  0x200070C3:  00           DC.B       0x00                     ; '\0'
+  0x200070C4:  00           DC.B       0x00                     ; '\0'
+  0x200070C5:  00           DC.B       0x00                     ; '\0'
+  0x200070C6:  00           DC.B       0x00                     ; '\0'
+  0x200070C7:  00           DC.B       0x00                     ; '\0'
+  0x200070C8:  00           DC.B       0x00                     ; '\0'
+  0x200070C9:  00           DC.B       0x00                     ; '\0'
+  0x200070CA:  00           DC.B       0x00                     ; '\0'
+  0x200070CB:  00           DC.B       0x00                     ; '\0'
+  0x200070CC:  00           DC.B       0x00                     ; '\0'
+  0x200070CD:  00           DC.B       0x00                     ; '\0'
+  0x200070CE:  00           DC.B       0x00                     ; '\0'
+  0x200070CF:  00           DC.B       0x00                     ; '\0'
+  0x200070D0:  00           DC.B       0x00                     ; '\0'
+  0x200070D1:  00           DC.B       0x00                     ; '\0'
+  0x200070D2:  00           DC.B       0x00                     ; '\0'
+  0x200070D3:  00           DC.B       0x00                     ; '\0'
+  0x200070D4:  00           DC.B       0x00                     ; '\0'
+  0x200070D5:  00           DC.B       0x00                     ; '\0'
+  0x200070D6:  00           DC.B       0x00                     ; '\0'
+  0x200070D7:  00           DC.B       0x00                     ; '\0'
+  0x200070D8:  00           DC.B       0x00                     ; '\0'
+  0x200070D9:  00           DC.B       0x00                     ; '\0'
+  0x200070DA:  00           DC.B       0x00                     ; '\0'
+  0x200070DB:  00           DC.B       0x00                     ; '\0'
+  0x200070DC:  00           DC.B       0x00                     ; '\0'
+  0x200070DD:  00           DC.B       0x00                     ; '\0'
+  0x200070DE:  00           DC.B       0x00                     ; '\0'
+  0x200070DF:  00           DC.B       0x00                     ; '\0'
+  0x200070E0:  00           DC.B       0x00                     ; '\0'
+  0x200070E1:  00           DC.B       0x00                     ; '\0'
+  0x200070E2:  00           DC.B       0x00                     ; '\0'
+  0x200070E3:  00           DC.B       0x00                     ; '\0'
+  0x200070E4:  00           DC.B       0x00                     ; '\0'
+  0x200070E5:  00           DC.B       0x00                     ; '\0'
+  0x200070E6:  00           DC.B       0x00                     ; '\0'
+  0x200070E7:  00           DC.B       0x00                     ; '\0'
+  0x200070E8:  00           DC.B       0x00                     ; '\0'
+  0x200070E9:  00           DC.B       0x00                     ; '\0'
+  0x200070EA:  00           DC.B       0x00                     ; '\0'
+  0x200070EB:  00           DC.B       0x00                     ; '\0'
+  0x200070EC:  00           DC.B       0x00                     ; '\0'
+  0x200070ED:  00           DC.B       0x00                     ; '\0'
+  0x200070EE:  00           DC.B       0x00                     ; '\0'
+  0x200070EF:  00           DC.B       0x00                     ; '\0'
+  0x200070F0:  00           DC.B       0x00                     ; '\0'
+  0x200070F1:  00           DC.B       0x00                     ; '\0'
+  0x200070F2:  00           DC.B       0x00                     ; '\0'
+  0x200070F3:  00           DC.B       0x00                     ; '\0'
+  0x200070F4:  00           DC.B       0x00                     ; '\0'
+  0x200070F5:  00           DC.B       0x00                     ; '\0'
+  0x200070F6:  00           DC.B       0x00                     ; '\0'
+  0x200070F7:  00           DC.B       0x00                     ; '\0'
+  0x200070F8:  00           DC.B       0x00                     ; '\0'
+  0x200070F9:  00           DC.B       0x00                     ; '\0'
+  0x200070FA:  00           DC.B       0x00                     ; '\0'
+  0x200070FB:  00           DC.B       0x00                     ; '\0'
+  0x200070FC:  00           DC.B       0x00                     ; '\0'
+  0x200070FD:  00           DC.B       0x00                     ; '\0'
+  0x200070FE:  00           DC.B       0x00                     ; '\0'
+  0x200070FF:  00           DC.B       0x00                     ; '\0'
+  0x20007100:  00           DC.B       0x00                     ; '\0'
+  0x20007101:  00           DC.B       0x00                     ; '\0'
+  0x20007102:  00           DC.B       0x00                     ; '\0'
+  0x20007103:  00           DC.B       0x00                     ; '\0'
+  0x20007104:  00           DC.B       0x00                     ; '\0'
+  0x20007105:  00           DC.B       0x00                     ; '\0'
+  0x20007106:  00           DC.B       0x00                     ; '\0'
+  0x20007107:  00           DC.B       0x00                     ; '\0'
+  0x20007108:  00           DC.B       0x00                     ; '\0'
+  0x20007109:  00           DC.B       0x00                     ; '\0'
+  0x2000710A:  00           DC.B       0x00                     ; '\0'
+  0x2000710B:  00           DC.B       0x00                     ; '\0'
+  0x2000710C:  00           DC.B       0x00                     ; '\0'
+  0x2000710D:  00           DC.B       0x00                     ; '\0'
+  0x2000710E:  00           DC.B       0x00                     ; '\0'
+  0x2000710F:  00           DC.B       0x00                     ; '\0'
+  0x20007110:  00           DC.B       0x00                     ; '\0'
+  0x20007111:  00           DC.B       0x00                     ; '\0'
+  0x20007112:  00           DC.B       0x00                     ; '\0'
+  0x20007113:  00           DC.B       0x00                     ; '\0'
+  0x20007114:  00           DC.B       0x00                     ; '\0'
+  0x20007115:  00           DC.B       0x00                     ; '\0'
+  0x20007116:  00           DC.B       0x00                     ; '\0'
+  0x20007117:  00           DC.B       0x00                     ; '\0'
+  0x20007118:  00           DC.B       0x00                     ; '\0'
+  0x20007119:  00           DC.B       0x00                     ; '\0'
+  0x2000711A:  00           DC.B       0x00                     ; '\0'
+  0x2000711B:  00           DC.B       0x00                     ; '\0'
+  0x2000711C:  00           DC.B       0x00                     ; '\0'
+  0x2000711D:  00           DC.B       0x00                     ; '\0'
+  0x2000711E:  00           DC.B       0x00                     ; '\0'
+  0x2000711F:  00           DC.B       0x00                     ; '\0'
+  0x20007120:  00           DC.B       0x00                     ; '\0'
+  0x20007121:  00           DC.B       0x00                     ; '\0'
+  0x20007122:  00           DC.B       0x00                     ; '\0'
+  0x20007123:  00           DC.B       0x00                     ; '\0'
+  0x20007124:  00           DC.B       0x00                     ; '\0'
+  0x20007125:  00           DC.B       0x00                     ; '\0'
+  0x20007126:  00           DC.B       0x00                     ; '\0'
+  0x20007127:  00           DC.B       0x00                     ; '\0'
+  0x20007128:  00           DC.B       0x00                     ; '\0'
+  0x20007129:  00           DC.B       0x00                     ; '\0'
+  0x2000712A:  00           DC.B       0x00                     ; '\0'
+  0x2000712B:  00           DC.B       0x00                     ; '\0'
+  0x2000712C:  00           DC.B       0x00                     ; '\0'
+  0x2000712D:  00           DC.B       0x00                     ; '\0'
+  0x2000712E:  00           DC.B       0x00                     ; '\0'
+  0x2000712F:  00           DC.B       0x00                     ; '\0'
+  0x20007130:  00           DC.B       0x00                     ; '\0'
+  0x20007131:  00           DC.B       0x00                     ; '\0'
+  0x20007132:  00           DC.B       0x00                     ; '\0'
+  0x20007133:  00           DC.B       0x00                     ; '\0'
+  0x20007134:  00           DC.B       0x00                     ; '\0'
+  0x20007135:  00           DC.B       0x00                     ; '\0'
+  0x20007136:  00           DC.B       0x00                     ; '\0'
+  0x20007137:  00           DC.B       0x00                     ; '\0'
+  0x20007138:  00           DC.B       0x00                     ; '\0'
+  0x20007139:  00           DC.B       0x00                     ; '\0'
+  0x2000713A:  00           DC.B       0x00                     ; '\0'
+  0x2000713B:  00           DC.B       0x00                     ; '\0'
+  0x2000713C:  00           DC.B       0x00                     ; '\0'
+  0x2000713D:  00           DC.B       0x00                     ; '\0'
+  0x2000713E:  00           DC.B       0x00                     ; '\0'
+  0x2000713F:  00           DC.B       0x00                     ; '\0'
+  0x20007140:  00           DC.B       0x00                     ; '\0'
+  0x20007141:  00           DC.B       0x00                     ; '\0'
+  0x20007142:  00           DC.B       0x00                     ; '\0'
+  0x20007143:  00           DC.B       0x00                     ; '\0'
+  0x20007144:  00           DC.B       0x00                     ; '\0'
+  0x20007145:  00           DC.B       0x00                     ; '\0'
+  0x20007146:  00           DC.B       0x00                     ; '\0'
+  0x20007147:  00           DC.B       0x00                     ; '\0'
+  0x20007148:  00           DC.B       0x00                     ; '\0'
+  0x20007149:  00           DC.B       0x00                     ; '\0'
+  0x2000714A:  00           DC.B       0x00                     ; '\0'
+  0x2000714B:  00           DC.B       0x00                     ; '\0'
+  0x2000714C:  00           DC.B       0x00                     ; '\0'
+  0x2000714D:  00           DC.B       0x00                     ; '\0'
+  0x2000714E:  00           DC.B       0x00                     ; '\0'
+  0x2000714F:  00           DC.B       0x00                     ; '\0'
+  0x20007150:  00           DC.B       0x00                     ; '\0'
+  0x20007151:  00           DC.B       0x00                     ; '\0'
+  0x20007152:  00           DC.B       0x00                     ; '\0'
+  0x20007153:  00           DC.B       0x00                     ; '\0'
+  0x20007154:  00           DC.B       0x00                     ; '\0'
+  0x20007155:  00           DC.B       0x00                     ; '\0'
+  0x20007156:  00           DC.B       0x00                     ; '\0'
+  0x20007157:  00           DC.B       0x00                     ; '\0'
+  0x20007158:  00           DC.B       0x00                     ; '\0'
+  0x20007159:  00           DC.B       0x00                     ; '\0'
+  0x2000715A:  00           DC.B       0x00                     ; '\0'
+  0x2000715B:  00           DC.B       0x00                     ; '\0'
+  0x2000715C:  00           DC.B       0x00                     ; '\0'
+  0x2000715D:  00           DC.B       0x00                     ; '\0'
+  0x2000715E:  00           DC.B       0x00                     ; '\0'
+  0x2000715F:  00           DC.B       0x00                     ; '\0'
+  0x20007160:  00           DC.B       0x00                     ; '\0'
+  0x20007161:  00           DC.B       0x00                     ; '\0'
+  0x20007162:  00           DC.B       0x00                     ; '\0'
+  0x20007163:  00           DC.B       0x00                     ; '\0'
+  0x20007164:  00           DC.B       0x00                     ; '\0'
+  0x20007165:  00           DC.B       0x00                     ; '\0'
+  0x20007166:  00           DC.B       0x00                     ; '\0'
+  0x20007167:  00           DC.B       0x00                     ; '\0'
+  0x20007168:  00           DC.B       0x00                     ; '\0'
+  0x20007169:  00           DC.B       0x00                     ; '\0'
+  0x2000716A:  00           DC.B       0x00                     ; '\0'
+  0x2000716B:  00           DC.B       0x00                     ; '\0'
+  0x2000716C:  00           DC.B       0x00                     ; '\0'
+  0x2000716D:  00           DC.B       0x00                     ; '\0'
+  0x2000716E:  00           DC.B       0x00                     ; '\0'
+  0x2000716F:  00           DC.B       0x00                     ; '\0'
+  0x20007170:  00           DC.B       0x00                     ; '\0'
+  0x20007171:  00           DC.B       0x00                     ; '\0'
+  0x20007172:  00           DC.B       0x00                     ; '\0'
+  0x20007173:  00           DC.B       0x00                     ; '\0'
+  0x20007174:  00           DC.B       0x00                     ; '\0'
+  0x20007175:  00           DC.B       0x00                     ; '\0'
+  0x20007176:  00           DC.B       0x00                     ; '\0'
+  0x20007177:  00           DC.B       0x00                     ; '\0'
+  0x20007178:  00           DC.B       0x00                     ; '\0'
+  0x20007179:  00           DC.B       0x00                     ; '\0'
+  0x2000717A:  00           DC.B       0x00                     ; '\0'
+  0x2000717B:  00           DC.B       0x00                     ; '\0'
+  0x2000717C:  00           DC.B       0x00                     ; '\0'
+  0x2000717D:  00           DC.B       0x00                     ; '\0'
+  0x2000717E:  00           DC.B       0x00                     ; '\0'
+  0x2000717F:  00           DC.B       0x00                     ; '\0'
+  0x20007180:  00           DC.B       0x00                     ; '\0'
+  0x20007181:  00           DC.B       0x00                     ; '\0'
+  0x20007182:  00           DC.B       0x00                     ; '\0'
+  0x20007183:  00           DC.B       0x00                     ; '\0'
+  0x20007184:  00           DC.B       0x00                     ; '\0'
+  0x20007185:  00           DC.B       0x00                     ; '\0'
+  0x20007186:  00           DC.B       0x00                     ; '\0'
+  0x20007187:  00           DC.B       0x00                     ; '\0'
+  0x20007188:  00           DC.B       0x00                     ; '\0'
+  0x20007189:  00           DC.B       0x00                     ; '\0'
+  0x2000718A:  00           DC.B       0x00                     ; '\0'
+  0x2000718B:  00           DC.B       0x00                     ; '\0'
+  0x2000718C:  00           DC.B       0x00                     ; '\0'
+  0x2000718D:  00           DC.B       0x00                     ; '\0'
+  0x2000718E:  00           DC.B       0x00                     ; '\0'
+  0x2000718F:  00           DC.B       0x00                     ; '\0'
+  0x20007190:  00           DC.B       0x00                     ; '\0'
+  0x20007191:  00           DC.B       0x00                     ; '\0'
+  0x20007192:  00           DC.B       0x00                     ; '\0'
+  0x20007193:  00           DC.B       0x00                     ; '\0'
+  0x20007194:  00           DC.B       0x00                     ; '\0'
+  0x20007195:  00           DC.B       0x00                     ; '\0'
+  0x20007196:  00           DC.B       0x00                     ; '\0'
+  0x20007197:  00           DC.B       0x00                     ; '\0'
+  0x20007198:  00           DC.B       0x00                     ; '\0'
+  0x20007199:  00           DC.B       0x00                     ; '\0'
+  0x2000719A:  00           DC.B       0x00                     ; '\0'
+  0x2000719B:  00           DC.B       0x00                     ; '\0'
+  0x2000719C:  00           DC.B       0x00                     ; '\0'
+  0x2000719D:  00           DC.B       0x00                     ; '\0'
+  0x2000719E:  00           DC.B       0x00                     ; '\0'
+  0x2000719F:  00           DC.B       0x00                     ; '\0'
+  0x200071A0:  00           DC.B       0x00                     ; '\0'
+  0x200071A1:  00           DC.B       0x00                     ; '\0'
+  0x200071A2:  00           DC.B       0x00                     ; '\0'
+  0x200071A3:  00           DC.B       0x00                     ; '\0'
+  0x200071A4:  00           DC.B       0x00                     ; '\0'
+  0x200071A5:  00           DC.B       0x00                     ; '\0'
+  0x200071A6:  00           DC.B       0x00                     ; '\0'
+  0x200071A7:  00           DC.B       0x00                     ; '\0'
+  0x200071A8:  00           DC.B       0x00                     ; '\0'
+  0x200071A9:  00           DC.B       0x00                     ; '\0'
+  0x200071AA:  00           DC.B       0x00                     ; '\0'
+  0x200071AB:  00           DC.B       0x00                     ; '\0'
+  0x200071AC:  00           DC.B       0x00                     ; '\0'
+  0x200071AD:  00           DC.B       0x00                     ; '\0'
+  0x200071AE:  00           DC.B       0x00                     ; '\0'
+  0x200071AF:  00           DC.B       0x00                     ; '\0'
+  0x200071B0:  00           DC.B       0x00                     ; '\0'
+  0x200071B1:  00           DC.B       0x00                     ; '\0'
+  0x200071B2:  00           DC.B       0x00                     ; '\0'
+  0x200071B3:  00           DC.B       0x00                     ; '\0'
+  0x200071B4:  00           DC.B       0x00                     ; '\0'
+  0x200071B5:  00           DC.B       0x00                     ; '\0'
+  0x200071B6:  00           DC.B       0x00                     ; '\0'
+  0x200071B7:  00           DC.B       0x00                     ; '\0'
+  0x200071B8:  00           DC.B       0x00                     ; '\0'
+  0x200071B9:  00           DC.B       0x00                     ; '\0'
+  0x200071BA:  00           DC.B       0x00                     ; '\0'
+  0x200071BB:  00           DC.B       0x00                     ; '\0'
+  0x200071BC:  00           DC.B       0x00                     ; '\0'
+  0x200071BD:  00           DC.B       0x00                     ; '\0'
+  0x200071BE:  00           DC.B       0x00                     ; '\0'
+  0x200071BF:  00           DC.B       0x00                     ; '\0'
+  0x200071C0:  00           DC.B       0x00                     ; '\0'
+  0x200071C1:  00           DC.B       0x00                     ; '\0'
+  0x200071C2:  00           DC.B       0x00                     ; '\0'
+  0x200071C3:  00           DC.B       0x00                     ; '\0'
+  0x200071C4:  00           DC.B       0x00                     ; '\0'
+  0x200071C5:  00           DC.B       0x00                     ; '\0'
+  0x200071C6:  00           DC.B       0x00                     ; '\0'
+  0x200071C7:  00           DC.B       0x00                     ; '\0'
+  0x200071C8:  00           DC.B       0x00                     ; '\0'
+  0x200071C9:  00           DC.B       0x00                     ; '\0'
+  0x200071CA:  00           DC.B       0x00                     ; '\0'
+  0x200071CB:  00           DC.B       0x00                     ; '\0'
+  0x200071CC:  00           DC.B       0x00                     ; '\0'
+  0x200071CD:  00           DC.B       0x00                     ; '\0'
+  0x200071CE:  00           DC.B       0x00                     ; '\0'
+  0x200071CF:  00           DC.B       0x00                     ; '\0'
+  0x200071D0:  00           DC.B       0x00                     ; '\0'
+  0x200071D1:  00           DC.B       0x00                     ; '\0'
+  0x200071D2:  00           DC.B       0x00                     ; '\0'
+  0x200071D3:  00           DC.B       0x00                     ; '\0'
+  0x200071D4:  00           DC.B       0x00                     ; '\0'
+  0x200071D5:  00           DC.B       0x00                     ; '\0'
+  0x200071D6:  00           DC.B       0x00                     ; '\0'
+  0x200071D7:  00           DC.B       0x00                     ; '\0'
+  0x200071D8:  00           DC.B       0x00                     ; '\0'
+  0x200071D9:  00           DC.B       0x00                     ; '\0'
+  0x200071DA:  00           DC.B       0x00                     ; '\0'
+  0x200071DB:  00           DC.B       0x00                     ; '\0'
+  0x200071DC:  00           DC.B       0x00                     ; '\0'
+  0x200071DD:  00           DC.B       0x00                     ; '\0'
+  0x200071DE:  00           DC.B       0x00                     ; '\0'
+  0x200071DF:  00           DC.B       0x00                     ; '\0'
+  0x200071E0:  00           DC.B       0x00                     ; '\0'
+  0x200071E1:  00           DC.B       0x00                     ; '\0'
+  0x200071E2:  00           DC.B       0x00                     ; '\0'
+  0x200071E3:  00           DC.B       0x00                     ; '\0'
+  0x200071E4:  00           DC.B       0x00                     ; '\0'
+  0x200071E5:  00           DC.B       0x00                     ; '\0'
+  0x200071E6:  00           DC.B       0x00                     ; '\0'
+  0x200071E7:  00           DC.B       0x00                     ; '\0'
+  0x200071E8:  00           DC.B       0x00                     ; '\0'
+  0x200071E9:  00           DC.B       0x00                     ; '\0'
+  0x200071EA:  00           DC.B       0x00                     ; '\0'
+  0x200071EB:  00           DC.B       0x00                     ; '\0'
+  0x200071EC:  00           DC.B       0x00                     ; '\0'
+  0x200071ED:  00           DC.B       0x00                     ; '\0'
+  0x200071EE:  00           DC.B       0x00                     ; '\0'
+  0x200071EF:  00           DC.B       0x00                     ; '\0'
+  0x200071F0:  00           DC.B       0x00                     ; '\0'
+  0x200071F1:  00           DC.B       0x00                     ; '\0'
+  0x200071F2:  00           DC.B       0x00                     ; '\0'
+  0x200071F3:  00           DC.B       0x00                     ; '\0'
+  0x200071F4:  00           DC.B       0x00                     ; '\0'
+  0x200071F5:  00           DC.B       0x00                     ; '\0'
+  0x200071F6:  00           DC.B       0x00                     ; '\0'
+  0x200071F7:  00           DC.B       0x00                     ; '\0'
+  0x200071F8:  00           DC.B       0x00                     ; '\0'
+  0x200071F9:  00           DC.B       0x00                     ; '\0'
+  0x200071FA:  00           DC.B       0x00                     ; '\0'
+  0x200071FB:  00           DC.B       0x00                     ; '\0'
+  0x200071FC:  00           DC.B       0x00                     ; '\0'
+  0x200071FD:  00           DC.B       0x00                     ; '\0'
+  0x200071FE:  00           DC.B       0x00                     ; '\0'
+  0x200071FF:  00           DC.B       0x00                     ; '\0'
+  0x20007200:  00           DC.B       0x00                     ; '\0'
+  0x20007201:  00           DC.B       0x00                     ; '\0'
+  0x20007202:  00           DC.B       0x00                     ; '\0'
+  0x20007203:  00           DC.B       0x00                     ; '\0'
+  0x20007204:  00           DC.B       0x00                     ; '\0'
+  0x20007205:  00           DC.B       0x00                     ; '\0'
+  0x20007206:  00           DC.B       0x00                     ; '\0'
+  0x20007207:  00           DC.B       0x00                     ; '\0'
+  0x20007208:  00           DC.B       0x00                     ; '\0'
+  0x20007209:  00           DC.B       0x00                     ; '\0'
+  0x2000720A:  00           DC.B       0x00                     ; '\0'
+  0x2000720B:  00           DC.B       0x00                     ; '\0'
+  0x2000720C:  00           DC.B       0x00                     ; '\0'
+  0x2000720D:  00           DC.B       0x00                     ; '\0'
+  0x2000720E:  00           DC.B       0x00                     ; '\0'
+  0x2000720F:  00           DC.B       0x00                     ; '\0'
+  0x20007210:  00           DC.B       0x00                     ; '\0'
+  0x20007211:  00           DC.B       0x00                     ; '\0'
+  0x20007212:  00           DC.B       0x00                     ; '\0'
+  0x20007213:  00           DC.B       0x00                     ; '\0'
+  0x20007214:  00           DC.B       0x00                     ; '\0'
+  0x20007215:  00           DC.B       0x00                     ; '\0'
+  0x20007216:  00           DC.B       0x00                     ; '\0'
+  0x20007217:  00           DC.B       0x00                     ; '\0'
+  0x20007218:  00           DC.B       0x00                     ; '\0'
+  0x20007219:  00           DC.B       0x00                     ; '\0'
+  0x2000721A:  00           DC.B       0x00                     ; '\0'
+  0x2000721B:  00           DC.B       0x00                     ; '\0'
+  0x2000721C:  00           DC.B       0x00                     ; '\0'
+  0x2000721D:  00           DC.B       0x00                     ; '\0'
+  0x2000721E:  00           DC.B       0x00                     ; '\0'
+  0x2000721F:  00           DC.B       0x00                     ; '\0'
+  0x20007220:  00           DC.B       0x00                     ; '\0'
+  0x20007221:  00           DC.B       0x00                     ; '\0'
+  0x20007222:  00           DC.B       0x00                     ; '\0'
+  0x20007223:  00           DC.B       0x00                     ; '\0'
+  0x20007224:  00           DC.B       0x00                     ; '\0'
+  0x20007225:  00           DC.B       0x00                     ; '\0'
+  0x20007226:  00           DC.B       0x00                     ; '\0'
+  0x20007227:  00           DC.B       0x00                     ; '\0'
+  0x20007228:  00           DC.B       0x00                     ; '\0'
+  0x20007229:  00           DC.B       0x00                     ; '\0'
+  0x2000722A:  00           DC.B       0x00                     ; '\0'
+  0x2000722B:  00           DC.B       0x00                     ; '\0'
+  0x2000722C:  00           DC.B       0x00                     ; '\0'
+  0x2000722D:  00           DC.B       0x00                     ; '\0'
+  0x2000722E:  00           DC.B       0x00                     ; '\0'
+  0x2000722F:  00           DC.B       0x00                     ; '\0'
+  0x20007230:  00           DC.B       0x00                     ; '\0'
+  0x20007231:  00           DC.B       0x00                     ; '\0'
+  0x20007232:  00           DC.B       0x00                     ; '\0'
+  0x20007233:  00           DC.B       0x00                     ; '\0'
+  0x20007234:  00           DC.B       0x00                     ; '\0'
+  0x20007235:  00           DC.B       0x00                     ; '\0'
+  0x20007236:  00           DC.B       0x00                     ; '\0'
+  0x20007237:  00           DC.B       0x00                     ; '\0'
+  0x20007238:  00           DC.B       0x00                     ; '\0'
+  0x20007239:  00           DC.B       0x00                     ; '\0'
+  0x2000723A:  00           DC.B       0x00                     ; '\0'
+  0x2000723B:  00           DC.B       0x00                     ; '\0'
+  0x2000723C:  00           DC.B       0x00                     ; '\0'
+  0x2000723D:  00           DC.B       0x00                     ; '\0'
+  0x2000723E:  00           DC.B       0x00                     ; '\0'
+  0x2000723F:  00           DC.B       0x00                     ; '\0'
+  0x20007240:  00           DC.B       0x00                     ; '\0'
+  0x20007241:  00           DC.B       0x00                     ; '\0'
+  0x20007242:  00           DC.B       0x00                     ; '\0'
+  0x20007243:  00           DC.B       0x00                     ; '\0'
+  0x20007244:  00           DC.B       0x00                     ; '\0'
+  0x20007245:  00           DC.B       0x00                     ; '\0'
+  0x20007246:  00           DC.B       0x00                     ; '\0'
+  0x20007247:  00           DC.B       0x00                     ; '\0'
+  0x20007248:  00           DC.B       0x00                     ; '\0'
+  0x20007249:  00           DC.B       0x00                     ; '\0'
+  0x2000724A:  00           DC.B       0x00                     ; '\0'
+  0x2000724B:  00           DC.B       0x00                     ; '\0'
+  0x2000724C:  00           DC.B       0x00                     ; '\0'
+  0x2000724D:  00           DC.B       0x00                     ; '\0'
+  0x2000724E:  00           DC.B       0x00                     ; '\0'
+  0x2000724F:  00           DC.B       0x00                     ; '\0'
+  0x20007250:  00           DC.B       0x00                     ; '\0'
+  0x20007251:  00           DC.B       0x00                     ; '\0'
+  0x20007252:  00           DC.B       0x00                     ; '\0'
+  0x20007253:  00           DC.B       0x00                     ; '\0'
+  0x20007254:  00           DC.B       0x00                     ; '\0'
+  0x20007255:  00           DC.B       0x00                     ; '\0'
+  0x20007256:  00           DC.B       0x00                     ; '\0'
+  0x20007257:  00           DC.B       0x00                     ; '\0'
+  0x20007258:  00           DC.B       0x00                     ; '\0'
+  0x20007259:  00           DC.B       0x00                     ; '\0'
+  0x2000725A:  00           DC.B       0x00                     ; '\0'
+  0x2000725B:  00           DC.B       0x00                     ; '\0'
+  0x2000725C:  00           DC.B       0x00                     ; '\0'
+  0x2000725D:  00           DC.B       0x00                     ; '\0'
+  0x2000725E:  00           DC.B       0x00                     ; '\0'
+  0x2000725F:  00           DC.B       0x00                     ; '\0'
+  0x20007260:  00           DC.B       0x00                     ; '\0'
+  0x20007261:  00           DC.B       0x00                     ; '\0'
+  0x20007262:  00           DC.B       0x00                     ; '\0'
+  0x20007263:  00           DC.B       0x00                     ; '\0'
+  0x20007264:  00           DC.B       0x00                     ; '\0'
+  0x20007265:  00           DC.B       0x00                     ; '\0'
+  0x20007266:  00           DC.B       0x00                     ; '\0'
+  0x20007267:  00           DC.B       0x00                     ; '\0'
+  0x20007268:  00           DC.B       0x00                     ; '\0'
+  0x20007269:  00           DC.B       0x00                     ; '\0'
+  0x2000726A:  00           DC.B       0x00                     ; '\0'
+  0x2000726B:  00           DC.B       0x00                     ; '\0'
+  0x2000726C:  00           DC.B       0x00                     ; '\0'
+  0x2000726D:  00           DC.B       0x00                     ; '\0'
+  0x2000726E:  00           DC.B       0x00                     ; '\0'
+  0x2000726F:  00           DC.B       0x00                     ; '\0'
+  0x20007270:  00           DC.B       0x00                     ; '\0'
+  0x20007271:  00           DC.B       0x00                     ; '\0'
+  0x20007272:  00           DC.B       0x00                     ; '\0'
+  0x20007273:  00           DC.B       0x00                     ; '\0'
+  0x20007274:  00           DC.B       0x00                     ; '\0'
+  0x20007275:  00           DC.B       0x00                     ; '\0'
+  0x20007276:  00           DC.B       0x00                     ; '\0'
+  0x20007277:  00           DC.B       0x00                     ; '\0'
+  0x20007278:  00           DC.B       0x00                     ; '\0'
+  0x20007279:  00           DC.B       0x00                     ; '\0'
+  0x2000727A:  00           DC.B       0x00                     ; '\0'
+  0x2000727B:  00           DC.B       0x00                     ; '\0'
+  0x2000727C:  00           DC.B       0x00                     ; '\0'
+  0x2000727D:  00           DC.B       0x00                     ; '\0'
+  0x2000727E:  00           DC.B       0x00                     ; '\0'
+  0x2000727F:  00           DC.B       0x00                     ; '\0'
+  0x20007280:  00           DC.B       0x00                     ; '\0'
+  0x20007281:  00           DC.B       0x00                     ; '\0'
+  0x20007282:  00           DC.B       0x00                     ; '\0'
+  0x20007283:  00           DC.B       0x00                     ; '\0'
+  0x20007284:  00           DC.B       0x00                     ; '\0'
+  0x20007285:  00           DC.B       0x00                     ; '\0'
+  0x20007286:  00           DC.B       0x00                     ; '\0'
+  0x20007287:  00           DC.B       0x00                     ; '\0'
+  0x20007288:  00           DC.B       0x00                     ; '\0'
+  0x20007289:  00           DC.B       0x00                     ; '\0'
+  0x2000728A:  00           DC.B       0x00                     ; '\0'
+  0x2000728B:  00           DC.B       0x00                     ; '\0'
+  0x2000728C:  00           DC.B       0x00                     ; '\0'
+  0x2000728D:  00           DC.B       0x00                     ; '\0'
+  0x2000728E:  00           DC.B       0x00                     ; '\0'
+  0x2000728F:  00           DC.B       0x00                     ; '\0'
+  0x20007290:  00           DC.B       0x00                     ; '\0'
+  0x20007291:  00           DC.B       0x00                     ; '\0'
+  0x20007292:  00           DC.B       0x00                     ; '\0'
+  0x20007293:  00           DC.B       0x00                     ; '\0'
+  0x20007294:  00           DC.B       0x00                     ; '\0'
+  0x20007295:  00           DC.B       0x00                     ; '\0'
+  0x20007296:  00           DC.B       0x00                     ; '\0'
+  0x20007297:  00           DC.B       0x00                     ; '\0'
+  0x20007298:  00           DC.B       0x00                     ; '\0'
+  0x20007299:  00           DC.B       0x00                     ; '\0'
+  0x2000729A:  00           DC.B       0x00                     ; '\0'
+  0x2000729B:  00           DC.B       0x00                     ; '\0'
+  0x2000729C:  00           DC.B       0x00                     ; '\0'
+  0x2000729D:  00           DC.B       0x00                     ; '\0'
+  0x2000729E:  00           DC.B       0x00                     ; '\0'
+  0x2000729F:  00           DC.B       0x00                     ; '\0'
+  0x200072A0:  00           DC.B       0x00                     ; '\0'
+  0x200072A1:  00           DC.B       0x00                     ; '\0'
+  0x200072A2:  00           DC.B       0x00                     ; '\0'
+  0x200072A3:  00           DC.B       0x00                     ; '\0'
+  0x200072A4:  00           DC.B       0x00                     ; '\0'
+  0x200072A5:  00           DC.B       0x00                     ; '\0'
+  0x200072A6:  00           DC.B       0x00                     ; '\0'
+  0x200072A7:  00           DC.B       0x00                     ; '\0'
+  0x200072A8:  00           DC.B       0x00                     ; '\0'
+  0x200072A9:  00           DC.B       0x00                     ; '\0'
+  0x200072AA:  00           DC.B       0x00                     ; '\0'
+  0x200072AB:  00           DC.B       0x00                     ; '\0'
+  0x200072AC:  00           DC.B       0x00                     ; '\0'
+  0x200072AD:  00           DC.B       0x00                     ; '\0'
+  0x200072AE:  00           DC.B       0x00                     ; '\0'
+  0x200072AF:  00           DC.B       0x00                     ; '\0'
+  0x200072B0:  00           DC.B       0x00                     ; '\0'
+  0x200072B1:  00           DC.B       0x00                     ; '\0'
+  0x200072B2:  00           DC.B       0x00                     ; '\0'
+  0x200072B3:  00           DC.B       0x00                     ; '\0'
+  0x200072B4:  00           DC.B       0x00                     ; '\0'
+  0x200072B5:  00           DC.B       0x00                     ; '\0'
+  0x200072B6:  00           DC.B       0x00                     ; '\0'
+  0x200072B7:  00           DC.B       0x00                     ; '\0'
+  0x200072B8:  00           DC.B       0x00                     ; '\0'
+  0x200072B9:  00           DC.B       0x00                     ; '\0'
+  0x200072BA:  00           DC.B       0x00                     ; '\0'
+  0x200072BB:  00           DC.B       0x00                     ; '\0'
+  0x200072BC:  00           DC.B       0x00                     ; '\0'
+  0x200072BD:  00           DC.B       0x00                     ; '\0'
+  0x200072BE:  00           DC.B       0x00                     ; '\0'
+  0x200072BF:  00           DC.B       0x00                     ; '\0'
+  0x200072C0:  00           DC.B       0x00                     ; '\0'
+  0x200072C1:  00           DC.B       0x00                     ; '\0'
+  0x200072C2:  00           DC.B       0x00                     ; '\0'
+  0x200072C3:  00           DC.B       0x00                     ; '\0'
+  0x200072C4:  00           DC.B       0x00                     ; '\0'
+  0x200072C5:  00           DC.B       0x00                     ; '\0'
+  0x200072C6:  00           DC.B       0x00                     ; '\0'
+  0x200072C7:  00           DC.B       0x00                     ; '\0'
+  0x200072C8:  00           DC.B       0x00                     ; '\0'
+  0x200072C9:  00           DC.B       0x00                     ; '\0'
+  0x200072CA:  00           DC.B       0x00                     ; '\0'
+  0x200072CB:  00           DC.B       0x00                     ; '\0'
+  0x200072CC:  00           DC.B       0x00                     ; '\0'
+  0x200072CD:  00           DC.B       0x00                     ; '\0'
+  0x200072CE:  00           DC.B       0x00                     ; '\0'
+  0x200072CF:  00           DC.B       0x00                     ; '\0'
+  0x200072D0:  00           DC.B       0x00                     ; '\0'
+  0x200072D1:  00           DC.B       0x00                     ; '\0'
+  0x200072D2:  00           DC.B       0x00                     ; '\0'
+  0x200072D3:  00           DC.B       0x00                     ; '\0'
+  0x200072D4:  00           DC.B       0x00                     ; '\0'
+  0x200072D5:  00           DC.B       0x00                     ; '\0'
+  0x200072D6:  00           DC.B       0x00                     ; '\0'
+  0x200072D7:  00           DC.B       0x00                     ; '\0'
+  0x200072D8:  00           DC.B       0x00                     ; '\0'
+  0x200072D9:  00           DC.B       0x00                     ; '\0'
+  0x200072DA:  00           DC.B       0x00                     ; '\0'
+  0x200072DB:  00           DC.B       0x00                     ; '\0'
+  0x200072DC:  00           DC.B       0x00                     ; '\0'
+  0x200072DD:  00           DC.B       0x00                     ; '\0'
+  0x200072DE:  00           DC.B       0x00                     ; '\0'
+  0x200072DF:  00           DC.B       0x00                     ; '\0'
+  0x200072E0:  00           DC.B       0x00                     ; '\0'
+  0x200072E1:  00           DC.B       0x00                     ; '\0'
+  0x200072E2:  00           DC.B       0x00                     ; '\0'
+  0x200072E3:  00           DC.B       0x00                     ; '\0'
+  0x200072E4:  00           DC.B       0x00                     ; '\0'
+  0x200072E5:  00           DC.B       0x00                     ; '\0'
+  0x200072E6:  00           DC.B       0x00                     ; '\0'
+  0x200072E7:  00           DC.B       0x00                     ; '\0'
+  0x200072E8:  00           DC.B       0x00                     ; '\0'
+  0x200072E9:  00           DC.B       0x00                     ; '\0'
+  0x200072EA:  00           DC.B       0x00                     ; '\0'
+  0x200072EB:  00           DC.B       0x00                     ; '\0'
+  0x200072EC:  00           DC.B       0x00                     ; '\0'
+  0x200072ED:  00           DC.B       0x00                     ; '\0'
+  0x200072EE:  00           DC.B       0x00                     ; '\0'
+  0x200072EF:  00           DC.B       0x00                     ; '\0'
+  0x200072F0:  00           DC.B       0x00                     ; '\0'
+  0x200072F1:  00           DC.B       0x00                     ; '\0'
+  0x200072F2:  00           DC.B       0x00                     ; '\0'
+  0x200072F3:  00           DC.B       0x00                     ; '\0'
+  0x200072F4:  00           DC.B       0x00                     ; '\0'
+  0x200072F5:  00           DC.B       0x00                     ; '\0'
+  0x200072F6:  00           DC.B       0x00                     ; '\0'
+  0x200072F7:  00           DC.B       0x00                     ; '\0'
+  0x200072F8:  00           DC.B       0x00                     ; '\0'
+  0x200072F9:  00           DC.B       0x00                     ; '\0'
+  0x200072FA:  00           DC.B       0x00                     ; '\0'
+  0x200072FB:  00           DC.B       0x00                     ; '\0'
+  0x200072FC:  00           DC.B       0x00                     ; '\0'
+  0x200072FD:  00           DC.B       0x00                     ; '\0'
+  0x200072FE:  00           DC.B       0x00                     ; '\0'
+  0x200072FF:  00           DC.B       0x00                     ; '\0'
+  0x20007300:  00           DC.B       0x00                     ; '\0'
+  0x20007301:  00           DC.B       0x00                     ; '\0'
+  0x20007302:  00           DC.B       0x00                     ; '\0'
+  0x20007303:  00           DC.B       0x00                     ; '\0'
+  0x20007304:  00           DC.B       0x00                     ; '\0'
+  0x20007305:  00           DC.B       0x00                     ; '\0'
+  0x20007306:  00           DC.B       0x00                     ; '\0'
+  0x20007307:  00           DC.B       0x00                     ; '\0'
+  0x20007308:  00           DC.B       0x00                     ; '\0'
+  0x20007309:  00           DC.B       0x00                     ; '\0'
+  0x2000730A:  00           DC.B       0x00                     ; '\0'
+  0x2000730B:  00           DC.B       0x00                     ; '\0'
+  0x2000730C:  00           DC.B       0x00                     ; '\0'
+  0x2000730D:  00           DC.B       0x00                     ; '\0'
+  0x2000730E:  00           DC.B       0x00                     ; '\0'
+  0x2000730F:  00           DC.B       0x00                     ; '\0'
+  0x20007310:  00           DC.B       0x00                     ; '\0'
+  0x20007311:  00           DC.B       0x00                     ; '\0'
+  0x20007312:  00           DC.B       0x00                     ; '\0'
+  0x20007313:  00           DC.B       0x00                     ; '\0'
+  0x20007314:  00           DC.B       0x00                     ; '\0'
+  0x20007315:  00           DC.B       0x00                     ; '\0'
+  0x20007316:  00           DC.B       0x00                     ; '\0'
+  0x20007317:  00           DC.B       0x00                     ; '\0'
+  0x20007318:  00           DC.B       0x00                     ; '\0'
+  0x20007319:  00           DC.B       0x00                     ; '\0'
+  0x2000731A:  00           DC.B       0x00                     ; '\0'
+  0x2000731B:  00           DC.B       0x00                     ; '\0'
+  0x2000731C:  00           DC.B       0x00                     ; '\0'
+  0x2000731D:  00           DC.B       0x00                     ; '\0'
+  0x2000731E:  00           DC.B       0x00                     ; '\0'
+  0x2000731F:  00           DC.B       0x00                     ; '\0'
+  0x20007320:  00           DC.B       0x00                     ; '\0'
+  0x20007321:  00           DC.B       0x00                     ; '\0'
+  0x20007322:  00           DC.B       0x00                     ; '\0'
+  0x20007323:  00           DC.B       0x00                     ; '\0'
+  0x20007324:  00           DC.B       0x00                     ; '\0'
+  0x20007325:  00           DC.B       0x00                     ; '\0'
+  0x20007326:  00           DC.B       0x00                     ; '\0'
+  0x20007327:  00           DC.B       0x00                     ; '\0'
+  0x20007328:  00           DC.B       0x00                     ; '\0'
+  0x20007329:  00           DC.B       0x00                     ; '\0'
+  0x2000732A:  00           DC.B       0x00                     ; '\0'
+  0x2000732B:  00           DC.B       0x00                     ; '\0'
+  0x2000732C:  00           DC.B       0x00                     ; '\0'
+  0x2000732D:  00           DC.B       0x00                     ; '\0'
+  0x2000732E:  00           DC.B       0x00                     ; '\0'
+  0x2000732F:  00           DC.B       0x00                     ; '\0'
+  0x20007330:  00           DC.B       0x00                     ; '\0'
+  0x20007331:  00           DC.B       0x00                     ; '\0'
+  0x20007332:  00           DC.B       0x00                     ; '\0'
+  0x20007333:  00           DC.B       0x00                     ; '\0'
+  0x20007334:  00           DC.B       0x00                     ; '\0'
+  0x20007335:  00           DC.B       0x00                     ; '\0'
+  0x20007336:  00           DC.B       0x00                     ; '\0'
+  0x20007337:  00           DC.B       0x00                     ; '\0'
+  0x20007338:  00           DC.B       0x00                     ; '\0'
+  0x20007339:  00           DC.B       0x00                     ; '\0'
+  0x2000733A:  00           DC.B       0x00                     ; '\0'
+  0x2000733B:  00           DC.B       0x00                     ; '\0'
+  0x2000733C:  00           DC.B       0x00                     ; '\0'
+  0x2000733D:  00           DC.B       0x00                     ; '\0'
+  0x2000733E:  00           DC.B       0x00                     ; '\0'
+  0x2000733F:  00           DC.B       0x00                     ; '\0'
+  0x20007340:  00           DC.B       0x00                     ; '\0'
+  0x20007341:  00           DC.B       0x00                     ; '\0'
+  0x20007342:  00           DC.B       0x00                     ; '\0'
+  0x20007343:  00           DC.B       0x00                     ; '\0'
+  0x20007344:  00           DC.B       0x00                     ; '\0'
+  0x20007345:  00           DC.B       0x00                     ; '\0'
+  0x20007346:  00           DC.B       0x00                     ; '\0'
+  0x20007347:  00           DC.B       0x00                     ; '\0'
+  0x20007348:  00           DC.B       0x00                     ; '\0'
+  0x20007349:  00           DC.B       0x00                     ; '\0'
+  0x2000734A:  00           DC.B       0x00                     ; '\0'
+  0x2000734B:  00           DC.B       0x00                     ; '\0'
+  0x2000734C:  00           DC.B       0x00                     ; '\0'
+  0x2000734D:  00           DC.B       0x00                     ; '\0'
+  0x2000734E:  00           DC.B       0x00                     ; '\0'
+  0x2000734F:  00           DC.B       0x00                     ; '\0'
+  0x20007350:  00           DC.B       0x00                     ; '\0'
+  0x20007351:  00           DC.B       0x00                     ; '\0'
+  0x20007352:  00           DC.B       0x00                     ; '\0'
+  0x20007353:  00           DC.B       0x00                     ; '\0'
+  0x20007354:  00           DC.B       0x00                     ; '\0'
+  0x20007355:  00           DC.B       0x00                     ; '\0'
+  0x20007356:  00           DC.B       0x00                     ; '\0'
+  0x20007357:  00           DC.B       0x00                     ; '\0'
+  0x20007358:  00           DC.B       0x00                     ; '\0'
+  0x20007359:  00           DC.B       0x00                     ; '\0'
+  0x2000735A:  00           DC.B       0x00                     ; '\0'
+  0x2000735B:  00           DC.B       0x00                     ; '\0'
+  0x2000735C:  00           DC.B       0x00                     ; '\0'
+  0x2000735D:  00           DC.B       0x00                     ; '\0'
+  0x2000735E:  00           DC.B       0x00                     ; '\0'
+  0x2000735F:  00           DC.B       0x00                     ; '\0'
+  0x20007360:  00           DC.B       0x00                     ; '\0'
+  0x20007361:  00           DC.B       0x00                     ; '\0'
+  0x20007362:  00           DC.B       0x00                     ; '\0'
+  0x20007363:  00           DC.B       0x00                     ; '\0'
+  0x20007364:  00           DC.B       0x00                     ; '\0'
+  0x20007365:  00           DC.B       0x00                     ; '\0'
+  0x20007366:  00           DC.B       0x00                     ; '\0'
+  0x20007367:  00           DC.B       0x00                     ; '\0'
+  0x20007368:  00           DC.B       0x00                     ; '\0'
+  0x20007369:  00           DC.B       0x00                     ; '\0'
+  0x2000736A:  00           DC.B       0x00                     ; '\0'
+  0x2000736B:  00           DC.B       0x00                     ; '\0'
+  0x2000736C:  00           DC.B       0x00                     ; '\0'
+  0x2000736D:  00           DC.B       0x00                     ; '\0'
+  0x2000736E:  00           DC.B       0x00                     ; '\0'
+  0x2000736F:  00           DC.B       0x00                     ; '\0'
+  0x20007370:  00           DC.B       0x00                     ; '\0'
+  0x20007371:  00           DC.B       0x00                     ; '\0'
+  0x20007372:  00           DC.B       0x00                     ; '\0'
+  0x20007373:  00           DC.B       0x00                     ; '\0'
+  0x20007374:  00           DC.B       0x00                     ; '\0'
+  0x20007375:  00           DC.B       0x00                     ; '\0'
+  0x20007376:  00           DC.B       0x00                     ; '\0'
+  0x20007377:  00           DC.B       0x00                     ; '\0'
+  0x20007378:  00           DC.B       0x00                     ; '\0'
+  0x20007379:  00           DC.B       0x00                     ; '\0'
+  0x2000737A:  00           DC.B       0x00                     ; '\0'
+  0x2000737B:  00           DC.B       0x00                     ; '\0'
+  0x2000737C:  00           DC.B       0x00                     ; '\0'
+  0x2000737D:  00           DC.B       0x00                     ; '\0'
+  0x2000737E:  00           DC.B       0x00                     ; '\0'
+  0x2000737F:  00           DC.B       0x00                     ; '\0'
+  0x20007380:  00           DC.B       0x00                     ; '\0'
+  0x20007381:  00           DC.B       0x00                     ; '\0'
+  0x20007382:  00           DC.B       0x00                     ; '\0'
+  0x20007383:  00           DC.B       0x00                     ; '\0'
+  0x20007384:  00           DC.B       0x00                     ; '\0'
+  0x20007385:  00           DC.B       0x00                     ; '\0'
+  0x20007386:  00           DC.B       0x00                     ; '\0'
+  0x20007387:  00           DC.B       0x00                     ; '\0'
+  0x20007388:  00           DC.B       0x00                     ; '\0'
+  0x20007389:  00           DC.B       0x00                     ; '\0'
+  0x2000738A:  00           DC.B       0x00                     ; '\0'
+  0x2000738B:  00           DC.B       0x00                     ; '\0'
+  0x2000738C:  00           DC.B       0x00                     ; '\0'
+  0x2000738D:  00           DC.B       0x00                     ; '\0'
+  0x2000738E:  00           DC.B       0x00                     ; '\0'
+  0x2000738F:  00           DC.B       0x00                     ; '\0'
+  0x20007390:  00           DC.B       0x00                     ; '\0'
+  0x20007391:  00           DC.B       0x00                     ; '\0'
+  0x20007392:  00           DC.B       0x00                     ; '\0'
+  0x20007393:  00           DC.B       0x00                     ; '\0'
+  0x20007394:  00           DC.B       0x00                     ; '\0'
+  0x20007395:  00           DC.B       0x00                     ; '\0'
+  0x20007396:  00           DC.B       0x00                     ; '\0'
+  0x20007397:  00           DC.B       0x00                     ; '\0'
+  0x20007398:  00           DC.B       0x00                     ; '\0'
+  0x20007399:  00           DC.B       0x00                     ; '\0'
+  0x2000739A:  00           DC.B       0x00                     ; '\0'
+  0x2000739B:  00           DC.B       0x00                     ; '\0'
+  0x2000739C:  00           DC.B       0x00                     ; '\0'
+  0x2000739D:  00           DC.B       0x00                     ; '\0'
+  0x2000739E:  00           DC.B       0x00                     ; '\0'
+  0x2000739F:  00           DC.B       0x00                     ; '\0'
+  0x200073A0:  00           DC.B       0x00                     ; '\0'
+  0x200073A1:  00           DC.B       0x00                     ; '\0'
+  0x200073A2:  00           DC.B       0x00                     ; '\0'
+  0x200073A3:  00           DC.B       0x00                     ; '\0'
+  0x200073A4:  00           DC.B       0x00                     ; '\0'
+  0x200073A5:  00           DC.B       0x00                     ; '\0'
+  0x200073A6:  00           DC.B       0x00                     ; '\0'
+  0x200073A7:  00           DC.B       0x00                     ; '\0'
+  0x200073A8:  00           DC.B       0x00                     ; '\0'
+  0x200073A9:  00           DC.B       0x00                     ; '\0'
+  0x200073AA:  00           DC.B       0x00                     ; '\0'
+  0x200073AB:  00           DC.B       0x00                     ; '\0'
+  0x200073AC:  00           DC.B       0x00                     ; '\0'
+  0x200073AD:  00           DC.B       0x00                     ; '\0'
+  0x200073AE:  00           DC.B       0x00                     ; '\0'
+  0x200073AF:  00           DC.B       0x00                     ; '\0'
+  0x200073B0:  00           DC.B       0x00                     ; '\0'
+  0x200073B1:  00           DC.B       0x00                     ; '\0'
+  0x200073B2:  00           DC.B       0x00                     ; '\0'
+  0x200073B3:  00           DC.B       0x00                     ; '\0'
+  0x200073B4:  00           DC.B       0x00                     ; '\0'
+  0x200073B5:  00           DC.B       0x00                     ; '\0'
+  0x200073B6:  00           DC.B       0x00                     ; '\0'
+  0x200073B7:  00           DC.B       0x00                     ; '\0'
+  0x200073B8:  00           DC.B       0x00                     ; '\0'
+  0x200073B9:  00           DC.B       0x00                     ; '\0'
+  0x200073BA:  00           DC.B       0x00                     ; '\0'
+  0x200073BB:  00           DC.B       0x00                     ; '\0'
+  0x200073BC:  00           DC.B       0x00                     ; '\0'
+  0x200073BD:  00           DC.B       0x00                     ; '\0'
+  0x200073BE:  00           DC.B       0x00                     ; '\0'
+  0x200073BF:  00           DC.B       0x00                     ; '\0'
+  0x200073C0:  00           DC.B       0x00                     ; '\0'
+  0x200073C1:  00           DC.B       0x00                     ; '\0'
+  0x200073C2:  00           DC.B       0x00                     ; '\0'
+  0x200073C3:  00           DC.B       0x00                     ; '\0'
+  0x200073C4:  00           DC.B       0x00                     ; '\0'
+  0x200073C5:  00           DC.B       0x00                     ; '\0'
+  0x200073C6:  00           DC.B       0x00                     ; '\0'
+  0x200073C7:  00           DC.B       0x00                     ; '\0'
+  0x200073C8:  00           DC.B       0x00                     ; '\0'
+  0x200073C9:  00           DC.B       0x00                     ; '\0'
+  0x200073CA:  00           DC.B       0x00                     ; '\0'
+  0x200073CB:  00           DC.B       0x00                     ; '\0'
+  0x200073CC:  00           DC.B       0x00                     ; '\0'
+  0x200073CD:  00           DC.B       0x00                     ; '\0'
+  0x200073CE:  00           DC.B       0x00                     ; '\0'
+  0x200073CF:  00           DC.B       0x00                     ; '\0'
+  0x200073D0:  00           DC.B       0x00                     ; '\0'
+  0x200073D1:  00           DC.B       0x00                     ; '\0'
+  0x200073D2:  00           DC.B       0x00                     ; '\0'
+  0x200073D3:  00           DC.B       0x00                     ; '\0'
+  0x200073D4:  00           DC.B       0x00                     ; '\0'
+  0x200073D5:  00           DC.B       0x00                     ; '\0'
+  0x200073D6:  00           DC.B       0x00                     ; '\0'
+  0x200073D7:  00           DC.B       0x00                     ; '\0'
+  0x200073D8:  00           DC.B       0x00                     ; '\0'
+  0x200073D9:  00           DC.B       0x00                     ; '\0'
+  0x200073DA:  00           DC.B       0x00                     ; '\0'
+  0x200073DB:  00           DC.B       0x00                     ; '\0'
+  0x200073DC:  00           DC.B       0x00                     ; '\0'
+  0x200073DD:  00           DC.B       0x00                     ; '\0'
+  0x200073DE:  00           DC.B       0x00                     ; '\0'
+  0x200073DF:  00           DC.B       0x00                     ; '\0'
+  0x200073E0:  00           DC.B       0x00                     ; '\0'
+  0x200073E1:  00           DC.B       0x00                     ; '\0'
+  0x200073E2:  00           DC.B       0x00                     ; '\0'
+  0x200073E3:  00           DC.B       0x00                     ; '\0'
+  0x200073E4:  00           DC.B       0x00                     ; '\0'
+  0x200073E5:  00           DC.B       0x00                     ; '\0'
+  0x200073E6:  00           DC.B       0x00                     ; '\0'
+  0x200073E7:  00           DC.B       0x00                     ; '\0'
+  0x200073E8:  00           DC.B       0x00                     ; '\0'
+  0x200073E9:  00           DC.B       0x00                     ; '\0'
+  0x200073EA:  00           DC.B       0x00                     ; '\0'
+  0x200073EB:  00           DC.B       0x00                     ; '\0'
+  0x200073EC:  00           DC.B       0x00                     ; '\0'
+  0x200073ED:  00           DC.B       0x00                     ; '\0'
+  0x200073EE:  00           DC.B       0x00                     ; '\0'
+  0x200073EF:  00           DC.B       0x00                     ; '\0'
+  0x200073F0:  00           DC.B       0x00                     ; '\0'
+  0x200073F1:  00           DC.B       0x00                     ; '\0'
+  0x200073F2:  00           DC.B       0x00                     ; '\0'
+  0x200073F3:  00           DC.B       0x00                     ; '\0'
+  0x200073F4:  00           DC.B       0x00                     ; '\0'
+  0x200073F5:  00           DC.B       0x00                     ; '\0'
+  0x200073F6:  00           DC.B       0x00                     ; '\0'
+  0x200073F7:  00           DC.B       0x00                     ; '\0'
+  0x200073F8:  00           DC.B       0x00                     ; '\0'
+  0x200073F9:  00           DC.B       0x00                     ; '\0'
+  0x200073FA:  00           DC.B       0x00                     ; '\0'
+  0x200073FB:  00           DC.B       0x00                     ; '\0'
+  0x200073FC:  00           DC.B       0x00                     ; '\0'
+  0x200073FD:  00           DC.B       0x00                     ; '\0'
+  0x200073FE:  00           DC.B       0x00                     ; '\0'
+  0x200073FF:  00           DC.B       0x00                     ; '\0'
+  0x20007400:  00           DC.B       0x00                     ; '\0'
+  0x20007401:  00           DC.B       0x00                     ; '\0'
+  0x20007402:  00           DC.B       0x00                     ; '\0'
+  0x20007403:  00           DC.B       0x00                     ; '\0'
+  0x20007404:  00           DC.B       0x00                     ; '\0'
+  0x20007405:  00           DC.B       0x00                     ; '\0'
+  0x20007406:  00           DC.B       0x00                     ; '\0'
+  0x20007407:  00           DC.B       0x00                     ; '\0'
+  0x20007408:  00           DC.B       0x00                     ; '\0'
+  0x20007409:  00           DC.B       0x00                     ; '\0'
+  0x2000740A:  00           DC.B       0x00                     ; '\0'
+  0x2000740B:  00           DC.B       0x00                     ; '\0'
+  0x2000740C:  00           DC.B       0x00                     ; '\0'
+  0x2000740D:  00           DC.B       0x00                     ; '\0'
+  0x2000740E:  00           DC.B       0x00                     ; '\0'
+  0x2000740F:  00           DC.B       0x00                     ; '\0'
+  0x20007410:  00           DC.B       0x00                     ; '\0'
+  0x20007411:  00           DC.B       0x00                     ; '\0'
+  0x20007412:  00           DC.B       0x00                     ; '\0'
+  0x20007413:  00           DC.B       0x00                     ; '\0'
+  0x20007414:  00           DC.B       0x00                     ; '\0'
+  0x20007415:  00           DC.B       0x00                     ; '\0'
+  0x20007416:  00           DC.B       0x00                     ; '\0'
+  0x20007417:  00           DC.B       0x00                     ; '\0'
+  0x20007418:  00           DC.B       0x00                     ; '\0'
+  0x20007419:  00           DC.B       0x00                     ; '\0'
+  0x2000741A:  00           DC.B       0x00                     ; '\0'
+  0x2000741B:  00           DC.B       0x00                     ; '\0'
+  0x2000741C:  00           DC.B       0x00                     ; '\0'
+  0x2000741D:  00           DC.B       0x00                     ; '\0'
+  0x2000741E:  00           DC.B       0x00                     ; '\0'
+  0x2000741F:  00           DC.B       0x00                     ; '\0'
+  0x20007420:  00           DC.B       0x00                     ; '\0'
+  0x20007421:  00           DC.B       0x00                     ; '\0'
+  0x20007422:  00           DC.B       0x00                     ; '\0'
+  0x20007423:  00           DC.B       0x00                     ; '\0'
+  0x20007424:  00           DC.B       0x00                     ; '\0'
+  0x20007425:  00           DC.B       0x00                     ; '\0'
+  0x20007426:  00           DC.B       0x00                     ; '\0'
+  0x20007427:  00           DC.B       0x00                     ; '\0'
+  0x20007428:  00           DC.B       0x00                     ; '\0'
+  0x20007429:  00           DC.B       0x00                     ; '\0'
+  0x2000742A:  00           DC.B       0x00                     ; '\0'
+  0x2000742B:  00           DC.B       0x00                     ; '\0'
+  0x2000742C:  00           DC.B       0x00                     ; '\0'
+  0x2000742D:  00           DC.B       0x00                     ; '\0'
+  0x2000742E:  00           DC.B       0x00                     ; '\0'
+  0x2000742F:  00           DC.B       0x00                     ; '\0'
+  0x20007430:  00           DC.B       0x00                     ; '\0'
+  0x20007431:  00           DC.B       0x00                     ; '\0'
+  0x20007432:  00           DC.B       0x00                     ; '\0'
+  0x20007433:  00           DC.B       0x00                     ; '\0'
+  0x20007434:  00           DC.B       0x00                     ; '\0'
+  0x20007435:  00           DC.B       0x00                     ; '\0'
+  0x20007436:  00           DC.B       0x00                     ; '\0'
+  0x20007437:  00           DC.B       0x00                     ; '\0'
+  0x20007438:  00           DC.B       0x00                     ; '\0'
+  0x20007439:  00           DC.B       0x00                     ; '\0'
+  0x2000743A:  00           DC.B       0x00                     ; '\0'
+  0x2000743B:  00           DC.B       0x00                     ; '\0'
+  0x2000743C:  00           DC.B       0x00                     ; '\0'
+  0x2000743D:  00           DC.B       0x00                     ; '\0'
+  0x2000743E:  00           DC.B       0x00                     ; '\0'
+  0x2000743F:  00           DC.B       0x00                     ; '\0'
+  0x20007440:  00           DC.B       0x00                     ; '\0'
+  0x20007441:  00           DC.B       0x00                     ; '\0'
+  0x20007442:  00           DC.B       0x00                     ; '\0'
+  0x20007443:  00           DC.B       0x00                     ; '\0'
+  0x20007444:  00           DC.B       0x00                     ; '\0'
+  0x20007445:  00           DC.B       0x00                     ; '\0'
+  0x20007446:  00           DC.B       0x00                     ; '\0'
+  0x20007447:  00           DC.B       0x00                     ; '\0'
+  0x20007448:  00           DC.B       0x00                     ; '\0'
+  0x20007449:  00           DC.B       0x00                     ; '\0'
+  0x2000744A:  00           DC.B       0x00                     ; '\0'
+  0x2000744B:  00           DC.B       0x00                     ; '\0'
+  0x2000744C:  00           DC.B       0x00                     ; '\0'
+  0x2000744D:  00           DC.B       0x00                     ; '\0'
+  0x2000744E:  00           DC.B       0x00                     ; '\0'
+  0x2000744F:  00           DC.B       0x00                     ; '\0'
+  0x20007450:  00           DC.B       0x00                     ; '\0'
+  0x20007451:  00           DC.B       0x00                     ; '\0'
+  0x20007452:  00           DC.B       0x00                     ; '\0'
+  0x20007453:  00           DC.B       0x00                     ; '\0'
+  0x20007454:  00           DC.B       0x00                     ; '\0'
+  0x20007455:  00           DC.B       0x00                     ; '\0'
+  0x20007456:  00           DC.B       0x00                     ; '\0'
+  0x20007457:  00           DC.B       0x00                     ; '\0'
+  0x20007458:  00           DC.B       0x00                     ; '\0'
+  0x20007459:  00           DC.B       0x00                     ; '\0'
+  0x2000745A:  00           DC.B       0x00                     ; '\0'
+  0x2000745B:  00           DC.B       0x00                     ; '\0'
+  0x2000745C:  00           DC.B       0x00                     ; '\0'
+  0x2000745D:  00           DC.B       0x00                     ; '\0'
+  0x2000745E:  00           DC.B       0x00                     ; '\0'
+  0x2000745F:  00           DC.B       0x00                     ; '\0'
+  0x20007460:  00           DC.B       0x00                     ; '\0'
+  0x20007461:  00           DC.B       0x00                     ; '\0'
+  0x20007462:  00           DC.B       0x00                     ; '\0'
+  0x20007463:  00           DC.B       0x00                     ; '\0'
+  0x20007464:  00           DC.B       0x00                     ; '\0'
+  0x20007465:  00           DC.B       0x00                     ; '\0'
+  0x20007466:  00           DC.B       0x00                     ; '\0'
+  0x20007467:  00           DC.B       0x00                     ; '\0'
+  0x20007468:  00           DC.B       0x00                     ; '\0'
+  0x20007469:  00           DC.B       0x00                     ; '\0'
+  0x2000746A:  00           DC.B       0x00                     ; '\0'
+  0x2000746B:  00           DC.B       0x00                     ; '\0'
+  0x2000746C:  00           DC.B       0x00                     ; '\0'
+  0x2000746D:  00           DC.B       0x00                     ; '\0'
+  0x2000746E:  00           DC.B       0x00                     ; '\0'
+  0x2000746F:  00           DC.B       0x00                     ; '\0'
+  0x20007470:  00           DC.B       0x00                     ; '\0'
+  0x20007471:  00           DC.B       0x00                     ; '\0'
+  0x20007472:  00           DC.B       0x00                     ; '\0'
+  0x20007473:  00           DC.B       0x00                     ; '\0'
+  0x20007474:  00           DC.B       0x00                     ; '\0'
+  0x20007475:  00           DC.B       0x00                     ; '\0'
+  0x20007476:  00           DC.B       0x00                     ; '\0'
+  0x20007477:  00           DC.B       0x00                     ; '\0'
+  0x20007478:  00           DC.B       0x00                     ; '\0'
+  0x20007479:  00           DC.B       0x00                     ; '\0'
+  0x2000747A:  00           DC.B       0x00                     ; '\0'
+  0x2000747B:  00           DC.B       0x00                     ; '\0'
+  0x2000747C:  00           DC.B       0x00                     ; '\0'
+  0x2000747D:  00           DC.B       0x00                     ; '\0'
+  0x2000747E:  00           DC.B       0x00                     ; '\0'
+  0x2000747F:  00           DC.B       0x00                     ; '\0'
+  0x20007480:  00           DC.B       0x00                     ; '\0'
+  0x20007481:  00           DC.B       0x00                     ; '\0'
+  0x20007482:  00           DC.B       0x00                     ; '\0'
+  0x20007483:  00           DC.B       0x00                     ; '\0'
+  0x20007484:  00           DC.B       0x00                     ; '\0'
+  0x20007485:  00           DC.B       0x00                     ; '\0'
+  0x20007486:  00           DC.B       0x00                     ; '\0'
+  0x20007487:  00           DC.B       0x00                     ; '\0'
+  0x20007488:  00           DC.B       0x00                     ; '\0'
+  0x20007489:  00           DC.B       0x00                     ; '\0'
+  0x2000748A:  00           DC.B       0x00                     ; '\0'
+  0x2000748B:  00           DC.B       0x00                     ; '\0'
+  0x2000748C:  00           DC.B       0x00                     ; '\0'
+  0x2000748D:  00           DC.B       0x00                     ; '\0'
+  0x2000748E:  00           DC.B       0x00                     ; '\0'
+  0x2000748F:  00           DC.B       0x00                     ; '\0'
+  0x20007490:  00           DC.B       0x00                     ; '\0'
+  0x20007491:  00           DC.B       0x00                     ; '\0'
+  0x20007492:  00           DC.B       0x00                     ; '\0'
+  0x20007493:  00           DC.B       0x00                     ; '\0'
+  0x20007494:  00           DC.B       0x00                     ; '\0'
+  0x20007495:  00           DC.B       0x00                     ; '\0'
+  0x20007496:  00           DC.B       0x00                     ; '\0'
+  0x20007497:  00           DC.B       0x00                     ; '\0'
+  0x20007498:  00           DC.B       0x00                     ; '\0'
+  0x20007499:  00           DC.B       0x00                     ; '\0'
+  0x2000749A:  00           DC.B       0x00                     ; '\0'
+  0x2000749B:  00           DC.B       0x00                     ; '\0'
+  0x2000749C:  00           DC.B       0x00                     ; '\0'
+  0x2000749D:  00           DC.B       0x00                     ; '\0'
+  0x2000749E:  00           DC.B       0x00                     ; '\0'
+  0x2000749F:  00           DC.B       0x00                     ; '\0'
+  0x200074A0:  00           DC.B       0x00                     ; '\0'
+  0x200074A1:  00           DC.B       0x00                     ; '\0'
+  0x200074A2:  00           DC.B       0x00                     ; '\0'
+  0x200074A3:  00           DC.B       0x00                     ; '\0'
+  0x200074A4:  00           DC.B       0x00                     ; '\0'
+  0x200074A5:  00           DC.B       0x00                     ; '\0'
+  0x200074A6:  00           DC.B       0x00                     ; '\0'
+  0x200074A7:  00           DC.B       0x00                     ; '\0'
+  0x200074A8:  00           DC.B       0x00                     ; '\0'
+  0x200074A9:  00           DC.B       0x00                     ; '\0'
+  0x200074AA:  00           DC.B       0x00                     ; '\0'
+  0x200074AB:  00           DC.B       0x00                     ; '\0'
+  0x200074AC:  00           DC.B       0x00                     ; '\0'
+  0x200074AD:  00           DC.B       0x00                     ; '\0'
+  0x200074AE:  00           DC.B       0x00                     ; '\0'
+  0x200074AF:  00           DC.B       0x00                     ; '\0'
+  0x200074B0:  00           DC.B       0x00                     ; '\0'
+  0x200074B1:  00           DC.B       0x00                     ; '\0'
+  0x200074B2:  00           DC.B       0x00                     ; '\0'
+  0x200074B3:  00           DC.B       0x00                     ; '\0'
+  0x200074B4:  00           DC.B       0x00                     ; '\0'
+  0x200074B5:  00           DC.B       0x00                     ; '\0'
+  0x200074B6:  00           DC.B       0x00                     ; '\0'
+  0x200074B7:  00           DC.B       0x00                     ; '\0'
+  0x200074B8:  00           DC.B       0x00                     ; '\0'
+  0x200074B9:  00           DC.B       0x00                     ; '\0'
+  0x200074BA:  00           DC.B       0x00                     ; '\0'
+  0x200074BB:  00           DC.B       0x00                     ; '\0'
+  0x200074BC:  00           DC.B       0x00                     ; '\0'
+  0x200074BD:  00           DC.B       0x00                     ; '\0'
+  0x200074BE:  00           DC.B       0x00                     ; '\0'
+  0x200074BF:  00           DC.B       0x00                     ; '\0'
+  0x200074C0:  00           DC.B       0x00                     ; '\0'
+  0x200074C1:  00           DC.B       0x00                     ; '\0'
+  0x200074C2:  00           DC.B       0x00                     ; '\0'
+  0x200074C3:  00           DC.B       0x00                     ; '\0'
+  0x200074C4:  00           DC.B       0x00                     ; '\0'
+  0x200074C5:  00           DC.B       0x00                     ; '\0'
+  0x200074C6:  00           DC.B       0x00                     ; '\0'
+  0x200074C7:  00           DC.B       0x00                     ; '\0'
+  0x200074C8:  00           DC.B       0x00                     ; '\0'
+  0x200074C9:  00           DC.B       0x00                     ; '\0'
+  0x200074CA:  00           DC.B       0x00                     ; '\0'
+  0x200074CB:  00           DC.B       0x00                     ; '\0'
+  0x200074CC:  00           DC.B       0x00                     ; '\0'
+  0x200074CD:  00           DC.B       0x00                     ; '\0'
+  0x200074CE:  00           DC.B       0x00                     ; '\0'
+  0x200074CF:  00           DC.B       0x00                     ; '\0'
+  0x200074D0:  00           DC.B       0x00                     ; '\0'
+  0x200074D1:  00           DC.B       0x00                     ; '\0'
+  0x200074D2:  00           DC.B       0x00                     ; '\0'
+  0x200074D3:  00           DC.B       0x00                     ; '\0'
+  0x200074D4:  00           DC.B       0x00                     ; '\0'
+  0x200074D5:  00           DC.B       0x00                     ; '\0'
+  0x200074D6:  00           DC.B       0x00                     ; '\0'
+  0x200074D7:  00           DC.B       0x00                     ; '\0'
+  0x200074D8:  00           DC.B       0x00                     ; '\0'
+  0x200074D9:  00           DC.B       0x00                     ; '\0'
+  0x200074DA:  00           DC.B       0x00                     ; '\0'
+  0x200074DB:  00           DC.B       0x00                     ; '\0'
+  0x200074DC:  00           DC.B       0x00                     ; '\0'
+  0x200074DD:  00           DC.B       0x00                     ; '\0'
+  0x200074DE:  00           DC.B       0x00                     ; '\0'
+  0x200074DF:  00           DC.B       0x00                     ; '\0'
+  0x200074E0:  00           DC.B       0x00                     ; '\0'
+  0x200074E1:  00           DC.B       0x00                     ; '\0'
+  0x200074E2:  00           DC.B       0x00                     ; '\0'
+  0x200074E3:  00           DC.B       0x00                     ; '\0'
+  0x200074E4:  00           DC.B       0x00                     ; '\0'
+  0x200074E5:  00           DC.B       0x00                     ; '\0'
+  0x200074E6:  00           DC.B       0x00                     ; '\0'
+  0x200074E7:  00           DC.B       0x00                     ; '\0'
+  0x200074E8:  00           DC.B       0x00                     ; '\0'
+  0x200074E9:  00           DC.B       0x00                     ; '\0'
+  0x200074EA:  00           DC.B       0x00                     ; '\0'
+  0x200074EB:  00           DC.B       0x00                     ; '\0'
+  0x200074EC:  00           DC.B       0x00                     ; '\0'
+  0x200074ED:  00           DC.B       0x00                     ; '\0'
+  0x200074EE:  00           DC.B       0x00                     ; '\0'
+  0x200074EF:  00           DC.B       0x00                     ; '\0'
+  0x200074F0:  00           DC.B       0x00                     ; '\0'
+  0x200074F1:  00           DC.B       0x00                     ; '\0'
+  0x200074F2:  00           DC.B       0x00                     ; '\0'
+  0x200074F3:  00           DC.B       0x00                     ; '\0'
+  0x200074F4:  00           DC.B       0x00                     ; '\0'
+  0x200074F5:  00           DC.B       0x00                     ; '\0'
+  0x200074F6:  00           DC.B       0x00                     ; '\0'
+  0x200074F7:  00           DC.B       0x00                     ; '\0'
+  0x200074F8:  00           DC.B       0x00                     ; '\0'
+  0x200074F9:  00           DC.B       0x00                     ; '\0'
+  0x200074FA:  00           DC.B       0x00                     ; '\0'
+  0x200074FB:  00           DC.B       0x00                     ; '\0'
+  0x200074FC:  00           DC.B       0x00                     ; '\0'
+  0x200074FD:  00           DC.B       0x00                     ; '\0'
+  0x200074FE:  00           DC.B       0x00                     ; '\0'
+  0x200074FF:  00           DC.B       0x00                     ; '\0'
+  0x20007500:  00           DC.B       0x00                     ; '\0'
+  0x20007501:  00           DC.B       0x00                     ; '\0'
+  0x20007502:  00           DC.B       0x00                     ; '\0'
+  0x20007503:  00           DC.B       0x00                     ; '\0'
+  0x20007504:  00           DC.B       0x00                     ; '\0'
+  0x20007505:  00           DC.B       0x00                     ; '\0'
+  0x20007506:  00           DC.B       0x00                     ; '\0'
+  0x20007507:  00           DC.B       0x00                     ; '\0'
+  0x20007508:  00           DC.B       0x00                     ; '\0'
+  0x20007509:  00           DC.B       0x00                     ; '\0'
+  0x2000750A:  00           DC.B       0x00                     ; '\0'
+  0x2000750B:  00           DC.B       0x00                     ; '\0'
+  0x2000750C:  00           DC.B       0x00                     ; '\0'
+  0x2000750D:  00           DC.B       0x00                     ; '\0'
+  0x2000750E:  00           DC.B       0x00                     ; '\0'
+  0x2000750F:  00           DC.B       0x00                     ; '\0'
+  0x20007510:  00           DC.B       0x00                     ; '\0'
+  0x20007511:  00           DC.B       0x00                     ; '\0'
+  0x20007512:  00           DC.B       0x00                     ; '\0'
+  0x20007513:  00           DC.B       0x00                     ; '\0'
+  0x20007514:  00           DC.B       0x00                     ; '\0'
+  0x20007515:  00           DC.B       0x00                     ; '\0'
+  0x20007516:  00           DC.B       0x00                     ; '\0'
+  0x20007517:  00           DC.B       0x00                     ; '\0'
+  0x20007518:  00           DC.B       0x00                     ; '\0'
+  0x20007519:  00           DC.B       0x00                     ; '\0'
+  0x2000751A:  00           DC.B       0x00                     ; '\0'
+  0x2000751B:  00           DC.B       0x00                     ; '\0'
+  0x2000751C:  00           DC.B       0x00                     ; '\0'
+  0x2000751D:  00           DC.B       0x00                     ; '\0'
+  0x2000751E:  00           DC.B       0x00                     ; '\0'
+  0x2000751F:  00           DC.B       0x00                     ; '\0'
+  0x20007520:  00           DC.B       0x00                     ; '\0'
+  0x20007521:  00           DC.B       0x00                     ; '\0'
+  0x20007522:  00           DC.B       0x00                     ; '\0'
+  0x20007523:  00           DC.B       0x00                     ; '\0'
+  0x20007524:  00           DC.B       0x00                     ; '\0'
+  0x20007525:  00           DC.B       0x00                     ; '\0'
+  0x20007526:  00           DC.B       0x00                     ; '\0'
+  0x20007527:  00           DC.B       0x00                     ; '\0'
+  0x20007528:  00           DC.B       0x00                     ; '\0'
+  0x20007529:  00           DC.B       0x00                     ; '\0'
+  0x2000752A:  00           DC.B       0x00                     ; '\0'
+  0x2000752B:  00           DC.B       0x00                     ; '\0'
+  0x2000752C:  00           DC.B       0x00                     ; '\0'
+  0x2000752D:  00           DC.B       0x00                     ; '\0'
+  0x2000752E:  00           DC.B       0x00                     ; '\0'
+  0x2000752F:  00           DC.B       0x00                     ; '\0'
+  0x20007530:  00           DC.B       0x00                     ; '\0'
+  0x20007531:  00           DC.B       0x00                     ; '\0'
+  0x20007532:  00           DC.B       0x00                     ; '\0'
+  0x20007533:  00           DC.B       0x00                     ; '\0'
+  0x20007534:  00           DC.B       0x00                     ; '\0'
+  0x20007535:  00           DC.B       0x00                     ; '\0'
+  0x20007536:  00           DC.B       0x00                     ; '\0'
+  0x20007537:  00           DC.B       0x00                     ; '\0'
+  0x20007538:  00           DC.B       0x00                     ; '\0'
+  0x20007539:  00           DC.B       0x00                     ; '\0'
+  0x2000753A:  00           DC.B       0x00                     ; '\0'
+  0x2000753B:  00           DC.B       0x00                     ; '\0'
+  0x2000753C:  00           DC.B       0x00                     ; '\0'
+  0x2000753D:  00           DC.B       0x00                     ; '\0'
+  0x2000753E:  00           DC.B       0x00                     ; '\0'
+  0x2000753F:  00           DC.B       0x00                     ; '\0'
+  0x20007540:  00           DC.B       0x00                     ; '\0'
+  0x20007541:  00           DC.B       0x00                     ; '\0'
+  0x20007542:  00           DC.B       0x00                     ; '\0'
+  0x20007543:  00           DC.B       0x00                     ; '\0'
+  0x20007544:  00           DC.B       0x00                     ; '\0'
+  0x20007545:  00           DC.B       0x00                     ; '\0'
+  0x20007546:  00           DC.B       0x00                     ; '\0'
+  0x20007547:  00           DC.B       0x00                     ; '\0'
+  0x20007548:  00           DC.B       0x00                     ; '\0'
+  0x20007549:  00           DC.B       0x00                     ; '\0'
+  0x2000754A:  00           DC.B       0x00                     ; '\0'
+  0x2000754B:  00           DC.B       0x00                     ; '\0'
+  0x2000754C:  00           DC.B       0x00                     ; '\0'
+  0x2000754D:  00           DC.B       0x00                     ; '\0'
+  0x2000754E:  00           DC.B       0x00                     ; '\0'
+  0x2000754F:  00           DC.B       0x00                     ; '\0'
+  0x20007550:  00           DC.B       0x00                     ; '\0'
+  0x20007551:  00           DC.B       0x00                     ; '\0'
+  0x20007552:  00           DC.B       0x00                     ; '\0'
+  0x20007553:  00           DC.B       0x00                     ; '\0'
+  0x20007554:  00           DC.B       0x00                     ; '\0'
+  0x20007555:  00           DC.B       0x00                     ; '\0'
+  0x20007556:  00           DC.B       0x00                     ; '\0'
+  0x20007557:  00           DC.B       0x00                     ; '\0'
+  0x20007558:  00           DC.B       0x00                     ; '\0'
+  0x20007559:  00           DC.B       0x00                     ; '\0'
+  0x2000755A:  00           DC.B       0x00                     ; '\0'
+  0x2000755B:  00           DC.B       0x00                     ; '\0'
+  0x2000755C:  00           DC.B       0x00                     ; '\0'
+  0x2000755D:  00           DC.B       0x00                     ; '\0'
+  0x2000755E:  00           DC.B       0x00                     ; '\0'
+  0x2000755F:  00           DC.B       0x00                     ; '\0'
+  0x20007560:  00           DC.B       0x00                     ; '\0'
+  0x20007561:  00           DC.B       0x00                     ; '\0'
+  0x20007562:  00           DC.B       0x00                     ; '\0'
+  0x20007563:  00           DC.B       0x00                     ; '\0'
+  0x20007564:  00           DC.B       0x00                     ; '\0'
+  0x20007565:  00           DC.B       0x00                     ; '\0'
+  0x20007566:  00           DC.B       0x00                     ; '\0'
+  0x20007567:  00           DC.B       0x00                     ; '\0'
+  0x20007568:  00           DC.B       0x00                     ; '\0'
+  0x20007569:  00           DC.B       0x00                     ; '\0'
+  0x2000756A:  00           DC.B       0x00                     ; '\0'
+  0x2000756B:  00           DC.B       0x00                     ; '\0'
+  0x2000756C:  00           DC.B       0x00                     ; '\0'
+  0x2000756D:  00           DC.B       0x00                     ; '\0'
+  0x2000756E:  00           DC.B       0x00                     ; '\0'
+  0x2000756F:  00           DC.B       0x00                     ; '\0'
+  0x20007570:  00           DC.B       0x00                     ; '\0'
+  0x20007571:  00           DC.B       0x00                     ; '\0'
+  0x20007572:  00           DC.B       0x00                     ; '\0'
+  0x20007573:  00           DC.B       0x00                     ; '\0'
+  0x20007574:  00           DC.B       0x00                     ; '\0'
+  0x20007575:  00           DC.B       0x00                     ; '\0'
+  0x20007576:  00           DC.B       0x00                     ; '\0'
+  0x20007577:  00           DC.B       0x00                     ; '\0'
+  0x20007578:  00           DC.B       0x00                     ; '\0'
+  0x20007579:  00           DC.B       0x00                     ; '\0'
+  0x2000757A:  00           DC.B       0x00                     ; '\0'
+  0x2000757B:  00           DC.B       0x00                     ; '\0'
+  0x2000757C:  00           DC.B       0x00                     ; '\0'
+  0x2000757D:  00           DC.B       0x00                     ; '\0'
+  0x2000757E:  00           DC.B       0x00                     ; '\0'
+  0x2000757F:  00           DC.B       0x00                     ; '\0'
+  0x20007580:  00           DC.B       0x00                     ; '\0'
+  0x20007581:  00           DC.B       0x00                     ; '\0'
+  0x20007582:  00           DC.B       0x00                     ; '\0'
+  0x20007583:  00           DC.B       0x00                     ; '\0'
+  0x20007584:  00           DC.B       0x00                     ; '\0'
+  0x20007585:  00           DC.B       0x00                     ; '\0'
+  0x20007586:  00           DC.B       0x00                     ; '\0'
+  0x20007587:  00           DC.B       0x00                     ; '\0'
+  0x20007588:  00           DC.B       0x00                     ; '\0'
+  0x20007589:  00           DC.B       0x00                     ; '\0'
+  0x2000758A:  00           DC.B       0x00                     ; '\0'
+  0x2000758B:  00           DC.B       0x00                     ; '\0'
+  0x2000758C:  00           DC.B       0x00                     ; '\0'
+  0x2000758D:  00           DC.B       0x00                     ; '\0'
+  0x2000758E:  00           DC.B       0x00                     ; '\0'
+  0x2000758F:  00           DC.B       0x00                     ; '\0'
+  0x20007590:  00           DC.B       0x00                     ; '\0'
+  0x20007591:  00           DC.B       0x00                     ; '\0'
+  0x20007592:  00           DC.B       0x00                     ; '\0'
+  0x20007593:  00           DC.B       0x00                     ; '\0'
+  0x20007594:  00           DC.B       0x00                     ; '\0'
+  0x20007595:  00           DC.B       0x00                     ; '\0'
+  0x20007596:  00           DC.B       0x00                     ; '\0'
+  0x20007597:  00           DC.B       0x00                     ; '\0'
+  0x20007598:  00           DC.B       0x00                     ; '\0'
+  0x20007599:  00           DC.B       0x00                     ; '\0'
+  0x2000759A:  00           DC.B       0x00                     ; '\0'
+  0x2000759B:  00           DC.B       0x00                     ; '\0'
+  0x2000759C:  00           DC.B       0x00                     ; '\0'
+  0x2000759D:  00           DC.B       0x00                     ; '\0'
+  0x2000759E:  00           DC.B       0x00                     ; '\0'
+  0x2000759F:  00           DC.B       0x00                     ; '\0'
+  0x200075A0:  00           DC.B       0x00                     ; '\0'
+  0x200075A1:  00           DC.B       0x00                     ; '\0'
+  0x200075A2:  00           DC.B       0x00                     ; '\0'
+  0x200075A3:  00           DC.B       0x00                     ; '\0'
+  0x200075A4:  00           DC.B       0x00                     ; '\0'
+  0x200075A5:  00           DC.B       0x00                     ; '\0'
+  0x200075A6:  00           DC.B       0x00                     ; '\0'
+  0x200075A7:  00           DC.B       0x00                     ; '\0'
+  0x200075A8:  00           DC.B       0x00                     ; '\0'
+  0x200075A9:  00           DC.B       0x00                     ; '\0'
+  0x200075AA:  00           DC.B       0x00                     ; '\0'
+  0x200075AB:  00           DC.B       0x00                     ; '\0'
+  0x200075AC:  00           DC.B       0x00                     ; '\0'
+  0x200075AD:  00           DC.B       0x00                     ; '\0'
+  0x200075AE:  00           DC.B       0x00                     ; '\0'
+  0x200075AF:  00           DC.B       0x00                     ; '\0'
+  0x200075B0:  00           DC.B       0x00                     ; '\0'
+  0x200075B1:  00           DC.B       0x00                     ; '\0'
+  0x200075B2:  00           DC.B       0x00                     ; '\0'
+  0x200075B3:  00           DC.B       0x00                     ; '\0'
+  0x200075B4:  00           DC.B       0x00                     ; '\0'
+  0x200075B5:  00           DC.B       0x00                     ; '\0'
+  0x200075B6:  00           DC.B       0x00                     ; '\0'
+  0x200075B7:  00           DC.B       0x00                     ; '\0'
+  0x200075B8:  00           DC.B       0x00                     ; '\0'
+  0x200075B9:  00           DC.B       0x00                     ; '\0'
+  0x200075BA:  00           DC.B       0x00                     ; '\0'
+  0x200075BB:  00           DC.B       0x00                     ; '\0'
+  0x200075BC:  00           DC.B       0x00                     ; '\0'
+  0x200075BD:  00           DC.B       0x00                     ; '\0'
+  0x200075BE:  00           DC.B       0x00                     ; '\0'
+  0x200075BF:  00           DC.B       0x00                     ; '\0'
+  0x200075C0:  00           DC.B       0x00                     ; '\0'
+  0x200075C1:  00           DC.B       0x00                     ; '\0'
+  0x200075C2:  00           DC.B       0x00                     ; '\0'
+  0x200075C3:  00           DC.B       0x00                     ; '\0'
+  0x200075C4:  00           DC.B       0x00                     ; '\0'
+  0x200075C5:  00           DC.B       0x00                     ; '\0'
+  0x200075C6:  00           DC.B       0x00                     ; '\0'
+  0x200075C7:  00           DC.B       0x00                     ; '\0'
+  0x200075C8:  00           DC.B       0x00                     ; '\0'
+  0x200075C9:  00           DC.B       0x00                     ; '\0'
+  0x200075CA:  00           DC.B       0x00                     ; '\0'
+  0x200075CB:  00           DC.B       0x00                     ; '\0'
+  0x200075CC:  00           DC.B       0x00                     ; '\0'
+  0x200075CD:  00           DC.B       0x00                     ; '\0'
+  0x200075CE:  00           DC.B       0x00                     ; '\0'
+  0x200075CF:  00           DC.B       0x00                     ; '\0'
+  0x200075D0:  00           DC.B       0x00                     ; '\0'
+  0x200075D1:  00           DC.B       0x00                     ; '\0'
+  0x200075D2:  00           DC.B       0x00                     ; '\0'
+  0x200075D3:  00           DC.B       0x00                     ; '\0'
+  0x200075D4:  00           DC.B       0x00                     ; '\0'
+  0x200075D5:  00           DC.B       0x00                     ; '\0'
+  0x200075D6:  00           DC.B       0x00                     ; '\0'
+  0x200075D7:  00           DC.B       0x00                     ; '\0'
+  0x200075D8:  00           DC.B       0x00                     ; '\0'
+  0x200075D9:  00           DC.B       0x00                     ; '\0'
+  0x200075DA:  00           DC.B       0x00                     ; '\0'
+  0x200075DB:  00           DC.B       0x00                     ; '\0'
+  0x200075DC:  00           DC.B       0x00                     ; '\0'
+  0x200075DD:  00           DC.B       0x00                     ; '\0'
+  0x200075DE:  00           DC.B       0x00                     ; '\0'
+  0x200075DF:  00           DC.B       0x00                     ; '\0'
+  0x200075E0:  00           DC.B       0x00                     ; '\0'
+  0x200075E1:  00           DC.B       0x00                     ; '\0'
+  0x200075E2:  00           DC.B       0x00                     ; '\0'
+  0x200075E3:  00           DC.B       0x00                     ; '\0'
+  0x200075E4:  00           DC.B       0x00                     ; '\0'
+  0x200075E5:  00           DC.B       0x00                     ; '\0'
+  0x200075E6:  00           DC.B       0x00                     ; '\0'
+  0x200075E7:  00           DC.B       0x00                     ; '\0'
+  0x200075E8:  00           DC.B       0x00                     ; '\0'
+  0x200075E9:  00           DC.B       0x00                     ; '\0'
+  0x200075EA:  00           DC.B       0x00                     ; '\0'
+  0x200075EB:  00           DC.B       0x00                     ; '\0'
+  0x200075EC:  00           DC.B       0x00                     ; '\0'
+  0x200075ED:  00           DC.B       0x00                     ; '\0'
+  0x200075EE:  00           DC.B       0x00                     ; '\0'
+  0x200075EF:  00           DC.B       0x00                     ; '\0'
+  0x200075F0:  00           DC.B       0x00                     ; '\0'
+  0x200075F1:  00           DC.B       0x00                     ; '\0'
+  0x200075F2:  00           DC.B       0x00                     ; '\0'
+  0x200075F3:  00           DC.B       0x00                     ; '\0'
+  0x200075F4:  00           DC.B       0x00                     ; '\0'
+  0x200075F5:  00           DC.B       0x00                     ; '\0'
+  0x200075F6:  00           DC.B       0x00                     ; '\0'
+  0x200075F7:  00           DC.B       0x00                     ; '\0'
+  0x200075F8:  00           DC.B       0x00                     ; '\0'
+  0x200075F9:  00           DC.B       0x00                     ; '\0'
+  0x200075FA:  00           DC.B       0x00                     ; '\0'
+  0x200075FB:  00           DC.B       0x00                     ; '\0'
+  0x200075FC:  00           DC.B       0x00                     ; '\0'
+  0x200075FD:  00           DC.B       0x00                     ; '\0'
+  0x200075FE:  00           DC.B       0x00                     ; '\0'
+  0x200075FF:  00           DC.B       0x00                     ; '\0'
+  0x20007600:  00           DC.B       0x00                     ; '\0'
+  0x20007601:  00           DC.B       0x00                     ; '\0'
+  0x20007602:  00           DC.B       0x00                     ; '\0'
+  0x20007603:  00           DC.B       0x00                     ; '\0'
+  0x20007604:  00           DC.B       0x00                     ; '\0'
+  0x20007605:  00           DC.B       0x00                     ; '\0'
+  0x20007606:  00           DC.B       0x00                     ; '\0'
+  0x20007607:  00           DC.B       0x00                     ; '\0'
+  0x20007608:  00           DC.B       0x00                     ; '\0'
+  0x20007609:  00           DC.B       0x00                     ; '\0'
+  0x2000760A:  00           DC.B       0x00                     ; '\0'
+  0x2000760B:  00           DC.B       0x00                     ; '\0'
+  0x2000760C:  00           DC.B       0x00                     ; '\0'
+  0x2000760D:  00           DC.B       0x00                     ; '\0'
+  0x2000760E:  00           DC.B       0x00                     ; '\0'
+  0x2000760F:  00           DC.B       0x00                     ; '\0'
+  0x20007610:  00           DC.B       0x00                     ; '\0'
+  0x20007611:  00           DC.B       0x00                     ; '\0'
+  0x20007612:  00           DC.B       0x00                     ; '\0'
+  0x20007613:  00           DC.B       0x00                     ; '\0'
+  0x20007614:  00           DC.B       0x00                     ; '\0'
+  0x20007615:  00           DC.B       0x00                     ; '\0'
+  0x20007616:  00           DC.B       0x00                     ; '\0'
+  0x20007617:  00           DC.B       0x00                     ; '\0'
+  0x20007618:  00           DC.B       0x00                     ; '\0'
+  0x20007619:  00           DC.B       0x00                     ; '\0'
+  0x2000761A:  00           DC.B       0x00                     ; '\0'
+  0x2000761B:  00           DC.B       0x00                     ; '\0'
+  0x2000761C:  00           DC.B       0x00                     ; '\0'
+  0x2000761D:  00           DC.B       0x00                     ; '\0'
+  0x2000761E:  00           DC.B       0x00                     ; '\0'
+  0x2000761F:  00           DC.B       0x00                     ; '\0'
+  0x20007620:  00           DC.B       0x00                     ; '\0'
+  0x20007621:  00           DC.B       0x00                     ; '\0'
+  0x20007622:  00           DC.B       0x00                     ; '\0'
+  0x20007623:  00           DC.B       0x00                     ; '\0'
+  0x20007624:  00           DC.B       0x00                     ; '\0'
+  0x20007625:  00           DC.B       0x00                     ; '\0'
+  0x20007626:  00           DC.B       0x00                     ; '\0'
+  0x20007627:  00           DC.B       0x00                     ; '\0'
+  0x20007628:  00           DC.B       0x00                     ; '\0'
+  0x20007629:  00           DC.B       0x00                     ; '\0'
+  0x2000762A:  00           DC.B       0x00                     ; '\0'
+  0x2000762B:  00           DC.B       0x00                     ; '\0'
+  0x2000762C:  00           DC.B       0x00                     ; '\0'
+  0x2000762D:  00           DC.B       0x00                     ; '\0'
+  0x2000762E:  00           DC.B       0x00                     ; '\0'
+  0x2000762F:  00           DC.B       0x00                     ; '\0'
+  0x20007630:  00           DC.B       0x00                     ; '\0'
+  0x20007631:  00           DC.B       0x00                     ; '\0'
+  0x20007632:  00           DC.B       0x00                     ; '\0'
+  0x20007633:  00           DC.B       0x00                     ; '\0'
+  0x20007634:  00           DC.B       0x00                     ; '\0'
+  0x20007635:  00           DC.B       0x00                     ; '\0'
+  0x20007636:  00           DC.B       0x00                     ; '\0'
+  0x20007637:  00           DC.B       0x00                     ; '\0'
+  0x20007638:  00           DC.B       0x00                     ; '\0'
+  0x20007639:  00           DC.B       0x00                     ; '\0'
+  0x2000763A:  00           DC.B       0x00                     ; '\0'
+  0x2000763B:  00           DC.B       0x00                     ; '\0'
+  0x2000763C:  00           DC.B       0x00                     ; '\0'
+  0x2000763D:  00           DC.B       0x00                     ; '\0'
+  0x2000763E:  00           DC.B       0x00                     ; '\0'
+  0x2000763F:  00           DC.B       0x00                     ; '\0'
+  0x20007640:  00           DC.B       0x00                     ; '\0'
+  0x20007641:  00           DC.B       0x00                     ; '\0'
+  0x20007642:  00           DC.B       0x00                     ; '\0'
+  0x20007643:  00           DC.B       0x00                     ; '\0'
+  0x20007644:  00           DC.B       0x00                     ; '\0'
+  0x20007645:  00           DC.B       0x00                     ; '\0'
+  0x20007646:  00           DC.B       0x00                     ; '\0'
+  0x20007647:  00           DC.B       0x00                     ; '\0'
+  0x20007648:  00           DC.B       0x00                     ; '\0'
+  0x20007649:  00           DC.B       0x00                     ; '\0'
+  0x2000764A:  00           DC.B       0x00                     ; '\0'
+  0x2000764B:  00           DC.B       0x00                     ; '\0'
+  0x2000764C:  00           DC.B       0x00                     ; '\0'
+  0x2000764D:  00           DC.B       0x00                     ; '\0'
+  0x2000764E:  00           DC.B       0x00                     ; '\0'
+  0x2000764F:  00           DC.B       0x00                     ; '\0'
+  0x20007650:  00           DC.B       0x00                     ; '\0'
+  0x20007651:  00           DC.B       0x00                     ; '\0'
+  0x20007652:  00           DC.B       0x00                     ; '\0'
+  0x20007653:  00           DC.B       0x00                     ; '\0'
+  0x20007654:  00           DC.B       0x00                     ; '\0'
+  0x20007655:  00           DC.B       0x00                     ; '\0'
+  0x20007656:  00           DC.B       0x00                     ; '\0'
+  0x20007657:  00           DC.B       0x00                     ; '\0'
+  0x20007658:  00           DC.B       0x00                     ; '\0'
+  0x20007659:  00           DC.B       0x00                     ; '\0'
+  0x2000765A:  00           DC.B       0x00                     ; '\0'
+  0x2000765B:  00           DC.B       0x00                     ; '\0'
+  0x2000765C:  00           DC.B       0x00                     ; '\0'
+  0x2000765D:  00           DC.B       0x00                     ; '\0'
+  0x2000765E:  00           DC.B       0x00                     ; '\0'
+  0x2000765F:  00           DC.B       0x00                     ; '\0'
+  0x20007660:  00           DC.B       0x00                     ; '\0'
+  0x20007661:  00           DC.B       0x00                     ; '\0'
+  0x20007662:  00           DC.B       0x00                     ; '\0'
+  0x20007663:  00           DC.B       0x00                     ; '\0'
+  0x20007664:  00           DC.B       0x00                     ; '\0'
+  0x20007665:  00           DC.B       0x00                     ; '\0'
+  0x20007666:  00           DC.B       0x00                     ; '\0'
+  0x20007667:  00           DC.B       0x00                     ; '\0'
+  0x20007668:  00           DC.B       0x00                     ; '\0'
+  0x20007669:  00           DC.B       0x00                     ; '\0'
+  0x2000766A:  00           DC.B       0x00                     ; '\0'
+  0x2000766B:  00           DC.B       0x00                     ; '\0'
+  0x2000766C:  00           DC.B       0x00                     ; '\0'
+  0x2000766D:  00           DC.B       0x00                     ; '\0'
+  0x2000766E:  00           DC.B       0x00                     ; '\0'
+  0x2000766F:  00           DC.B       0x00                     ; '\0'
+  0x20007670:  00           DC.B       0x00                     ; '\0'
+  0x20007671:  00           DC.B       0x00                     ; '\0'
+  0x20007672:  00           DC.B       0x00                     ; '\0'
+  0x20007673:  00           DC.B       0x00                     ; '\0'
+  0x20007674:  00           DC.B       0x00                     ; '\0'
+  0x20007675:  00           DC.B       0x00                     ; '\0'
+  0x20007676:  00           DC.B       0x00                     ; '\0'
+  0x20007677:  00           DC.B       0x00                     ; '\0'
+  0x20007678:  00           DC.B       0x00                     ; '\0'
+  0x20007679:  00           DC.B       0x00                     ; '\0'
+  0x2000767A:  00           DC.B       0x00                     ; '\0'
+  0x2000767B:  00           DC.B       0x00                     ; '\0'
+  0x2000767C:  00           DC.B       0x00                     ; '\0'
+  0x2000767D:  00           DC.B       0x00                     ; '\0'
+  0x2000767E:  00           DC.B       0x00                     ; '\0'
+  0x2000767F:  00           DC.B       0x00                     ; '\0'
+  0x20007680:  00           DC.B       0x00                     ; '\0'
+  0x20007681:  00           DC.B       0x00                     ; '\0'
+  0x20007682:  00           DC.B       0x00                     ; '\0'
+  0x20007683:  00           DC.B       0x00                     ; '\0'
+  0x20007684:  00           DC.B       0x00                     ; '\0'
+  0x20007685:  00           DC.B       0x00                     ; '\0'
+  0x20007686:  00           DC.B       0x00                     ; '\0'
+  0x20007687:  00           DC.B       0x00                     ; '\0'
+  0x20007688:  00           DC.B       0x00                     ; '\0'
+  0x20007689:  00           DC.B       0x00                     ; '\0'
+  0x2000768A:  00           DC.B       0x00                     ; '\0'
+  0x2000768B:  00           DC.B       0x00                     ; '\0'
+  0x2000768C:  00           DC.B       0x00                     ; '\0'
+  0x2000768D:  00           DC.B       0x00                     ; '\0'
+  0x2000768E:  00           DC.B       0x00                     ; '\0'
+  0x2000768F:  00           DC.B       0x00                     ; '\0'
+  0x20007690:  00           DC.B       0x00                     ; '\0'
+  0x20007691:  00           DC.B       0x00                     ; '\0'
+  0x20007692:  00           DC.B       0x00                     ; '\0'
+  0x20007693:  00           DC.B       0x00                     ; '\0'
+  0x20007694:  00           DC.B       0x00                     ; '\0'
+  0x20007695:  00           DC.B       0x00                     ; '\0'
+  0x20007696:  00           DC.B       0x00                     ; '\0'
+  0x20007697:  00           DC.B       0x00                     ; '\0'
+  0x20007698:  00           DC.B       0x00                     ; '\0'
+  0x20007699:  00           DC.B       0x00                     ; '\0'
+  0x2000769A:  00           DC.B       0x00                     ; '\0'
+  0x2000769B:  00           DC.B       0x00                     ; '\0'
+  0x2000769C:  00           DC.B       0x00                     ; '\0'
+  0x2000769D:  00           DC.B       0x00                     ; '\0'
+  0x2000769E:  00           DC.B       0x00                     ; '\0'
+  0x2000769F:  00           DC.B       0x00                     ; '\0'
+  0x200076A0:  00           DC.B       0x00                     ; '\0'
+  0x200076A1:  00           DC.B       0x00                     ; '\0'
+  0x200076A2:  00           DC.B       0x00                     ; '\0'
+  0x200076A3:  00           DC.B       0x00                     ; '\0'
+  0x200076A4:  00           DC.B       0x00                     ; '\0'
+  0x200076A5:  00           DC.B       0x00                     ; '\0'
+  0x200076A6:  00           DC.B       0x00                     ; '\0'
+  0x200076A7:  00           DC.B       0x00                     ; '\0'
+  0x200076A8:  00           DC.B       0x00                     ; '\0'
+  0x200076A9:  00           DC.B       0x00                     ; '\0'
+  0x200076AA:  00           DC.B       0x00                     ; '\0'
+  0x200076AB:  00           DC.B       0x00                     ; '\0'
+  0x200076AC:  00           DC.B       0x00                     ; '\0'
+  0x200076AD:  00           DC.B       0x00                     ; '\0'
+  0x200076AE:  00           DC.B       0x00                     ; '\0'
+  0x200076AF:  00           DC.B       0x00                     ; '\0'
+  0x200076B0:  00           DC.B       0x00                     ; '\0'
+  0x200076B1:  00           DC.B       0x00                     ; '\0'
+  0x200076B2:  00           DC.B       0x00                     ; '\0'
+  0x200076B3:  00           DC.B       0x00                     ; '\0'
+  0x200076B4:  00           DC.B       0x00                     ; '\0'
+  0x200076B5:  00           DC.B       0x00                     ; '\0'
+  0x200076B6:  00           DC.B       0x00                     ; '\0'
+  0x200076B7:  00           DC.B       0x00                     ; '\0'
+  0x200076B8:  00           DC.B       0x00                     ; '\0'
+  0x200076B9:  00           DC.B       0x00                     ; '\0'
+  0x200076BA:  00           DC.B       0x00                     ; '\0'
+  0x200076BB:  00           DC.B       0x00                     ; '\0'
+  0x200076BC:  00           DC.B       0x00                     ; '\0'
+  0x200076BD:  00           DC.B       0x00                     ; '\0'
+  0x200076BE:  00           DC.B       0x00                     ; '\0'
+  0x200076BF:  00           DC.B       0x00                     ; '\0'
+  0x200076C0:  00           DC.B       0x00                     ; '\0'
+  0x200076C1:  00           DC.B       0x00                     ; '\0'
+  0x200076C2:  00           DC.B       0x00                     ; '\0'
+  0x200076C3:  00           DC.B       0x00                     ; '\0'
+  0x200076C4:  00           DC.B       0x00                     ; '\0'
+  0x200076C5:  00           DC.B       0x00                     ; '\0'
+  0x200076C6:  00           DC.B       0x00                     ; '\0'
+  0x200076C7:  00           DC.B       0x00                     ; '\0'
+  0x200076C8:  00           DC.B       0x00                     ; '\0'
+  0x200076C9:  00           DC.B       0x00                     ; '\0'
+  0x200076CA:  00           DC.B       0x00                     ; '\0'
+  0x200076CB:  00           DC.B       0x00                     ; '\0'
+  0x200076CC:  00           DC.B       0x00                     ; '\0'
+  0x200076CD:  00           DC.B       0x00                     ; '\0'
+  0x200076CE:  00           DC.B       0x00                     ; '\0'
+  0x200076CF:  00           DC.B       0x00                     ; '\0'
+  0x200076D0:  00           DC.B       0x00                     ; '\0'
+  0x200076D1:  00           DC.B       0x00                     ; '\0'
+  0x200076D2:  00           DC.B       0x00                     ; '\0'
+  0x200076D3:  00           DC.B       0x00                     ; '\0'
+  0x200076D4:  00           DC.B       0x00                     ; '\0'
+  0x200076D5:  00           DC.B       0x00                     ; '\0'
+  0x200076D6:  00           DC.B       0x00                     ; '\0'
+  0x200076D7:  00           DC.B       0x00                     ; '\0'
+  0x200076D8:  00           DC.B       0x00                     ; '\0'
+  0x200076D9:  00           DC.B       0x00                     ; '\0'
+  0x200076DA:  00           DC.B       0x00                     ; '\0'
+  0x200076DB:  00           DC.B       0x00                     ; '\0'
+  0x200076DC:  00           DC.B       0x00                     ; '\0'
+  0x200076DD:  00           DC.B       0x00                     ; '\0'
+  0x200076DE:  00           DC.B       0x00                     ; '\0'
+  0x200076DF:  00           DC.B       0x00                     ; '\0'
+  0x200076E0:  00           DC.B       0x00                     ; '\0'
+  0x200076E1:  00           DC.B       0x00                     ; '\0'
+  0x200076E2:  00           DC.B       0x00                     ; '\0'
+  0x200076E3:  00           DC.B       0x00                     ; '\0'
+  0x200076E4:  00           DC.B       0x00                     ; '\0'
+  0x200076E5:  00           DC.B       0x00                     ; '\0'
+  0x200076E6:  00           DC.B       0x00                     ; '\0'
+  0x200076E7:  00           DC.B       0x00                     ; '\0'
+  0x200076E8:  00           DC.B       0x00                     ; '\0'
+  0x200076E9:  00           DC.B       0x00                     ; '\0'
+  0x200076EA:  00           DC.B       0x00                     ; '\0'
+  0x200076EB:  00           DC.B       0x00                     ; '\0'
+  0x200076EC:  00           DC.B       0x00                     ; '\0'
+  0x200076ED:  00           DC.B       0x00                     ; '\0'
+  0x200076EE:  00           DC.B       0x00                     ; '\0'
+  0x200076EF:  00           DC.B       0x00                     ; '\0'
+  0x200076F0:  00           DC.B       0x00                     ; '\0'
+  0x200076F1:  00           DC.B       0x00                     ; '\0'
+  0x200076F2:  00           DC.B       0x00                     ; '\0'
+  0x200076F3:  00           DC.B       0x00                     ; '\0'
+  0x200076F4:  00           DC.B       0x00                     ; '\0'
+  0x200076F5:  00           DC.B       0x00                     ; '\0'
+  0x200076F6:  00           DC.B       0x00                     ; '\0'
+  0x200076F7:  00           DC.B       0x00                     ; '\0'
+  0x200076F8:  00           DC.B       0x00                     ; '\0'
+  0x200076F9:  00           DC.B       0x00                     ; '\0'
+  0x200076FA:  00           DC.B       0x00                     ; '\0'
+  0x200076FB:  00           DC.B       0x00                     ; '\0'
+  0x200076FC:  00           DC.B       0x00                     ; '\0'
+  0x200076FD:  00           DC.B       0x00                     ; '\0'
+  0x200076FE:  00           DC.B       0x00                     ; '\0'
+  0x200076FF:  00           DC.B       0x00                     ; '\0'
+  0x20007700:  00           DC.B       0x00                     ; '\0'
+  0x20007701:  00           DC.B       0x00                     ; '\0'
+  0x20007702:  00           DC.B       0x00                     ; '\0'
+  0x20007703:  00           DC.B       0x00                     ; '\0'
+  0x20007704:  00           DC.B       0x00                     ; '\0'
+  0x20007705:  00           DC.B       0x00                     ; '\0'
+  0x20007706:  00           DC.B       0x00                     ; '\0'
+  0x20007707:  00           DC.B       0x00                     ; '\0'
+  0x20007708:  00           DC.B       0x00                     ; '\0'
+  0x20007709:  00           DC.B       0x00                     ; '\0'
+  0x2000770A:  00           DC.B       0x00                     ; '\0'
+  0x2000770B:  00           DC.B       0x00                     ; '\0'
+  0x2000770C:  00           DC.B       0x00                     ; '\0'
+  0x2000770D:  00           DC.B       0x00                     ; '\0'
+  0x2000770E:  00           DC.B       0x00                     ; '\0'
+  0x2000770F:  00           DC.B       0x00                     ; '\0'
+  0x20007710:  00           DC.B       0x00                     ; '\0'
+  0x20007711:  00           DC.B       0x00                     ; '\0'
+  0x20007712:  00           DC.B       0x00                     ; '\0'
+  0x20007713:  00           DC.B       0x00                     ; '\0'
+  0x20007714:  00           DC.B       0x00                     ; '\0'
+  0x20007715:  00           DC.B       0x00                     ; '\0'
+  0x20007716:  00           DC.B       0x00                     ; '\0'
+  0x20007717:  00           DC.B       0x00                     ; '\0'
+  0x20007718:  00           DC.B       0x00                     ; '\0'
+  0x20007719:  00           DC.B       0x00                     ; '\0'
+  0x2000771A:  00           DC.B       0x00                     ; '\0'
+  0x2000771B:  00           DC.B       0x00                     ; '\0'
+  0x2000771C:  00           DC.B       0x00                     ; '\0'
+  0x2000771D:  00           DC.B       0x00                     ; '\0'
+  0x2000771E:  00           DC.B       0x00                     ; '\0'
+  0x2000771F:  00           DC.B       0x00                     ; '\0'
+  0x20007720:  00           DC.B       0x00                     ; '\0'
+  0x20007721:  00           DC.B       0x00                     ; '\0'
+  0x20007722:  00           DC.B       0x00                     ; '\0'
+  0x20007723:  00           DC.B       0x00                     ; '\0'
+  0x20007724:  00           DC.B       0x00                     ; '\0'
+  0x20007725:  00           DC.B       0x00                     ; '\0'
+  0x20007726:  00           DC.B       0x00                     ; '\0'
+  0x20007727:  00           DC.B       0x00                     ; '\0'
+  0x20007728:  00           DC.B       0x00                     ; '\0'
+  0x20007729:  00           DC.B       0x00                     ; '\0'
+  0x2000772A:  00           DC.B       0x00                     ; '\0'
+  0x2000772B:  00           DC.B       0x00                     ; '\0'
+  0x2000772C:  00           DC.B       0x00                     ; '\0'
+  0x2000772D:  00           DC.B       0x00                     ; '\0'
+  0x2000772E:  00           DC.B       0x00                     ; '\0'
+  0x2000772F:  00           DC.B       0x00                     ; '\0'
+  0x20007730:  00           DC.B       0x00                     ; '\0'
+  0x20007731:  00           DC.B       0x00                     ; '\0'
+  0x20007732:  00           DC.B       0x00                     ; '\0'
+  0x20007733:  00           DC.B       0x00                     ; '\0'
+  0x20007734:  00           DC.B       0x00                     ; '\0'
+  0x20007735:  00           DC.B       0x00                     ; '\0'
+  0x20007736:  00           DC.B       0x00                     ; '\0'
+  0x20007737:  00           DC.B       0x00                     ; '\0'
+  0x20007738:  00           DC.B       0x00                     ; '\0'
+  0x20007739:  00           DC.B       0x00                     ; '\0'
+  0x2000773A:  00           DC.B       0x00                     ; '\0'
+  0x2000773B:  00           DC.B       0x00                     ; '\0'
+  0x2000773C:  00           DC.B       0x00                     ; '\0'
+  0x2000773D:  00           DC.B       0x00                     ; '\0'
+  0x2000773E:  00           DC.B       0x00                     ; '\0'
+  0x2000773F:  00           DC.B       0x00                     ; '\0'
+  0x20007740:  00           DC.B       0x00                     ; '\0'
+  0x20007741:  00           DC.B       0x00                     ; '\0'
+  0x20007742:  00           DC.B       0x00                     ; '\0'
+  0x20007743:  00           DC.B       0x00                     ; '\0'
+  0x20007744:  00           DC.B       0x00                     ; '\0'
+  0x20007745:  00           DC.B       0x00                     ; '\0'
+  0x20007746:  00           DC.B       0x00                     ; '\0'
+  0x20007747:  00           DC.B       0x00                     ; '\0'
+  0x20007748:  00           DC.B       0x00                     ; '\0'
+  0x20007749:  00           DC.B       0x00                     ; '\0'
+  0x2000774A:  00           DC.B       0x00                     ; '\0'
+  0x2000774B:  00           DC.B       0x00                     ; '\0'
+  0x2000774C:  00           DC.B       0x00                     ; '\0'
+  0x2000774D:  00           DC.B       0x00                     ; '\0'
+  0x2000774E:  00           DC.B       0x00                     ; '\0'
+  0x2000774F:  00           DC.B       0x00                     ; '\0'
+  0x20007750:  00           DC.B       0x00                     ; '\0'
+  0x20007751:  00           DC.B       0x00                     ; '\0'
+  0x20007752:  00           DC.B       0x00                     ; '\0'
+  0x20007753:  00           DC.B       0x00                     ; '\0'
+  0x20007754:  00           DC.B       0x00                     ; '\0'
+  0x20007755:  00           DC.B       0x00                     ; '\0'
+  0x20007756:  00           DC.B       0x00                     ; '\0'
+  0x20007757:  00           DC.B       0x00                     ; '\0'
+  0x20007758:  00           DC.B       0x00                     ; '\0'
+  0x20007759:  00           DC.B       0x00                     ; '\0'
+  0x2000775A:  00           DC.B       0x00                     ; '\0'
+  0x2000775B:  00           DC.B       0x00                     ; '\0'
+  0x2000775C:  00           DC.B       0x00                     ; '\0'
+  0x2000775D:  00           DC.B       0x00                     ; '\0'
+  0x2000775E:  00           DC.B       0x00                     ; '\0'
+  0x2000775F:  00           DC.B       0x00                     ; '\0'
+  0x20007760:  00           DC.B       0x00                     ; '\0'
+  0x20007761:  00           DC.B       0x00                     ; '\0'
+  0x20007762:  00           DC.B       0x00                     ; '\0'
+  0x20007763:  00           DC.B       0x00                     ; '\0'
+  0x20007764:  00           DC.B       0x00                     ; '\0'
+  0x20007765:  00           DC.B       0x00                     ; '\0'
+  0x20007766:  00           DC.B       0x00                     ; '\0'
+  0x20007767:  00           DC.B       0x00                     ; '\0'
+  0x20007768:  00           DC.B       0x00                     ; '\0'
+  0x20007769:  00           DC.B       0x00                     ; '\0'
+  0x2000776A:  00           DC.B       0x00                     ; '\0'
+  0x2000776B:  00           DC.B       0x00                     ; '\0'
+  0x2000776C:  00           DC.B       0x00                     ; '\0'
+  0x2000776D:  00           DC.B       0x00                     ; '\0'
+  0x2000776E:  00           DC.B       0x00                     ; '\0'
+  0x2000776F:  00           DC.B       0x00                     ; '\0'
+  0x20007770:  00           DC.B       0x00                     ; '\0'
+  0x20007771:  00           DC.B       0x00                     ; '\0'
+  0x20007772:  00           DC.B       0x00                     ; '\0'
+  0x20007773:  00           DC.B       0x00                     ; '\0'
+  0x20007774:  00           DC.B       0x00                     ; '\0'
+  0x20007775:  00           DC.B       0x00                     ; '\0'
+  0x20007776:  00           DC.B       0x00                     ; '\0'
+  0x20007777:  00           DC.B       0x00                     ; '\0'
+  0x20007778:  00           DC.B       0x00                     ; '\0'
+  0x20007779:  00           DC.B       0x00                     ; '\0'
+  0x2000777A:  00           DC.B       0x00                     ; '\0'
+  0x2000777B:  00           DC.B       0x00                     ; '\0'
+  0x2000777C:  00           DC.B       0x00                     ; '\0'
+  0x2000777D:  00           DC.B       0x00                     ; '\0'
+  0x2000777E:  00           DC.B       0x00                     ; '\0'
+  0x2000777F:  00           DC.B       0x00                     ; '\0'
+  0x20007780:  00           DC.B       0x00                     ; '\0'
+  0x20007781:  00           DC.B       0x00                     ; '\0'
+  0x20007782:  00           DC.B       0x00                     ; '\0'
+  0x20007783:  00           DC.B       0x00                     ; '\0'
+  0x20007784:  00           DC.B       0x00                     ; '\0'
+  0x20007785:  00           DC.B       0x00                     ; '\0'
+  0x20007786:  00           DC.B       0x00                     ; '\0'
+  0x20007787:  00           DC.B       0x00                     ; '\0'
+  0x20007788:  00           DC.B       0x00                     ; '\0'
+  0x20007789:  00           DC.B       0x00                     ; '\0'
+  0x2000778A:  00           DC.B       0x00                     ; '\0'
+  0x2000778B:  00           DC.B       0x00                     ; '\0'
+  0x2000778C:  00           DC.B       0x00                     ; '\0'
+  0x2000778D:  00           DC.B       0x00                     ; '\0'
+  0x2000778E:  00           DC.B       0x00                     ; '\0'
+  0x2000778F:  00           DC.B       0x00                     ; '\0'
+  0x20007790:  00           DC.B       0x00                     ; '\0'
+  0x20007791:  00           DC.B       0x00                     ; '\0'
+  0x20007792:  00           DC.B       0x00                     ; '\0'
+  0x20007793:  00           DC.B       0x00                     ; '\0'
+  0x20007794:  00           DC.B       0x00                     ; '\0'
+  0x20007795:  00           DC.B       0x00                     ; '\0'
+  0x20007796:  00           DC.B       0x00                     ; '\0'
+  0x20007797:  00           DC.B       0x00                     ; '\0'
+  0x20007798:  00           DC.B       0x00                     ; '\0'
+  0x20007799:  00           DC.B       0x00                     ; '\0'
+  0x2000779A:  00           DC.B       0x00                     ; '\0'
+  0x2000779B:  00           DC.B       0x00                     ; '\0'
+  0x2000779C:  00           DC.B       0x00                     ; '\0'
+  0x2000779D:  00           DC.B       0x00                     ; '\0'
+  0x2000779E:  00           DC.B       0x00                     ; '\0'
+  0x2000779F:  00           DC.B       0x00                     ; '\0'
+  0x200077A0:  00           DC.B       0x00                     ; '\0'
+  0x200077A1:  00           DC.B       0x00                     ; '\0'
+  0x200077A2:  00           DC.B       0x00                     ; '\0'
+  0x200077A3:  00           DC.B       0x00                     ; '\0'
+  0x200077A4:  00           DC.B       0x00                     ; '\0'
+  0x200077A5:  00           DC.B       0x00                     ; '\0'
+  0x200077A6:  00           DC.B       0x00                     ; '\0'
+  0x200077A7:  00           DC.B       0x00                     ; '\0'
+  0x200077A8:  00           DC.B       0x00                     ; '\0'
+  0x200077A9:  00           DC.B       0x00                     ; '\0'
+  0x200077AA:  00           DC.B       0x00                     ; '\0'
+  0x200077AB:  00           DC.B       0x00                     ; '\0'
+  0x200077AC:  00           DC.B       0x00                     ; '\0'
+  0x200077AD:  00           DC.B       0x00                     ; '\0'
+  0x200077AE:  00           DC.B       0x00                     ; '\0'
+  0x200077AF:  00           DC.B       0x00                     ; '\0'
+  0x200077B0:  00           DC.B       0x00                     ; '\0'
+  0x200077B1:  00           DC.B       0x00                     ; '\0'
+  0x200077B2:  00           DC.B       0x00                     ; '\0'
+  0x200077B3:  00           DC.B       0x00                     ; '\0'
+  0x200077B4:  00           DC.B       0x00                     ; '\0'
+  0x200077B5:  00           DC.B       0x00                     ; '\0'
+  0x200077B6:  00           DC.B       0x00                     ; '\0'
+  0x200077B7:  00           DC.B       0x00                     ; '\0'
+  0x200077B8:  00           DC.B       0x00                     ; '\0'
+  0x200077B9:  00           DC.B       0x00                     ; '\0'
+  0x200077BA:  00           DC.B       0x00                     ; '\0'
+  0x200077BB:  00           DC.B       0x00                     ; '\0'
+  0x200077BC:  00           DC.B       0x00                     ; '\0'
+  0x200077BD:  00           DC.B       0x00                     ; '\0'
+  0x200077BE:  00           DC.B       0x00                     ; '\0'
+  0x200077BF:  00           DC.B       0x00                     ; '\0'
+  0x200077C0:  00           DC.B       0x00                     ; '\0'
+  0x200077C1:  00           DC.B       0x00                     ; '\0'
+  0x200077C2:  00           DC.B       0x00                     ; '\0'
+  0x200077C3:  00           DC.B       0x00                     ; '\0'
+  0x200077C4:  00           DC.B       0x00                     ; '\0'
+  0x200077C5:  00           DC.B       0x00                     ; '\0'
+  0x200077C6:  00           DC.B       0x00                     ; '\0'
+  0x200077C7:  00           DC.B       0x00                     ; '\0'
+  0x200077C8:  00           DC.B       0x00                     ; '\0'
+  0x200077C9:  00           DC.B       0x00                     ; '\0'
+  0x200077CA:  00           DC.B       0x00                     ; '\0'
+  0x200077CB:  00           DC.B       0x00                     ; '\0'
+  0x200077CC:  00           DC.B       0x00                     ; '\0'
+  0x200077CD:  00           DC.B       0x00                     ; '\0'
+  0x200077CE:  00           DC.B       0x00                     ; '\0'
+  0x200077CF:  00           DC.B       0x00                     ; '\0'
+  0x200077D0:  00           DC.B       0x00                     ; '\0'
+  0x200077D1:  00           DC.B       0x00                     ; '\0'
+  0x200077D2:  00           DC.B       0x00                     ; '\0'
+  0x200077D3:  00           DC.B       0x00                     ; '\0'
+  0x200077D4:  00           DC.B       0x00                     ; '\0'
+  0x200077D5:  00           DC.B       0x00                     ; '\0'
+  0x200077D6:  00           DC.B       0x00                     ; '\0'
+  0x200077D7:  00           DC.B       0x00                     ; '\0'
+  0x200077D8:  00           DC.B       0x00                     ; '\0'
+  0x200077D9:  00           DC.B       0x00                     ; '\0'
+  0x200077DA:  00           DC.B       0x00                     ; '\0'
+  0x200077DB:  00           DC.B       0x00                     ; '\0'
+  0x200077DC:  00           DC.B       0x00                     ; '\0'
+  0x200077DD:  00           DC.B       0x00                     ; '\0'
+  0x200077DE:  00           DC.B       0x00                     ; '\0'
+  0x200077DF:  00           DC.B       0x00                     ; '\0'
+  0x200077E0:  00           DC.B       0x00                     ; '\0'
+  0x200077E1:  00           DC.B       0x00                     ; '\0'
+  0x200077E2:  00           DC.B       0x00                     ; '\0'
+  0x200077E3:  00           DC.B       0x00                     ; '\0'
+  0x200077E4:  00           DC.B       0x00                     ; '\0'
+  0x200077E5:  00           DC.B       0x00                     ; '\0'
+  0x200077E6:  00           DC.B       0x00                     ; '\0'
+  0x200077E7:  00           DC.B       0x00                     ; '\0'
+  0x200077E8:  00           DC.B       0x00                     ; '\0'
+  0x200077E9:  00           DC.B       0x00                     ; '\0'
+  0x200077EA:  00           DC.B       0x00                     ; '\0'
+  0x200077EB:  00           DC.B       0x00                     ; '\0'
+  0x200077EC:  00           DC.B       0x00                     ; '\0'
+  0x200077ED:  00           DC.B       0x00                     ; '\0'
+  0x200077EE:  00           DC.B       0x00                     ; '\0'
+  0x200077EF:  00           DC.B       0x00                     ; '\0'
+  0x200077F0:  00           DC.B       0x00                     ; '\0'
+  0x200077F1:  00           DC.B       0x00                     ; '\0'
+  0x200077F2:  00           DC.B       0x00                     ; '\0'
+  0x200077F3:  00           DC.B       0x00                     ; '\0'
+  0x200077F4:  00           DC.B       0x00                     ; '\0'
+  0x200077F5:  00           DC.B       0x00                     ; '\0'
+  0x200077F6:  00           DC.B       0x00                     ; '\0'
+  0x200077F7:  00           DC.B       0x00                     ; '\0'
+  0x200077F8:  00           DC.B       0x00                     ; '\0'
+  0x200077F9:  00           DC.B       0x00                     ; '\0'
+  0x200077FA:  00           DC.B       0x00                     ; '\0'
+  0x200077FB:  00           DC.B       0x00                     ; '\0'
+  0x200077FC:  00           DC.B       0x00                     ; '\0'
+  0x200077FD:  00           DC.B       0x00                     ; '\0'
+  0x200077FE:  00           DC.B       0x00                     ; '\0'
+  0x200077FF:  00           DC.B       0x00                     ; '\0'
+  0x20007800:  00           DC.B       0x00                     ; '\0'
+  0x20007801:  00           DC.B       0x00                     ; '\0'
+  0x20007802:  00           DC.B       0x00                     ; '\0'
+  0x20007803:  00           DC.B       0x00                     ; '\0'
+  0x20007804:  00           DC.B       0x00                     ; '\0'
+  0x20007805:  00           DC.B       0x00                     ; '\0'
+  0x20007806:  00           DC.B       0x00                     ; '\0'
+  0x20007807:  00           DC.B       0x00                     ; '\0'
+  0x20007808:  00           DC.B       0x00                     ; '\0'
+  0x20007809:  00           DC.B       0x00                     ; '\0'
+  0x2000780A:  00           DC.B       0x00                     ; '\0'
+  0x2000780B:  00           DC.B       0x00                     ; '\0'
+  0x2000780C:  00           DC.B       0x00                     ; '\0'
+  0x2000780D:  00           DC.B       0x00                     ; '\0'
+  0x2000780E:  00           DC.B       0x00                     ; '\0'
+  0x2000780F:  00           DC.B       0x00                     ; '\0'
+  0x20007810:  00           DC.B       0x00                     ; '\0'
+  0x20007811:  00           DC.B       0x00                     ; '\0'
+  0x20007812:  00           DC.B       0x00                     ; '\0'
+  0x20007813:  00           DC.B       0x00                     ; '\0'
+  0x20007814:  00           DC.B       0x00                     ; '\0'
+  0x20007815:  00           DC.B       0x00                     ; '\0'
+  0x20007816:  00           DC.B       0x00                     ; '\0'
+  0x20007817:  00           DC.B       0x00                     ; '\0'
+  0x20007818:  00           DC.B       0x00                     ; '\0'
+  0x20007819:  00           DC.B       0x00                     ; '\0'
+  0x2000781A:  00           DC.B       0x00                     ; '\0'
+  0x2000781B:  00           DC.B       0x00                     ; '\0'
+  0x2000781C:  00           DC.B       0x00                     ; '\0'
+  0x2000781D:  00           DC.B       0x00                     ; '\0'
+  0x2000781E:  00           DC.B       0x00                     ; '\0'
+  0x2000781F:  00           DC.B       0x00                     ; '\0'
+  0x20007820:  00           DC.B       0x00                     ; '\0'
+  0x20007821:  00           DC.B       0x00                     ; '\0'
+  0x20007822:  00           DC.B       0x00                     ; '\0'
+  0x20007823:  00           DC.B       0x00                     ; '\0'
+  0x20007824:  00           DC.B       0x00                     ; '\0'
+  0x20007825:  00           DC.B       0x00                     ; '\0'
+  0x20007826:  00           DC.B       0x00                     ; '\0'
+  0x20007827:  00           DC.B       0x00                     ; '\0'
+  0x20007828:  00           DC.B       0x00                     ; '\0'
+  0x20007829:  00           DC.B       0x00                     ; '\0'
+  0x2000782A:  00           DC.B       0x00                     ; '\0'
+  0x2000782B:  00           DC.B       0x00                     ; '\0'
+  0x2000782C:  00           DC.B       0x00                     ; '\0'
+  0x2000782D:  00           DC.B       0x00                     ; '\0'
+  0x2000782E:  00           DC.B       0x00                     ; '\0'
+  0x2000782F:  00           DC.B       0x00                     ; '\0'
+  0x20007830:  00           DC.B       0x00                     ; '\0'
+  0x20007831:  00           DC.B       0x00                     ; '\0'
+  0x20007832:  00           DC.B       0x00                     ; '\0'
+  0x20007833:  00           DC.B       0x00                     ; '\0'
+  0x20007834:  00           DC.B       0x00                     ; '\0'
+  0x20007835:  00           DC.B       0x00                     ; '\0'
+  0x20007836:  00           DC.B       0x00                     ; '\0'
+  0x20007837:  00           DC.B       0x00                     ; '\0'
+  0x20007838:  00           DC.B       0x00                     ; '\0'
+  0x20007839:  00           DC.B       0x00                     ; '\0'
+  0x2000783A:  00           DC.B       0x00                     ; '\0'
+  0x2000783B:  00           DC.B       0x00                     ; '\0'
+  0x2000783C:  00           DC.B       0x00                     ; '\0'
+  0x2000783D:  00           DC.B       0x00                     ; '\0'
+  0x2000783E:  00           DC.B       0x00                     ; '\0'
+  0x2000783F:  00           DC.B       0x00                     ; '\0'
+  0x20007840:  00           DC.B       0x00                     ; '\0'
+  0x20007841:  00           DC.B       0x00                     ; '\0'
+  0x20007842:  00           DC.B       0x00                     ; '\0'
+  0x20007843:  00           DC.B       0x00                     ; '\0'
+  0x20007844:  00           DC.B       0x00                     ; '\0'
+  0x20007845:  00           DC.B       0x00                     ; '\0'
+  0x20007846:  00           DC.B       0x00                     ; '\0'
+  0x20007847:  00           DC.B       0x00                     ; '\0'
+  0x20007848:  00           DC.B       0x00                     ; '\0'
+  0x20007849:  00           DC.B       0x00                     ; '\0'
+  0x2000784A:  00           DC.B       0x00                     ; '\0'
+  0x2000784B:  00           DC.B       0x00                     ; '\0'
+  0x2000784C:  00           DC.B       0x00                     ; '\0'
+  0x2000784D:  00           DC.B       0x00                     ; '\0'
+  0x2000784E:  00           DC.B       0x00                     ; '\0'
+  0x2000784F:  00           DC.B       0x00                     ; '\0'
+  0x20007850:  00           DC.B       0x00                     ; '\0'
+  0x20007851:  00           DC.B       0x00                     ; '\0'
+  0x20007852:  00           DC.B       0x00                     ; '\0'
+  0x20007853:  00           DC.B       0x00                     ; '\0'
+  0x20007854:  00           DC.B       0x00                     ; '\0'
+  0x20007855:  00           DC.B       0x00                     ; '\0'
+  0x20007856:  00           DC.B       0x00                     ; '\0'
+  0x20007857:  00           DC.B       0x00                     ; '\0'
+  0x20007858:  00           DC.B       0x00                     ; '\0'
+  0x20007859:  00           DC.B       0x00                     ; '\0'
+  0x2000785A:  00           DC.B       0x00                     ; '\0'
+  0x2000785B:  00           DC.B       0x00                     ; '\0'
+  0x2000785C:  00           DC.B       0x00                     ; '\0'
+  0x2000785D:  00           DC.B       0x00                     ; '\0'
+  0x2000785E:  00           DC.B       0x00                     ; '\0'
+  0x2000785F:  00           DC.B       0x00                     ; '\0'
+  0x20007860:  00           DC.B       0x00                     ; '\0'
+  0x20007861:  00           DC.B       0x00                     ; '\0'
+  0x20007862:  00           DC.B       0x00                     ; '\0'
+  0x20007863:  00           DC.B       0x00                     ; '\0'
+  0x20007864:  00           DC.B       0x00                     ; '\0'
+  0x20007865:  00           DC.B       0x00                     ; '\0'
+  0x20007866:  00           DC.B       0x00                     ; '\0'
+  0x20007867:  00           DC.B       0x00                     ; '\0'
+  0x20007868:  00           DC.B       0x00                     ; '\0'
+  0x20007869:  00           DC.B       0x00                     ; '\0'
+  0x2000786A:  00           DC.B       0x00                     ; '\0'
+  0x2000786B:  00           DC.B       0x00                     ; '\0'
+  0x2000786C:  00           DC.B       0x00                     ; '\0'
+  0x2000786D:  00           DC.B       0x00                     ; '\0'
+  0x2000786E:  00           DC.B       0x00                     ; '\0'
+  0x2000786F:  00           DC.B       0x00                     ; '\0'
+  0x20007870:  00           DC.B       0x00                     ; '\0'
+  0x20007871:  00           DC.B       0x00                     ; '\0'
+  0x20007872:  00           DC.B       0x00                     ; '\0'
+  0x20007873:  00           DC.B       0x00                     ; '\0'
+  0x20007874:  00           DC.B       0x00                     ; '\0'
+  0x20007875:  00           DC.B       0x00                     ; '\0'
+  0x20007876:  00           DC.B       0x00                     ; '\0'
+  0x20007877:  00           DC.B       0x00                     ; '\0'
+  0x20007878:  00           DC.B       0x00                     ; '\0'
+  0x20007879:  00           DC.B       0x00                     ; '\0'
+  0x2000787A:  00           DC.B       0x00                     ; '\0'
+  0x2000787B:  00           DC.B       0x00                     ; '\0'
+  0x2000787C:  00           DC.B       0x00                     ; '\0'
+  0x2000787D:  00           DC.B       0x00                     ; '\0'
+  0x2000787E:  00           DC.B       0x00                     ; '\0'
+  0x2000787F:  00           DC.B       0x00                     ; '\0'
+  0x20007880:  00           DC.B       0x00                     ; '\0'
+  0x20007881:  00           DC.B       0x00                     ; '\0'
+  0x20007882:  00           DC.B       0x00                     ; '\0'
+  0x20007883:  00           DC.B       0x00                     ; '\0'
+  0x20007884:  00           DC.B       0x00                     ; '\0'
+  0x20007885:  00           DC.B       0x00                     ; '\0'
+  0x20007886:  00           DC.B       0x00                     ; '\0'
+  0x20007887:  00           DC.B       0x00                     ; '\0'
+  0x20007888:  00           DC.B       0x00                     ; '\0'
+  0x20007889:  00           DC.B       0x00                     ; '\0'
+  0x2000788A:  00           DC.B       0x00                     ; '\0'
+  0x2000788B:  00           DC.B       0x00                     ; '\0'
+  0x2000788C:  00           DC.B       0x00                     ; '\0'
+  0x2000788D:  00           DC.B       0x00                     ; '\0'
+  0x2000788E:  00           DC.B       0x00                     ; '\0'
+  0x2000788F:  00           DC.B       0x00                     ; '\0'
+  0x20007890:  00           DC.B       0x00                     ; '\0'
+  0x20007891:  00           DC.B       0x00                     ; '\0'
+  0x20007892:  00           DC.B       0x00                     ; '\0'
+  0x20007893:  00           DC.B       0x00                     ; '\0'
+  0x20007894:  00           DC.B       0x00                     ; '\0'
+  0x20007895:  00           DC.B       0x00                     ; '\0'
+  0x20007896:  00           DC.B       0x00                     ; '\0'
+  0x20007897:  00           DC.B       0x00                     ; '\0'
+  0x20007898:  00           DC.B       0x00                     ; '\0'
+  0x20007899:  00           DC.B       0x00                     ; '\0'
+  0x2000789A:  00           DC.B       0x00                     ; '\0'
+  0x2000789B:  00           DC.B       0x00                     ; '\0'
+  0x2000789C:  00           DC.B       0x00                     ; '\0'
+  0x2000789D:  00           DC.B       0x00                     ; '\0'
+  0x2000789E:  00           DC.B       0x00                     ; '\0'
+  0x2000789F:  00           DC.B       0x00                     ; '\0'
+  0x200078A0:  00           DC.B       0x00                     ; '\0'
+  0x200078A1:  00           DC.B       0x00                     ; '\0'
+  0x200078A2:  00           DC.B       0x00                     ; '\0'
+  0x200078A3:  00           DC.B       0x00                     ; '\0'
+  0x200078A4:  00           DC.B       0x00                     ; '\0'
+  0x200078A5:  00           DC.B       0x00                     ; '\0'
+  0x200078A6:  00           DC.B       0x00                     ; '\0'
+  0x200078A7:  00           DC.B       0x00                     ; '\0'
+  0x200078A8:  00           DC.B       0x00                     ; '\0'
+  0x200078A9:  00           DC.B       0x00                     ; '\0'
+  0x200078AA:  00           DC.B       0x00                     ; '\0'
+  0x200078AB:  00           DC.B       0x00                     ; '\0'
+  0x200078AC:  00           DC.B       0x00                     ; '\0'
+  0x200078AD:  00           DC.B       0x00                     ; '\0'
+  0x200078AE:  00           DC.B       0x00                     ; '\0'
+  0x200078AF:  00           DC.B       0x00                     ; '\0'
+  0x200078B0:  00           DC.B       0x00                     ; '\0'
+  0x200078B1:  00           DC.B       0x00                     ; '\0'
+  0x200078B2:  00           DC.B       0x00                     ; '\0'
+  0x200078B3:  00           DC.B       0x00                     ; '\0'
+  0x200078B4:  00           DC.B       0x00                     ; '\0'
+  0x200078B5:  00           DC.B       0x00                     ; '\0'
+  0x200078B6:  00           DC.B       0x00                     ; '\0'
+  0x200078B7:  00           DC.B       0x00                     ; '\0'
+  0x200078B8:  00           DC.B       0x00                     ; '\0'
+  0x200078B9:  00           DC.B       0x00                     ; '\0'
+  0x200078BA:  00           DC.B       0x00                     ; '\0'
+  0x200078BB:  00           DC.B       0x00                     ; '\0'
+  0x200078BC:  00           DC.B       0x00                     ; '\0'
+  0x200078BD:  00           DC.B       0x00                     ; '\0'
+  0x200078BE:  00           DC.B       0x00                     ; '\0'
+  0x200078BF:  00           DC.B       0x00                     ; '\0'
+  0x200078C0:  00           DC.B       0x00                     ; '\0'
+  0x200078C1:  00           DC.B       0x00                     ; '\0'
+  0x200078C2:  00           DC.B       0x00                     ; '\0'
+  0x200078C3:  00           DC.B       0x00                     ; '\0'
+  0x200078C4:  00           DC.B       0x00                     ; '\0'
+  0x200078C5:  00           DC.B       0x00                     ; '\0'
+  0x200078C6:  00           DC.B       0x00                     ; '\0'
+  0x200078C7:  00           DC.B       0x00                     ; '\0'
+  0x200078C8:  00           DC.B       0x00                     ; '\0'
+  0x200078C9:  00           DC.B       0x00                     ; '\0'
+  0x200078CA:  00           DC.B       0x00                     ; '\0'
+  0x200078CB:  00           DC.B       0x00                     ; '\0'
+  0x200078CC:  00           DC.B       0x00                     ; '\0'
+  0x200078CD:  00           DC.B       0x00                     ; '\0'
+  0x200078CE:  00           DC.B       0x00                     ; '\0'
+  0x200078CF:  00           DC.B       0x00                     ; '\0'
+  0x200078D0:  00           DC.B       0x00                     ; '\0'
+  0x200078D1:  00           DC.B       0x00                     ; '\0'
+  0x200078D2:  00           DC.B       0x00                     ; '\0'
+  0x200078D3:  00           DC.B       0x00                     ; '\0'
+  0x200078D4:  00           DC.B       0x00                     ; '\0'
+  0x200078D5:  00           DC.B       0x00                     ; '\0'
+  0x200078D6:  00           DC.B       0x00                     ; '\0'
+  0x200078D7:  00           DC.B       0x00                     ; '\0'
+  0x200078D8:  00           DC.B       0x00                     ; '\0'
+  0x200078D9:  00           DC.B       0x00                     ; '\0'
+  0x200078DA:  00           DC.B       0x00                     ; '\0'
+  0x200078DB:  00           DC.B       0x00                     ; '\0'
+  0x200078DC:  00           DC.B       0x00                     ; '\0'
+  0x200078DD:  00           DC.B       0x00                     ; '\0'
+  0x200078DE:  00           DC.B       0x00                     ; '\0'
+  0x200078DF:  00           DC.B       0x00                     ; '\0'
+  0x200078E0:  00           DC.B       0x00                     ; '\0'
+  0x200078E1:  00           DC.B       0x00                     ; '\0'
+  0x200078E2:  00           DC.B       0x00                     ; '\0'
+  0x200078E3:  00           DC.B       0x00                     ; '\0'
+  0x200078E4:  00           DC.B       0x00                     ; '\0'
+  0x200078E5:  00           DC.B       0x00                     ; '\0'
+  0x200078E6:  00           DC.B       0x00                     ; '\0'
+  0x200078E7:  00           DC.B       0x00                     ; '\0'
+  0x200078E8:  00           DC.B       0x00                     ; '\0'
+  0x200078E9:  00           DC.B       0x00                     ; '\0'
+  0x200078EA:  00           DC.B       0x00                     ; '\0'
+  0x200078EB:  00           DC.B       0x00                     ; '\0'
+  0x200078EC:  00           DC.B       0x00                     ; '\0'
+  0x200078ED:  00           DC.B       0x00                     ; '\0'
+  0x200078EE:  00           DC.B       0x00                     ; '\0'
+  0x200078EF:  00           DC.B       0x00                     ; '\0'
+  0x200078F0:  00           DC.B       0x00                     ; '\0'
+  0x200078F1:  00           DC.B       0x00                     ; '\0'
+  0x200078F2:  00           DC.B       0x00                     ; '\0'
+  0x200078F3:  00           DC.B       0x00                     ; '\0'
+  0x200078F4:  00           DC.B       0x00                     ; '\0'
+  0x200078F5:  00           DC.B       0x00                     ; '\0'
+  0x200078F6:  00           DC.B       0x00                     ; '\0'
+  0x200078F7:  00           DC.B       0x00                     ; '\0'
+  0x200078F8:  00           DC.B       0x00                     ; '\0'
+  0x200078F9:  00           DC.B       0x00                     ; '\0'
+  0x200078FA:  00           DC.B       0x00                     ; '\0'
+  0x200078FB:  00           DC.B       0x00                     ; '\0'
+  0x200078FC:  00           DC.B       0x00                     ; '\0'
+  0x200078FD:  00           DC.B       0x00                     ; '\0'
+  0x200078FE:  00           DC.B       0x00                     ; '\0'
+  0x200078FF:  00           DC.B       0x00                     ; '\0'
+  0x20007900:  00           DC.B       0x00                     ; '\0'
+  0x20007901:  00           DC.B       0x00                     ; '\0'
+  0x20007902:  00           DC.B       0x00                     ; '\0'
+  0x20007903:  00           DC.B       0x00                     ; '\0'
+  0x20007904:  00           DC.B       0x00                     ; '\0'
+  0x20007905:  00           DC.B       0x00                     ; '\0'
+  0x20007906:  00           DC.B       0x00                     ; '\0'
+  0x20007907:  00           DC.B       0x00                     ; '\0'
+  0x20007908:  00           DC.B       0x00                     ; '\0'
+  0x20007909:  00           DC.B       0x00                     ; '\0'
+  0x2000790A:  00           DC.B       0x00                     ; '\0'
+  0x2000790B:  00           DC.B       0x00                     ; '\0'
+  0x2000790C:  00           DC.B       0x00                     ; '\0'
+  0x2000790D:  00           DC.B       0x00                     ; '\0'
+  0x2000790E:  00           DC.B       0x00                     ; '\0'
+  0x2000790F:  00           DC.B       0x00                     ; '\0'
+  0x20007910:  00           DC.B       0x00                     ; '\0'
+  0x20007911:  00           DC.B       0x00                     ; '\0'
+  0x20007912:  00           DC.B       0x00                     ; '\0'
+  0x20007913:  00           DC.B       0x00                     ; '\0'
+  0x20007914:  00           DC.B       0x00                     ; '\0'
+  0x20007915:  00           DC.B       0x00                     ; '\0'
+  0x20007916:  00           DC.B       0x00                     ; '\0'
+  0x20007917:  00           DC.B       0x00                     ; '\0'
+  0x20007918:  00           DC.B       0x00                     ; '\0'
+  0x20007919:  00           DC.B       0x00                     ; '\0'
+  0x2000791A:  00           DC.B       0x00                     ; '\0'
+  0x2000791B:  00           DC.B       0x00                     ; '\0'
+  0x2000791C:  00           DC.B       0x00                     ; '\0'
+  0x2000791D:  00           DC.B       0x00                     ; '\0'
+  0x2000791E:  00           DC.B       0x00                     ; '\0'
+  0x2000791F:  00           DC.B       0x00                     ; '\0'
+  0x20007920:  00           DC.B       0x00                     ; '\0'
+  0x20007921:  00           DC.B       0x00                     ; '\0'
+  0x20007922:  00           DC.B       0x00                     ; '\0'
+  0x20007923:  00           DC.B       0x00                     ; '\0'
+  0x20007924:  00           DC.B       0x00                     ; '\0'
+  0x20007925:  00           DC.B       0x00                     ; '\0'
+  0x20007926:  00           DC.B       0x00                     ; '\0'
+  0x20007927:  00           DC.B       0x00                     ; '\0'
+  0x20007928:  00           DC.B       0x00                     ; '\0'
+  0x20007929:  00           DC.B       0x00                     ; '\0'
+  0x2000792A:  00           DC.B       0x00                     ; '\0'
+  0x2000792B:  00           DC.B       0x00                     ; '\0'
+  0x2000792C:  00           DC.B       0x00                     ; '\0'
+  0x2000792D:  00           DC.B       0x00                     ; '\0'
+  0x2000792E:  00           DC.B       0x00                     ; '\0'
+  0x2000792F:  00           DC.B       0x00                     ; '\0'
+  0x20007930:  00           DC.B       0x00                     ; '\0'
+  0x20007931:  00           DC.B       0x00                     ; '\0'
+  0x20007932:  00           DC.B       0x00                     ; '\0'
+  0x20007933:  00           DC.B       0x00                     ; '\0'
+  0x20007934:  00           DC.B       0x00                     ; '\0'
+  0x20007935:  00           DC.B       0x00                     ; '\0'
+  0x20007936:  00           DC.B       0x00                     ; '\0'
+  0x20007937:  00           DC.B       0x00                     ; '\0'
+  0x20007938:  00           DC.B       0x00                     ; '\0'
+  0x20007939:  00           DC.B       0x00                     ; '\0'
+  0x2000793A:  00           DC.B       0x00                     ; '\0'
+  0x2000793B:  00           DC.B       0x00                     ; '\0'
+  0x2000793C:  00           DC.B       0x00                     ; '\0'
+  0x2000793D:  00           DC.B       0x00                     ; '\0'
+  0x2000793E:  00           DC.B       0x00                     ; '\0'
+  0x2000793F:  00           DC.B       0x00                     ; '\0'
+  0x20007940:  00           DC.B       0x00                     ; '\0'
+  0x20007941:  00           DC.B       0x00                     ; '\0'
+  0x20007942:  00           DC.B       0x00                     ; '\0'
+  0x20007943:  00           DC.B       0x00                     ; '\0'
+  0x20007944:  00           DC.B       0x00                     ; '\0'
+  0x20007945:  00           DC.B       0x00                     ; '\0'
+  0x20007946:  00           DC.B       0x00                     ; '\0'
+  0x20007947:  00           DC.B       0x00                     ; '\0'
+  0x20007948:  00           DC.B       0x00                     ; '\0'
+  0x20007949:  00           DC.B       0x00                     ; '\0'
+  0x2000794A:  00           DC.B       0x00                     ; '\0'
+  0x2000794B:  00           DC.B       0x00                     ; '\0'
+  0x2000794C:  00           DC.B       0x00                     ; '\0'
+  0x2000794D:  00           DC.B       0x00                     ; '\0'
+  0x2000794E:  00           DC.B       0x00                     ; '\0'
+  0x2000794F:  00           DC.B       0x00                     ; '\0'
+  0x20007950:  00           DC.B       0x00                     ; '\0'
+  0x20007951:  00           DC.B       0x00                     ; '\0'
+  0x20007952:  00           DC.B       0x00                     ; '\0'
+  0x20007953:  00           DC.B       0x00                     ; '\0'
+  0x20007954:  00           DC.B       0x00                     ; '\0'
+  0x20007955:  00           DC.B       0x00                     ; '\0'
+  0x20007956:  00           DC.B       0x00                     ; '\0'
+  0x20007957:  00           DC.B       0x00                     ; '\0'
+  0x20007958:  00           DC.B       0x00                     ; '\0'
+  0x20007959:  00           DC.B       0x00                     ; '\0'
+  0x2000795A:  00           DC.B       0x00                     ; '\0'
+  0x2000795B:  00           DC.B       0x00                     ; '\0'
+  0x2000795C:  00           DC.B       0x00                     ; '\0'
+  0x2000795D:  00           DC.B       0x00                     ; '\0'
+  0x2000795E:  00           DC.B       0x00                     ; '\0'
+  0x2000795F:  00           DC.B       0x00                     ; '\0'
+  0x20007960:  00           DC.B       0x00                     ; '\0'
+  0x20007961:  00           DC.B       0x00                     ; '\0'
+  0x20007962:  00           DC.B       0x00                     ; '\0'
+  0x20007963:  00           DC.B       0x00                     ; '\0'
+  0x20007964:  00           DC.B       0x00                     ; '\0'
+  0x20007965:  00           DC.B       0x00                     ; '\0'
+  0x20007966:  00           DC.B       0x00                     ; '\0'
+  0x20007967:  00           DC.B       0x00                     ; '\0'
+  0x20007968:  00           DC.B       0x00                     ; '\0'
+  0x20007969:  00           DC.B       0x00                     ; '\0'
+  0x2000796A:  00           DC.B       0x00                     ; '\0'
+  0x2000796B:  00           DC.B       0x00                     ; '\0'
+  0x2000796C:  00           DC.B       0x00                     ; '\0'
+  0x2000796D:  00           DC.B       0x00                     ; '\0'
+  0x2000796E:  00           DC.B       0x00                     ; '\0'
+  0x2000796F:  00           DC.B       0x00                     ; '\0'
+  0x20007970:  00           DC.B       0x00                     ; '\0'
+  0x20007971:  00           DC.B       0x00                     ; '\0'
+  0x20007972:  00           DC.B       0x00                     ; '\0'
+  0x20007973:  00           DC.B       0x00                     ; '\0'
+  0x20007974:  00           DC.B       0x00                     ; '\0'
+  0x20007975:  00           DC.B       0x00                     ; '\0'
+  0x20007976:  00           DC.B       0x00                     ; '\0'
+  0x20007977:  00           DC.B       0x00                     ; '\0'
+  0x20007978:  00           DC.B       0x00                     ; '\0'
+  0x20007979:  00           DC.B       0x00                     ; '\0'
+  0x2000797A:  00           DC.B       0x00                     ; '\0'
+  0x2000797B:  00           DC.B       0x00                     ; '\0'
+  0x2000797C:  00           DC.B       0x00                     ; '\0'
+  0x2000797D:  00           DC.B       0x00                     ; '\0'
+  0x2000797E:  00           DC.B       0x00                     ; '\0'
+  0x2000797F:  00           DC.B       0x00                     ; '\0'
+  0x20007980:  00           DC.B       0x00                     ; '\0'
+  0x20007981:  00           DC.B       0x00                     ; '\0'
+  0x20007982:  00           DC.B       0x00                     ; '\0'
+  0x20007983:  00           DC.B       0x00                     ; '\0'
+  0x20007984:  00           DC.B       0x00                     ; '\0'
+  0x20007985:  00           DC.B       0x00                     ; '\0'
+  0x20007986:  00           DC.B       0x00                     ; '\0'
+  0x20007987:  00           DC.B       0x00                     ; '\0'
+  0x20007988:  00           DC.B       0x00                     ; '\0'
+  0x20007989:  00           DC.B       0x00                     ; '\0'
+  0x2000798A:  00           DC.B       0x00                     ; '\0'
+  0x2000798B:  00           DC.B       0x00                     ; '\0'
+  0x2000798C:  00           DC.B       0x00                     ; '\0'
+  0x2000798D:  00           DC.B       0x00                     ; '\0'
+  0x2000798E:  00           DC.B       0x00                     ; '\0'
+  0x2000798F:  00           DC.B       0x00                     ; '\0'
+  0x20007990:  00           DC.B       0x00                     ; '\0'
+  0x20007991:  00           DC.B       0x00                     ; '\0'
+  0x20007992:  00           DC.B       0x00                     ; '\0'
+  0x20007993:  00           DC.B       0x00                     ; '\0'
+  0x20007994:  00           DC.B       0x00                     ; '\0'
+  0x20007995:  00           DC.B       0x00                     ; '\0'
+  0x20007996:  00           DC.B       0x00                     ; '\0'
+  0x20007997:  00           DC.B       0x00                     ; '\0'
+  0x20007998:  00           DC.B       0x00                     ; '\0'
+  0x20007999:  00           DC.B       0x00                     ; '\0'
+  0x2000799A:  00           DC.B       0x00                     ; '\0'
+  0x2000799B:  00           DC.B       0x00                     ; '\0'
+  0x2000799C:  00           DC.B       0x00                     ; '\0'
+  0x2000799D:  00           DC.B       0x00                     ; '\0'
+  0x2000799E:  00           DC.B       0x00                     ; '\0'
+  0x2000799F:  00           DC.B       0x00                     ; '\0'
+  0x200079A0:  00           DC.B       0x00                     ; '\0'
+  0x200079A1:  00           DC.B       0x00                     ; '\0'
+  0x200079A2:  00           DC.B       0x00                     ; '\0'
+  0x200079A3:  00           DC.B       0x00                     ; '\0'
+  0x200079A4:  00           DC.B       0x00                     ; '\0'
+  0x200079A5:  00           DC.B       0x00                     ; '\0'
+  0x200079A6:  00           DC.B       0x00                     ; '\0'
+  0x200079A7:  00           DC.B       0x00                     ; '\0'
+  0x200079A8:  00           DC.B       0x00                     ; '\0'
+  0x200079A9:  00           DC.B       0x00                     ; '\0'
+  0x200079AA:  00           DC.B       0x00                     ; '\0'
+  0x200079AB:  00           DC.B       0x00                     ; '\0'
+  0x200079AC:  00           DC.B       0x00                     ; '\0'
+  0x200079AD:  00           DC.B       0x00                     ; '\0'
+  0x200079AE:  00           DC.B       0x00                     ; '\0'
+  0x200079AF:  00           DC.B       0x00                     ; '\0'
+  0x200079B0:  00           DC.B       0x00                     ; '\0'
+  0x200079B1:  00           DC.B       0x00                     ; '\0'
+  0x200079B2:  00           DC.B       0x00                     ; '\0'
+  0x200079B3:  00           DC.B       0x00                     ; '\0'
+  0x200079B4:  00           DC.B       0x00                     ; '\0'
+  0x200079B5:  00           DC.B       0x00                     ; '\0'
+  0x200079B6:  00           DC.B       0x00                     ; '\0'
+  0x200079B7:  00           DC.B       0x00                     ; '\0'
+  0x200079B8:  00           DC.B       0x00                     ; '\0'
+  0x200079B9:  00           DC.B       0x00                     ; '\0'
+  0x200079BA:  00           DC.B       0x00                     ; '\0'
+  0x200079BB:  00           DC.B       0x00                     ; '\0'
+  0x200079BC:  00           DC.B       0x00                     ; '\0'
+  0x200079BD:  00           DC.B       0x00                     ; '\0'
+  0x200079BE:  00           DC.B       0x00                     ; '\0'
+  0x200079BF:  00           DC.B       0x00                     ; '\0'
+  0x200079C0:  00           DC.B       0x00                     ; '\0'
+  0x200079C1:  00           DC.B       0x00                     ; '\0'
+  0x200079C2:  00           DC.B       0x00                     ; '\0'
+  0x200079C3:  00           DC.B       0x00                     ; '\0'
+  0x200079C4:  00           DC.B       0x00                     ; '\0'
+  0x200079C5:  00           DC.B       0x00                     ; '\0'
+  0x200079C6:  00           DC.B       0x00                     ; '\0'
+  0x200079C7:  00           DC.B       0x00                     ; '\0'
+  0x200079C8:  00           DC.B       0x00                     ; '\0'
+  0x200079C9:  00           DC.B       0x00                     ; '\0'
+  0x200079CA:  00           DC.B       0x00                     ; '\0'
+  0x200079CB:  00           DC.B       0x00                     ; '\0'
+  0x200079CC:  00           DC.B       0x00                     ; '\0'
+  0x200079CD:  00           DC.B       0x00                     ; '\0'
+  0x200079CE:  00           DC.B       0x00                     ; '\0'
+  0x200079CF:  00           DC.B       0x00                     ; '\0'
+  0x200079D0:  00           DC.B       0x00                     ; '\0'
+  0x200079D1:  00           DC.B       0x00                     ; '\0'
+  0x200079D2:  00           DC.B       0x00                     ; '\0'
+  0x200079D3:  00           DC.B       0x00                     ; '\0'
+  0x200079D4:  00           DC.B       0x00                     ; '\0'
+  0x200079D5:  00           DC.B       0x00                     ; '\0'
+  0x200079D6:  00           DC.B       0x00                     ; '\0'
+  0x200079D7:  00           DC.B       0x00                     ; '\0'
+  0x200079D8:  00           DC.B       0x00                     ; '\0'
+  0x200079D9:  00           DC.B       0x00                     ; '\0'
+  0x200079DA:  00           DC.B       0x00                     ; '\0'
+  0x200079DB:  00           DC.B       0x00                     ; '\0'
+  0x200079DC:  00           DC.B       0x00                     ; '\0'
+  0x200079DD:  00           DC.B       0x00                     ; '\0'
+  0x200079DE:  00           DC.B       0x00                     ; '\0'
+  0x200079DF:  00           DC.B       0x00                     ; '\0'
+  0x200079E0:  00           DC.B       0x00                     ; '\0'
+  0x200079E1:  00           DC.B       0x00                     ; '\0'
+  0x200079E2:  00           DC.B       0x00                     ; '\0'
+  0x200079E3:  00           DC.B       0x00                     ; '\0'
+  0x200079E4:  00           DC.B       0x00                     ; '\0'
+  0x200079E5:  00           DC.B       0x00                     ; '\0'
+  0x200079E6:  00           DC.B       0x00                     ; '\0'
+  0x200079E7:  00           DC.B       0x00                     ; '\0'
+  0x200079E8:  00           DC.B       0x00                     ; '\0'
+  0x200079E9:  00           DC.B       0x00                     ; '\0'
+  0x200079EA:  00           DC.B       0x00                     ; '\0'
+  0x200079EB:  00           DC.B       0x00                     ; '\0'
+  0x200079EC:  00           DC.B       0x00                     ; '\0'
+  0x200079ED:  00           DC.B       0x00                     ; '\0'
+  0x200079EE:  00           DC.B       0x00                     ; '\0'
+  0x200079EF:  00           DC.B       0x00                     ; '\0'
+  0x200079F0:  00           DC.B       0x00                     ; '\0'
+  0x200079F1:  00           DC.B       0x00                     ; '\0'
+  0x200079F2:  00           DC.B       0x00                     ; '\0'
+  0x200079F3:  00           DC.B       0x00                     ; '\0'
+  0x200079F4:  00           DC.B       0x00                     ; '\0'
+  0x200079F5:  00           DC.B       0x00                     ; '\0'
+  0x200079F6:  00           DC.B       0x00                     ; '\0'
+  0x200079F7:  00           DC.B       0x00                     ; '\0'
+  0x200079F8:  00           DC.B       0x00                     ; '\0'
+  0x200079F9:  00           DC.B       0x00                     ; '\0'
+  0x200079FA:  00           DC.B       0x00                     ; '\0'
+  0x200079FB:  00           DC.B       0x00                     ; '\0'
+  0x200079FC:  00           DC.B       0x00                     ; '\0'
+  0x200079FD:  00           DC.B       0x00                     ; '\0'
+  0x200079FE:  00           DC.B       0x00                     ; '\0'
+  0x200079FF:  00           DC.B       0x00                     ; '\0'
+  0x20007A00:  00           DC.B       0x00                     ; '\0'
+  0x20007A01:  00           DC.B       0x00                     ; '\0'
+  0x20007A02:  00           DC.B       0x00                     ; '\0'
+  0x20007A03:  00           DC.B       0x00                     ; '\0'
+  0x20007A04:  00           DC.B       0x00                     ; '\0'
+  0x20007A05:  00           DC.B       0x00                     ; '\0'
+  0x20007A06:  00           DC.B       0x00                     ; '\0'
+  0x20007A07:  00           DC.B       0x00                     ; '\0'
+  0x20007A08:  00           DC.B       0x00                     ; '\0'
+  0x20007A09:  00           DC.B       0x00                     ; '\0'
+  0x20007A0A:  00           DC.B       0x00                     ; '\0'
+  0x20007A0B:  00           DC.B       0x00                     ; '\0'
+  0x20007A0C:  00           DC.B       0x00                     ; '\0'
+  0x20007A0D:  00           DC.B       0x00                     ; '\0'
+  0x20007A0E:  00           DC.B       0x00                     ; '\0'
+  0x20007A0F:  00           DC.B       0x00                     ; '\0'
+  0x20007A10:  00           DC.B       0x00                     ; '\0'
+  0x20007A11:  00           DC.B       0x00                     ; '\0'
+  0x20007A12:  00           DC.B       0x00                     ; '\0'
+  0x20007A13:  00           DC.B       0x00                     ; '\0'
+  0x20007A14:  00           DC.B       0x00                     ; '\0'
+  0x20007A15:  00           DC.B       0x00                     ; '\0'
+  0x20007A16:  00           DC.B       0x00                     ; '\0'
+  0x20007A17:  00           DC.B       0x00                     ; '\0'
+  0x20007A18:  00           DC.B       0x00                     ; '\0'
+  0x20007A19:  00           DC.B       0x00                     ; '\0'
+  0x20007A1A:  00           DC.B       0x00                     ; '\0'
+  0x20007A1B:  00           DC.B       0x00                     ; '\0'
+  0x20007A1C:  00           DC.B       0x00                     ; '\0'
+  0x20007A1D:  00           DC.B       0x00                     ; '\0'
+  0x20007A1E:  00           DC.B       0x00                     ; '\0'
+  0x20007A1F:  00           DC.B       0x00                     ; '\0'
+  0x20007A20:  00           DC.B       0x00                     ; '\0'
+  0x20007A21:  00           DC.B       0x00                     ; '\0'
+  0x20007A22:  00           DC.B       0x00                     ; '\0'
+  0x20007A23:  00           DC.B       0x00                     ; '\0'
+  0x20007A24:  00           DC.B       0x00                     ; '\0'
+  0x20007A25:  00           DC.B       0x00                     ; '\0'
+  0x20007A26:  00           DC.B       0x00                     ; '\0'
+  0x20007A27:  00           DC.B       0x00                     ; '\0'
+  0x20007A28:  00           DC.B       0x00                     ; '\0'
+  0x20007A29:  00           DC.B       0x00                     ; '\0'
+  0x20007A2A:  00           DC.B       0x00                     ; '\0'
+  0x20007A2B:  00           DC.B       0x00                     ; '\0'
+  0x20007A2C:  00           DC.B       0x00                     ; '\0'
+  0x20007A2D:  00           DC.B       0x00                     ; '\0'
+  0x20007A2E:  00           DC.B       0x00                     ; '\0'
+  0x20007A2F:  00           DC.B       0x00                     ; '\0'
+  0x20007A30:  00           DC.B       0x00                     ; '\0'
+  0x20007A31:  00           DC.B       0x00                     ; '\0'
+  0x20007A32:  00           DC.B       0x00                     ; '\0'
+  0x20007A33:  00           DC.B       0x00                     ; '\0'
+  0x20007A34:  00           DC.B       0x00                     ; '\0'
+  0x20007A35:  00           DC.B       0x00                     ; '\0'
+  0x20007A36:  00           DC.B       0x00                     ; '\0'
+  0x20007A37:  00           DC.B       0x00                     ; '\0'
+  0x20007A38:  00           DC.B       0x00                     ; '\0'
+  0x20007A39:  00           DC.B       0x00                     ; '\0'
+  0x20007A3A:  00           DC.B       0x00                     ; '\0'
+  0x20007A3B:  00           DC.B       0x00                     ; '\0'
+  0x20007A3C:  00           DC.B       0x00                     ; '\0'
+  0x20007A3D:  00           DC.B       0x00                     ; '\0'
+  0x20007A3E:  00           DC.B       0x00                     ; '\0'
+  0x20007A3F:  00           DC.B       0x00                     ; '\0'
+  0x20007A40:  00           DC.B       0x00                     ; '\0'
+  0x20007A41:  00           DC.B       0x00                     ; '\0'
+  0x20007A42:  00           DC.B       0x00                     ; '\0'
+  0x20007A43:  00           DC.B       0x00                     ; '\0'
+  0x20007A44:  00           DC.B       0x00                     ; '\0'
+  0x20007A45:  00           DC.B       0x00                     ; '\0'
+  0x20007A46:  00           DC.B       0x00                     ; '\0'
+  0x20007A47:  00           DC.B       0x00                     ; '\0'
+  0x20007A48:  00           DC.B       0x00                     ; '\0'
+  0x20007A49:  00           DC.B       0x00                     ; '\0'
+  0x20007A4A:  00           DC.B       0x00                     ; '\0'
+  0x20007A4B:  00           DC.B       0x00                     ; '\0'
+  0x20007A4C:  00           DC.B       0x00                     ; '\0'
+  0x20007A4D:  00           DC.B       0x00                     ; '\0'
+  0x20007A4E:  00           DC.B       0x00                     ; '\0'
+  0x20007A4F:  00           DC.B       0x00                     ; '\0'
+  0x20007A50:  00           DC.B       0x00                     ; '\0'
+  0x20007A51:  00           DC.B       0x00                     ; '\0'
+  0x20007A52:  00           DC.B       0x00                     ; '\0'
+  0x20007A53:  00           DC.B       0x00                     ; '\0'
+  0x20007A54:  00           DC.B       0x00                     ; '\0'
+  0x20007A55:  00           DC.B       0x00                     ; '\0'
+  0x20007A56:  00           DC.B       0x00                     ; '\0'
+  0x20007A57:  00           DC.B       0x00                     ; '\0'
+  0x20007A58:  00           DC.B       0x00                     ; '\0'
+  0x20007A59:  00           DC.B       0x00                     ; '\0'
+  0x20007A5A:  00           DC.B       0x00                     ; '\0'
+  0x20007A5B:  00           DC.B       0x00                     ; '\0'
+  0x20007A5C:  00           DC.B       0x00                     ; '\0'
+  0x20007A5D:  00           DC.B       0x00                     ; '\0'
+  0x20007A5E:  00           DC.B       0x00                     ; '\0'
+  0x20007A5F:  00           DC.B       0x00                     ; '\0'
+  0x20007A60:  00           DC.B       0x00                     ; '\0'
+  0x20007A61:  00           DC.B       0x00                     ; '\0'
+  0x20007A62:  00           DC.B       0x00                     ; '\0'
+  0x20007A63:  00           DC.B       0x00                     ; '\0'
+  0x20007A64:  00           DC.B       0x00                     ; '\0'
+  0x20007A65:  00           DC.B       0x00                     ; '\0'
+  0x20007A66:  00           DC.B       0x00                     ; '\0'
+  0x20007A67:  00           DC.B       0x00                     ; '\0'
+  0x20007A68:  00           DC.B       0x00                     ; '\0'
+  0x20007A69:  00           DC.B       0x00                     ; '\0'
+  0x20007A6A:  00           DC.B       0x00                     ; '\0'
+  0x20007A6B:  00           DC.B       0x00                     ; '\0'
+  0x20007A6C:  00           DC.B       0x00                     ; '\0'
+  0x20007A6D:  00           DC.B       0x00                     ; '\0'
+  0x20007A6E:  00           DC.B       0x00                     ; '\0'
+  0x20007A6F:  00           DC.B       0x00                     ; '\0'
+  0x20007A70:  00           DC.B       0x00                     ; '\0'
+  0x20007A71:  00           DC.B       0x00                     ; '\0'
+  0x20007A72:  00           DC.B       0x00                     ; '\0'
+  0x20007A73:  00           DC.B       0x00                     ; '\0'
+  0x20007A74:  00           DC.B       0x00                     ; '\0'
+  0x20007A75:  00           DC.B       0x00                     ; '\0'
+  0x20007A76:  00           DC.B       0x00                     ; '\0'
+  0x20007A77:  00           DC.B       0x00                     ; '\0'
+  0x20007A78:  00           DC.B       0x00                     ; '\0'
+  0x20007A79:  00           DC.B       0x00                     ; '\0'
+  0x20007A7A:  00           DC.B       0x00                     ; '\0'
+  0x20007A7B:  00           DC.B       0x00                     ; '\0'
+  0x20007A7C:  00           DC.B       0x00                     ; '\0'
+  0x20007A7D:  00           DC.B       0x00                     ; '\0'
+  0x20007A7E:  00           DC.B       0x00                     ; '\0'
+  0x20007A7F:  00           DC.B       0x00                     ; '\0'
+  0x20007A80:  00           DC.B       0x00                     ; '\0'
+  0x20007A81:  00           DC.B       0x00                     ; '\0'
+  0x20007A82:  00           DC.B       0x00                     ; '\0'
+  0x20007A83:  00           DC.B       0x00                     ; '\0'
+  0x20007A84:  00           DC.B       0x00                     ; '\0'
+  0x20007A85:  00           DC.B       0x00                     ; '\0'
+  0x20007A86:  00           DC.B       0x00                     ; '\0'
+  0x20007A87:  00           DC.B       0x00                     ; '\0'
+  0x20007A88:  00           DC.B       0x00                     ; '\0'
+  0x20007A89:  00           DC.B       0x00                     ; '\0'
+  0x20007A8A:  00           DC.B       0x00                     ; '\0'
+  0x20007A8B:  00           DC.B       0x00                     ; '\0'
+  0x20007A8C:  00           DC.B       0x00                     ; '\0'
+  0x20007A8D:  00           DC.B       0x00                     ; '\0'
+  0x20007A8E:  00           DC.B       0x00                     ; '\0'
+  0x20007A8F:  00           DC.B       0x00                     ; '\0'
+  0x20007A90:  00           DC.B       0x00                     ; '\0'
+  0x20007A91:  00           DC.B       0x00                     ; '\0'
+  0x20007A92:  00           DC.B       0x00                     ; '\0'
+  0x20007A93:  00           DC.B       0x00                     ; '\0'
+  0x20007A94:  00           DC.B       0x00                     ; '\0'
+  0x20007A95:  00           DC.B       0x00                     ; '\0'
+  0x20007A96:  00           DC.B       0x00                     ; '\0'
+  0x20007A97:  00           DC.B       0x00                     ; '\0'
+  0x20007A98:  00           DC.B       0x00                     ; '\0'
+  0x20007A99:  00           DC.B       0x00                     ; '\0'
+  0x20007A9A:  00           DC.B       0x00                     ; '\0'
+  0x20007A9B:  00           DC.B       0x00                     ; '\0'
+  0x20007A9C:  00           DC.B       0x00                     ; '\0'
+  0x20007A9D:  00           DC.B       0x00                     ; '\0'
+  0x20007A9E:  00           DC.B       0x00                     ; '\0'
+  0x20007A9F:  00           DC.B       0x00                     ; '\0'
+  0x20007AA0:  00           DC.B       0x00                     ; '\0'
+  0x20007AA1:  00           DC.B       0x00                     ; '\0'
+  0x20007AA2:  00           DC.B       0x00                     ; '\0'
+  0x20007AA3:  00           DC.B       0x00                     ; '\0'
+  0x20007AA4:  00           DC.B       0x00                     ; '\0'
+  0x20007AA5:  00           DC.B       0x00                     ; '\0'
+  0x20007AA6:  00           DC.B       0x00                     ; '\0'
+  0x20007AA7:  00           DC.B       0x00                     ; '\0'
+  0x20007AA8:  00           DC.B       0x00                     ; '\0'
+  0x20007AA9:  00           DC.B       0x00                     ; '\0'
+  0x20007AAA:  00           DC.B       0x00                     ; '\0'
+  0x20007AAB:  00           DC.B       0x00                     ; '\0'
+  0x20007AAC:  00           DC.B       0x00                     ; '\0'
+  0x20007AAD:  00           DC.B       0x00                     ; '\0'
+  0x20007AAE:  00           DC.B       0x00                     ; '\0'
+  0x20007AAF:  00           DC.B       0x00                     ; '\0'
+  0x20007AB0:  00           DC.B       0x00                     ; '\0'
+  0x20007AB1:  00           DC.B       0x00                     ; '\0'
+  0x20007AB2:  00           DC.B       0x00                     ; '\0'
+  0x20007AB3:  00           DC.B       0x00                     ; '\0'
+  0x20007AB4:  00           DC.B       0x00                     ; '\0'
+  0x20007AB5:  00           DC.B       0x00                     ; '\0'
+  0x20007AB6:  00           DC.B       0x00                     ; '\0'
+  0x20007AB7:  00           DC.B       0x00                     ; '\0'
+  0x20007AB8:  00           DC.B       0x00                     ; '\0'
+  0x20007AB9:  00           DC.B       0x00                     ; '\0'
+  0x20007ABA:  00           DC.B       0x00                     ; '\0'
+  0x20007ABB:  00           DC.B       0x00                     ; '\0'
+  0x20007ABC:  00           DC.B       0x00                     ; '\0'
+  0x20007ABD:  00           DC.B       0x00                     ; '\0'
+  0x20007ABE:  00           DC.B       0x00                     ; '\0'
+  0x20007ABF:  00           DC.B       0x00                     ; '\0'
+  0x20007AC0:  00           DC.B       0x00                     ; '\0'
+  0x20007AC1:  00           DC.B       0x00                     ; '\0'
+  0x20007AC2:  00           DC.B       0x00                     ; '\0'
+  0x20007AC3:  00           DC.B       0x00                     ; '\0'
+  0x20007AC4:  00           DC.B       0x00                     ; '\0'
+  0x20007AC5:  00           DC.B       0x00                     ; '\0'
+  0x20007AC6:  00           DC.B       0x00                     ; '\0'
+  0x20007AC7:  00           DC.B       0x00                     ; '\0'
+  0x20007AC8:  00           DC.B       0x00                     ; '\0'
+  0x20007AC9:  00           DC.B       0x00                     ; '\0'
+  0x20007ACA:  00           DC.B       0x00                     ; '\0'
+  0x20007ACB:  00           DC.B       0x00                     ; '\0'
+  0x20007ACC:  00           DC.B       0x00                     ; '\0'
+  0x20007ACD:  00           DC.B       0x00                     ; '\0'
+  0x20007ACE:  00           DC.B       0x00                     ; '\0'
+  0x20007ACF:  00           DC.B       0x00                     ; '\0'
+  0x20007AD0:  00           DC.B       0x00                     ; '\0'
+  0x20007AD1:  00           DC.B       0x00                     ; '\0'
+  0x20007AD2:  00           DC.B       0x00                     ; '\0'
+  0x20007AD3:  00           DC.B       0x00                     ; '\0'
+  0x20007AD4:  00           DC.B       0x00                     ; '\0'
+  0x20007AD5:  00           DC.B       0x00                     ; '\0'
+  0x20007AD6:  00           DC.B       0x00                     ; '\0'
+  0x20007AD7:  00           DC.B       0x00                     ; '\0'
+  0x20007AD8:  00           DC.B       0x00                     ; '\0'
+  0x20007AD9:  00           DC.B       0x00                     ; '\0'
+  0x20007ADA:  00           DC.B       0x00                     ; '\0'
+  0x20007ADB:  00           DC.B       0x00                     ; '\0'
+  0x20007ADC:  00           DC.B       0x00                     ; '\0'
+  0x20007ADD:  00           DC.B       0x00                     ; '\0'
+  0x20007ADE:  00           DC.B       0x00                     ; '\0'
+  0x20007ADF:  00           DC.B       0x00                     ; '\0'
+  0x20007AE0:  00           DC.B       0x00                     ; '\0'
+  0x20007AE1:  00           DC.B       0x00                     ; '\0'
+  0x20007AE2:  00           DC.B       0x00                     ; '\0'
+  0x20007AE3:  00           DC.B       0x00                     ; '\0'
+  0x20007AE4:  00           DC.B       0x00                     ; '\0'
+  0x20007AE5:  00           DC.B       0x00                     ; '\0'
+  0x20007AE6:  00           DC.B       0x00                     ; '\0'
+  0x20007AE7:  00           DC.B       0x00                     ; '\0'
+  0x20007AE8:  00           DC.B       0x00                     ; '\0'
+  0x20007AE9:  00           DC.B       0x00                     ; '\0'
+  0x20007AEA:  00           DC.B       0x00                     ; '\0'
+  0x20007AEB:  00           DC.B       0x00                     ; '\0'
+  0x20007AEC:  00           DC.B       0x00                     ; '\0'
+  0x20007AED:  00           DC.B       0x00                     ; '\0'
+  0x20007AEE:  00           DC.B       0x00                     ; '\0'
+  0x20007AEF:  00           DC.B       0x00                     ; '\0'
+  0x20007AF0:  00           DC.B       0x00                     ; '\0'
+  0x20007AF1:  00           DC.B       0x00                     ; '\0'
+  0x20007AF2:  00           DC.B       0x00                     ; '\0'
+  0x20007AF3:  00           DC.B       0x00                     ; '\0'
+  0x20007AF4:  00           DC.B       0x00                     ; '\0'
+  0x20007AF5:  00           DC.B       0x00                     ; '\0'
+  0x20007AF6:  00           DC.B       0x00                     ; '\0'
+  0x20007AF7:  00           DC.B       0x00                     ; '\0'
+  0x20007AF8:  00           DC.B       0x00                     ; '\0'
+  0x20007AF9:  00           DC.B       0x00                     ; '\0'
+  0x20007AFA:  00           DC.B       0x00                     ; '\0'
+  0x20007AFB:  00           DC.B       0x00                     ; '\0'
+  0x20007AFC:  00           DC.B       0x00                     ; '\0'
+  0x20007AFD:  00           DC.B       0x00                     ; '\0'
+  0x20007AFE:  00           DC.B       0x00                     ; '\0'
+  0x20007AFF:  00           DC.B       0x00                     ; '\0'
+  0x20007B00:  00           DC.B       0x00                     ; '\0'
+  0x20007B01:  00           DC.B       0x00                     ; '\0'
+  0x20007B02:  00           DC.B       0x00                     ; '\0'
+  0x20007B03:  00           DC.B       0x00                     ; '\0'
+  0x20007B04:  00           DC.B       0x00                     ; '\0'
+  0x20007B05:  00           DC.B       0x00                     ; '\0'
+  0x20007B06:  00           DC.B       0x00                     ; '\0'
+  0x20007B07:  00           DC.B       0x00                     ; '\0'
+  0x20007B08:  00           DC.B       0x00                     ; '\0'
+  0x20007B09:  00           DC.B       0x00                     ; '\0'
+  0x20007B0A:  00           DC.B       0x00                     ; '\0'
+  0x20007B0B:  00           DC.B       0x00                     ; '\0'
+  0x20007B0C:  00           DC.B       0x00                     ; '\0'
+  0x20007B0D:  00           DC.B       0x00                     ; '\0'
+  0x20007B0E:  00           DC.B       0x00                     ; '\0'
+  0x20007B0F:  00           DC.B       0x00                     ; '\0'
+  0x20007B10:  00           DC.B       0x00                     ; '\0'
+  0x20007B11:  00           DC.B       0x00                     ; '\0'
+  0x20007B12:  00           DC.B       0x00                     ; '\0'
+  0x20007B13:  00           DC.B       0x00                     ; '\0'
+  0x20007B14:  00           DC.B       0x00                     ; '\0'
+  0x20007B15:  00           DC.B       0x00                     ; '\0'
+  0x20007B16:  00           DC.B       0x00                     ; '\0'
+  0x20007B17:  00           DC.B       0x00                     ; '\0'
+  0x20007B18:  00           DC.B       0x00                     ; '\0'
+  0x20007B19:  00           DC.B       0x00                     ; '\0'
+  0x20007B1A:  00           DC.B       0x00                     ; '\0'
+  0x20007B1B:  00           DC.B       0x00                     ; '\0'
+  0x20007B1C:  00           DC.B       0x00                     ; '\0'
+  0x20007B1D:  00           DC.B       0x00                     ; '\0'
+  0x20007B1E:  00           DC.B       0x00                     ; '\0'
+  0x20007B1F:  00           DC.B       0x00                     ; '\0'
+  0x20007B20:  00           DC.B       0x00                     ; '\0'
+  0x20007B21:  00           DC.B       0x00                     ; '\0'
+  0x20007B22:  00           DC.B       0x00                     ; '\0'
+  0x20007B23:  00           DC.B       0x00                     ; '\0'
+  0x20007B24:  00           DC.B       0x00                     ; '\0'
+  0x20007B25:  00           DC.B       0x00                     ; '\0'
+  0x20007B26:  00           DC.B       0x00                     ; '\0'
+  0x20007B27:  00           DC.B       0x00                     ; '\0'
+  0x20007B28:  00           DC.B       0x00                     ; '\0'
+  0x20007B29:  00           DC.B       0x00                     ; '\0'
+  0x20007B2A:  00           DC.B       0x00                     ; '\0'
+  0x20007B2B:  00           DC.B       0x00                     ; '\0'
+  0x20007B2C:  00           DC.B       0x00                     ; '\0'
+  0x20007B2D:  00           DC.B       0x00                     ; '\0'
+  0x20007B2E:  00           DC.B       0x00                     ; '\0'
+  0x20007B2F:  00           DC.B       0x00                     ; '\0'
+  0x20007B30:  00           DC.B       0x00                     ; '\0'
+  0x20007B31:  00           DC.B       0x00                     ; '\0'
+  0x20007B32:  00           DC.B       0x00                     ; '\0'
+  0x20007B33:  00           DC.B       0x00                     ; '\0'
+  0x20007B34:  00           DC.B       0x00                     ; '\0'
+  0x20007B35:  00           DC.B       0x00                     ; '\0'
+  0x20007B36:  00           DC.B       0x00                     ; '\0'
+  0x20007B37:  00           DC.B       0x00                     ; '\0'
+  0x20007B38:  00           DC.B       0x00                     ; '\0'
+  0x20007B39:  00           DC.B       0x00                     ; '\0'
+  0x20007B3A:  00           DC.B       0x00                     ; '\0'
+  0x20007B3B:  00           DC.B       0x00                     ; '\0'
+  0x20007B3C:  00           DC.B       0x00                     ; '\0'
+  0x20007B3D:  00           DC.B       0x00                     ; '\0'
+  0x20007B3E:  00           DC.B       0x00                     ; '\0'
+  0x20007B3F:  00           DC.B       0x00                     ; '\0'
+  0x20007B40:  00           DC.B       0x00                     ; '\0'
+  0x20007B41:  00           DC.B       0x00                     ; '\0'
+  0x20007B42:  00           DC.B       0x00                     ; '\0'
+  0x20007B43:  00           DC.B       0x00                     ; '\0'
+  0x20007B44:  00           DC.B       0x00                     ; '\0'
+  0x20007B45:  00           DC.B       0x00                     ; '\0'
+  0x20007B46:  00           DC.B       0x00                     ; '\0'
+  0x20007B47:  00           DC.B       0x00                     ; '\0'
+  0x20007B48:  00           DC.B       0x00                     ; '\0'
+  0x20007B49:  00           DC.B       0x00                     ; '\0'
+  0x20007B4A:  00           DC.B       0x00                     ; '\0'
+  0x20007B4B:  00           DC.B       0x00                     ; '\0'
+  0x20007B4C:  00           DC.B       0x00                     ; '\0'
+  0x20007B4D:  00           DC.B       0x00                     ; '\0'
+  0x20007B4E:  00           DC.B       0x00                     ; '\0'
+  0x20007B4F:  00           DC.B       0x00                     ; '\0'
+  0x20007B50:  00           DC.B       0x00                     ; '\0'
+  0x20007B51:  00           DC.B       0x00                     ; '\0'
+  0x20007B52:  00           DC.B       0x00                     ; '\0'
+  0x20007B53:  00           DC.B       0x00                     ; '\0'
+  0x20007B54:  00           DC.B       0x00                     ; '\0'
+  0x20007B55:  00           DC.B       0x00                     ; '\0'
+  0x20007B56:  00           DC.B       0x00                     ; '\0'
+  0x20007B57:  00           DC.B       0x00                     ; '\0'
+  0x20007B58:  00           DC.B       0x00                     ; '\0'
+  0x20007B59:  00           DC.B       0x00                     ; '\0'
+  0x20007B5A:  00           DC.B       0x00                     ; '\0'
+  0x20007B5B:  00           DC.B       0x00                     ; '\0'
+  0x20007B5C:  00           DC.B       0x00                     ; '\0'
+  0x20007B5D:  00           DC.B       0x00                     ; '\0'
+  0x20007B5E:  00           DC.B       0x00                     ; '\0'
+  0x20007B5F:  00           DC.B       0x00                     ; '\0'
+  0x20007B60:  00           DC.B       0x00                     ; '\0'
+  0x20007B61:  00           DC.B       0x00                     ; '\0'
+  0x20007B62:  00           DC.B       0x00                     ; '\0'
+  0x20007B63:  00           DC.B       0x00                     ; '\0'
+  0x20007B64:  00           DC.B       0x00                     ; '\0'
+  0x20007B65:  00           DC.B       0x00                     ; '\0'
+  0x20007B66:  00           DC.B       0x00                     ; '\0'
+  0x20007B67:  00           DC.B       0x00                     ; '\0'
+  0x20007B68:  00           DC.B       0x00                     ; '\0'
+  0x20007B69:  00           DC.B       0x00                     ; '\0'
+  0x20007B6A:  00           DC.B       0x00                     ; '\0'
+  0x20007B6B:  00           DC.B       0x00                     ; '\0'
+  0x20007B6C:  00           DC.B       0x00                     ; '\0'
+  0x20007B6D:  00           DC.B       0x00                     ; '\0'
+  0x20007B6E:  00           DC.B       0x00                     ; '\0'
+  0x20007B6F:  00           DC.B       0x00                     ; '\0'
+  0x20007B70:  00           DC.B       0x00                     ; '\0'
+  0x20007B71:  00           DC.B       0x00                     ; '\0'
+  0x20007B72:  00           DC.B       0x00                     ; '\0'
+  0x20007B73:  00           DC.B       0x00                     ; '\0'
+  0x20007B74:  00           DC.B       0x00                     ; '\0'
+  0x20007B75:  00           DC.B       0x00                     ; '\0'
+  0x20007B76:  00           DC.B       0x00                     ; '\0'
+  0x20007B77:  00           DC.B       0x00                     ; '\0'
+  0x20007B78:  00           DC.B       0x00                     ; '\0'
+  0x20007B79:  00           DC.B       0x00                     ; '\0'
+  0x20007B7A:  00           DC.B       0x00                     ; '\0'
+  0x20007B7B:  00           DC.B       0x00                     ; '\0'
+  0x20007B7C:  00           DC.B       0x00                     ; '\0'
+  0x20007B7D:  00           DC.B       0x00                     ; '\0'
+  0x20007B7E:  00           DC.B       0x00                     ; '\0'
+  0x20007B7F:  00           DC.B       0x00                     ; '\0'
+  0x20007B80:  00           DC.B       0x00                     ; '\0'
+  0x20007B81:  00           DC.B       0x00                     ; '\0'
+  0x20007B82:  00           DC.B       0x00                     ; '\0'
+  0x20007B83:  00           DC.B       0x00                     ; '\0'
+  0x20007B84:  00           DC.B       0x00                     ; '\0'
+  0x20007B85:  00           DC.B       0x00                     ; '\0'
+  0x20007B86:  00           DC.B       0x00                     ; '\0'
+  0x20007B87:  00           DC.B       0x00                     ; '\0'
+  0x20007B88:  00           DC.B       0x00                     ; '\0'
+  0x20007B89:  00           DC.B       0x00                     ; '\0'
+  0x20007B8A:  00           DC.B       0x00                     ; '\0'
+  0x20007B8B:  00           DC.B       0x00                     ; '\0'
+  0x20007B8C:  00           DC.B       0x00                     ; '\0'
+  0x20007B8D:  00           DC.B       0x00                     ; '\0'
+  0x20007B8E:  00           DC.B       0x00                     ; '\0'
+  0x20007B8F:  00           DC.B       0x00                     ; '\0'
+  0x20007B90:  00           DC.B       0x00                     ; '\0'
+  0x20007B91:  00           DC.B       0x00                     ; '\0'
+  0x20007B92:  00           DC.B       0x00                     ; '\0'
+  0x20007B93:  00           DC.B       0x00                     ; '\0'
+  0x20007B94:  00           DC.B       0x00                     ; '\0'
+  0x20007B95:  00           DC.B       0x00                     ; '\0'
+  0x20007B96:  00           DC.B       0x00                     ; '\0'
+  0x20007B97:  00           DC.B       0x00                     ; '\0'
+  0x20007B98:  00           DC.B       0x00                     ; '\0'
+  0x20007B99:  00           DC.B       0x00                     ; '\0'
+  0x20007B9A:  00           DC.B       0x00                     ; '\0'
+  0x20007B9B:  00           DC.B       0x00                     ; '\0'
+  0x20007B9C:  00           DC.B       0x00                     ; '\0'
+  0x20007B9D:  00           DC.B       0x00                     ; '\0'
+  0x20007B9E:  00           DC.B       0x00                     ; '\0'
+  0x20007B9F:  00           DC.B       0x00                     ; '\0'
+  0x20007BA0:  00           DC.B       0x00                     ; '\0'
+  0x20007BA1:  00           DC.B       0x00                     ; '\0'
+  0x20007BA2:  00           DC.B       0x00                     ; '\0'
+  0x20007BA3:  00           DC.B       0x00                     ; '\0'
+  0x20007BA4:  00           DC.B       0x00                     ; '\0'
+  0x20007BA5:  00           DC.B       0x00                     ; '\0'
+  0x20007BA6:  00           DC.B       0x00                     ; '\0'
+  0x20007BA7:  00           DC.B       0x00                     ; '\0'
+  0x20007BA8:  00           DC.B       0x00                     ; '\0'
+  0x20007BA9:  00           DC.B       0x00                     ; '\0'
+  0x20007BAA:  00           DC.B       0x00                     ; '\0'
+  0x20007BAB:  00           DC.B       0x00                     ; '\0'
+  0x20007BAC:  00           DC.B       0x00                     ; '\0'
+  0x20007BAD:  00           DC.B       0x00                     ; '\0'
+  0x20007BAE:  00           DC.B       0x00                     ; '\0'
+  0x20007BAF:  00           DC.B       0x00                     ; '\0'
+  0x20007BB0:  00           DC.B       0x00                     ; '\0'
+  0x20007BB1:  00           DC.B       0x00                     ; '\0'
+  0x20007BB2:  00           DC.B       0x00                     ; '\0'
+  0x20007BB3:  00           DC.B       0x00                     ; '\0'
+  0x20007BB4:  00           DC.B       0x00                     ; '\0'
+  0x20007BB5:  00           DC.B       0x00                     ; '\0'
+  0x20007BB6:  00           DC.B       0x00                     ; '\0'
+  0x20007BB7:  00           DC.B       0x00                     ; '\0'
+  0x20007BB8:  00           DC.B       0x00                     ; '\0'
+  0x20007BB9:  00           DC.B       0x00                     ; '\0'
+  0x20007BBA:  00           DC.B       0x00                     ; '\0'
+  0x20007BBB:  00           DC.B       0x00                     ; '\0'
+  0x20007BBC:  00           DC.B       0x00                     ; '\0'
+  0x20007BBD:  00           DC.B       0x00                     ; '\0'
+  0x20007BBE:  00           DC.B       0x00                     ; '\0'
+  0x20007BBF:  00           DC.B       0x00                     ; '\0'
+  0x20007BC0:  00           DC.B       0x00                     ; '\0'
+  0x20007BC1:  00           DC.B       0x00                     ; '\0'
+  0x20007BC2:  00           DC.B       0x00                     ; '\0'
+  0x20007BC3:  00           DC.B       0x00                     ; '\0'
+  0x20007BC4:  00           DC.B       0x00                     ; '\0'
+  0x20007BC5:  00           DC.B       0x00                     ; '\0'
+  0x20007BC6:  00           DC.B       0x00                     ; '\0'
+  0x20007BC7:  00           DC.B       0x00                     ; '\0'
+  0x20007BC8:  00           DC.B       0x00                     ; '\0'
+  0x20007BC9:  00           DC.B       0x00                     ; '\0'
+  0x20007BCA:  00           DC.B       0x00                     ; '\0'
+  0x20007BCB:  00           DC.B       0x00                     ; '\0'
+  0x20007BCC:  00           DC.B       0x00                     ; '\0'
+  0x20007BCD:  00           DC.B       0x00                     ; '\0'
+  0x20007BCE:  00           DC.B       0x00                     ; '\0'
+  0x20007BCF:  00           DC.B       0x00                     ; '\0'
+  0x20007BD0:  00           DC.B       0x00                     ; '\0'
+  0x20007BD1:  00           DC.B       0x00                     ; '\0'
+  0x20007BD2:  00           DC.B       0x00                     ; '\0'
+  0x20007BD3:  00           DC.B       0x00                     ; '\0'
+  0x20007BD4:  00           DC.B       0x00                     ; '\0'
+  0x20007BD5:  00           DC.B       0x00                     ; '\0'
+  0x20007BD6:  00           DC.B       0x00                     ; '\0'
+  0x20007BD7:  00           DC.B       0x00                     ; '\0'
+  0x20007BD8:  00           DC.B       0x00                     ; '\0'
+  0x20007BD9:  00           DC.B       0x00                     ; '\0'
+  0x20007BDA:  00           DC.B       0x00                     ; '\0'
+  0x20007BDB:  00           DC.B       0x00                     ; '\0'
+  0x20007BDC:  00           DC.B       0x00                     ; '\0'
+  0x20007BDD:  00           DC.B       0x00                     ; '\0'
+  0x20007BDE:  00           DC.B       0x00                     ; '\0'
+  0x20007BDF:  00           DC.B       0x00                     ; '\0'
+  0x20007BE0:  00           DC.B       0x00                     ; '\0'
+  0x20007BE1:  00           DC.B       0x00                     ; '\0'
+  0x20007BE2:  00           DC.B       0x00                     ; '\0'
+  0x20007BE3:  00           DC.B       0x00                     ; '\0'
+  0x20007BE4:  00           DC.B       0x00                     ; '\0'
+  0x20007BE5:  00           DC.B       0x00                     ; '\0'
+  0x20007BE6:  00           DC.B       0x00                     ; '\0'
+  0x20007BE7:  00           DC.B       0x00                     ; '\0'
+  0x20007BE8:  00           DC.B       0x00                     ; '\0'
+  0x20007BE9:  00           DC.B       0x00                     ; '\0'
+  0x20007BEA:  00           DC.B       0x00                     ; '\0'
+  0x20007BEB:  00           DC.B       0x00                     ; '\0'
+  0x20007BEC:  00           DC.B       0x00                     ; '\0'
+  0x20007BED:  00           DC.B       0x00                     ; '\0'
+  0x20007BEE:  00           DC.B       0x00                     ; '\0'
+  0x20007BEF:  00           DC.B       0x00                     ; '\0'
+  0x20007BF0:  00           DC.B       0x00                     ; '\0'
+  0x20007BF1:  00           DC.B       0x00                     ; '\0'
+  0x20007BF2:  00           DC.B       0x00                     ; '\0'
+  0x20007BF3:  00           DC.B       0x00                     ; '\0'
+  0x20007BF4:  00           DC.B       0x00                     ; '\0'
+  0x20007BF5:  00           DC.B       0x00                     ; '\0'
+  0x20007BF6:  00           DC.B       0x00                     ; '\0'
+  0x20007BF7:  00           DC.B       0x00                     ; '\0'
+  0x20007BF8:  00           DC.B       0x00                     ; '\0'
+  0x20007BF9:  00           DC.B       0x00                     ; '\0'
+  0x20007BFA:  00           DC.B       0x00                     ; '\0'
+  0x20007BFB:  00           DC.B       0x00                     ; '\0'
+  0x20007BFC:  00           DC.B       0x00                     ; '\0'
+  0x20007BFD:  00           DC.B       0x00                     ; '\0'
+  0x20007BFE:  00           DC.B       0x00                     ; '\0'
+  0x20007BFF:  00           DC.B       0x00                     ; '\0'
+  0x20007C00:  00           DC.B       0x00                     ; '\0'
+  0x20007C01:  00           DC.B       0x00                     ; '\0'
+  0x20007C02:  00           DC.B       0x00                     ; '\0'
+  0x20007C03:  00           DC.B       0x00                     ; '\0'
+  0x20007C04:  00           DC.B       0x00                     ; '\0'
+  0x20007C05:  00           DC.B       0x00                     ; '\0'
+  0x20007C06:  00           DC.B       0x00                     ; '\0'
+  0x20007C07:  00           DC.B       0x00                     ; '\0'
+  0x20007C08:  00           DC.B       0x00                     ; '\0'
+  0x20007C09:  00           DC.B       0x00                     ; '\0'
+  0x20007C0A:  00           DC.B       0x00                     ; '\0'
+  0x20007C0B:  00           DC.B       0x00                     ; '\0'
+  0x20007C0C:  00           DC.B       0x00                     ; '\0'
+  0x20007C0D:  00           DC.B       0x00                     ; '\0'
+  0x20007C0E:  00           DC.B       0x00                     ; '\0'
+  0x20007C0F:  00           DC.B       0x00                     ; '\0'
+  0x20007C10:  00           DC.B       0x00                     ; '\0'
+  0x20007C11:  00           DC.B       0x00                     ; '\0'
+  0x20007C12:  00           DC.B       0x00                     ; '\0'
+  0x20007C13:  00           DC.B       0x00                     ; '\0'
+  0x20007C14:  00           DC.B       0x00                     ; '\0'
+  0x20007C15:  00           DC.B       0x00                     ; '\0'
+  0x20007C16:  00           DC.B       0x00                     ; '\0'
+  0x20007C17:  00           DC.B       0x00                     ; '\0'
+  0x20007C18:  00           DC.B       0x00                     ; '\0'
+  0x20007C19:  00           DC.B       0x00                     ; '\0'
+  0x20007C1A:  00           DC.B       0x00                     ; '\0'
+  0x20007C1B:  00           DC.B       0x00                     ; '\0'
+  0x20007C1C:  00           DC.B       0x00                     ; '\0'
+  0x20007C1D:  00           DC.B       0x00                     ; '\0'
+  0x20007C1E:  00           DC.B       0x00                     ; '\0'
+  0x20007C1F:  00           DC.B       0x00                     ; '\0'
+  0x20007C20:  00           DC.B       0x00                     ; '\0'
+  0x20007C21:  00           DC.B       0x00                     ; '\0'
+  0x20007C22:  00           DC.B       0x00                     ; '\0'
+  0x20007C23:  00           DC.B       0x00                     ; '\0'
+  0x20007C24:  00           DC.B       0x00                     ; '\0'
+  0x20007C25:  00           DC.B       0x00                     ; '\0'
+  0x20007C26:  00           DC.B       0x00                     ; '\0'
+  0x20007C27:  00           DC.B       0x00                     ; '\0'
+  0x20007C28:  00           DC.B       0x00                     ; '\0'
+  0x20007C29:  00           DC.B       0x00                     ; '\0'
+  0x20007C2A:  00           DC.B       0x00                     ; '\0'
+  0x20007C2B:  00           DC.B       0x00                     ; '\0'
+  0x20007C2C:  00           DC.B       0x00                     ; '\0'
+  0x20007C2D:  00           DC.B       0x00                     ; '\0'
+  0x20007C2E:  00           DC.B       0x00                     ; '\0'
+  0x20007C2F:  00           DC.B       0x00                     ; '\0'
+  0x20007C30:  00           DC.B       0x00                     ; '\0'
+  0x20007C31:  00           DC.B       0x00                     ; '\0'
+  0x20007C32:  00           DC.B       0x00                     ; '\0'
+  0x20007C33:  00           DC.B       0x00                     ; '\0'
+  0x20007C34:  00           DC.B       0x00                     ; '\0'
+  0x20007C35:  00           DC.B       0x00                     ; '\0'
+  0x20007C36:  00           DC.B       0x00                     ; '\0'
+  0x20007C37:  00           DC.B       0x00                     ; '\0'
+  0x20007C38:  00           DC.B       0x00                     ; '\0'
+  0x20007C39:  00           DC.B       0x00                     ; '\0'
+  0x20007C3A:  00           DC.B       0x00                     ; '\0'
+  0x20007C3B:  00           DC.B       0x00                     ; '\0'
+  0x20007C3C:  00           DC.B       0x00                     ; '\0'
+  0x20007C3D:  00           DC.B       0x00                     ; '\0'
+  0x20007C3E:  00           DC.B       0x00                     ; '\0'
+  0x20007C3F:  00           DC.B       0x00                     ; '\0'
+  0x20007C40:  00           DC.B       0x00                     ; '\0'
+  0x20007C41:  00           DC.B       0x00                     ; '\0'
+  0x20007C42:  00           DC.B       0x00                     ; '\0'
+  0x20007C43:  00           DC.B       0x00                     ; '\0'
+  0x20007C44:  00           DC.B       0x00                     ; '\0'
+  0x20007C45:  00           DC.B       0x00                     ; '\0'
+  0x20007C46:  00           DC.B       0x00                     ; '\0'
+  0x20007C47:  00           DC.B       0x00                     ; '\0'
+  0x20007C48:  00           DC.B       0x00                     ; '\0'
+  0x20007C49:  00           DC.B       0x00                     ; '\0'
+  0x20007C4A:  00           DC.B       0x00                     ; '\0'
+  0x20007C4B:  00           DC.B       0x00                     ; '\0'
+  0x20007C4C:  00           DC.B       0x00                     ; '\0'
+  0x20007C4D:  00           DC.B       0x00                     ; '\0'
+  0x20007C4E:  00           DC.B       0x00                     ; '\0'
+  0x20007C4F:  00           DC.B       0x00                     ; '\0'
+  0x20007C50:  00           DC.B       0x00                     ; '\0'
+  0x20007C51:  00           DC.B       0x00                     ; '\0'
+  0x20007C52:  00           DC.B       0x00                     ; '\0'
+  0x20007C53:  00           DC.B       0x00                     ; '\0'
+  0x20007C54:  00           DC.B       0x00                     ; '\0'
+  0x20007C55:  00           DC.B       0x00                     ; '\0'
+  0x20007C56:  00           DC.B       0x00                     ; '\0'
+  0x20007C57:  00           DC.B       0x00                     ; '\0'
+  0x20007C58:  00           DC.B       0x00                     ; '\0'
+  0x20007C59:  00           DC.B       0x00                     ; '\0'
+  0x20007C5A:  00           DC.B       0x00                     ; '\0'
+  0x20007C5B:  00           DC.B       0x00                     ; '\0'
+  0x20007C5C:  00           DC.B       0x00                     ; '\0'
+  0x20007C5D:  00           DC.B       0x00                     ; '\0'
+  0x20007C5E:  00           DC.B       0x00                     ; '\0'
+  0x20007C5F:  00           DC.B       0x00                     ; '\0'
+  0x20007C60:  00           DC.B       0x00                     ; '\0'
+  0x20007C61:  00           DC.B       0x00                     ; '\0'
+  0x20007C62:  00           DC.B       0x00                     ; '\0'
+  0x20007C63:  00           DC.B       0x00                     ; '\0'
+  0x20007C64:  00           DC.B       0x00                     ; '\0'
+  0x20007C65:  00           DC.B       0x00                     ; '\0'
+  0x20007C66:  00           DC.B       0x00                     ; '\0'
+  0x20007C67:  00           DC.B       0x00                     ; '\0'
+  0x20007C68:  00           DC.B       0x00                     ; '\0'
+  0x20007C69:  00           DC.B       0x00                     ; '\0'
+  0x20007C6A:  00           DC.B       0x00                     ; '\0'
+  0x20007C6B:  00           DC.B       0x00                     ; '\0'
+  0x20007C6C:  00           DC.B       0x00                     ; '\0'
+  0x20007C6D:  00           DC.B       0x00                     ; '\0'
+  0x20007C6E:  00           DC.B       0x00                     ; '\0'
+  0x20007C6F:  00           DC.B       0x00                     ; '\0'
+  0x20007C70:  00           DC.B       0x00                     ; '\0'
+  0x20007C71:  00           DC.B       0x00                     ; '\0'
+  0x20007C72:  00           DC.B       0x00                     ; '\0'
+  0x20007C73:  00           DC.B       0x00                     ; '\0'
+  0x20007C74:  00           DC.B       0x00                     ; '\0'
+  0x20007C75:  00           DC.B       0x00                     ; '\0'
+  0x20007C76:  00           DC.B       0x00                     ; '\0'
+  0x20007C77:  00           DC.B       0x00                     ; '\0'
+  0x20007C78:  00           DC.B       0x00                     ; '\0'
+  0x20007C79:  00           DC.B       0x00                     ; '\0'
+  0x20007C7A:  00           DC.B       0x00                     ; '\0'
+  0x20007C7B:  00           DC.B       0x00                     ; '\0'
+  0x20007C7C:  00           DC.B       0x00                     ; '\0'
+  0x20007C7D:  00           DC.B       0x00                     ; '\0'
+  0x20007C7E:  00           DC.B       0x00                     ; '\0'
+  0x20007C7F:  00           DC.B       0x00                     ; '\0'
+  0x20007C80:  00           DC.B       0x00                     ; '\0'
+  0x20007C81:  00           DC.B       0x00                     ; '\0'
+  0x20007C82:  00           DC.B       0x00                     ; '\0'
+  0x20007C83:  00           DC.B       0x00                     ; '\0'
+  0x20007C84:  00           DC.B       0x00                     ; '\0'
+  0x20007C85:  00           DC.B       0x00                     ; '\0'
+  0x20007C86:  00           DC.B       0x00                     ; '\0'
+  0x20007C87:  00           DC.B       0x00                     ; '\0'
+  0x20007C88:  00           DC.B       0x00                     ; '\0'
+  0x20007C89:  00           DC.B       0x00                     ; '\0'
+  0x20007C8A:  00           DC.B       0x00                     ; '\0'
+  0x20007C8B:  00           DC.B       0x00                     ; '\0'
+  0x20007C8C:  00           DC.B       0x00                     ; '\0'
+  0x20007C8D:  00           DC.B       0x00                     ; '\0'
+  0x20007C8E:  00           DC.B       0x00                     ; '\0'
+  0x20007C8F:  00           DC.B       0x00                     ; '\0'
+  0x20007C90:  00           DC.B       0x00                     ; '\0'
+  0x20007C91:  00           DC.B       0x00                     ; '\0'
+  0x20007C92:  00           DC.B       0x00                     ; '\0'
+  0x20007C93:  00           DC.B       0x00                     ; '\0'
+  0x20007C94:  00           DC.B       0x00                     ; '\0'
+  0x20007C95:  00           DC.B       0x00                     ; '\0'
+  0x20007C96:  00           DC.B       0x00                     ; '\0'
+  0x20007C97:  00           DC.B       0x00                     ; '\0'
+  0x20007C98:  00           DC.B       0x00                     ; '\0'
+  0x20007C99:  00           DC.B       0x00                     ; '\0'
+  0x20007C9A:  00           DC.B       0x00                     ; '\0'
+  0x20007C9B:  00           DC.B       0x00                     ; '\0'
+  0x20007C9C:  00           DC.B       0x00                     ; '\0'
+  0x20007C9D:  00           DC.B       0x00                     ; '\0'
+  0x20007C9E:  00           DC.B       0x00                     ; '\0'
+  0x20007C9F:  00           DC.B       0x00                     ; '\0'
+  0x20007CA0:  00           DC.B       0x00                     ; '\0'
+  0x20007CA1:  00           DC.B       0x00                     ; '\0'
+  0x20007CA2:  00           DC.B       0x00                     ; '\0'
+  0x20007CA3:  00           DC.B       0x00                     ; '\0'
+  0x20007CA4:  00           DC.B       0x00                     ; '\0'
+  0x20007CA5:  00           DC.B       0x00                     ; '\0'
+  0x20007CA6:  00           DC.B       0x00                     ; '\0'
+  0x20007CA7:  00           DC.B       0x00                     ; '\0'
+  0x20007CA8:  00           DC.B       0x00                     ; '\0'
+  0x20007CA9:  00           DC.B       0x00                     ; '\0'
+  0x20007CAA:  00           DC.B       0x00                     ; '\0'
+  0x20007CAB:  00           DC.B       0x00                     ; '\0'
+  0x20007CAC:  00           DC.B       0x00                     ; '\0'
+  0x20007CAD:  00           DC.B       0x00                     ; '\0'
+  0x20007CAE:  00           DC.B       0x00                     ; '\0'
+  0x20007CAF:  00           DC.B       0x00                     ; '\0'
+  0x20007CB0:  00           DC.B       0x00                     ; '\0'
+  0x20007CB1:  00           DC.B       0x00                     ; '\0'
+  0x20007CB2:  00           DC.B       0x00                     ; '\0'
+  0x20007CB3:  00           DC.B       0x00                     ; '\0'
+  0x20007CB4:  00           DC.B       0x00                     ; '\0'
+  0x20007CB5:  00           DC.B       0x00                     ; '\0'
+  0x20007CB6:  00           DC.B       0x00                     ; '\0'
+  0x20007CB7:  00           DC.B       0x00                     ; '\0'
+  0x20007CB8:  00           DC.B       0x00                     ; '\0'
+  0x20007CB9:  00           DC.B       0x00                     ; '\0'
+  0x20007CBA:  00           DC.B       0x00                     ; '\0'
+  0x20007CBB:  00           DC.B       0x00                     ; '\0'
+  0x20007CBC:  00           DC.B       0x00                     ; '\0'
+  0x20007CBD:  00           DC.B       0x00                     ; '\0'
+  0x20007CBE:  00           DC.B       0x00                     ; '\0'
+  0x20007CBF:  00           DC.B       0x00                     ; '\0'
+  0x20007CC0:  00           DC.B       0x00                     ; '\0'
+  0x20007CC1:  00           DC.B       0x00                     ; '\0'
+  0x20007CC2:  00           DC.B       0x00                     ; '\0'
+  0x20007CC3:  00           DC.B       0x00                     ; '\0'
+  0x20007CC4:  00           DC.B       0x00                     ; '\0'
+  0x20007CC5:  00           DC.B       0x00                     ; '\0'
+  0x20007CC6:  00           DC.B       0x00                     ; '\0'
+  0x20007CC7:  00           DC.B       0x00                     ; '\0'
+  0x20007CC8:  00           DC.B       0x00                     ; '\0'
+  0x20007CC9:  00           DC.B       0x00                     ; '\0'
+  0x20007CCA:  00           DC.B       0x00                     ; '\0'
+  0x20007CCB:  00           DC.B       0x00                     ; '\0'
+  0x20007CCC:  00           DC.B       0x00                     ; '\0'
+  0x20007CCD:  00           DC.B       0x00                     ; '\0'
+  0x20007CCE:  00           DC.B       0x00                     ; '\0'
+  0x20007CCF:  00           DC.B       0x00                     ; '\0'
+  0x20007CD0:  00           DC.B       0x00                     ; '\0'
+  0x20007CD1:  00           DC.B       0x00                     ; '\0'
+  0x20007CD2:  00           DC.B       0x00                     ; '\0'
+  0x20007CD3:  00           DC.B       0x00                     ; '\0'
+  0x20007CD4:  00           DC.B       0x00                     ; '\0'
+  0x20007CD5:  00           DC.B       0x00                     ; '\0'
+  0x20007CD6:  00           DC.B       0x00                     ; '\0'
+  0x20007CD7:  00           DC.B       0x00                     ; '\0'
+  0x20007CD8:  00           DC.B       0x00                     ; '\0'
+  0x20007CD9:  00           DC.B       0x00                     ; '\0'
+  0x20007CDA:  00           DC.B       0x00                     ; '\0'
+  0x20007CDB:  00           DC.B       0x00                     ; '\0'
+  0x20007CDC:  00           DC.B       0x00                     ; '\0'
+  0x20007CDD:  00           DC.B       0x00                     ; '\0'
+  0x20007CDE:  00           DC.B       0x00                     ; '\0'
+  0x20007CDF:  00           DC.B       0x00                     ; '\0'
+  0x20007CE0:  00           DC.B       0x00                     ; '\0'
+  0x20007CE1:  00           DC.B       0x00                     ; '\0'
+  0x20007CE2:  00           DC.B       0x00                     ; '\0'
+  0x20007CE3:  00           DC.B       0x00                     ; '\0'
+  0x20007CE4:  00           DC.B       0x00                     ; '\0'
+  0x20007CE5:  00           DC.B       0x00                     ; '\0'
+  0x20007CE6:  00           DC.B       0x00                     ; '\0'
+  0x20007CE7:  00           DC.B       0x00                     ; '\0'
+  0x20007CE8:  00           DC.B       0x00                     ; '\0'
+  0x20007CE9:  00           DC.B       0x00                     ; '\0'
+  0x20007CEA:  00           DC.B       0x00                     ; '\0'
+  0x20007CEB:  00           DC.B       0x00                     ; '\0'
+  0x20007CEC:  00           DC.B       0x00                     ; '\0'
+  0x20007CED:  00           DC.B       0x00                     ; '\0'
+  0x20007CEE:  00           DC.B       0x00                     ; '\0'
+  0x20007CEF:  00           DC.B       0x00                     ; '\0'
+  0x20007CF0:  00           DC.B       0x00                     ; '\0'
+  0x20007CF1:  00           DC.B       0x00                     ; '\0'
+  0x20007CF2:  00           DC.B       0x00                     ; '\0'
+  0x20007CF3:  00           DC.B       0x00                     ; '\0'
+  0x20007CF4:  00           DC.B       0x00                     ; '\0'
+  0x20007CF5:  00           DC.B       0x00                     ; '\0'
+  0x20007CF6:  00           DC.B       0x00                     ; '\0'
+  0x20007CF7:  00           DC.B       0x00                     ; '\0'
+  0x20007CF8:  00           DC.B       0x00                     ; '\0'
+  0x20007CF9:  00           DC.B       0x00                     ; '\0'
+  0x20007CFA:  00           DC.B       0x00                     ; '\0'
+  0x20007CFB:  00           DC.B       0x00                     ; '\0'
+  0x20007CFC:  00           DC.B       0x00                     ; '\0'
+  0x20007CFD:  00           DC.B       0x00                     ; '\0'
+  0x20007CFE:  00           DC.B       0x00                     ; '\0'
+  0x20007CFF:  00           DC.B       0x00                     ; '\0'
+  0x20007D00:  00           DC.B       0x00                     ; '\0'
+  0x20007D01:  00           DC.B       0x00                     ; '\0'
+  0x20007D02:  00           DC.B       0x00                     ; '\0'
+  0x20007D03:  00           DC.B       0x00                     ; '\0'
+  0x20007D04:  00           DC.B       0x00                     ; '\0'
+  0x20007D05:  00           DC.B       0x00                     ; '\0'
+  0x20007D06:  00           DC.B       0x00                     ; '\0'
+  0x20007D07:  00           DC.B       0x00                     ; '\0'
+  0x20007D08:  00           DC.B       0x00                     ; '\0'
+  0x20007D09:  00           DC.B       0x00                     ; '\0'
+  0x20007D0A:  00           DC.B       0x00                     ; '\0'
+  0x20007D0B:  00           DC.B       0x00                     ; '\0'
+  0x20007D0C:  00           DC.B       0x00                     ; '\0'
+  0x20007D0D:  00           DC.B       0x00                     ; '\0'
+  0x20007D0E:  00           DC.B       0x00                     ; '\0'
+  0x20007D0F:  00           DC.B       0x00                     ; '\0'
+  0x20007D10:  00           DC.B       0x00                     ; '\0'
+  0x20007D11:  00           DC.B       0x00                     ; '\0'
+  0x20007D12:  00           DC.B       0x00                     ; '\0'
+  0x20007D13:  00           DC.B       0x00                     ; '\0'
+  0x20007D14:  00           DC.B       0x00                     ; '\0'
+  0x20007D15:  00           DC.B       0x00                     ; '\0'
+  0x20007D16:  00           DC.B       0x00                     ; '\0'
+  0x20007D17:  00           DC.B       0x00                     ; '\0'
+  0x20007D18:  00           DC.B       0x00                     ; '\0'
+  0x20007D19:  00           DC.B       0x00                     ; '\0'
+  0x20007D1A:  00           DC.B       0x00                     ; '\0'
+  0x20007D1B:  00           DC.B       0x00                     ; '\0'
+  0x20007D1C:  00           DC.B       0x00                     ; '\0'
+  0x20007D1D:  00           DC.B       0x00                     ; '\0'
+  0x20007D1E:  00           DC.B       0x00                     ; '\0'
+  0x20007D1F:  00           DC.B       0x00                     ; '\0'
+  0x20007D20:  00           DC.B       0x00                     ; '\0'
+  0x20007D21:  00           DC.B       0x00                     ; '\0'
+  0x20007D22:  00           DC.B       0x00                     ; '\0'
+  0x20007D23:  00           DC.B       0x00                     ; '\0'
+  0x20007D24:  00           DC.B       0x00                     ; '\0'
+  0x20007D25:  00           DC.B       0x00                     ; '\0'
+  0x20007D26:  00           DC.B       0x00                     ; '\0'
+  0x20007D27:  00           DC.B       0x00                     ; '\0'
+  0x20007D28:  00           DC.B       0x00                     ; '\0'
+  0x20007D29:  00           DC.B       0x00                     ; '\0'
+  0x20007D2A:  00           DC.B       0x00                     ; '\0'
+  0x20007D2B:  00           DC.B       0x00                     ; '\0'
+  0x20007D2C:  00           DC.B       0x00                     ; '\0'
+  0x20007D2D:  00           DC.B       0x00                     ; '\0'
+  0x20007D2E:  00           DC.B       0x00                     ; '\0'
+  0x20007D2F:  00           DC.B       0x00                     ; '\0'
+  0x20007D30:  00           DC.B       0x00                     ; '\0'
+  0x20007D31:  00           DC.B       0x00                     ; '\0'
+  0x20007D32:  00           DC.B       0x00                     ; '\0'
+  0x20007D33:  00           DC.B       0x00                     ; '\0'
+  0x20007D34:  00           DC.B       0x00                     ; '\0'
+  0x20007D35:  00           DC.B       0x00                     ; '\0'
+  0x20007D36:  00           DC.B       0x00                     ; '\0'
+  0x20007D37:  00           DC.B       0x00                     ; '\0'
+  0x20007D38:  00           DC.B       0x00                     ; '\0'
+  0x20007D39:  00           DC.B       0x00                     ; '\0'
+  0x20007D3A:  00           DC.B       0x00                     ; '\0'
+  0x20007D3B:  00           DC.B       0x00                     ; '\0'
+  0x20007D3C:  00           DC.B       0x00                     ; '\0'
+  0x20007D3D:  00           DC.B       0x00                     ; '\0'
+  0x20007D3E:  00           DC.B       0x00                     ; '\0'
+  0x20007D3F:  00           DC.B       0x00                     ; '\0'
+  0x20007D40:  00           DC.B       0x00                     ; '\0'
+  0x20007D41:  00           DC.B       0x00                     ; '\0'
+  0x20007D42:  00           DC.B       0x00                     ; '\0'
+  0x20007D43:  00           DC.B       0x00                     ; '\0'
+  0x20007D44:  00           DC.B       0x00                     ; '\0'
+  0x20007D45:  00           DC.B       0x00                     ; '\0'
+  0x20007D46:  00           DC.B       0x00                     ; '\0'
+  0x20007D47:  00           DC.B       0x00                     ; '\0'
+  0x20007D48:  00           DC.B       0x00                     ; '\0'
+  0x20007D49:  00           DC.B       0x00                     ; '\0'
+  0x20007D4A:  00           DC.B       0x00                     ; '\0'
+  0x20007D4B:  00           DC.B       0x00                     ; '\0'
+  0x20007D4C:  00           DC.B       0x00                     ; '\0'
+  0x20007D4D:  00           DC.B       0x00                     ; '\0'
+  0x20007D4E:  00           DC.B       0x00                     ; '\0'
+  0x20007D4F:  00           DC.B       0x00                     ; '\0'
+  0x20007D50:  00           DC.B       0x00                     ; '\0'
+  0x20007D51:  00           DC.B       0x00                     ; '\0'
+  0x20007D52:  00           DC.B       0x00                     ; '\0'
+  0x20007D53:  00           DC.B       0x00                     ; '\0'
+  0x20007D54:  00           DC.B       0x00                     ; '\0'
+  0x20007D55:  00           DC.B       0x00                     ; '\0'
+  0x20007D56:  00           DC.B       0x00                     ; '\0'
+  0x20007D57:  00           DC.B       0x00                     ; '\0'
+  0x20007D58:  00           DC.B       0x00                     ; '\0'
+  0x20007D59:  00           DC.B       0x00                     ; '\0'
+  0x20007D5A:  00           DC.B       0x00                     ; '\0'
+  0x20007D5B:  00           DC.B       0x00                     ; '\0'
+  0x20007D5C:  00           DC.B       0x00                     ; '\0'
+  0x20007D5D:  00           DC.B       0x00                     ; '\0'
+  0x20007D5E:  00           DC.B       0x00                     ; '\0'
+  0x20007D5F:  00           DC.B       0x00                     ; '\0'
+  0x20007D60:  00           DC.B       0x00                     ; '\0'
+  0x20007D61:  00           DC.B       0x00                     ; '\0'
+  0x20007D62:  00           DC.B       0x00                     ; '\0'
+  0x20007D63:  00           DC.B       0x00                     ; '\0'
+  0x20007D64:  00           DC.B       0x00                     ; '\0'
+  0x20007D65:  00           DC.B       0x00                     ; '\0'
+  0x20007D66:  00           DC.B       0x00                     ; '\0'
+  0x20007D67:  00           DC.B       0x00                     ; '\0'
+  0x20007D68:  00           DC.B       0x00                     ; '\0'
+  0x20007D69:  00           DC.B       0x00                     ; '\0'
+  0x20007D6A:  00           DC.B       0x00                     ; '\0'
+  0x20007D6B:  00           DC.B       0x00                     ; '\0'
+  0x20007D6C:  00           DC.B       0x00                     ; '\0'
+  0x20007D6D:  00           DC.B       0x00                     ; '\0'
+  0x20007D6E:  00           DC.B       0x00                     ; '\0'
+  0x20007D6F:  00           DC.B       0x00                     ; '\0'
+  0x20007D70:  00           DC.B       0x00                     ; '\0'
+  0x20007D71:  00           DC.B       0x00                     ; '\0'
+  0x20007D72:  00           DC.B       0x00                     ; '\0'
+  0x20007D73:  00           DC.B       0x00                     ; '\0'
+  0x20007D74:  00           DC.B       0x00                     ; '\0'
+  0x20007D75:  00           DC.B       0x00                     ; '\0'
+  0x20007D76:  00           DC.B       0x00                     ; '\0'
+  0x20007D77:  00           DC.B       0x00                     ; '\0'
+  0x20007D78:  00           DC.B       0x00                     ; '\0'
+  0x20007D79:  00           DC.B       0x00                     ; '\0'
+  0x20007D7A:  00           DC.B       0x00                     ; '\0'
+  0x20007D7B:  00           DC.B       0x00                     ; '\0'
+  0x20007D7C:  00           DC.B       0x00                     ; '\0'
+  0x20007D7D:  00           DC.B       0x00                     ; '\0'
+  0x20007D7E:  00           DC.B       0x00                     ; '\0'
+  0x20007D7F:  00           DC.B       0x00                     ; '\0'
+  0x20007D80:  00           DC.B       0x00                     ; '\0'
+  0x20007D81:  00           DC.B       0x00                     ; '\0'
+  0x20007D82:  00           DC.B       0x00                     ; '\0'
+  0x20007D83:  00           DC.B       0x00                     ; '\0'
+  0x20007D84:  00           DC.B       0x00                     ; '\0'
+  0x20007D85:  00           DC.B       0x00                     ; '\0'
+  0x20007D86:  00           DC.B       0x00                     ; '\0'
+  0x20007D87:  00           DC.B       0x00                     ; '\0'
+  0x20007D88:  00           DC.B       0x00                     ; '\0'
+  0x20007D89:  00           DC.B       0x00                     ; '\0'
+  0x20007D8A:  00           DC.B       0x00                     ; '\0'
+  0x20007D8B:  00           DC.B       0x00                     ; '\0'
+  0x20007D8C:  00           DC.B       0x00                     ; '\0'
+  0x20007D8D:  00           DC.B       0x00                     ; '\0'
+  0x20007D8E:  00           DC.B       0x00                     ; '\0'
+  0x20007D8F:  00           DC.B       0x00                     ; '\0'
+  0x20007D90:  00           DC.B       0x00                     ; '\0'
+  0x20007D91:  00           DC.B       0x00                     ; '\0'
+  0x20007D92:  00           DC.B       0x00                     ; '\0'
+  0x20007D93:  00           DC.B       0x00                     ; '\0'
+  0x20007D94:  00           DC.B       0x00                     ; '\0'
+  0x20007D95:  00           DC.B       0x00                     ; '\0'
+  0x20007D96:  00           DC.B       0x00                     ; '\0'
+  0x20007D97:  00           DC.B       0x00                     ; '\0'
+  0x20007D98:  00           DC.B       0x00                     ; '\0'
+  0x20007D99:  00           DC.B       0x00                     ; '\0'
+  0x20007D9A:  00           DC.B       0x00                     ; '\0'
+  0x20007D9B:  00           DC.B       0x00                     ; '\0'
+  0x20007D9C:  00           DC.B       0x00                     ; '\0'
+  0x20007D9D:  00           DC.B       0x00                     ; '\0'
+  0x20007D9E:  00           DC.B       0x00                     ; '\0'
+  0x20007D9F:  00           DC.B       0x00                     ; '\0'
+  0x20007DA0:  00           DC.B       0x00                     ; '\0'
+  0x20007DA1:  00           DC.B       0x00                     ; '\0'
+  0x20007DA2:  00           DC.B       0x00                     ; '\0'
+  0x20007DA3:  00           DC.B       0x00                     ; '\0'
+  0x20007DA4:  00           DC.B       0x00                     ; '\0'
+  0x20007DA5:  00           DC.B       0x00                     ; '\0'
+  0x20007DA6:  00           DC.B       0x00                     ; '\0'
+  0x20007DA7:  00           DC.B       0x00                     ; '\0'
+  0x20007DA8:  00           DC.B       0x00                     ; '\0'
+  0x20007DA9:  00           DC.B       0x00                     ; '\0'
+  0x20007DAA:  00           DC.B       0x00                     ; '\0'
+  0x20007DAB:  00           DC.B       0x00                     ; '\0'
+  0x20007DAC:  00           DC.B       0x00                     ; '\0'
+  0x20007DAD:  00           DC.B       0x00                     ; '\0'
+  0x20007DAE:  00           DC.B       0x00                     ; '\0'
+  0x20007DAF:  00           DC.B       0x00                     ; '\0'
+  0x20007DB0:  00           DC.B       0x00                     ; '\0'
+  0x20007DB1:  00           DC.B       0x00                     ; '\0'
+  0x20007DB2:  00           DC.B       0x00                     ; '\0'
+  0x20007DB3:  00           DC.B       0x00                     ; '\0'
+  0x20007DB4:  00           DC.B       0x00                     ; '\0'
+  0x20007DB5:  00           DC.B       0x00                     ; '\0'
+  0x20007DB6:  00           DC.B       0x00                     ; '\0'
+  0x20007DB7:  00           DC.B       0x00                     ; '\0'
+  0x20007DB8:  00           DC.B       0x00                     ; '\0'
+  0x20007DB9:  00           DC.B       0x00                     ; '\0'
+  0x20007DBA:  00           DC.B       0x00                     ; '\0'
+  0x20007DBB:  00           DC.B       0x00                     ; '\0'
+  0x20007DBC:  00           DC.B       0x00                     ; '\0'
+  0x20007DBD:  00           DC.B       0x00                     ; '\0'
+  0x20007DBE:  00           DC.B       0x00                     ; '\0'
+  0x20007DBF:  00           DC.B       0x00                     ; '\0'
+  0x20007DC0:  00           DC.B       0x00                     ; '\0'
+  0x20007DC1:  00           DC.B       0x00                     ; '\0'
+  0x20007DC2:  00           DC.B       0x00                     ; '\0'
+  0x20007DC3:  00           DC.B       0x00                     ; '\0'
+  0x20007DC4:  00           DC.B       0x00                     ; '\0'
+  0x20007DC5:  00           DC.B       0x00                     ; '\0'
+  0x20007DC6:  00           DC.B       0x00                     ; '\0'
+  0x20007DC7:  00           DC.B       0x00                     ; '\0'
+  0x20007DC8:  00           DC.B       0x00                     ; '\0'
+  0x20007DC9:  00           DC.B       0x00                     ; '\0'
+  0x20007DCA:  00           DC.B       0x00                     ; '\0'
+  0x20007DCB:  00           DC.B       0x00                     ; '\0'
+  0x20007DCC:  00           DC.B       0x00                     ; '\0'
+  0x20007DCD:  00           DC.B       0x00                     ; '\0'
+  0x20007DCE:  00           DC.B       0x00                     ; '\0'
+  0x20007DCF:  00           DC.B       0x00                     ; '\0'
+  0x20007DD0:  00           DC.B       0x00                     ; '\0'
+  0x20007DD1:  00           DC.B       0x00                     ; '\0'
+  0x20007DD2:  00           DC.B       0x00                     ; '\0'
+  0x20007DD3:  00           DC.B       0x00                     ; '\0'
+  0x20007DD4:  00           DC.B       0x00                     ; '\0'
+  0x20007DD5:  00           DC.B       0x00                     ; '\0'
+  0x20007DD6:  00           DC.B       0x00                     ; '\0'
+  0x20007DD7:  00           DC.B       0x00                     ; '\0'
+  0x20007DD8:  00           DC.B       0x00                     ; '\0'
+  0x20007DD9:  00           DC.B       0x00                     ; '\0'
+  0x20007DDA:  00           DC.B       0x00                     ; '\0'
+  0x20007DDB:  00           DC.B       0x00                     ; '\0'
+  0x20007DDC:  00           DC.B       0x00                     ; '\0'
+  0x20007DDD:  00           DC.B       0x00                     ; '\0'
+  0x20007DDE:  00           DC.B       0x00                     ; '\0'
+  0x20007DDF:  00           DC.B       0x00                     ; '\0'
+  0x20007DE0:  00           DC.B       0x00                     ; '\0'
+  0x20007DE1:  00           DC.B       0x00                     ; '\0'
+  0x20007DE2:  00           DC.B       0x00                     ; '\0'
+  0x20007DE3:  00           DC.B       0x00                     ; '\0'
+  0x20007DE4:  00           DC.B       0x00                     ; '\0'
+  0x20007DE5:  00           DC.B       0x00                     ; '\0'
+  0x20007DE6:  00           DC.B       0x00                     ; '\0'
+  0x20007DE7:  00           DC.B       0x00                     ; '\0'
+  0x20007DE8:  00           DC.B       0x00                     ; '\0'
+  0x20007DE9:  00           DC.B       0x00                     ; '\0'
+  0x20007DEA:  00           DC.B       0x00                     ; '\0'
+  0x20007DEB:  00           DC.B       0x00                     ; '\0'
+  0x20007DEC:  00           DC.B       0x00                     ; '\0'
+  0x20007DED:  00           DC.B       0x00                     ; '\0'
+  0x20007DEE:  00           DC.B       0x00                     ; '\0'
+  0x20007DEF:  00           DC.B       0x00                     ; '\0'
+  0x20007DF0:  00           DC.B       0x00                     ; '\0'
+  0x20007DF1:  00           DC.B       0x00                     ; '\0'
+  0x20007DF2:  00           DC.B       0x00                     ; '\0'
+  0x20007DF3:  00           DC.B       0x00                     ; '\0'
+  0x20007DF4:  00           DC.B       0x00                     ; '\0'
+  0x20007DF5:  00           DC.B       0x00                     ; '\0'
+  0x20007DF6:  00           DC.B       0x00                     ; '\0'
+  0x20007DF7:  00           DC.B       0x00                     ; '\0'
+  0x20007DF8:  00           DC.B       0x00                     ; '\0'
+  0x20007DF9:  00           DC.B       0x00                     ; '\0'
+  0x20007DFA:  00           DC.B       0x00                     ; '\0'
+  0x20007DFB:  00           DC.B       0x00                     ; '\0'
+  0x20007DFC:  00           DC.B       0x00                     ; '\0'
+  0x20007DFD:  00           DC.B       0x00                     ; '\0'
+  0x20007DFE:  00           DC.B       0x00                     ; '\0'
+  0x20007DFF:  00           DC.B       0x00                     ; '\0'
+  0x20007E00:  00           DC.B       0x00                     ; '\0'
+  0x20007E01:  00           DC.B       0x00                     ; '\0'
+  0x20007E02:  00           DC.B       0x00                     ; '\0'
+  0x20007E03:  00           DC.B       0x00                     ; '\0'
+  0x20007E04:  00           DC.B       0x00                     ; '\0'
+  0x20007E05:  00           DC.B       0x00                     ; '\0'
+  0x20007E06:  00           DC.B       0x00                     ; '\0'
+  0x20007E07:  00           DC.B       0x00                     ; '\0'
+  0x20007E08:  00           DC.B       0x00                     ; '\0'
+  0x20007E09:  00           DC.B       0x00                     ; '\0'
+  0x20007E0A:  00           DC.B       0x00                     ; '\0'
+  0x20007E0B:  00           DC.B       0x00                     ; '\0'
+  0x20007E0C:  00           DC.B       0x00                     ; '\0'
+  0x20007E0D:  00           DC.B       0x00                     ; '\0'
+  0x20007E0E:  00           DC.B       0x00                     ; '\0'
+  0x20007E0F:  00           DC.B       0x00                     ; '\0'
+  0x20007E10:  00           DC.B       0x00                     ; '\0'
+  0x20007E11:  00           DC.B       0x00                     ; '\0'
+  0x20007E12:  00           DC.B       0x00                     ; '\0'
+  0x20007E13:  00           DC.B       0x00                     ; '\0'
+  0x20007E14:  00           DC.B       0x00                     ; '\0'
+  0x20007E15:  00           DC.B       0x00                     ; '\0'
+  0x20007E16:  00           DC.B       0x00                     ; '\0'
+  0x20007E17:  00           DC.B       0x00                     ; '\0'
+  0x20007E18:  00           DC.B       0x00                     ; '\0'
+  0x20007E19:  00           DC.B       0x00                     ; '\0'
+  0x20007E1A:  00           DC.B       0x00                     ; '\0'
+  0x20007E1B:  00           DC.B       0x00                     ; '\0'
+  0x20007E1C:  00           DC.B       0x00                     ; '\0'
+  0x20007E1D:  00           DC.B       0x00                     ; '\0'
+  0x20007E1E:  00           DC.B       0x00                     ; '\0'
+  0x20007E1F:  00           DC.B       0x00                     ; '\0'
+  0x20007E20:  00           DC.B       0x00                     ; '\0'
+  0x20007E21:  00           DC.B       0x00                     ; '\0'
+  0x20007E22:  00           DC.B       0x00                     ; '\0'
+  0x20007E23:  00           DC.B       0x00                     ; '\0'
+  0x20007E24:  00           DC.B       0x00                     ; '\0'
+  0x20007E25:  00           DC.B       0x00                     ; '\0'
+  0x20007E26:  00           DC.B       0x00                     ; '\0'
+  0x20007E27:  00           DC.B       0x00                     ; '\0'
+  0x20007E28:  00           DC.B       0x00                     ; '\0'
+  0x20007E29:  00           DC.B       0x00                     ; '\0'
+  0x20007E2A:  00           DC.B       0x00                     ; '\0'
+  0x20007E2B:  00           DC.B       0x00                     ; '\0'
+  0x20007E2C:  00           DC.B       0x00                     ; '\0'
+  0x20007E2D:  00           DC.B       0x00                     ; '\0'
+  0x20007E2E:  00           DC.B       0x00                     ; '\0'
+  0x20007E2F:  00           DC.B       0x00                     ; '\0'
+  0x20007E30:  00           DC.B       0x00                     ; '\0'
+  0x20007E31:  00           DC.B       0x00                     ; '\0'
+  0x20007E32:  00           DC.B       0x00                     ; '\0'
+  0x20007E33:  00           DC.B       0x00                     ; '\0'
+  0x20007E34:  00           DC.B       0x00                     ; '\0'
+  0x20007E35:  00           DC.B       0x00                     ; '\0'
+  0x20007E36:  00           DC.B       0x00                     ; '\0'
+  0x20007E37:  00           DC.B       0x00                     ; '\0'
+  0x20007E38:  00           DC.B       0x00                     ; '\0'
+  0x20007E39:  00           DC.B       0x00                     ; '\0'
+  0x20007E3A:  00           DC.B       0x00                     ; '\0'
+  0x20007E3B:  00           DC.B       0x00                     ; '\0'
+  0x20007E3C:  00           DC.B       0x00                     ; '\0'
+  0x20007E3D:  00           DC.B       0x00                     ; '\0'
+  0x20007E3E:  00           DC.B       0x00                     ; '\0'
+  0x20007E3F:  00           DC.B       0x00                     ; '\0'
+  0x20007E40:  00           DC.B       0x00                     ; '\0'
+  0x20007E41:  00           DC.B       0x00                     ; '\0'
+  0x20007E42:  00           DC.B       0x00                     ; '\0'
+  0x20007E43:  00           DC.B       0x00                     ; '\0'
+  0x20007E44:  00           DC.B       0x00                     ; '\0'
+  0x20007E45:  00           DC.B       0x00                     ; '\0'
+  0x20007E46:  00           DC.B       0x00                     ; '\0'
+  0x20007E47:  00           DC.B       0x00                     ; '\0'
+  0x20007E48:  00           DC.B       0x00                     ; '\0'
+  0x20007E49:  00           DC.B       0x00                     ; '\0'
+  0x20007E4A:  00           DC.B       0x00                     ; '\0'
+  0x20007E4B:  00           DC.B       0x00                     ; '\0'
+  0x20007E4C:  00           DC.B       0x00                     ; '\0'
+  0x20007E4D:  00           DC.B       0x00                     ; '\0'
+  0x20007E4E:  00           DC.B       0x00                     ; '\0'
+  0x20007E4F:  00           DC.B       0x00                     ; '\0'
+  0x20007E50:  00           DC.B       0x00                     ; '\0'
+  0x20007E51:  00           DC.B       0x00                     ; '\0'
+  0x20007E52:  00           DC.B       0x00                     ; '\0'
+  0x20007E53:  00           DC.B       0x00                     ; '\0'
+  0x20007E54:  00           DC.B       0x00                     ; '\0'
+  0x20007E55:  00           DC.B       0x00                     ; '\0'
+  0x20007E56:  00           DC.B       0x00                     ; '\0'
+  0x20007E57:  00           DC.B       0x00                     ; '\0'
+  0x20007E58:  00           DC.B       0x00                     ; '\0'
+  0x20007E59:  00           DC.B       0x00                     ; '\0'
+  0x20007E5A:  00           DC.B       0x00                     ; '\0'
+  0x20007E5B:  00           DC.B       0x00                     ; '\0'
+  0x20007E5C:  00           DC.B       0x00                     ; '\0'
+  0x20007E5D:  00           DC.B       0x00                     ; '\0'
+  0x20007E5E:  00           DC.B       0x00                     ; '\0'
+  0x20007E5F:  00           DC.B       0x00                     ; '\0'
+  0x20007E60:  00           DC.B       0x00                     ; '\0'
+  0x20007E61:  00           DC.B       0x00                     ; '\0'
+  0x20007E62:  00           DC.B       0x00                     ; '\0'
+  0x20007E63:  00           DC.B       0x00                     ; '\0'
+  0x20007E64:  00           DC.B       0x00                     ; '\0'
+  0x20007E65:  00           DC.B       0x00                     ; '\0'
+  0x20007E66:  00           DC.B       0x00                     ; '\0'
+  0x20007E67:  00           DC.B       0x00                     ; '\0'
+  0x20007E68:  00           DC.B       0x00                     ; '\0'
+  0x20007E69:  00           DC.B       0x00                     ; '\0'
+  0x20007E6A:  00           DC.B       0x00                     ; '\0'
+  0x20007E6B:  00           DC.B       0x00                     ; '\0'
+  0x20007E6C:  00           DC.B       0x00                     ; '\0'
+  0x20007E6D:  00           DC.B       0x00                     ; '\0'
+  0x20007E6E:  00           DC.B       0x00                     ; '\0'
+  0x20007E6F:  00           DC.B       0x00                     ; '\0'
+  0x20007E70:  00           DC.B       0x00                     ; '\0'
+  0x20007E71:  00           DC.B       0x00                     ; '\0'
+  0x20007E72:  00           DC.B       0x00                     ; '\0'
+  0x20007E73:  00           DC.B       0x00                     ; '\0'
+  0x20007E74:  00           DC.B       0x00                     ; '\0'
+  0x20007E75:  00           DC.B       0x00                     ; '\0'
+  0x20007E76:  00           DC.B       0x00                     ; '\0'
+  0x20007E77:  00           DC.B       0x00                     ; '\0'
+  0x20007E78:  00           DC.B       0x00                     ; '\0'
+  0x20007E79:  00           DC.B       0x00                     ; '\0'
+  0x20007E7A:  00           DC.B       0x00                     ; '\0'
+  0x20007E7B:  00           DC.B       0x00                     ; '\0'
+  0x20007E7C:  00           DC.B       0x00                     ; '\0'
+  0x20007E7D:  00           DC.B       0x00                     ; '\0'
+  0x20007E7E:  00           DC.B       0x00                     ; '\0'
+  0x20007E7F:  00           DC.B       0x00                     ; '\0'
+  0x20007E80:  00           DC.B       0x00                     ; '\0'
+  0x20007E81:  00           DC.B       0x00                     ; '\0'
+  0x20007E82:  00           DC.B       0x00                     ; '\0'
+  0x20007E83:  00           DC.B       0x00                     ; '\0'
+  0x20007E84:  00           DC.B       0x00                     ; '\0'
+  0x20007E85:  00           DC.B       0x00                     ; '\0'
+  0x20007E86:  00           DC.B       0x00                     ; '\0'
+  0x20007E87:  00           DC.B       0x00                     ; '\0'
+  0x20007E88:  00           DC.B       0x00                     ; '\0'
+  0x20007E89:  00           DC.B       0x00                     ; '\0'
+  0x20007E8A:  00           DC.B       0x00                     ; '\0'
+  0x20007E8B:  00           DC.B       0x00                     ; '\0'
+  0x20007E8C:  00           DC.B       0x00                     ; '\0'
+  0x20007E8D:  00           DC.B       0x00                     ; '\0'
+  0x20007E8E:  00           DC.B       0x00                     ; '\0'
+  0x20007E8F:  00           DC.B       0x00                     ; '\0'
+  0x20007E90:  00           DC.B       0x00                     ; '\0'
+  0x20007E91:  00           DC.B       0x00                     ; '\0'
+  0x20007E92:  00           DC.B       0x00                     ; '\0'
+  0x20007E93:  00           DC.B       0x00                     ; '\0'
+  0x20007E94:  00           DC.B       0x00                     ; '\0'
+  0x20007E95:  00           DC.B       0x00                     ; '\0'
+  0x20007E96:  00           DC.B       0x00                     ; '\0'
+  0x20007E97:  00           DC.B       0x00                     ; '\0'
+  0x20007E98:  00           DC.B       0x00                     ; '\0'
+  0x20007E99:  00           DC.B       0x00                     ; '\0'
+  0x20007E9A:  00           DC.B       0x00                     ; '\0'
+  0x20007E9B:  00           DC.B       0x00                     ; '\0'
+  0x20007E9C:  00           DC.B       0x00                     ; '\0'
+  0x20007E9D:  00           DC.B       0x00                     ; '\0'
+  0x20007E9E:  00           DC.B       0x00                     ; '\0'
+  0x20007E9F:  00           DC.B       0x00                     ; '\0'
+  0x20007EA0:  00           DC.B       0x00                     ; '\0'
+  0x20007EA1:  00           DC.B       0x00                     ; '\0'
+  0x20007EA2:  00           DC.B       0x00                     ; '\0'
+  0x20007EA3:  00           DC.B       0x00                     ; '\0'
+  0x20007EA4:  00           DC.B       0x00                     ; '\0'
+  0x20007EA5:  00           DC.B       0x00                     ; '\0'
+  0x20007EA6:  00           DC.B       0x00                     ; '\0'
+  0x20007EA7:  00           DC.B       0x00                     ; '\0'
+  0x20007EA8:  00           DC.B       0x00                     ; '\0'
+  0x20007EA9:  00           DC.B       0x00                     ; '\0'
+  0x20007EAA:  00           DC.B       0x00                     ; '\0'
+  0x20007EAB:  00           DC.B       0x00                     ; '\0'
+  0x20007EAC:  00           DC.B       0x00                     ; '\0'
+  0x20007EAD:  00           DC.B       0x00                     ; '\0'
+  0x20007EAE:  00           DC.B       0x00                     ; '\0'
+  0x20007EAF:  00           DC.B       0x00                     ; '\0'
+  0x20007EB0:  00           DC.B       0x00                     ; '\0'
+  0x20007EB1:  00           DC.B       0x00                     ; '\0'
+  0x20007EB2:  00           DC.B       0x00                     ; '\0'
+  0x20007EB3:  00           DC.B       0x00                     ; '\0'
+  0x20007EB4:  00           DC.B       0x00                     ; '\0'
+  0x20007EB5:  00           DC.B       0x00                     ; '\0'
+  0x20007EB6:  00           DC.B       0x00                     ; '\0'
+  0x20007EB7:  00           DC.B       0x00                     ; '\0'
+  0x20007EB8:  00           DC.B       0x00                     ; '\0'
+  0x20007EB9:  00           DC.B       0x00                     ; '\0'
+  0x20007EBA:  00           DC.B       0x00                     ; '\0'
+  0x20007EBB:  00           DC.B       0x00                     ; '\0'
+  0x20007EBC:  00           DC.B       0x00                     ; '\0'
+  0x20007EBD:  00           DC.B       0x00                     ; '\0'
+  0x20007EBE:  00           DC.B       0x00                     ; '\0'
+  0x20007EBF:  00           DC.B       0x00                     ; '\0'
+  0x20007EC0:  00           DC.B       0x00                     ; '\0'
+  0x20007EC1:  00           DC.B       0x00                     ; '\0'
+  0x20007EC2:  00           DC.B       0x00                     ; '\0'
+  0x20007EC3:  00           DC.B       0x00                     ; '\0'
+  0x20007EC4:  00           DC.B       0x00                     ; '\0'
+  0x20007EC5:  00           DC.B       0x00                     ; '\0'
+  0x20007EC6:  00           DC.B       0x00                     ; '\0'
+  0x20007EC7:  00           DC.B       0x00                     ; '\0'
+  0x20007EC8:  00           DC.B       0x00                     ; '\0'
+  0x20007EC9:  00           DC.B       0x00                     ; '\0'
+  0x20007ECA:  00           DC.B       0x00                     ; '\0'
+  0x20007ECB:  00           DC.B       0x00                     ; '\0'
+  0x20007ECC:  00           DC.B       0x00                     ; '\0'
+  0x20007ECD:  00           DC.B       0x00                     ; '\0'
+  0x20007ECE:  00           DC.B       0x00                     ; '\0'
+  0x20007ECF:  00           DC.B       0x00                     ; '\0'
+  0x20007ED0:  00           DC.B       0x00                     ; '\0'
+  0x20007ED1:  00           DC.B       0x00                     ; '\0'
+  0x20007ED2:  00           DC.B       0x00                     ; '\0'
+  0x20007ED3:  00           DC.B       0x00                     ; '\0'
+  0x20007ED4:  00           DC.B       0x00                     ; '\0'
+  0x20007ED5:  00           DC.B       0x00                     ; '\0'
+  0x20007ED6:  00           DC.B       0x00                     ; '\0'
+  0x20007ED7:  00           DC.B       0x00                     ; '\0'
+  0x20007ED8:  00           DC.B       0x00                     ; '\0'
+  0x20007ED9:  00           DC.B       0x00                     ; '\0'
+  0x20007EDA:  00           DC.B       0x00                     ; '\0'
+  0x20007EDB:  00           DC.B       0x00                     ; '\0'
+  0x20007EDC:  00           DC.B       0x00                     ; '\0'
+  0x20007EDD:  00           DC.B       0x00                     ; '\0'
+  0x20007EDE:  00           DC.B       0x00                     ; '\0'
+  0x20007EDF:  00           DC.B       0x00                     ; '\0'
+  0x20007EE0:  00           DC.B       0x00                     ; '\0'
+  0x20007EE1:  00           DC.B       0x00                     ; '\0'
+  0x20007EE2:  00           DC.B       0x00                     ; '\0'
+  0x20007EE3:  00           DC.B       0x00                     ; '\0'
+  0x20007EE4:  00           DC.B       0x00                     ; '\0'
+  0x20007EE5:  00           DC.B       0x00                     ; '\0'
+  0x20007EE6:  00           DC.B       0x00                     ; '\0'
+  0x20007EE7:  00           DC.B       0x00                     ; '\0'
+  0x20007EE8:  00           DC.B       0x00                     ; '\0'
+  0x20007EE9:  00           DC.B       0x00                     ; '\0'
+  0x20007EEA:  00           DC.B       0x00                     ; '\0'
+  0x20007EEB:  00           DC.B       0x00                     ; '\0'
+  0x20007EEC:  00           DC.B       0x00                     ; '\0'
+  0x20007EED:  00           DC.B       0x00                     ; '\0'
+  0x20007EEE:  00           DC.B       0x00                     ; '\0'
+  0x20007EEF:  00           DC.B       0x00                     ; '\0'
+  0x20007EF0:  00           DC.B       0x00                     ; '\0'
+  0x20007EF1:  00           DC.B       0x00                     ; '\0'
+  0x20007EF2:  00           DC.B       0x00                     ; '\0'
+  0x20007EF3:  00           DC.B       0x00                     ; '\0'
+  0x20007EF4:  00           DC.B       0x00                     ; '\0'
+  0x20007EF5:  00           DC.B       0x00                     ; '\0'
+  0x20007EF6:  00           DC.B       0x00                     ; '\0'
+  0x20007EF7:  00           DC.B       0x00                     ; '\0'
+  0x20007EF8:  00           DC.B       0x00                     ; '\0'
+  0x20007EF9:  00           DC.B       0x00                     ; '\0'
+  0x20007EFA:  00           DC.B       0x00                     ; '\0'
+  0x20007EFB:  00           DC.B       0x00                     ; '\0'
+  0x20007EFC:  00           DC.B       0x00                     ; '\0'
+  0x20007EFD:  00           DC.B       0x00                     ; '\0'
+  0x20007EFE:  00           DC.B       0x00                     ; '\0'
+  0x20007EFF:  00           DC.B       0x00                     ; '\0'
+  0x20007F00:  00           DC.B       0x00                     ; '\0'
+  0x20007F01:  00           DC.B       0x00                     ; '\0'
+  0x20007F02:  00           DC.B       0x00                     ; '\0'
+  0x20007F03:  00           DC.B       0x00                     ; '\0'
+  0x20007F04:  00           DC.B       0x00                     ; '\0'
+  0x20007F05:  00           DC.B       0x00                     ; '\0'
+  0x20007F06:  00           DC.B       0x00                     ; '\0'
+  0x20007F07:  00           DC.B       0x00                     ; '\0'
+  0x20007F08:  00           DC.B       0x00                     ; '\0'
+  0x20007F09:  00           DC.B       0x00                     ; '\0'
+  0x20007F0A:  00           DC.B       0x00                     ; '\0'
+  0x20007F0B:  00           DC.B       0x00                     ; '\0'
+  0x20007F0C:  00           DC.B       0x00                     ; '\0'
+  0x20007F0D:  00           DC.B       0x00                     ; '\0'
+  0x20007F0E:  00           DC.B       0x00                     ; '\0'
+  0x20007F0F:  00           DC.B       0x00                     ; '\0'
+  0x20007F10:  00           DC.B       0x00                     ; '\0'
+  0x20007F11:  00           DC.B       0x00                     ; '\0'
+  0x20007F12:  00           DC.B       0x00                     ; '\0'
+  0x20007F13:  00           DC.B       0x00                     ; '\0'
+  0x20007F14:  00           DC.B       0x00                     ; '\0'
+  0x20007F15:  00           DC.B       0x00                     ; '\0'
+  0x20007F16:  00           DC.B       0x00                     ; '\0'
+  0x20007F17:  00           DC.B       0x00                     ; '\0'
+  0x20007F18:  00           DC.B       0x00                     ; '\0'
+  0x20007F19:  00           DC.B       0x00                     ; '\0'
+  0x20007F1A:  00           DC.B       0x00                     ; '\0'
+  0x20007F1B:  00           DC.B       0x00                     ; '\0'
+  0x20007F1C:  00           DC.B       0x00                     ; '\0'
+  0x20007F1D:  00           DC.B       0x00                     ; '\0'
+  0x20007F1E:  00           DC.B       0x00                     ; '\0'
+  0x20007F1F:  00           DC.B       0x00                     ; '\0'
+  0x20007F20:  00           DC.B       0x00                     ; '\0'
+  0x20007F21:  00           DC.B       0x00                     ; '\0'
+  0x20007F22:  00           DC.B       0x00                     ; '\0'
+  0x20007F23:  00           DC.B       0x00                     ; '\0'
+  0x20007F24:  00           DC.B       0x00                     ; '\0'
+  0x20007F25:  00           DC.B       0x00                     ; '\0'
+  0x20007F26:  00           DC.B       0x00                     ; '\0'
+  0x20007F27:  00           DC.B       0x00                     ; '\0'
+  0x20007F28:  00           DC.B       0x00                     ; '\0'
+  0x20007F29:  00           DC.B       0x00                     ; '\0'
+  0x20007F2A:  00           DC.B       0x00                     ; '\0'
+  0x20007F2B:  00           DC.B       0x00                     ; '\0'
+  0x20007F2C:  00           DC.B       0x00                     ; '\0'
+  0x20007F2D:  00           DC.B       0x00                     ; '\0'
+  0x20007F2E:  00           DC.B       0x00                     ; '\0'
+  0x20007F2F:  00           DC.B       0x00                     ; '\0'
+  0x20007F30:  00           DC.B       0x00                     ; '\0'
+  0x20007F31:  00           DC.B       0x00                     ; '\0'
+  0x20007F32:  00           DC.B       0x00                     ; '\0'
+  0x20007F33:  00           DC.B       0x00                     ; '\0'
+  0x20007F34:  00           DC.B       0x00                     ; '\0'
+  0x20007F35:  00           DC.B       0x00                     ; '\0'
+  0x20007F36:  00           DC.B       0x00                     ; '\0'
+  0x20007F37:  00           DC.B       0x00                     ; '\0'
+  0x20007F38:  00           DC.B       0x00                     ; '\0'
+  0x20007F39:  00           DC.B       0x00                     ; '\0'
+  0x20007F3A:  00           DC.B       0x00                     ; '\0'
+  0x20007F3B:  00           DC.B       0x00                     ; '\0'
+  0x20007F3C:  00           DC.B       0x00                     ; '\0'
+  0x20007F3D:  00           DC.B       0x00                     ; '\0'
+  0x20007F3E:  00           DC.B       0x00                     ; '\0'
+  0x20007F3F:  00           DC.B       0x00                     ; '\0'
+  0x20007F40:  00           DC.B       0x00                     ; '\0'
+  0x20007F41:  00           DC.B       0x00                     ; '\0'
+  0x20007F42:  00           DC.B       0x00                     ; '\0'
+  0x20007F43:  00           DC.B       0x00                     ; '\0'
+  0x20007F44:  00           DC.B       0x00                     ; '\0'
+  0x20007F45:  00           DC.B       0x00                     ; '\0'
+  0x20007F46:  00           DC.B       0x00                     ; '\0'
+  0x20007F47:  00           DC.B       0x00                     ; '\0'
+  0x20007F48:  00           DC.B       0x00                     ; '\0'
+  0x20007F49:  00           DC.B       0x00                     ; '\0'
+  0x20007F4A:  00           DC.B       0x00                     ; '\0'
+  0x20007F4B:  00           DC.B       0x00                     ; '\0'
+  0x20007F4C:  00           DC.B       0x00                     ; '\0'
+  0x20007F4D:  00           DC.B       0x00                     ; '\0'
+  0x20007F4E:  00           DC.B       0x00                     ; '\0'
+  0x20007F4F:  00           DC.B       0x00                     ; '\0'
+  0x20007F50:  00           DC.B       0x00                     ; '\0'
+  0x20007F51:  00           DC.B       0x00                     ; '\0'
+  0x20007F52:  00           DC.B       0x00                     ; '\0'
+  0x20007F53:  00           DC.B       0x00                     ; '\0'
+  0x20007F54:  00           DC.B       0x00                     ; '\0'
+  0x20007F55:  00           DC.B       0x00                     ; '\0'
+  0x20007F56:  00           DC.B       0x00                     ; '\0'
+  0x20007F57:  00           DC.B       0x00                     ; '\0'
+  0x20007F58:  00           DC.B       0x00                     ; '\0'
+  0x20007F59:  00           DC.B       0x00                     ; '\0'
+  0x20007F5A:  00           DC.B       0x00                     ; '\0'
+  0x20007F5B:  00           DC.B       0x00                     ; '\0'
+  0x20007F5C:  00           DC.B       0x00                     ; '\0'
+  0x20007F5D:  00           DC.B       0x00                     ; '\0'
+  0x20007F5E:  00           DC.B       0x00                     ; '\0'
+  0x20007F5F:  00           DC.B       0x00                     ; '\0'
+  0x20007F60:  00           DC.B       0x00                     ; '\0'
+  0x20007F61:  00           DC.B       0x00                     ; '\0'
+  0x20007F62:  00           DC.B       0x00                     ; '\0'
+  0x20007F63:  00           DC.B       0x00                     ; '\0'
+  0x20007F64:  00           DC.B       0x00                     ; '\0'
+  0x20007F65:  00           DC.B       0x00                     ; '\0'
+  0x20007F66:  00           DC.B       0x00                     ; '\0'
+  0x20007F67:  00           DC.B       0x00                     ; '\0'
+  0x20007F68:  00           DC.B       0x00                     ; '\0'
+  0x20007F69:  00           DC.B       0x00                     ; '\0'
+  0x20007F6A:  00           DC.B       0x00                     ; '\0'
+  0x20007F6B:  00           DC.B       0x00                     ; '\0'
+  0x20007F6C:  00           DC.B       0x00                     ; '\0'
+  0x20007F6D:  00           DC.B       0x00                     ; '\0'
+  0x20007F6E:  00           DC.B       0x00                     ; '\0'
+  0x20007F6F:  00           DC.B       0x00                     ; '\0'
+  0x20007F70:  00           DC.B       0x00                     ; '\0'
+  0x20007F71:  00           DC.B       0x00                     ; '\0'
+  0x20007F72:  00           DC.B       0x00                     ; '\0'
+  0x20007F73:  00           DC.B       0x00                     ; '\0'
+  0x20007F74:  00           DC.B       0x00                     ; '\0'
+  0x20007F75:  00           DC.B       0x00                     ; '\0'
+  0x20007F76:  00           DC.B       0x00                     ; '\0'
+  0x20007F77:  00           DC.B       0x00                     ; '\0'
+  0x20007F78:  00           DC.B       0x00                     ; '\0'
+  0x20007F79:  00           DC.B       0x00                     ; '\0'
+  0x20007F7A:  00           DC.B       0x00                     ; '\0'
+  0x20007F7B:  00           DC.B       0x00                     ; '\0'
+  0x20007F7C:  00           DC.B       0x00                     ; '\0'
+  0x20007F7D:  00           DC.B       0x00                     ; '\0'
+  0x20007F7E:  00           DC.B       0x00                     ; '\0'
+  0x20007F7F:  00           DC.B       0x00                     ; '\0'
+  0x20007F80:  00           DC.B       0x00                     ; '\0'
+  0x20007F81:  00           DC.B       0x00                     ; '\0'
+  0x20007F82:  00           DC.B       0x00                     ; '\0'
+  0x20007F83:  00           DC.B       0x00                     ; '\0'
+  0x20007F84:  00           DC.B       0x00                     ; '\0'
+  0x20007F85:  00           DC.B       0x00                     ; '\0'
+  0x20007F86:  00           DC.B       0x00                     ; '\0'
+  0x20007F87:  00           DC.B       0x00                     ; '\0'
+  0x20007F88:  00           DC.B       0x00                     ; '\0'
+  0x20007F89:  00           DC.B       0x00                     ; '\0'
+  0x20007F8A:  00           DC.B       0x00                     ; '\0'
+  0x20007F8B:  00           DC.B       0x00                     ; '\0'
+  0x20007F8C:  00           DC.B       0x00                     ; '\0'
+  0x20007F8D:  00           DC.B       0x00                     ; '\0'
+  0x20007F8E:  00           DC.B       0x00                     ; '\0'
+  0x20007F8F:  00           DC.B       0x00                     ; '\0'
+  0x20007F90:  00           DC.B       0x00                     ; '\0'
+  0x20007F91:  00           DC.B       0x00                     ; '\0'
+  0x20007F92:  00           DC.B       0x00                     ; '\0'
+  0x20007F93:  00           DC.B       0x00                     ; '\0'
+  0x20007F94:  00           DC.B       0x00                     ; '\0'
+  0x20007F95:  00           DC.B       0x00                     ; '\0'
+  0x20007F96:  00           DC.B       0x00                     ; '\0'
+  0x20007F97:  00           DC.B       0x00                     ; '\0'
+  0x20007F98:  00           DC.B       0x00                     ; '\0'
+  0x20007F99:  00           DC.B       0x00                     ; '\0'
+  0x20007F9A:  00           DC.B       0x00                     ; '\0'
+  0x20007F9B:  00           DC.B       0x00                     ; '\0'
+  0x20007F9C:  00           DC.B       0x00                     ; '\0'
+  0x20007F9D:  00           DC.B       0x00                     ; '\0'
+  0x20007F9E:  00           DC.B       0x00                     ; '\0'
+  0x20007F9F:  00           DC.B       0x00                     ; '\0'
+  0x20007FA0:  00           DC.B       0x00                     ; '\0'
+  0x20007FA1:  00           DC.B       0x00                     ; '\0'
+  0x20007FA2:  00           DC.B       0x00                     ; '\0'
+  0x20007FA3:  00           DC.B       0x00                     ; '\0'
+  0x20007FA4:  00           DC.B       0x00                     ; '\0'
+  0x20007FA5:  00           DC.B       0x00                     ; '\0'
+  0x20007FA6:  00           DC.B       0x00                     ; '\0'
+  0x20007FA7:  00           DC.B       0x00                     ; '\0'
+  0x20007FA8:  00           DC.B       0x00                     ; '\0'
+  0x20007FA9:  00           DC.B       0x00                     ; '\0'
+  0x20007FAA:  00           DC.B       0x00                     ; '\0'
+  0x20007FAB:  00           DC.B       0x00                     ; '\0'
+  0x20007FAC:  00           DC.B       0x00                     ; '\0'
+  0x20007FAD:  00           DC.B       0x00                     ; '\0'
+  0x20007FAE:  00           DC.B       0x00                     ; '\0'
+  0x20007FAF:  00           DC.B       0x00                     ; '\0'
+  0x20007FB0:  00           DC.B       0x00                     ; '\0'
+  0x20007FB1:  00           DC.B       0x00                     ; '\0'
+  0x20007FB2:  00           DC.B       0x00                     ; '\0'
+  0x20007FB3:  00           DC.B       0x00                     ; '\0'
+  0x20007FB4:  00           DC.B       0x00                     ; '\0'
+  0x20007FB5:  00           DC.B       0x00                     ; '\0'
+  0x20007FB6:  00           DC.B       0x00                     ; '\0'
+  0x20007FB7:  00           DC.B       0x00                     ; '\0'
+  0x20007FB8:  00           DC.B       0x00                     ; '\0'
+  0x20007FB9:  00           DC.B       0x00                     ; '\0'
+  0x20007FBA:  00           DC.B       0x00                     ; '\0'
+  0x20007FBB:  00           DC.B       0x00                     ; '\0'
+  0x20007FBC:  00           DC.B       0x00                     ; '\0'
+  0x20007FBD:  00           DC.B       0x00                     ; '\0'
+  0x20007FBE:  00           DC.B       0x00                     ; '\0'
+  0x20007FBF:  00           DC.B       0x00                     ; '\0'
+  0x20007FC0:  00           DC.B       0x00                     ; '\0'
+  0x20007FC1:  00           DC.B       0x00                     ; '\0'
+  0x20007FC2:  00           DC.B       0x00                     ; '\0'
+  0x20007FC3:  00           DC.B       0x00                     ; '\0'
+  0x20007FC4:  00           DC.B       0x00                     ; '\0'
+  0x20007FC5:  00           DC.B       0x00                     ; '\0'
+  0x20007FC6:  00           DC.B       0x00                     ; '\0'
+  0x20007FC7:  00           DC.B       0x00                     ; '\0'
+  0x20007FC8:  00           DC.B       0x00                     ; '\0'
+  0x20007FC9:  00           DC.B       0x00                     ; '\0'
+  0x20007FCA:  00           DC.B       0x00                     ; '\0'
+  0x20007FCB:  00           DC.B       0x00                     ; '\0'
+  0x20007FCC:  00           DC.B       0x00                     ; '\0'
+  0x20007FCD:  00           DC.B       0x00                     ; '\0'
+  0x20007FCE:  00           DC.B       0x00                     ; '\0'
+  0x20007FCF:  00           DC.B       0x00                     ; '\0'
+  0x20007FD0:  00           DC.B       0x00                     ; '\0'
+  0x20007FD1:  00           DC.B       0x00                     ; '\0'
+  0x20007FD2:  00           DC.B       0x00                     ; '\0'
+  0x20007FD3:  00           DC.B       0x00                     ; '\0'
+  0x20007FD4:  00           DC.B       0x00                     ; '\0'
+  0x20007FD5:  00           DC.B       0x00                     ; '\0'
+  0x20007FD6:  00           DC.B       0x00                     ; '\0'
+  0x20007FD7:  00           DC.B       0x00                     ; '\0'
+  0x20007FD8:  00           DC.B       0x00                     ; '\0'
+  0x20007FD9:  00           DC.B       0x00                     ; '\0'
+  0x20007FDA:  00           DC.B       0x00                     ; '\0'
+  0x20007FDB:  00           DC.B       0x00                     ; '\0'
+  0x20007FDC:  00           DC.B       0x00                     ; '\0'
+  0x20007FDD:  00           DC.B       0x00                     ; '\0'
+  0x20007FDE:  00           DC.B       0x00                     ; '\0'
+  0x20007FDF:  00           DC.B       0x00                     ; '\0'
+  0x20007FE0:  00           DC.B       0x00                     ; '\0'
+  0x20007FE1:  00           DC.B       0x00                     ; '\0'
+  0x20007FE2:  00           DC.B       0x00                     ; '\0'
+  0x20007FE3:  00           DC.B       0x00                     ; '\0'
+  0x20007FE4:  00           DC.B       0x00                     ; '\0'
+  0x20007FE5:  00           DC.B       0x00                     ; '\0'
+  0x20007FE6:  00           DC.B       0x00                     ; '\0'
+  0x20007FE7:  00           DC.B       0x00                     ; '\0'
+  0x20007FE8:  00           DC.B       0x00                     ; '\0'
+  0x20007FE9:  00           DC.B       0x00                     ; '\0'
+  0x20007FEA:  00           DC.B       0x00                     ; '\0'
+  0x20007FEB:  00           DC.B       0x00                     ; '\0'
+  0x20007FEC:  00           DC.B       0x00                     ; '\0'
+  0x20007FED:  00           DC.B       0x00                     ; '\0'
+  0x20007FEE:  00           DC.B       0x00                     ; '\0'
+  0x20007FEF:  00           DC.B       0x00                     ; '\0'
+  0x20007FF0:  00           DC.B       0x00                     ; '\0'
+  0x20007FF1:  00           DC.B       0x00                     ; '\0'
+  0x20007FF2:  00           DC.B       0x00                     ; '\0'
+  0x20007FF3:  00           DC.B       0x00                     ; '\0'
+  0x20007FF4:  00           DC.B       0x00                     ; '\0'
+  0x20007FF5:  00           DC.B       0x00                     ; '\0'
+  0x20007FF6:  00           DC.B       0x00                     ; '\0'
+  0x20007FF7:  00           DC.B       0x00                     ; '\0'
+  0x20007FF8:  00           DC.B       0x00                     ; '\0'
+  0x20007FF9:  00           DC.B       0x00                     ; '\0'
+  0x20007FFA:  00           DC.B       0x00                     ; '\0'
+  0x20007FFB:  00           DC.B       0x00                     ; '\0'
+  0x20007FFC:  00           DC.B       0x00                     ; '\0'
+  0x20007FFD:  00           DC.B       0x00                     ; '\0'
+  0x20007FFE:  00           DC.B       0x00                     ; '\0'
+  0x20007FFF:  00           DC.B       0x00                     ; '\0'
+

LINK SUMMARY

Memory breakdown

+ 3 464 bytes read-only code + + 911 bytes read-only data = 4 375 bytes read-only (total) + 4 293 bytes read-write data +

Region summary

+ + + + + + + + + + + + + + + + + + + + + + + + + +

Name	Range	Size	Used	Unused	Alignment Loss
`FLASH`	`08000000-08002fff`	`12 288`	`4 379 35.64%`	`7 909 64.36%`	`0 0.00%`
`RAM`	`20000000-20007fff`	`32 768`	`4 293 13.10%`	`28 472 86.89%`	`3 0.01%`

Diagnostic summary

+Link complete: 0 errors, 0 warnings, 0 remarks + Index: trunk/firmware_bootloader/SES/Output/Release/Exe/bootloader.map =================================================================== --- trunk/firmware_bootloader/SES/Output/Release/Exe/bootloader.map (revision 1) +++ (revision ) @@ -1,572 +1,0 @@ -*********************************************************************************************** -*** *** -*** LINK INFORMATION *** -*** *** -*********************************************************************************************** - -Linker version: - - SEGGER ARM Linker 4.38.0 compiled Nov 21 2022 19:07:37 - Copyright (c) 2017-2022 SEGGER Microcontroller GmbH www.segger.com - - -*********************************************************************************************** -*** *** -*** MODULE SUMMARY *** -*** *** -*********************************************************************************************** - -Memory use by input file: - - Object File RX Code RO Data RW Data ZI Data - --------------------------------------------- ---------- ---------- ---------- ---------- - aes.o 752 767 184 - main.o 2 170 32 9 - SEGGER_THUMB_Startup.o 20 - STM32G07x_Vectors.o 260 - STM32G0xx_Startup.o 6 - system_stm32g0xx.o 156 64 4 - --------------------------------------------- ---------- ---------- ---------- ---------- - Subtotal (6 objects) 3 364 863 4 193 - --------------------------------------------- ---------- ---------- ---------- ---------- - libc_v6m_t_le_eabi_small.a 82 - SEGGER_crtinit_v6m_t_le_eabi_small.a 38 - --------------------------------------------- ---------- ---------- ---------- ---------- - Subtotal (2 archives) 120 - --------------------------------------------- ---------- ---------- ---------- ---------- - Linker created (shared data, fills, blocks): 48 4 096 - ============================================= ========== ========== ========== ========== - Total: 3 484 911 4 4 289 - ============================================= ========== ========== ========== ========== - -Memory use by archive member: - - Archive member RX Code RO Data RW Data ZI Data - --------------------------------------------- ---------- ---------- ---------- ---------- - intasmops_arm.o (libc_v6m_t_le_eabi_small.a) 62 - SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - 38 - strasmops_arm.o (libc_v6m_t_le_eabi_small.a) 20 - --------------------------------------------- ---------- ---------- ---------- ---------- - Subtotal (3 members from 2 archives) 120 - Objects (6 files) 3 364 863 4 193 - Linker created (shared data, fills, blocks): 48 4 096 - ============================================= ========== ========== ========== ========== - Total: 3 484 911 4 4 289 - ============================================= ========== ========== ========== ========== - -Memory use by linker: - - Description RX Code RO Data RW Data ZI Data - --------------------------------------------- ---------- ---------- ---------- ---------- - Initialization table 48 - Memory for block 'stack' 4 096 - --------------------------------------------- ---------- ---------- ---------- ---------- - Subtotal (linker created): 48 4 096 - --------------------------------------------- ---------- ---------- ---------- ---------- - Objects (6 files) 3 364 863 4 193 - Archives (2 files) 120 - ============================================= ========== ========== ========== ========== - Total: 3 484 911 4 4 289 - ============================================= ========== ========== ========== ========== - - -*********************************************************************************************** -*** *** -*** SECTION DETAIL *** -*** *** -*********************************************************************************************** - -Sections by address: - - Range Symbol or [section] Name Size Al Init Ac Object File - ----------------- ------------------------- ---------- -- ---- -- ----------- - 08000000-080000bf _vectors 192 512 - Code RX STM32G07x_Vectors.o - 080000c0-080000cf FW_VERSION 16 16 Cnst RO main.o - 080000d0-080000df SystemInit 16 4 Code RX system_stm32g0xx.o - 080000e0-0800016b SystemCoreClockUpdate 140 4 Code RX system_stm32g0xx.o - 0800016c-080001ab AHBPrescTable 64 4 Cnst RO system_stm32g0xx.o - 080001ac-08000627 main 1 148 4 Code RX main.o - 08000628-0800082b Init 516 4 Code RX main.o - 0800082c-080008b7 WaitForByte 140 4 Code RX main.o - 080008b8-0800094f JumpToApplication 152 4 Code RX main.o - 08000950-0800096f Transmit 32 4 Code RX main.o - 08000970-080009b3 TurnErrorLEDOn 68 4 Code RX main.o - 080009b4-080009cf Delay 28 4 Code RX main.o - 080009d0-080009df SysTick_Handler 16 4 Code RX main.o - 080009e0-08000c97 AES128_ECB_decrypt 696 4 Code RX aes.o - 08000c98-08000ccf AddRoundKey 56 4 Code RX aes.o - 08000cd0-08000ce3 _start 20 4 Code RX SEGGER_THUMB_Startup.o - 08000ce4-08000ce9 reset_handler 6 2 Code RX STM32G0xx_Startup.o - 08000cea-08000ceb SVC_Handler 2 2 Code RX STM32G07x_Vectors.o - 08000cec-08000ced PendSV_Handler 2 2 Code RX STM32G07x_Vectors.o - 08000cee-08000cef WWDG_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000cf0-08000cf1 PVD_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000cf2-08000cf3 RTC_STAMP_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000cf4-08000cf5 FLASH_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000cf6-08000cf7 RCC_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000cf8-08000cf9 EXTI0_1_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000cfa-08000cfb EXTI2_3_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000cfc-08000cfd EXTI4_15_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000cfe-08000cff UCPD1_UCPD2_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d00-08000d01 DMA_Channel1_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d02-08000d03 DMA_Channel2_3_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d04-08000d05 DMA_Channel4_5_6_7_IRQHandler - 2 2 Code RX STM32G07x_Vectors.o - 08000d06-08000d07 ADC_COMP_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d08-08000d09 TIM1_BRK_UP_TRG_COMP_IRQHandler - 2 2 Code RX STM32G07x_Vectors.o - 08000d0a-08000d0b TIM1_CC_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d0c-08000d0d TIM2_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d0e-08000d0f TIM3_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d10-08000d11 TIM6_DAC_LPTIM1_IRQHandler - 2 2 Code RX STM32G07x_Vectors.o - 08000d12-08000d13 TIM7_LPTIM2_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d14-08000d15 TIM14_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d16-08000d17 TIM15_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d18-08000d19 TIM16_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d1a-08000d1b TIM17_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d1c-08000d1d I2C1_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d1e-08000d1f I2C2_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d20-08000d21 SPI1_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d22-08000d23 SPI2_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d24-08000d25 USART1_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d26-08000d27 USART2_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d28-08000d29 USART3_USART4_LPUART1_IRQHandler - 2 2 Code RX STM32G07x_Vectors.o - 08000d2a-08000d2b CEC_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d2c-08000d2d AES_RNG_IRQHandler 2 2 Code RX STM32G07x_Vectors.o - 08000d2e-08000d3b NMI_Handler 14 2 Code RX main.o - 08000d3c-08000d41 __aeabi_idiv0 6 2 Code RX intasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 08000d42-08000d55 TransmitACK 20 2 Code RX main.o - 08000d56-08000d69 TransmitNACK 20 2 Code RX main.o - 08000d6a-08000d79 HardFault_Handler 16 2 Code RX main.o - 08000d7a-08000db1 __aeabi_uidiv 56 2 Code RX intasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 08000db2-08000dc5 __aeabi_memclr 20 2 Code RX strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 08000dc6-08000ec4 Rcon 255 1 Cnst RO aes.o - 08000ec5-08000ec7 ( UNUSED .=.+3 ) 3 - ---- - - - 08000ec8-08000ecb [.init_array] 4 4 ---- -- STM32G0xx_Startup.o - 08000ecc-08000edb AES_KEY 16 1 Cnst RO main.o - 08000edc-08000fdb sbox 256 1 Cnst RO aes.o - 08000fdc-080010db rsbox 256 1 Cnst RO aes.o - 080010dc-08001107 __SEGGER_init_table__ 44 4 Cnst RO [ Linker created ] - 08001108-0800110b __SEGGER_init_data__ 4 4 Cnst RO [ Linker created ] - 0800110c-0800111d __SEGGER_init_zero 18 2 Code RX SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - 0800111e-08001131 __SEGGER_init_copy 20 2 Code RX SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - 08001132-1fffffff ( UNUSED .=.+402648782 ) 402 648 782 - - ---- - - - 20000000-20000003 SystemCoreClock 4 4 Init RW system_stm32g0xx.o - 20000004-20000008 u 5 4 Zero ZI main.o - 20000009-2000000b ( ALIGN .=.+3 ) 3 - ---- - - - 2000000c-2000000f state 4 4 Zero ZI aes.o - 20000010-20000013 msCounter 4 4 Zero ZI main.o - 20000014-20000017 Key 4 4 Zero ZI aes.o - 20000018-200000c7 RoundKey 176 1 Zero ZI aes.o - 200000c8-20006fff ( UNUSED .=.+28472 ) 28 472 - ---- - - - 20007000-20007fff [.bss.block.stack] 4 096 8 None ZI [ Linker created ] - - -*********************************************************************************************** -*** *** -*** SYMBOL LIST *** -*** *** -*********************************************************************************************** - -Function symbols by name: - - Symbol name Address Size Align Type Bd Object File - ------------------------- ---------- ---------- ----- ---- -- ----------- - ADC_COMP_IRQHandler 0x08000D07 2 Code Wk STM32G07x_Vectors.o - AES128_ECB_decrypt 0x080009E1 696 4 Code Gb aes.o - AES_RNG_IRQHandler 0x08000D2D 2 Code Wk STM32G07x_Vectors.o - AddRoundKey 0x08000C99 56 4 Code Lc aes.o - CEC_IRQHandler 0x08000D2B 2 Code Wk STM32G07x_Vectors.o - DMA_Channel1_IRQHandler 0x08000D01 2 Code Wk STM32G07x_Vectors.o - DMA_Channel2_3_IRQHandler 0x08000D03 2 Code Wk STM32G07x_Vectors.o - DMA_Channel4_5_6_7_IRQHandler - 0x08000D05 2 Code Wk STM32G07x_Vectors.o - Delay 0x080009B5 28 4 Code Gb main.o - EXTI0_1_IRQHandler 0x08000CF9 2 Code Wk STM32G07x_Vectors.o - EXTI2_3_IRQHandler 0x08000CFB 2 Code Wk STM32G07x_Vectors.o - EXTI4_15_IRQHandler 0x08000CFD 2 Code Wk STM32G07x_Vectors.o - FLASH_IRQHandler 0x08000CF5 2 Code Wk STM32G07x_Vectors.o - HardFault_Handler 0x08000D6B 16 2 Code Gb main.o - I2C1_IRQHandler 0x08000D1D 2 Code Wk STM32G07x_Vectors.o - I2C2_IRQHandler 0x08000D1F 2 Code Wk STM32G07x_Vectors.o - Init 0x08000629 516 4 Code Gb main.o - JumpToApplication 0x080008B9 152 4 Code Gb main.o - NMI_Handler 0x08000D2F 14 2 Code Gb main.o - PVD_IRQHandler 0x08000CF1 2 Code Wk STM32G07x_Vectors.o - PendSV_Handler 0x08000CED 2 Code Wk STM32G07x_Vectors.o - RCC_IRQHandler 0x08000CF7 2 Code Wk STM32G07x_Vectors.o - RTC_STAMP_IRQHandler 0x08000CF3 2 Code Wk STM32G07x_Vectors.o - Reset_Handler 0x08000CE5 2 Code Gb STM32G0xx_Startup.o - SPI1_IRQHandler 0x08000D21 2 Code Wk STM32G07x_Vectors.o - SPI2_IRQHandler 0x08000D23 2 Code Wk STM32G07x_Vectors.o - SVC_Handler 0x08000CEB 2 Code Wk STM32G07x_Vectors.o - SysTick_Handler 0x080009D1 16 4 Code Gb main.o - SystemCoreClockUpdate 0x080000E1 140 4 Code Gb system_stm32g0xx.o - SystemInit 0x080000D1 16 4 Code Gb system_stm32g0xx.o - TIM14_IRQHandler 0x08000D15 2 Code Wk STM32G07x_Vectors.o - TIM15_IRQHandler 0x08000D17 2 Code Wk STM32G07x_Vectors.o - TIM16_IRQHandler 0x08000D19 2 Code Wk STM32G07x_Vectors.o - TIM17_IRQHandler 0x08000D1B 2 Code Wk STM32G07x_Vectors.o - TIM1_BRK_UP_TRG_COMP_IRQHandler - 0x08000D09 2 Code Wk STM32G07x_Vectors.o - TIM1_CC_IRQHandler 0x08000D0B 2 Code Wk STM32G07x_Vectors.o - TIM2_IRQHandler 0x08000D0D 2 Code Wk STM32G07x_Vectors.o - TIM3_IRQHandler 0x08000D0F 2 Code Wk STM32G07x_Vectors.o - TIM6_DAC_LPTIM1_IRQHandler - 0x08000D11 2 Code Wk STM32G07x_Vectors.o - TIM7_LPTIM2_IRQHandler 0x08000D13 2 Code Wk STM32G07x_Vectors.o - Transmit 0x08000951 32 4 Code Gb main.o - TransmitACK 0x08000D43 20 2 Code Gb main.o - TransmitNACK 0x08000D57 20 2 Code Gb main.o - TurnErrorLEDOn 0x08000971 68 4 Code Gb main.o - UCPD1_UCPD2_IRQHandler 0x08000CFF 2 Code Wk STM32G07x_Vectors.o - USART1_IRQHandler 0x08000D25 2 Code Wk STM32G07x_Vectors.o - USART2_IRQHandler 0x08000D27 2 Code Wk STM32G07x_Vectors.o - USART3_USART4_LPUART1_IRQHandler - 0x08000D29 2 Code Wk STM32G07x_Vectors.o - WWDG_IRQHandler 0x08000CEF 2 Code Wk STM32G07x_Vectors.o - WaitForByte 0x0800082D 140 4 Code Gb main.o - __SEGGER_init_copy 0x0800111F 20 2 Code Wk SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - __SEGGER_init_done 0x08000CDB 4 Code Gb SEGGER_THUMB_Startup.o - __SEGGER_init_zero 0x0800110D 18 2 Code Wk SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - __aeabi_idiv0 0x08000D3D 6 2 Code Wk intasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memclr 0x08000DB3 20 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memclr4 0x08000DB3 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memclr8 0x08000DB3 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memset 0x08000DB5 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memset4 0x08000DB5 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memset8 0x08000DB5 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_uidiv 0x08000D7B 56 2 Code Wk intasmops_arm.o (libc_v6m_t_le_eabi_small.a) - _start 0x08000CD1 4 Code Gb SEGGER_THUMB_Startup.o - exit 0x08000CDF 4 Code Gb SEGGER_THUMB_Startup.o - main 0x080001AD 1 148 4 Code Gb main.o - memset 0x08000DBB 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - reset_handler 0x08000CE5 2 Code Gb STM32G0xx_Startup.o - -Function symbols by address: - - Address Symbol name Size Align Type Bd Object File - ---------- ------------------------- ---------- ----- ---- -- ----------- - 0x080000D1 SystemInit 16 4 Code Gb system_stm32g0xx.o - 0x080000E1 SystemCoreClockUpdate 140 4 Code Gb system_stm32g0xx.o - 0x080001AD main 1 148 4 Code Gb main.o - 0x08000629 Init 516 4 Code Gb main.o - 0x0800082D WaitForByte 140 4 Code Gb main.o - 0x080008B9 JumpToApplication 152 4 Code Gb main.o - 0x08000951 Transmit 32 4 Code Gb main.o - 0x08000971 TurnErrorLEDOn 68 4 Code Gb main.o - 0x080009B5 Delay 28 4 Code Gb main.o - 0x080009D1 SysTick_Handler 16 4 Code Gb main.o - 0x080009E1 AES128_ECB_decrypt 696 4 Code Gb aes.o - 0x08000C99 AddRoundKey 56 4 Code Lc aes.o - 0x08000CD1 _start 4 Code Gb SEGGER_THUMB_Startup.o - 0x08000CDB __SEGGER_init_done 4 Code Gb SEGGER_THUMB_Startup.o - 0x08000CDF exit 4 Code Gb SEGGER_THUMB_Startup.o - 0x08000CE5 reset_handler 2 Code Gb STM32G0xx_Startup.o - 0x08000CE5 Reset_Handler 2 Code Gb STM32G0xx_Startup.o - 0x08000CEB SVC_Handler 2 Code Wk STM32G07x_Vectors.o - 0x08000CED PendSV_Handler 2 Code Wk STM32G07x_Vectors.o - 0x08000CEF WWDG_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000CF1 PVD_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000CF3 RTC_STAMP_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000CF5 FLASH_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000CF7 RCC_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000CF9 EXTI0_1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000CFB EXTI2_3_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000CFD EXTI4_15_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000CFF UCPD1_UCPD2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D01 DMA_Channel1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D03 DMA_Channel2_3_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D05 DMA_Channel4_5_6_7_IRQHandler - 2 Code Wk STM32G07x_Vectors.o - 0x08000D07 ADC_COMP_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D09 TIM1_BRK_UP_TRG_COMP_IRQHandler - 2 Code Wk STM32G07x_Vectors.o - 0x08000D0B TIM1_CC_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D0D TIM2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D0F TIM3_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D11 TIM6_DAC_LPTIM1_IRQHandler - 2 Code Wk STM32G07x_Vectors.o - 0x08000D13 TIM7_LPTIM2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D15 TIM14_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D17 TIM15_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D19 TIM16_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D1B TIM17_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D1D I2C1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D1F I2C2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D21 SPI1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D23 SPI2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D25 USART1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D27 USART2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D29 USART3_USART4_LPUART1_IRQHandler - 2 Code Wk STM32G07x_Vectors.o - 0x08000D2B CEC_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D2D AES_RNG_IRQHandler 2 Code Wk STM32G07x_Vectors.o - 0x08000D2F NMI_Handler 14 2 Code Gb main.o - 0x08000D3D __aeabi_idiv0 6 2 Code Wk intasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x08000D43 TransmitACK 20 2 Code Gb main.o - 0x08000D57 TransmitNACK 20 2 Code Gb main.o - 0x08000D6B HardFault_Handler 16 2 Code Gb main.o - 0x08000D7B __aeabi_uidiv 56 2 Code Wk intasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x08000DB3 __aeabi_memclr8 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x08000DB3 __aeabi_memclr4 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x08000DB3 __aeabi_memclr 20 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x08000DB5 __aeabi_memset8 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x08000DB5 __aeabi_memset4 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x08000DB5 __aeabi_memset 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x08000DBB memset 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - 0x0800110D __SEGGER_init_zero 18 2 Code Wk SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - 0x0800111F __SEGGER_init_copy 20 2 Code Wk SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - -Function symbols by descending size: - - Symbol name Size Align Type Bd Object File - ------------------------- ---------- ----- ---- -- ----------- - main 1 148 4 Code Gb main.o - AES128_ECB_decrypt 696 4 Code Gb aes.o - Init 516 4 Code Gb main.o - JumpToApplication 152 4 Code Gb main.o - SystemCoreClockUpdate 140 4 Code Gb system_stm32g0xx.o - WaitForByte 140 4 Code Gb main.o - TurnErrorLEDOn 68 4 Code Gb main.o - AddRoundKey 56 4 Code Lc aes.o - __aeabi_uidiv 56 2 Code Wk intasmops_arm.o (libc_v6m_t_le_eabi_small.a) - Transmit 32 4 Code Gb main.o - Delay 28 4 Code Gb main.o - TransmitACK 20 2 Code Gb main.o - TransmitNACK 20 2 Code Gb main.o - __SEGGER_init_copy 20 2 Code Wk SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - __aeabi_memclr 20 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __SEGGER_init_zero 18 2 Code Wk SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a) - HardFault_Handler 16 2 Code Gb main.o - SysTick_Handler 16 4 Code Gb main.o - SystemInit 16 4 Code Gb system_stm32g0xx.o - NMI_Handler 14 2 Code Gb main.o - __aeabi_idiv0 6 2 Code Wk intasmops_arm.o (libc_v6m_t_le_eabi_small.a) - ADC_COMP_IRQHandler 2 Code Wk STM32G07x_Vectors.o - AES_RNG_IRQHandler 2 Code Wk STM32G07x_Vectors.o - CEC_IRQHandler 2 Code Wk STM32G07x_Vectors.o - DMA_Channel1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - DMA_Channel2_3_IRQHandler 2 Code Wk STM32G07x_Vectors.o - DMA_Channel4_5_6_7_IRQHandler - 2 Code Wk STM32G07x_Vectors.o - EXTI0_1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - EXTI2_3_IRQHandler 2 Code Wk STM32G07x_Vectors.o - EXTI4_15_IRQHandler 2 Code Wk STM32G07x_Vectors.o - FLASH_IRQHandler 2 Code Wk STM32G07x_Vectors.o - I2C1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - I2C2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - PVD_IRQHandler 2 Code Wk STM32G07x_Vectors.o - PendSV_Handler 2 Code Wk STM32G07x_Vectors.o - RCC_IRQHandler 2 Code Wk STM32G07x_Vectors.o - RTC_STAMP_IRQHandler 2 Code Wk STM32G07x_Vectors.o - Reset_Handler 2 Code Gb STM32G0xx_Startup.o - SPI1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - SPI2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - SVC_Handler 2 Code Wk STM32G07x_Vectors.o - TIM14_IRQHandler 2 Code Wk STM32G07x_Vectors.o - TIM15_IRQHandler 2 Code Wk STM32G07x_Vectors.o - TIM16_IRQHandler 2 Code Wk STM32G07x_Vectors.o - TIM17_IRQHandler 2 Code Wk STM32G07x_Vectors.o - TIM1_BRK_UP_TRG_COMP_IRQHandler - 2 Code Wk STM32G07x_Vectors.o - TIM1_CC_IRQHandler 2 Code Wk STM32G07x_Vectors.o - TIM2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - TIM3_IRQHandler 2 Code Wk STM32G07x_Vectors.o - TIM6_DAC_LPTIM1_IRQHandler - 2 Code Wk STM32G07x_Vectors.o - TIM7_LPTIM2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - UCPD1_UCPD2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - USART1_IRQHandler 2 Code Wk STM32G07x_Vectors.o - USART2_IRQHandler 2 Code Wk STM32G07x_Vectors.o - USART3_USART4_LPUART1_IRQHandler - 2 Code Wk STM32G07x_Vectors.o - WWDG_IRQHandler 2 Code Wk STM32G07x_Vectors.o - __SEGGER_init_done 4 Code Gb SEGGER_THUMB_Startup.o - __aeabi_memclr4 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memclr8 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memset 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memset4 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - __aeabi_memset8 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - _start 4 Code Gb SEGGER_THUMB_Startup.o - exit 4 Code Gb SEGGER_THUMB_Startup.o - memset 2 Code Wk strasmops_arm.o (libc_v6m_t_le_eabi_small.a) - reset_handler 2 Code Gb STM32G0xx_Startup.o - -Read-write data symbols by name: - - Symbol name Address Size Align Type Bd Object File - ------------------------- ---------- ---------- ----- ---- -- ----------- - Key 0x20000014 4 4 Zero Lc aes.o - RoundKey 0x20000018 176 Zero Lc aes.o - SystemCoreClock 0x20000000 4 4 Init Gb system_stm32g0xx.o - msCounter 0x20000010 4 4 Zero Gb main.o - state 0x2000000C 4 4 Zero Lc aes.o - u 0x20000004 5 4 Zero Gb main.o - -Read-write data symbols by address: - - Address Symbol name Size Align Type Bd Object File - ---------- ------------------------- ---------- ----- ---- -- ----------- - 0x20000000 SystemCoreClock 4 4 Init Gb system_stm32g0xx.o - 0x20000004 u 5 4 Zero Gb main.o - 0x2000000C state 4 4 Zero Lc aes.o - 0x20000010 msCounter 4 4 Zero Gb main.o - 0x20000014 Key 4 4 Zero Lc aes.o - 0x20000018 RoundKey 176 Zero Lc aes.o - -Read-write data symbols by descending size: - - Symbol name Size Align Type Bd Object File - ------------------------- ---------- ----- ---- -- ----------- - RoundKey 176 Zero Lc aes.o - u 5 4 Zero Gb main.o - Key 4 4 Zero Lc aes.o - SystemCoreClock 4 4 Init Gb system_stm32g0xx.o - msCounter 4 4 Zero Gb main.o - state 4 4 Zero Lc aes.o - -Read-only data symbols by name: - - Symbol name Address Size Align Type Bd Object File - ------------------------- ---------- ---------- ----- ---- -- ----------- - AES_KEY 0x08000ECC 16 Cnst Gb main.o - AHBPrescTable 0x0800016C 64 4 Cnst Gb system_stm32g0xx.o - FW_VERSION 0x080000C0 16 16 Cnst Gb main.o - Rcon 0x08000DC6 255 Cnst Lc aes.o - __SEGGER_init_data__ 0x08001108 [4] 4 Cnst Lc [ Linker created ] - __SEGGER_init_table__ 0x080010DC [44] 4 Cnst Lc [ Linker created ] - rsbox 0x08000FDC 256 Cnst Lc aes.o - sbox 0x08000EDC 256 Cnst Lc aes.o - -Read-only data symbols by address: - - Address Symbol name Size Align Type Bd Object File - ---------- ------------------------- ---------- ----- ---- -- ----------- - 0x080000C0 FW_VERSION 16 16 Cnst Gb main.o - 0x0800016C AHBPrescTable 64 4 Cnst Gb system_stm32g0xx.o - 0x08000DC6 Rcon 255 Cnst Lc aes.o - 0x08000ECC AES_KEY 16 Cnst Gb main.o - 0x08000EDC sbox 256 Cnst Lc aes.o - 0x08000FDC rsbox 256 Cnst Lc aes.o - 0x080010DC __SEGGER_init_table__ [44] 4 Cnst Lc [ Linker created ] - 0x08001108 __SEGGER_init_data__ [4] 4 Cnst Lc [ Linker created ] - -Untyped symbols by name: - - Symbol name Value Size Align Type Bd Object File - ------------------------- ---------- ---------- ----- ---- -- ----------- - __FLASH1_segment_end__ 0x08003000 ---- Gb [ Linker created ] - __FLASH1_segment_size__ 0x00003000 ---- Gb [ Linker created ] - __FLASH1_segment_start__ 0x08000000 ---- Gb [ Linker created ] - __FLASH1_segment_used_end__ - 0x08001132 ---- Gb [ Linker created ] - __FLASH1_segment_used_size__ - 0x00001132 ---- Gb [ Linker created ] - __FLASH1_segment_used_start__ - 0x08000000 ---- Gb [ Linker created ] - __FLASH_segment_end__ 0x08003000 ---- Gb [ Linker created ] - __FLASH_segment_size__ 0x00003000 ---- Gb [ Linker created ] - __FLASH_segment_start__ 0x08000000 ---- Gb [ Linker created ] - __FLASH_segment_used_end__ - 0x08001132 ---- Gb [ Linker created ] - __FLASH_segment_used_size__ - 0x00001132 ---- Gb [ Linker created ] - __FLASH_segment_used_start__ - 0x08000000 ---- Gb [ Linker created ] - __HEAPSIZE__ 0x00000000 ---- Gb [ Linker created ] - __RAM1_segment_end__ 0x20008000 ---- Gb [ Linker created ] - __RAM1_segment_size__ 0x00008000 ---- Gb [ Linker created ] - __RAM1_segment_start__ 0x20000000 ---- Gb [ Linker created ] - __RAM1_segment_used_end__ 0x20008000 ---- Gb [ Linker created ] - __RAM1_segment_used_size__ - 0x00008000 ---- Gb [ Linker created ] - __RAM1_segment_used_start__ - 0x20000000 ---- Gb [ Linker created ] - __RAM_segment_end__ 0x20008000 ---- Gb [ Linker created ] - __RAM_segment_size__ 0x00008000 ---- Gb [ Linker created ] - __RAM_segment_start__ 0x20000000 ---- Gb [ Linker created ] - __RAM_segment_used_end__ 0x20008000 ---- Gb [ Linker created ] - __RAM_segment_used_size__ 0x00008000 ---- Gb [ Linker created ] - __RAM_segment_used_start__ - 0x20000000 ---- Gb [ Linker created ] - __SEGGER_init_run_loop 0x08000CD2 4 Code Lc SEGGER_THUMB_Startup.o - __STACKSIZE_PROCESS__ 0x00000000 ---- Gb [ Linker created ] - __STACKSIZE__ 0x00001000 ---- Gb [ Linker created ] - __stack_end__ 0x20008000 ---- Gb [ Linker created ] - __thread_pointer$ 0x00000000 ---- Gb [ Linker created ] - _vectors 0x08000000 [192] 512 Code Gb STM32G07x_Vectors.o - _vectors_end 0x080000C0 512 Code Lc STM32G07x_Vectors.o - -Untyped symbols by address: - - Value Symbol name Size Align Type Bd Object File - ---------- ------------------------- ---------- ----- ---- -- ----------- - 0x00000000 __thread_pointer$ ---- Gb [ Linker created ] - 0x00000000 __STACKSIZE_PROCESS__ ---- Gb [ Linker created ] - 0x00000000 __HEAPSIZE__ ---- Gb [ Linker created ] - 0x00001000 __STACKSIZE__ ---- Gb [ Linker created ] - 0x00001132 __FLASH_segment_used_size__ - ---- Gb [ Linker created ] - 0x00001132 __FLASH1_segment_used_size__ - ---- Gb [ Linker created ] - 0x00003000 __FLASH_segment_size__ ---- Gb [ Linker created ] - 0x00003000 __FLASH1_segment_size__ ---- Gb [ Linker created ] - 0x00008000 __RAM_segment_used_size__ ---- Gb [ Linker created ] - 0x00008000 __RAM_segment_size__ ---- Gb [ Linker created ] - 0x00008000 __RAM1_segment_used_size__ - ---- Gb [ Linker created ] - 0x00008000 __RAM1_segment_size__ ---- Gb [ Linker created ] - 0x08000000 _vectors [192] 512 Code Gb STM32G07x_Vectors.o - 0x08000000 __FLASH_segment_used_start__ - ---- Gb [ Linker created ] - 0x08000000 __FLASH_segment_start__ ---- Gb [ Linker created ] - 0x08000000 __FLASH1_segment_used_start__ - ---- Gb [ Linker created ] - 0x08000000 __FLASH1_segment_start__ ---- Gb [ Linker created ] - 0x080000C0 _vectors_end 512 Code Lc STM32G07x_Vectors.o - 0x08000CD2 __SEGGER_init_run_loop 4 Code Lc SEGGER_THUMB_Startup.o - 0x08001132 __FLASH_segment_used_end__ - ---- Gb [ Linker created ] - 0x08001132 __FLASH1_segment_used_end__ - ---- Gb [ Linker created ] - 0x08003000 __FLASH_segment_end__ ---- Gb [ Linker created ] - 0x08003000 __FLASH1_segment_end__ ---- Gb [ Linker created ] - 0x20000000 __RAM_segment_used_start__ - ---- Gb [ Linker created ] - 0x20000000 __RAM_segment_start__ ---- Gb [ Linker created ] - 0x20000000 __RAM1_segment_used_start__ - ---- Gb [ Linker created ] - 0x20000000 __RAM1_segment_start__ ---- Gb [ Linker created ] - 0x20008000 __stack_end__ ---- Gb [ Linker created ] - 0x20008000 __RAM_segment_used_end__ ---- Gb [ Linker created ] - 0x20008000 __RAM_segment_end__ ---- Gb [ Linker created ] - 0x20008000 __RAM1_segment_used_end__ ---- Gb [ Linker created ] - 0x20008000 __RAM1_segment_end__ ---- Gb [ Linker created ] - - -*********************************************************************************************** -*** *** -*** LINK SUMMARY *** -*** *** -*********************************************************************************************** - -Memory breakdown: - - 3 484 bytes read-only code + - 911 bytes read-only data = 4 395 bytes read-only (total) - 4 293 bytes read-write data - -Region summary: - - Name Range Size Used Unused Alignment Loss - ---------- ----------------- ----------- ------------------- ------------------- ------------------- - FLASH 08000000-08002fff 12 288 4 399 35.80% 7 889 64.20% 0 0.00% - RAM 20000000-20007fff 32 768 4 293 13.10% 28 472 86.89% 3 0.01% - -Link complete: 0 errors, 0 warnings, 0 remarks

CONTENTS

LINK INFORMATION

Linker version

Command line

LINKER SCRIPT

Linker script 'D:/Projekte/ecs_greenSmartSwitch/trunk/firmware_bootloader/SES/STM32G0xx_Flash.icf'

PLACEMENT SUMMARY

place at 0x08000000

place at 0x20008000

at line 77, col 45": place in [0x08000000 to 0x08002fff] with maximum packing">"<#4> at line 77, col 45": place in [0x08000000 to 0x08002fff] with maximum packing

at line 97, col 45": place in [0x20000000 to 0x20007fff] with auto order">"<#9> at line 97, col 45": place in [0x20000000 to 0x20007fff] with auto order

at line 101, col 45": place in [0x20000000 to 0x20007fff] with auto order">"<#10> at line 101, col 45": place in [0x20000000 to 0x20007fff] with auto order

MODULE SUMMARY

Memory use by input file

Memory use by archive member

Memory use by linker

MODULE DETAIL

Module system_stm32g0xx.o

Module aes.o

Module main.o

Module SEGGER_THUMB_Startup.o

Module STM32G07x_Vectors.o

Module STM32G0xx_Startup.o

Module intasmops_arm.o (libc_v6m_t_le_eabi_small.a)

Module strasmops_arm.o (libc_v6m_t_le_eabi_small.a)

Module SEGGER_crtinit.o (SEGGER_crtinit_v6m_t_le_eabi_small.a)

All modules

SECTION DETAIL

Sections by address

UNUSED MEMORY SUMMARY

Detail

INITIALIZATION TABLE

Constructor list

Initialize by zero

Initialize by zero

Initialize by copy with packing=none

Summary

LINKER-CREATED VENEERS

Arm-Arm range extension veneers

Thumb-Thumb range extension veneers

Arm-Thumb mode switch veneers

Thumb-Arm mode switch veneers

Summary

SYMBOL LIST

Function symbols by name

Function symbols by address

Function symbols by descending size

Read-write data symbols by name

Read-write data symbols by address

Read-write data symbols by descending size

Read-only data symbols by name

Read-only data symbols by address

Untyped symbols by name

Untyped symbols by address

REGION LIST

Regions by name

Analysis

BLOCK LIST

Blocks by name

Blocks by address

STACK SIZES

Functions by stack size

Functions without stack size information

UNUSED INPUTS

Unused object files

ABSOLUTE LISTING

Section .vectors from STM32G07x_Vectors.o, size=192, align=512

Section .rodata.FW_VERSION from main.o, size=16, align=16

Section .init.SystemInit from system_stm32g0xx.o, size=16, align=4

Section .init.SystemCoreClockUpdate from system_stm32g0xx.o, size=140, align=4

Section .init_rodata.AHBPrescTable from system_stm32g0xx.o, size=64, align=4

Section .text.AES128_ECB_decrypt from aes.o, size=692, align=4

Section .text.AddRoundKey from aes.o, size=56, align=4

Section .text.main from main.o, size=1136, align=4

Section .text.Init from main.o, size=512, align=4

Section .text.WaitForByte from main.o, size=140, align=4

Section .text.JumpToApplication from main.o, size=152, align=4

Section .text.Transmit from main.o, size=32, align=4

Section .text.TurnErrorLEDOn from main.o, size=68, align=4

Section .text.Delay from main.o, size=28, align=4