commit ae1d14d2a75462820abb9fab158c2bdd3675b482 Author: Twoje Imię Date: Tue Jun 11 11:29:20 2024 +0200 Branch diff --git a/FIFA99/FIFA_99/FIFA_99/FIFA 99_Repack_Setup-1.bin b/FIFA99/FIFA_99/FIFA_99/FIFA 99_Repack_Setup-1.bin new file mode 100644 index 0000000..6336927 Binary files /dev/null and b/FIFA99/FIFA_99/FIFA_99/FIFA 99_Repack_Setup-1.bin differ diff --git a/FIFA99/FIFA_99/FIFA_99/FIFA 99_Repack_Setup.exe b/FIFA99/FIFA_99/FIFA_99/FIFA 99_Repack_Setup.exe new file mode 100644 index 0000000..3d48c26 Binary files /dev/null and b/FIFA99/FIFA_99/FIFA_99/FIFA 99_Repack_Setup.exe differ diff --git a/FIFA99/FIFA_99/HOW TO RUN GAME!!.txt b/FIFA99/FIFA_99/HOW TO RUN GAME!!.txt new file mode 100644 index 0000000..c012515 --- /dev/null +++ b/FIFA99/FIFA_99/HOW TO RUN GAME!!.txt @@ -0,0 +1,7 @@ +To play game, go inside the 'FIFA_99' folder, right click and run 'FIFA 99_Repack_Setup' as administrator + +Install game and launch + +If you get any missing dll errors or the game isn't launching, go inside the _Redist folder and install all 8 programs in the folder + +For more FREE STEAM GAMES, visit steamunlocked.net \ No newline at end of file diff --git a/FIFA99/FIFA_99/STEAMUNLOCKED » Free Steam Games Pre-installed for PC.url b/FIFA99/FIFA_99/STEAMUNLOCKED » Free Steam Games Pre-installed for PC.url new file mode 100644 index 0000000..145ec96 --- /dev/null +++ b/FIFA99/FIFA_99/STEAMUNLOCKED » Free Steam Games Pre-installed for PC.url @@ -0,0 +1,2 @@ +[InternetShortcut] +URL=https://steamunlocked.net/ diff --git a/FIFA99/FIFA_99/_Redist/dotNetFx40_Full_setup.exe b/FIFA99/FIFA_99/_Redist/dotNetFx40_Full_setup.exe new file mode 100644 index 0000000..384fb83 Binary files /dev/null and b/FIFA99/FIFA_99/_Redist/dotNetFx40_Full_setup.exe differ diff --git a/FIFA99/FIFA_99/_Redist/dxwebsetup.exe b/FIFA99/FIFA_99/_Redist/dxwebsetup.exe new file mode 100644 index 0000000..07ef6b8 Binary files /dev/null and b/FIFA99/FIFA_99/_Redist/dxwebsetup.exe differ diff --git a/FIFA99/FIFA_99/_Redist/oalinst.exe b/FIFA99/FIFA_99/_Redist/oalinst.exe new file mode 100644 index 0000000..0b61822 Binary files /dev/null and b/FIFA99/FIFA_99/_Redist/oalinst.exe differ diff --git a/FIFA99/FIFA_99/_Redist/vcredist_2015-2019_x64.exe b/FIFA99/FIFA_99/_Redist/vcredist_2015-2019_x64.exe new file mode 100644 index 0000000..7476d75 Binary files /dev/null and b/FIFA99/FIFA_99/_Redist/vcredist_2015-2019_x64.exe differ diff --git a/FIFA99/FIFA_99/_Redist/vcredist_2015-2019_x86.exe b/FIFA99/FIFA_99/_Redist/vcredist_2015-2019_x86.exe new file mode 100644 index 0000000..e1fe7cf Binary files /dev/null and b/FIFA99/FIFA_99/_Redist/vcredist_2015-2019_x86.exe differ diff --git a/FIFA99/FIFA_99/_Redist/vcredist_x64.exe b/FIFA99/FIFA_99/_Redist/vcredist_x64.exe new file mode 100644 index 0000000..6ae64fb Binary files /dev/null and b/FIFA99/FIFA_99/_Redist/vcredist_x64.exe differ diff --git a/FIFA99/FIFA_99/_Redist/vcredist_x86.exe b/FIFA99/FIFA_99/_Redist/vcredist_x86.exe new file mode 100644 index 0000000..57e15c0 Binary files /dev/null and b/FIFA99/FIFA_99/_Redist/vcredist_x86.exe differ diff --git a/FIFA99/FIFA_99/_Redist/xnafx40_redist.msi b/FIFA99/FIFA_99/_Redist/xnafx40_redist.msi new file mode 100644 index 0000000..42bbb26 Binary files /dev/null and b/FIFA99/FIFA_99/_Redist/xnafx40_redist.msi differ diff --git a/conf.json b/conf.json new file mode 100644 index 0000000..a059d03 --- /dev/null +++ b/conf.json @@ -0,0 +1,16 @@ +{ + "user": "borysr", + "email": "borysr@gmail.com", + "remotes": [ + { + "name": "r", + "protocol": "http", + "domain": "qstack.pl", + "port": "3000", + "token_name": "t", + "token": "8ee3f1b7980197aeceadee3cf4d980f817d44f06", + "group": "1i-2023", + "project": "homework" + } + ] +} \ No newline at end of file diff --git a/cpp/._rvmain.cpp.swl b/cpp/._rvmain.cpp.swl new file mode 100644 index 0000000..1080c39 Binary files /dev/null and b/cpp/._rvmain.cpp.swl differ diff --git a/cpp/._rvmain.cpp.swm b/cpp/._rvmain.cpp.swm new file mode 100644 index 0000000..ee08e76 Binary files /dev/null and b/cpp/._rvmain.cpp.swm differ diff --git a/cpp/._rvmain.cpp.swn b/cpp/._rvmain.cpp.swn new file mode 100644 index 0000000..d0b40fb Binary files /dev/null and b/cpp/._rvmain.cpp.swn differ diff --git a/cpp/._rvmain.cpp.swo b/cpp/._rvmain.cpp.swo new file mode 100644 index 0000000..4d5e1f4 Binary files /dev/null and b/cpp/._rvmain.cpp.swo differ diff --git a/cpp/._rvmain.cpp.swp b/cpp/._rvmain.cpp.swp new file mode 100644 index 0000000..e6a5d76 Binary files /dev/null and b/cpp/._rvmain.cpp.swp differ diff --git a/cpp/Make.rules b/cpp/Make.rules new file mode 100644 index 0000000..9e7045e --- /dev/null +++ b/cpp/Make.rules @@ -0,0 +1,85 @@ + +ARCH=riscv64-unknown-elf +GNU_DIR=$(HOME)/riscv/riscv/ +GNU_BIN=$(GNU_DIR)/bin + + +CC=$(GNU_BIN)/$(ARCH)-gcc +CXX=$(GNU_BIN)/$(ARCH)-g++ +AS=$(GNU_BIN)/$(ARCH)-as +LD=$(GNU_BIN)/$(ARCH)-ld +OBJCOPY=$(GNU_BIN)/$(ARCH)-objcopy +OBJDUMP=$(GNU_BIN)/$(ARCH)-objdump +SIZE=$(GNU_BIN)/$(ARCH)-size +AR=$(GNU_BIN)/$(ARCH)-ar +RANLIB=$(GNU_BIN)/$(ARCH)-ranlib + + +CFLAGS+=-ffreestanding +CFLAGS+=-fno-pic +CFLAGS+=-march=rv32i -mabi=ilp32 +CFLAGS+= -g + + +LDFLAGS+=-nostdlib +<<<<<<< HEAD +LDFLAGS+=-Wl,-Ttext=0x00000000 +======= +LDFLAGS+=-Wl,-Ttext=0x80000000 +>>>>>>> origin/fabian + +# see: https://github.com/riscv/riscv-gcc/issues/120 +#LDFLAGS+=-Wl,--no-relax + + + +ASFLAGS+=$(CFLAGS) +CXXFLAGS+=$(CFLAGS) + +CLEAN_DIRS=$(SUBDIRS:%=clean-%) +ALL_DIRS=$(SUBDIRS:%=all-%) + +OBJDUMPFLAGS+=-Mnumeric,no-aliases + +.PHONY: all clean world $(CLEAN_DIRS) $(ALL_DIRS) + + +%.bin : % + $(OBJCOPY) $< -O binary $@ + +%.lst : % + $(OBJDUMP) $(OBJDUMPFLAGS) -dr --disassemble-all $< > $<.lst + +% : %.o + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(LDLIBS) + $(SIZE) -x -A $@ + +%.s: %.c + $(COMPILE.c) -S -o $@ $< + +%.s: %.cc + $(COMPILE.cc) -S -o $@ $< + +%.o: %.c + $(COMPILE.c) -o $@ $< + +%.o: %.cc + $(COMPILE.cc) -o $@ $< + +%.srec: % + $(OBJCOPY) $< -O srec $@ + + + + +all:: $(ALL_DIRS) + +clean:: $(CLEAN_DIRS) + +$(ALL_DIRS):: + $(MAKE) -C $(@:all-%=%) all + +$(CLEAN_DIRS):: + $(MAKE) -C $(@:clean-%=%) clean + +world:: clean all diff --git a/cpp/Make.rules-kopia b/cpp/Make.rules-kopia new file mode 100644 index 0000000..2bd12e9 --- /dev/null +++ b/cpp/Make.rules-kopia @@ -0,0 +1,81 @@ + +ARCH=riscv64-unknown-elf +GNU_DIR=$(HOME)/riscv/riscv/ +GNU_BIN=$(GNU_DIR)/bin + + +CC=$(GNU_BIN)/$(ARCH)-gcc +CXX=$(GNU_BIN)/$(ARCH)-g++ +AS=$(GNU_BIN)/$(ARCH)-as +LD=$(GNU_BIN)/$(ARCH)-ld +OBJCOPY=$(GNU_BIN)/$(ARCH)-objcopy +OBJDUMP=$(GNU_BIN)/$(ARCH)-objdump +SIZE=$(GNU_BIN)/$(ARCH)-size +AR=$(GNU_BIN)/$(ARCH)-ar +RANLIB=$(GNU_BIN)/$(ARCH)-ranlib + + +CFLAGS+=-ffreestanding +CFLAGS+=-fno-pic +CFLAGS+=-march=rv32i -mabi=ilp32 +CFLAGS+= -g + + +LDFLAGS+=-nostdlib +LDFLAGS+=-Wl,-Ttext=0x00000000 + +# see: https://github.com/riscv/riscv-gcc/issues/120 +#LDFLAGS+=-Wl,--no-relax + + + +ASFLAGS+=$(CFLAGS) +CXXFLAGS+=$(CFLAGS) + +CLEAN_DIRS=$(SUBDIRS:%=clean-%) +ALL_DIRS=$(SUBDIRS:%=all-%) + +OBJDUMPFLAGS+=-Mnumeric,no-aliases + +.PHONY: all clean world $(CLEAN_DIRS) $(ALL_DIRS) + + +%.bin : % + $(OBJCOPY) $< -O binary $@ + +%.lst : % + $(OBJDUMP) $(OBJDUMPFLAGS) -dr --disassemble-all $< > $<.lst + +% : %.o + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(LDLIBS) + $(SIZE) -x -A $@ + +%.s: %.c + $(COMPILE.c) -S -o $@ $< + +%.s: %.cc + $(COMPILE.cc) -S -o $@ $< + +%.o: %.c + $(COMPILE.c) -o $@ $< + +%.o: %.cc + $(COMPILE.cc) -o $@ $< + +%.srec: % + $(OBJCOPY) $< -O srec $@ + + + + +all:: $(ALL_DIRS) + +clean:: $(CLEAN_DIRS) + +$(ALL_DIRS):: + $(MAKE) -C $(@:all-%=%) all + +$(CLEAN_DIRS):: + $(MAKE) -C $(@:clean-%=%) clean + +world:: clean all diff --git a/cpp/Makefile b/cpp/Makefile new file mode 100644 index 0000000..24b307b --- /dev/null +++ b/cpp/Makefile @@ -0,0 +1,38 @@ +TOP=./ +include $(TOP)/Make.rules + +LDLIBS= +<<<<<<< HEAD +#CFLAGS+=-O0 -g +# CFLAGS+=-Og -ggdb3 +CFLAGS+=-O0 -ggdb3 + +LDFLAGS+=-Wl,--no-relax +LDFLAGS+=-Wl,-Ttext=0x80000000,-Tdata=0x80010000 +# LDFLAGS+=-T murax_128k_ram.ld +======= +CFLAGS+=-O0 -g + +LDFLAGS+=-Wl,--no-relax +LDFLAGS+=-Wl,-Tdata=0x10000 +>>>>>>> origin/fabian + +PROGS=prog prog.bin prog.lst + +all:: $(PROGS) + +<<<<<<< HEAD +prog: _crt0.o _rvmain.o myfunc.o +======= +prog: _crt0.o _rvmain.o myfunc.o myfuncStruct.o myfuncStructOOP.o myfuncOOP.o +>>>>>>> origin/fabian + $(LINK.cc) -o $@ $^ $(LDLIBS) + $(SIZE) -A -x $@ + +clean:: + rm -f $(PROGS) *.o *.s *.lst *.bin *.srec *.dis + +.PHONY: run +run: prog.bin + ../../../src/rvddt -l0x3000 -f prog.bin + diff --git a/cpp/Murax.scala b/cpp/Murax.scala new file mode 100644 index 0000000..2260833 --- /dev/null +++ b/cpp/Murax.scala @@ -0,0 +1,543 @@ +package vexriscv.demo + +import spinal.core._ +import spinal.lib._ +import spinal.lib.bus.amba3.apb._ +import spinal.lib.bus.misc.SizeMapping +import spinal.lib.bus.simple.PipelinedMemoryBus +import spinal.lib.com.jtag.Jtag +import spinal.lib.com.spi.ddr.SpiXdrMaster +import spinal.lib.com.uart._ +import spinal.lib.io.{InOutWrapper, TriStateArray} +import spinal.lib.misc.{InterruptCtrl, Prescaler, Timer} +import spinal.lib.soc.pinsec.{PinsecTimerCtrl, PinsecTimerCtrlExternal} +import vexriscv.plugin._ +import vexriscv.{VexRiscv, VexRiscvConfig, plugin} +import spinal.lib.com.spi.ddr._ +import spinal.lib.bus.simple._ +import scala.collection.mutable.ArrayBuffer +import scala.collection.Seq + +/** + * Created by PIC32F_USER on 28/07/2017. + * + * Murax is a very light SoC which could work without any external component. + * - ICE40-hx8k + icestorm => 53 Mhz, 2142 LC + * - 0.37 DMIPS/Mhz + * - 8 kB of on-chip ram + * - JTAG debugger (eclipse/GDB/openocd ready) + * - Interrupt support + * - APB bus for peripherals + * - 32 GPIO pin + * - one 16 bits prescaler, two 16 bits timers + * - one UART with tx/rx fifo + */ + + +case class MuraxConfig(coreFrequency : HertzNumber, + onChipRamSize : BigInt, + onChipRamHexFile : String, + pipelineDBus : Boolean, + pipelineMainBus : Boolean, + pipelineApbBridge : Boolean, + gpioWidth : Int, + uartCtrlConfig : UartCtrlMemoryMappedConfig, + xipConfig : SpiXdrMasterCtrl.MemoryMappingParameters, + hardwareBreakpointCount : Int, + cpuPlugins : ArrayBuffer[Plugin[VexRiscv]]){ + require(pipelineApbBridge || pipelineMainBus, "At least pipelineMainBus or pipelineApbBridge should be enable to avoid wipe transactions") + val genXip = xipConfig != null + +} + + + +object MuraxConfig{ + def default : MuraxConfig = default(false, false) + def default(withXip : Boolean = false, bigEndian : Boolean = false) = MuraxConfig( + coreFrequency = 12 MHz, + onChipRamSize = 128 kB, + onChipRamHexFile = null, + pipelineDBus = true, + pipelineMainBus = false, + pipelineApbBridge = true, + gpioWidth = 32, + xipConfig = ifGen(withXip) (SpiXdrMasterCtrl.MemoryMappingParameters( + SpiXdrMasterCtrl.Parameters(8, 12, SpiXdrParameter(2, 2, 1)).addFullDuplex(0,1,false), + cmdFifoDepth = 32, + rspFifoDepth = 32, + xip = SpiXdrMasterCtrl.XipBusParameters(addressWidth = 24, lengthWidth = 2) + )), + hardwareBreakpointCount = if(withXip) 3 else 0, + cpuPlugins = ArrayBuffer( //DebugPlugin added by the toplevel + new IBusSimplePlugin( + resetVector = if(withXip) 0xF001E000l else 0x00000000l, + cmdForkOnSecondStage = true, + cmdForkPersistence = withXip, //Required by the Xip controller + prediction = NONE, + catchAccessFault = false, + compressedGen = false, + bigEndian = bigEndian + ), + new DBusSimplePlugin( + catchAddressMisaligned = false, + catchAccessFault = false, + earlyInjection = false, + bigEndian = bigEndian + ), + new CsrPlugin(CsrPluginConfig.smallest(mtvecInit = if(withXip) 0xE0040020l else 0x00000020l)), + new DecoderSimplePlugin( + catchIllegalInstruction = false + ), + new RegFilePlugin( + regFileReadyKind = plugin.SYNC, + zeroBoot = false + ), + new IntAluPlugin, + new SrcPlugin( + separatedAddSub = false, + executeInsertion = false + ), + new LightShifterPlugin, + new HazardSimplePlugin( + bypassExecute = false, + bypassMemory = false, + bypassWriteBack = false, + bypassWriteBackBuffer = false, + pessimisticUseSrc = false, + pessimisticWriteRegFile = false, + pessimisticAddressMatch = false + ), + new BranchPlugin( + earlyBranch = false, + catchAddressMisaligned = false + ), + new YamlPlugin("cpu0.yaml") + ), + uartCtrlConfig = UartCtrlMemoryMappedConfig( + uartCtrlConfig = UartCtrlGenerics( + dataWidthMax = 8, + clockDividerWidth = 20, + preSamplingSize = 1, + samplingSize = 3, + postSamplingSize = 1 + ), + initConfig = UartCtrlInitConfig( + baudrate = 115200, + dataLength = 7, //7 => 8 bits + parity = UartParityType.NONE, + stop = UartStopType.ONE + ), + busCanWriteClockDividerConfig = false, + busCanWriteFrameConfig = false, + txFifoDepth = 16, + rxFifoDepth = 16 + ) + + ) + + def fast = { + val config = default + + //Replace HazardSimplePlugin to get datapath bypass + config.cpuPlugins(config.cpuPlugins.indexWhere(_.isInstanceOf[HazardSimplePlugin])) = new HazardSimplePlugin( + bypassExecute = true, + bypassMemory = true, + bypassWriteBack = true, + bypassWriteBackBuffer = true + ) +// config.cpuPlugins(config.cpuPlugins.indexWhere(_.isInstanceOf[LightShifterPlugin])) = new FullBarrelShifterPlugin() + + config + } +} + + +case class Murax(config : MuraxConfig) extends Component{ + import config._ + + val io = new Bundle { + //Clocks / reset + val asyncReset = in Bool() + val mainClk = in Bool() + + //Main components IO + val jtag = slave(Jtag()) + + //Peripherals IO + val gpioA = master(TriStateArray(gpioWidth bits)) + val uart = master(Uart()) + + val xip = ifGen(genXip)(master(SpiXdrMaster(xipConfig.ctrl.spi))) + } + + + val resetCtrlClockDomain = ClockDomain( + clock = io.mainClk, + config = ClockDomainConfig( + resetKind = BOOT + ) + ) + + val resetCtrl = new ClockingArea(resetCtrlClockDomain) { + val mainClkResetUnbuffered = False + + //Implement an counter to keep the reset axiResetOrder high 64 cycles + // Also this counter will automatically do a reset when the system boot. + val systemClkResetCounter = Reg(UInt(6 bits)) init(0) + when(systemClkResetCounter =/= U(systemClkResetCounter.range -> true)){ + systemClkResetCounter := systemClkResetCounter + 1 + mainClkResetUnbuffered := True + } + when(BufferCC(io.asyncReset)){ + systemClkResetCounter := 0 + } + + //Create all reset used later in the design + val mainClkReset = RegNext(mainClkResetUnbuffered) + val systemReset = RegNext(mainClkResetUnbuffered) + } + + + val systemClockDomain = ClockDomain( + clock = io.mainClk, + reset = resetCtrl.systemReset, + frequency = FixedFrequency(coreFrequency) + ) + + val debugClockDomain = ClockDomain( + clock = io.mainClk, + reset = resetCtrl.mainClkReset, + frequency = FixedFrequency(coreFrequency) + ) + + val system = new ClockingArea(systemClockDomain) { + val pipelinedMemoryBusConfig = PipelinedMemoryBusConfig( + addressWidth = 32, + dataWidth = 32 + ) + + val bigEndianDBus = config.cpuPlugins.exists(_ match{ case plugin : DBusSimplePlugin => plugin.bigEndian case _ => false}) + + //Arbiter of the cpu dBus/iBus to drive the mainBus + //Priority to dBus, !! cmd transactions can change on the fly !! + val mainBusArbiter = new MuraxMasterArbiter(pipelinedMemoryBusConfig, bigEndianDBus) + + //Instanciate the CPU + val cpu = new VexRiscv( + config = VexRiscvConfig( + plugins = cpuPlugins += new DebugPlugin(debugClockDomain, hardwareBreakpointCount) + ) + ) + + //Checkout plugins used to instanciate the CPU to connect them to the SoC + val timerInterrupt = False + val externalInterrupt = False + for(plugin <- cpu.plugins) plugin match{ + case plugin : IBusSimplePlugin => + mainBusArbiter.io.iBus.cmd <> plugin.iBus.cmd + mainBusArbiter.io.iBus.rsp <> plugin.iBus.rsp + case plugin : DBusSimplePlugin => { + if(!pipelineDBus) + mainBusArbiter.io.dBus <> plugin.dBus + else { + mainBusArbiter.io.dBus.cmd << plugin.dBus.cmd.halfPipe() + mainBusArbiter.io.dBus.rsp <> plugin.dBus.rsp + } + } + case plugin : CsrPlugin => { + plugin.externalInterrupt := externalInterrupt + plugin.timerInterrupt := timerInterrupt + } + case plugin : DebugPlugin => plugin.debugClockDomain{ + resetCtrl.systemReset setWhen(RegNext(plugin.io.resetOut)) + io.jtag <> plugin.io.bus.fromJtag() + } + case _ => + } + + + + //****** MainBus slaves ******** + val mainBusMapping = ArrayBuffer[(PipelinedMemoryBus,SizeMapping)]() + val ram = new MuraxPipelinedMemoryBusRam( + onChipRamSize = onChipRamSize, + onChipRamHexFile = onChipRamHexFile, + pipelinedMemoryBusConfig = pipelinedMemoryBusConfig, + bigEndian = bigEndianDBus + ) + mainBusMapping += ram.io.bus -> (0x00000000l, onChipRamSize) + + val apbBridge = new PipelinedMemoryBusToApbBridge( + apb3Config = Apb3Config( + addressWidth = 20, + dataWidth = 32 + ), + pipelineBridge = pipelineApbBridge, + pipelinedMemoryBusConfig = pipelinedMemoryBusConfig + ) + mainBusMapping += apbBridge.io.pipelinedMemoryBus -> (0xF0000000l, 1 MB) + + + + //******** APB peripherals ********* + val apbMapping = ArrayBuffer[(Apb3, SizeMapping)]() + val gpioACtrl = Apb3Gpio(gpioWidth = gpioWidth, withReadSync = true) + io.gpioA <> gpioACtrl.io.gpio + apbMapping += gpioACtrl.io.apb -> (0x00000, 4 kB) + + val uartCtrl = Apb3UartCtrl(uartCtrlConfig) + uartCtrl.io.uart <> io.uart + externalInterrupt setWhen(uartCtrl.io.interrupt) + apbMapping += uartCtrl.io.apb -> (0x10000, 4 kB) + + val timer = new MuraxApb3Timer() + timerInterrupt setWhen(timer.io.interrupt) + apbMapping += timer.io.apb -> (0x20000, 4 kB) + + val xip = ifGen(genXip)(new Area{ + val ctrl = Apb3SpiXdrMasterCtrl(xipConfig) + ctrl.io.spi <> io.xip + externalInterrupt setWhen(ctrl.io.interrupt) + apbMapping += ctrl.io.apb -> (0x1F000, 4 kB) + + val accessBus = new PipelinedMemoryBus(PipelinedMemoryBusConfig(24,32)) + mainBusMapping += accessBus -> (0xE0000000l, 16 MB) + + ctrl.io.xip.fromPipelinedMemoryBus() << accessBus + val bootloader = Apb3Rom("src/main/c/murax/xipBootloader/crt.bin") + apbMapping += bootloader.io.apb -> (0x1E000, 4 kB) + }) + + + + //******** Memory mappings ********* + val apbDecoder = Apb3Decoder( + master = apbBridge.io.apb, + slaves = apbMapping.toSeq + ) + + val mainBusDecoder = new Area { + val logic = new MuraxPipelinedMemoryBusDecoder( + master = mainBusArbiter.io.masterBus, + specification = mainBusMapping.toSeq, + pipelineMaster = pipelineMainBus + ) + } + } +} + + + +object Murax{ + def main(args: Array[String]) { + SpinalVerilog(Murax(MuraxConfig.default)) + } +} + +object MuraxCfu{ + def main(args: Array[String]) { + SpinalVerilog{ + val config = MuraxConfig.default + config.cpuPlugins += new CfuPlugin( + stageCount = 1, + allowZeroLatency = true, + encodings = List( + CfuPluginEncoding ( + instruction = M"-------------------------0001011", + functionId = List(14 downto 12), + input2Kind = CfuPlugin.Input2Kind.RS + ) + ), + busParameter = CfuBusParameter( + CFU_VERSION = 0, + CFU_INTERFACE_ID_W = 0, + CFU_FUNCTION_ID_W = 3, + CFU_REORDER_ID_W = 0, + CFU_REQ_RESP_ID_W = 0, + CFU_INPUTS = 2, + CFU_INPUT_DATA_W = 32, + CFU_OUTPUTS = 1, + CFU_OUTPUT_DATA_W = 32, + CFU_FLOW_REQ_READY_ALWAYS = false, + CFU_FLOW_RESP_READY_ALWAYS = false, + CFU_WITH_STATUS = true, + CFU_RAW_INSN_W = 32, + CFU_CFU_ID_W = 4, + CFU_STATE_INDEX_NUM = 5 + ) + ) + + val toplevel = Murax(config) + + toplevel.rework { + for (plugin <- toplevel.system.cpu.plugins) plugin match { + case plugin: CfuPlugin => plugin.bus.toIo().setName("miaou") + case _ => + } + } + + toplevel + } + } +} + + +object Murax_iCE40_hx8k_breakout_board_xip{ + + case class SB_GB() extends BlackBox{ + val USER_SIGNAL_TO_GLOBAL_BUFFER = in Bool() + val GLOBAL_BUFFER_OUTPUT = out Bool() + } + + case class SB_IO_SCLK() extends BlackBox{ + addGeneric("PIN_TYPE", B"010000") + val PACKAGE_PIN = out Bool() + val OUTPUT_CLK = in Bool() + val CLOCK_ENABLE = in Bool() + val D_OUT_0 = in Bool() + val D_OUT_1 = in Bool() + setDefinitionName("SB_IO") + } + + case class SB_IO_DATA() extends BlackBox{ + addGeneric("PIN_TYPE", B"110000") + val PACKAGE_PIN = inout(Analog(Bool)) + val CLOCK_ENABLE = in Bool() + val INPUT_CLK = in Bool() + val OUTPUT_CLK = in Bool() + val OUTPUT_ENABLE = in Bool() + val D_OUT_0 = in Bool() + val D_OUT_1 = in Bool() + val D_IN_0 = out Bool() + val D_IN_1 = out Bool() + setDefinitionName("SB_IO") + } + + case class Murax_iCE40_hx8k_breakout_board_xip() extends Component{ + val io = new Bundle { + val mainClk = in Bool() + val jtag_tck = in Bool() + val jtag_tdi = in Bool() + val jtag_tdo = out Bool() + val jtag_tms = in Bool() + val uart_txd = out Bool() + val uart_rxd = in Bool() + + val mosi = inout(Analog(Bool)) + val miso = inout(Analog(Bool)) + val sclk = out Bool() + val spis = out Bool() + + val led = out Bits(8 bits) + } + val murax = Murax(MuraxConfig.default(withXip = true).copy(onChipRamSize = 8 kB)) + murax.io.asyncReset := False + + val mainClkBuffer = SB_GB() + mainClkBuffer.USER_SIGNAL_TO_GLOBAL_BUFFER <> io.mainClk + mainClkBuffer.GLOBAL_BUFFER_OUTPUT <> murax.io.mainClk + + val jtagClkBuffer = SB_GB() + jtagClkBuffer.USER_SIGNAL_TO_GLOBAL_BUFFER <> io.jtag_tck + jtagClkBuffer.GLOBAL_BUFFER_OUTPUT <> murax.io.jtag.tck + + io.led <> murax.io.gpioA.write(7 downto 0) + + murax.io.jtag.tdi <> io.jtag_tdi + murax.io.jtag.tdo <> io.jtag_tdo + murax.io.jtag.tms <> io.jtag_tms + murax.io.gpioA.read <> 0 + murax.io.uart.txd <> io.uart_txd + murax.io.uart.rxd <> io.uart_rxd + + + + val xip = new ClockingArea(murax.systemClockDomain) { + RegNext(murax.io.xip.ss.asBool) <> io.spis + + val sclkIo = SB_IO_SCLK() + sclkIo.PACKAGE_PIN <> io.sclk + sclkIo.CLOCK_ENABLE := True + + sclkIo.OUTPUT_CLK := ClockDomain.current.readClockWire + sclkIo.D_OUT_0 <> murax.io.xip.sclk.write(0) + sclkIo.D_OUT_1 <> RegNext(murax.io.xip.sclk.write(1)) + + val datas = for ((data, pin) <- (murax.io.xip.data, List(io.mosi, io.miso)).zipped) yield new Area { + val dataIo = SB_IO_DATA() + dataIo.PACKAGE_PIN := pin + dataIo.CLOCK_ENABLE := True + + dataIo.OUTPUT_CLK := ClockDomain.current.readClockWire + dataIo.OUTPUT_ENABLE <> data.writeEnable + dataIo.D_OUT_0 <> data.write(0) + dataIo.D_OUT_1 <> RegNext(data.write(1)) + + dataIo.INPUT_CLK := ClockDomain.current.readClockWire + data.read(0) := dataIo.D_IN_0 + data.read(1) := RegNext(dataIo.D_IN_1) + } + } + + } + + def main(args: Array[String]) { + SpinalVerilog(Murax_iCE40_hx8k_breakout_board_xip()) + } +} + +object MuraxDhrystoneReady{ + def main(args: Array[String]) { + SpinalVerilog(Murax(MuraxConfig.fast.copy(onChipRamSize = 256 kB))) + } +} + +object MuraxDhrystoneReadyMulDivStatic{ + def main(args: Array[String]) { + SpinalVerilog({ + val config = MuraxConfig.fast.copy(onChipRamSize = 256 kB) + config.cpuPlugins += new MulPlugin + config.cpuPlugins += new DivPlugin + config.cpuPlugins.remove(config.cpuPlugins.indexWhere(_.isInstanceOf[BranchPlugin])) + config.cpuPlugins +=new BranchPlugin( + earlyBranch = false, + catchAddressMisaligned = false + ) + config.cpuPlugins += new IBusSimplePlugin( + resetVector = 0x00000000l, + cmdForkOnSecondStage = true, + cmdForkPersistence = false, + prediction = STATIC, + catchAccessFault = false, + compressedGen = false + ) + config.cpuPlugins.remove(config.cpuPlugins.indexWhere(_.isInstanceOf[LightShifterPlugin])) + config.cpuPlugins += new FullBarrelShifterPlugin + Murax(config) + }) + } +} + +//Will blink led and echo UART RX to UART TX (in the verilator sim, type some text and press enter to send UART frame to the Murax RX pin) +object MuraxWithRamInit{ + def main(args: Array[String]) { + SpinalVerilog(Murax(MuraxConfig.default.copy(onChipRamSize = 4 kB, onChipRamHexFile = "src/main/ressource/hex/muraxDemo.hex"))) + } +} + +object Murax_arty{ + def main(args: Array[String]) { + val hex = "src/main/c/murax/hello_world/build/hello_world.hex" + SpinalVerilog(Murax(MuraxConfig.default(false).copy(coreFrequency = 100 MHz,onChipRamSize = 32 kB, onChipRamHexFile = hex))) + } +} + + +object MuraxAsicBlackBox extends App{ + println("Warning this soc do not has any rom to boot on.") + val config = SpinalConfig() + config.addStandardMemBlackboxing(blackboxAll) + config.generateVerilog(Murax(MuraxConfig.default())) +} + diff --git a/cpp/_crt0.S b/cpp/_crt0.S new file mode 100644 index 0000000..1bc0533 --- /dev/null +++ b/cpp/_crt0.S @@ -0,0 +1,50 @@ + .text + .global _start + .type _start, @function + +_start: + # Initialize global pointer + .option push + .option norelax + la gp, __global_pointer$ + .option pop + +<<<<<<< HEAD + li sp, 0x800ffff0 + +======= + li sp, 0x80020000 +>>>>>>> origin/fabian + # Clear the bss segment + la a0, __bss_start + la a1, __BSS_END__ + +<<<<<<< HEAD +======= + j finish_bss +>>>>>>> origin/fabian +clear_bss: + bgeu a0, a1, finish_bss + sb x0, 0(a0) + addi a0, a0, 1 + beq x0, x0, clear_bss +finish_bss: + + nop //! + + call main + + nop //! + + # abort execution here + ebreak + + .section .rodata +alfabet: + .string "abcdefghijklmnopqrstuwxyz" +slowo: + + .section .data +wynik: + .string "mpabi" + .space 26 # rezerwuje 26 bajtów dla wyniku, zainicjowane na 0 diff --git a/cpp/_crt0.S-k0 b/cpp/_crt0.S-k0 new file mode 100644 index 0000000..dbe07d9 --- /dev/null +++ b/cpp/_crt0.S-k0 @@ -0,0 +1,42 @@ + .text + .global _start + .type _start, @function + +_start: + # Initialize global pointer + .option push + .option norelax + la gp, __global_pointer$ + .option pop + + li sp, 0x1fff0 + + # Clear the bss segment + la a0, __bss_start + la a1, __BSS_END__ + +clear_bss: + bgeu a0, a1, finish_bss + sb x0, 0(a0) + addi a0, a0, 1 + beq x0, x0, clear_bss +finish_bss: + + nop //! + + call main + + nop //! + + # abort execution here + ebreak + + .section .rodata +alfabet: + .string "abcdefghijklmnopqrstuwxyz" +slowo: + + .section .data +wynik: + .string "mpabi" + .space 26 # rezerwuje 26 bajtów dla wyniku, zainicjowane na 0 \ No newline at end of file diff --git a/cpp/_crt0.S-k1 b/cpp/_crt0.S-k1 new file mode 100644 index 0000000..09af34b --- /dev/null +++ b/cpp/_crt0.S-k1 @@ -0,0 +1,39 @@ + .text + .global _start + .type _start, @function + +_start: + # Initialize global pointer + .option push + .option norelax + la gp, __global_pointer$ + .option pop + + # Initialize stack pointer from linker script symbol + la sp, __stack_top + + # Clear the BSS segment + la a0, __bss_start + la a1, __bss_end + +clear_bss: + bgeu a0, a1, finish_bss + sb x0, 0(a0) + addi a0, a0, 1 + j clear_bss +finish_bss: + + call main + + ebreak + +.section .rodata + +alfabet: + .string "abcdefghijklmnopqrstuwxyz" +slowo: + + .section .data +wynik: + .string "mpabi" + .space 26 # rezerwuje 26 bajtów dla wyniku, zainicjowane na 0 diff --git a/cpp/_crt0.o b/cpp/_crt0.o new file mode 100644 index 0000000..351a707 Binary files /dev/null and b/cpp/_crt0.o differ diff --git a/cpp/_rv-diss b/cpp/_rv-diss new file mode 100644 index 0000000..9a22230 --- /dev/null +++ b/cpp/_rv-diss @@ -0,0 +1 @@ +riscv64-unknown-elf-objdump -S --disassemble prog > prog.dis diff --git a/cpp/_rv-readelf b/cpp/_rv-readelf new file mode 100644 index 0000000..940c525 --- /dev/null +++ b/cpp/_rv-readelf @@ -0,0 +1 @@ +readelf -S -W prog diff --git a/cpp/_rvmain.cpp b/cpp/_rvmain.cpp new file mode 100644 index 0000000..de3dc47 --- /dev/null +++ b/cpp/_rvmain.cpp @@ -0,0 +1,184 @@ +<<<<<<< HEAD +#include + +int strlen(char *s) { + char *p = s; + while (*p != '\0') + p++; + return p - s; +} + + +void strcpy(char *s, char *t) +{ + while (*s++ = *t++); +} +#define ALLOCSIZE 10000 + +static char allocbuf[ALLOCSIZE]; +static char *allocp = allocbuf; + +char *alloc(int n) +{ + + if (n % 4 != 0) { + n += 4 - (n % 4); + } + + + if (allocbuf + ALLOCSIZE - allocp >= n) { + allocp += n; + return allocp - n; + } else + return 0; +} + +// def. model danych + +//pre processor +#define LEN (8+2)*10 + +struct model { + char * str; + uint32_t len ; +}; + + +//alg +// prosta implementacji func. z bibl. std. strok przy uzyciu gpt3.5 +// + +#define NULL ((void*) 0) + +// +// Funkcja pomocnicza do sprawdzania, czy znak jest wśród delimiterów +bool is_delim(char c, const char *delims) { + while (*delims) { + if (c == *delims) { + return true; + } + delims++; + } + return false; +} + +// Najprostsza implementacja funkcji strtok +char *simple_strtok(char *str, const char *delims) { + static char *static_str = (char *) NULL; // Przechowuje wskaźnik do bieżącej pozycji w ciągu + + // Jeśli przekazano nowy ciąg, zaktualizuj static_str + if (str == NULL) { + return (char *) NULL; // str nie wskazuje na zdanie !!! + } + static_str = str; + + // " .,mpabi" + // ^ + + // Pomiń początkowe delimitery + while (*static_str && is_delim(*static_str, delims)) { + static_str++; + } + + // Jeśli doszliśmy do końca ciągu, zwróć NULL + if (*static_str == '\0') { + return (char *) NULL; + } + + // Zapisz początek tokenu + char *token_start = static_str; + + // Znajdź koniec tokenu + while (*static_str && !is_delim(*static_str, delims)) { + static_str++; + } + + // Jeśli znaleziono delimitery, zamień je na '\0' i zaktualizuj static_str + if (*static_str) { + *static_str = '\0'; + static_str++; + } + + // Zwróć początek tokenu + return token_start; +} + +char buf[100]; +struct model * p = (struct model *) buf; //p[1] +////func alg +//in: ptr to date +//return: count of words +int alg (const char * ptr) { + + char bufer[ALLOCSIZE]; + strcpy(bufer, (char *)ptr); + + const char *delims = " ,.!?:;\n\t"; + + int8_t count = 0; + + char *token = simple_strtok(bufer, delims); + + while (token != (char *)NULL) { + + p[count].str = token; + p[count].len = strlen(token); + + token = simple_strtok((char *)NULL, delims); + count++; + } + + return count; +} + +int main() { + + char *str = "If wantered relation no surprise of all"; + + alg(str); + asm ("nop"); + + return 1; +} + +// wynik tego kodu: +// p[0].str = If +// p[0].len = 2 + +// p[1].str = wantered +// p[1].len = 8 + +// p[2].str = relation +// p[2].len = 8 + +// p[3].str = no +// p[3].len = 2 + +// p[4].str = surprise +// p[4].len = 8 + +// p[5].str = of +// p[5].len = 2 + +// p[6].str = all +// p[6].len = 3 +======= +#include + +size_t my_strlen(const char *str) { + size_t len = 0; + while (*str++) { + len++; + } + return len; +} + +int main() { + const char *test_string = "Hello, world!"; + size_t length = my_strlen(test_string); + + + return 0; +} + +>>>>>>> origin/fabian diff --git a/cpp/_rvmain.cpp.save b/cpp/_rvmain.cpp.save new file mode 100644 index 0000000..b986dde --- /dev/null +++ b/cpp/_rvmain.cpp.save @@ -0,0 +1,142 @@ +#include + +int strlen(char *s) { + char *p = s; + while (*p != '\0') + p++; + return p - s; +} + +void strcpy(char *s, char *t) +{ + while (*s++ = *t++); +} +#define ALLOCSIZE 10000 + +static char allocbuf[ALLOCSIZE]; +static char *allocp = allocbuf; + +char *alloc(int n) +{ + + if (n % 4 != 0) { + n += 4 - (n % 4); + } + + + if (allocbuf + ALLOCSIZE - allocp >= n) { + allocp += n; + return allocp - n; + } else + return 0; +} + +// def. model danych + +//pre processor +#define LEN (8+2)*10 + +struct model { + char * str; + uint32_t len ; +}; + + +//alg +// prosta implementacji func. z bibl. std. strok przy uzyciu gpt3.5 +// + +#define NULL ((void*) 0) + +// +// Funkcja pomocnicza do sprawdzania, czy znak jest wśród delimiterów +bool is_delim(char c, const char *delims) { + while (*delims) { + if (c == *delims) { + return true; + } + delims++; + } + return false; +} + +// Najprostsza implementacja funkcji strtok +char *simple_strtok(char *str, const char *delims) { + static char *static_str = (char *) NULL; // Przechowuje wskaźnik do bieżącej pozycji w ciągu + + // Jeśli przekazano nowy ciąg, zaktualizuj static_str + if (str != NULL) { + static_str = str; + } + + // Jeśli static_str jest NULL, zwróć NULL + if (static_str == NULL) { + return (char *) NULL; + } + + // Pomiń początkowe delimitery + while (*static_str && is_delim(*static_str, delims)) { + static_str++; + } + + // Jeśli doszliśmy do końca ciągu, zwróć NULL + if (*static_str == '\0') { + return (char *) NULL; + } + + // Zapisz początek tokenu + char *token_start = static_str; + + // Znajdź koniec tokenu + while (*static_str && !is_delim(*static_str, delims)) { + static_str++; + } + + // Jeśli znaleziono delimitery, zamień je na '\0' i zaktualizuj static_str + if (*static_str) { + *static_str = '\0'; + static_str++; + } + + // Zwróć początek tokenu + return token_start; +} + +////func alg +//in: ptr to date +//return: count of words +int alg (const char * ptr) { + + char bufer[ALLOCSIZE]; + strcpy(bufer, (char *)ptr); + + const char *delims = " ,.!?:;\n\t"; + + int8_t count = 0; + + char *token = simple_strtok(bufer, delims); + while (token != (char *)NULL) { + count++; + token = simple_strtok((char *)NULL, delims); + } + return count; +} + + +int main() { + + const char *str = "If wantered relation no surprise of all"; + + struct model *ptr = (struct model *) alloc(LEN); + if (ptr != (struct model *) NULL) { + ptr->str = alloc(strlen((char *)str) + 1); + if (ptr->str != (char *)NULL) { + strcpy (ptr->str, (char *)str); + ptr->len = strlen(ptr->str); + + int8_t count = alg(ptr->str); + } + } + + return 1; +} diff --git a/cpp/_rvmain.o b/cpp/_rvmain.o new file mode 100644 index 0000000..1ab3264 Binary files /dev/null and b/cpp/_rvmain.o differ diff --git a/cpp/gdb/z.py b/cpp/gdb/z.py new file mode 100644 index 0000000..98c6a26 --- /dev/null +++ b/cpp/gdb/z.py @@ -0,0 +1,17 @@ +# set args 0x1FF80 0x80 0x30 +# source gdb/z.py + +import gdb +import sys + +# Parse arguments from the GDB command +args = gdb.string_to_argv(gdb.parameter("args")) +if len(args) != 3: + print("Usage: source gdb/zero_with_params.py ") +else: + start_address = int(args[0], 16) # Convert start address from hex to int + num_bytes = int(args[1], 16) # Convert number of bytes from hex to int + pattern = int(args[2], 16) # Convert pattern from hex to int + + for i in range(num_bytes): + gdb.execute("set *((char*)%x + %x) = %x" % (start_address, i, pattern)) diff --git a/cpp/gdb/zero.py b/cpp/gdb/zero.py new file mode 100644 index 0000000..0095bd7 --- /dev/null +++ b/cpp/gdb/zero.py @@ -0,0 +1,5 @@ +#source gdb/z.py + +import gdb +for i in range(0, 128): # 128 bajtów + gdb.execute("set *((char*)(0x1FF80 + %x)) = 0xaa" % i) diff --git a/cpp/murax_128k_ram-sp.ld b/cpp/murax_128k_ram-sp.ld new file mode 100644 index 0000000..b3ac278 --- /dev/null +++ b/cpp/murax_128k_ram-sp.ld @@ -0,0 +1,43 @@ +MEMORY +{ + RAM (wx) : ORIGIN = 0x0, LENGTH = 128K +} + +SECTIONS +{ + .text : + { + *(.text*) + *(.rodata*) + } > RAM + + .data : + { + *(.data*) + } > RAM + + .bss : + { + *(.bss*) + *(COMMON) + } > RAM + + /* Add stack at the end of RAM */ + . = ALIGN(4); + _end = .; + PROVIDE(end = .); + + /* Define stack size and location */ + _stack_size = 0x4000; /* Example stack size: 16KB */ + _stack_end = ORIGIN(RAM) + LENGTH(RAM); /* End of RAM */ + _stack_start = _stack_end - _stack_size; /* Calculate start of the stack */ + .stack (NOLOAD) : + { + . = ALIGN(4); + . = . + _stack_size; + . = ALIGN(4); + _sp = .; + } > RAM + + PROVIDE(__stack = _sp); +} diff --git a/cpp/murax_128k_ram.ld b/cpp/murax_128k_ram.ld new file mode 100644 index 0000000..244668e --- /dev/null +++ b/cpp/murax_128k_ram.ld @@ -0,0 +1,67 @@ +/* Linker script for a system with 128KB RAM starting at 0x10000 */ +MEMORY +{ + RAM (wx) : ORIGIN = 0x0000, LENGTH = 128K +} + +SECTIONS +{ + /* Place code and readonly data at the beginning of RAM */ + .text : + { + *(.text*) + *(.rodata*) + } > RAM + + /* Place initialized data right after the .text section */ + .data : + { + . = ALIGN(4); + *(.data*) + } > RAM + + /* Uninitialized data (BSS) follows initialized data */ + .bss : + { + . = ALIGN(4); + __bss_start = .; + *(.bss*) + *(COMMON) + . = ALIGN(4); + __bss_end = .; + } > RAM + + /* Define heap start right after bss */ + . = ALIGN(4); + __heap_start = .; + PROVIDE(heap_start = __heap_start); + + /* Leave space for the heap by not explicitly defining its end */ + /* The heap grows towards the stack */ + + /* Reserve space for the stack at the end of RAM */ + /* Let's say we want a 16KB stack */ + . = ALIGN(4); + __stack_size = 16K; /* Size of the stack */ + __stack_top = ORIGIN(RAM) + LENGTH(RAM); /* Top of the stack */ + __stack_start = __stack_top - __stack_size; /* Start of the stack */ + .stack (NOLOAD) : + { + . = __stack_start; + . += __stack_size; /* Allocate space for the stack */ + . = ALIGN(4); + } > RAM + + PROVIDE(__stack = __stack_top); + PROVIDE(stack_top = __stack_top); + PROVIDE(stack_start = __stack_start); + + /* Heap end is dynamically located at the start of the stack */ + __heap_end = __stack_start; + PROVIDE(heap_end = __heap_end); + + /* End of RAM usage */ + . = ALIGN(4); + _end = .; + PROVIDE(end = _end); +} diff --git a/cpp/murax_128k_ram.ld-kopia b/cpp/murax_128k_ram.ld-kopia new file mode 100644 index 0000000..6488ff3 --- /dev/null +++ b/cpp/murax_128k_ram.ld-kopia @@ -0,0 +1,13 @@ +MEMORY +{ + RAM (wx) : ORIGIN = 0x10000, LENGTH = 128K +} + +SECTIONS +{ + .text : { *(.text*) } > RAM + .rodata : { *(.rodata*) } > RAM + .data : { *(.data*) } > RAM + .bss : { *(.bss*) } > RAM + _end = .; /* Definiuje koniec sekcji danych, może być używane do określenia rozmiaru sterty */ +} diff --git a/cpp/myfunc.cpp b/cpp/myfunc.cpp new file mode 100644 index 0000000..b621842 --- /dev/null +++ b/cpp/myfunc.cpp @@ -0,0 +1,35 @@ +#include "myfunc.h" + +// Lokalna deklaracja funkcji my_strlen +static int my_strlen(const char *str) { + int length = 0; + while (str[length] != '\0') { + length++; + } + return length; +} + +void count_characters(const char* alfabet, const char* slowo, uint8_t* wynik) { + // Użycie my_strlen do obliczenia długości alfabetu + int alfabet_length = my_strlen(alfabet); + + for (int i = 0; i < alfabet_length; ++i) { + wynik[i] = 0; + } + + for (int i = 0; i < alfabet_length; ++i) { + for (int j = 0; slowo[j] != '\0'; ++j) { + if (alfabet[i] == slowo[j]) { + wynik[i]++; + } + } + } +} + +// #include "myfunc.h" + +// const char* alfabet = "abcdefghijklmnopqrstuwxyz"; +// const char* slowo = "mpabi"; +// int wynik[26] = {0}; // Inicjalizacja tablicy wyników na 0 + +// count_characters(alfabet, slowo, wynik); diff --git a/cpp/myfunc.h b/cpp/myfunc.h new file mode 100644 index 0000000..99a5984 --- /dev/null +++ b/cpp/myfunc.h @@ -0,0 +1,9 @@ +#ifndef myfunc_H +#define myfunc_H + +#include + + +void count_characters(const char* alfabet, const char* slowo, uint8_t* wynik); + +#endif diff --git a/cpp/myfunc.o b/cpp/myfunc.o new file mode 100644 index 0000000..7f37a6a Binary files /dev/null and b/cpp/myfunc.o differ diff --git a/cpp/myfuncOOP.cpp b/cpp/myfuncOOP.cpp new file mode 100644 index 0000000..02e929d --- /dev/null +++ b/cpp/myfuncOOP.cpp @@ -0,0 +1,38 @@ +#include "myfuncOOP.hpp" + +MyfuncOOP::MyfuncOOP(const char* alfabet, const char* slowo, uint8_t* wynik) + : alfabet(alfabet), slowo(slowo), wynik(wynik) { +} + +void MyfuncOOP::countCharacters() { + int alfabet_length = myStrlen(alfabet); + + for (int i = 0; i < alfabet_length; ++i) { + wynik[i] = 0; // Initialize counts to zero + } + + for (int i = 0; i < alfabet_length; ++i) { + for (int j = 0; slowo[j] != '\0'; ++j) { + if (alfabet[i] == slowo[j]) { + wynik[i]++; + } + } + } +} + +const uint8_t* MyfuncOOP::getResults() const { + return wynik; +} + +int MyfuncOOP::myStrlen(const char* str) { + int length = 0; + while (str[length] != '\0') { + ++length; + } + return length; +} + + +// MyfuncOOP zliczacz(alfabet, slowo, wynik); +// zliczacz.countCharacters(); +// const uint8_t* results = zliczacz.getResults(); \ No newline at end of file diff --git a/cpp/myfuncOOP.hpp b/cpp/myfuncOOP.hpp new file mode 100644 index 0000000..277e918 --- /dev/null +++ b/cpp/myfuncOOP.hpp @@ -0,0 +1,22 @@ +#ifndef MYFUNC_OOP_HPP +#define MYFUNC_OOP_HPP + +#include + +class MyfuncOOP { +public: + MyfuncOOP(const char* alfabet, const char* slowo, uint8_t* wynik); + + void countCharacters(); + + const uint8_t* getResults() const; + +private: + const char* alfabet; + const char* slowo; + uint8_t* wynik; + + static int myStrlen(const char* str); +}; + +#endif // MYFUNC_OOP_HPP diff --git a/cpp/myfuncOOP.o b/cpp/myfuncOOP.o new file mode 100644 index 0000000..7741c3a Binary files /dev/null and b/cpp/myfuncOOP.o differ diff --git a/cpp/myfuncStruct.cpp b/cpp/myfuncStruct.cpp new file mode 100644 index 0000000..47e307f --- /dev/null +++ b/cpp/myfuncStruct.cpp @@ -0,0 +1,29 @@ +#include "myfuncStruct.h" + +// Static function for string length calculation +static int my_strlen(const char *str) { + int length = 0; + while (str[length] != '\0') { + length++; + } + return length; +} + +// Function to count occurrences of each character in 'alfabet' within 'slowo' +void count_charactersStruct(ZliczaczStruct* zliczacz) { + int alfabet_length = my_strlen(zliczacz->alfabet); + + // Initialize the result array to zero + for (int i = 0; i < alfabet_length; ++i) { + zliczacz->wynik[i] = 0; + } + + // Count occurrences + for (int i = 0; i < alfabet_length; ++i) { + for (int j = 0; zliczacz->slowo[j] != '\0'; ++j) { + if (zliczacz->alfabet[i] == zliczacz->slowo[j]) { + zliczacz->wynik[i]++; + } + } + } +} diff --git a/cpp/myfuncStruct.h b/cpp/myfuncStruct.h new file mode 100644 index 0000000..2671140 --- /dev/null +++ b/cpp/myfuncStruct.h @@ -0,0 +1,15 @@ +#ifndef MYFUNCSTRUCT_H +#define MYFUNCSTRUCT_H + +#include + +typedef struct { + const char* alfabet; + const char* slowo; + uint8_t* wynik; // Pointer to an array for results +} ZliczaczStruct; + +// Function declaration for counting character occurrences +void count_charactersStruct(ZliczaczStruct* zliczacz); + +#endif // MYFUNCSTRUCT_H diff --git a/cpp/myfuncStruct.o b/cpp/myfuncStruct.o new file mode 100644 index 0000000..4b9b64a Binary files /dev/null and b/cpp/myfuncStruct.o differ diff --git a/cpp/myfuncStructOOP.cpp b/cpp/myfuncStructOOP.cpp new file mode 100644 index 0000000..8138dc3 --- /dev/null +++ b/cpp/myfuncStructOOP.cpp @@ -0,0 +1,44 @@ +#include "myfuncStructOOP.h" + +// Static function for string length calculation +static int my_strlen(const char *str) { + int length = 0; + while (str[length] != '\0') { + length++; + } + return length; +} + +// 'Method' to count occurrences of each character +static void count_charactersStructOOP(ZliczaczStructOOP* zliczacz) { + int alfabet_length = my_strlen(zliczacz->alfabet); + + // Initialize the result array to zero + for (int i = 0; i < alfabet_length; ++i) { + zliczacz->wynik[i] = 0; + } + + // Count occurrences + for (int i = 0; i < alfabet_length; ++i) { + for (int j = 0; zliczacz->slowo[j] != '\0'; ++j) { + if (zliczacz->alfabet[i] == zliczacz->slowo[j]) { + zliczacz->wynik[i]++; + } + } + } +} + +// Constructor-like function to initialize a ZliczaczStructOOP +void initializeZliczaczStructOOP(ZliczaczStructOOP* zliczacz, const char* alfabet, const char* slowo, uint8_t* wynik) { + zliczacz->alfabet = alfabet; + zliczacz->slowo = slowo; + zliczacz->wynik = wynik; + zliczacz->count_characters = count_charactersStructOOP; +} + +// #include "myfuncStructOOP.h" + +// ZliczaczStructOOP zliczacz; +// initializeZliczaczStructOOP(&zliczacz, alfabet, slowo, wynik); + +// zliczacz.count_characters(&zliczacz); diff --git a/cpp/myfuncStructOOP.h b/cpp/myfuncStructOOP.h new file mode 100644 index 0000000..dd3e7e4 --- /dev/null +++ b/cpp/myfuncStructOOP.h @@ -0,0 +1,21 @@ +#ifndef MYFUNCSTRUCTOOP_H +#define MYFUNCSTRUCTOOP_H + +#include + +typedef struct ZliczaczStructOOP ZliczaczStructOOP; + +struct ZliczaczStructOOP { + // Data members + const char* alfabet; + const char* slowo; + uint8_t* wynik; // Pointer to an array for results + + // Function pointers, acting as 'methods' + void (*count_characters)(ZliczaczStructOOP*); +}; + +void initializeZliczaczStructOOP(ZliczaczStructOOP* zliczacz, const char* alfabet, const char* slowo, uint8_t* wynik); + + +#endif // MYFUNCSTRUCTOOP_H diff --git a/cpp/myfuncStructOOP.o b/cpp/myfuncStructOOP.o new file mode 100644 index 0000000..1f658c4 Binary files /dev/null and b/cpp/myfuncStructOOP.o differ diff --git a/cpp/prog b/cpp/prog new file mode 100755 index 0000000..e773156 Binary files /dev/null and b/cpp/prog differ diff --git a/cpp/prog.bin b/cpp/prog.bin new file mode 100755 index 0000000..f91b78a Binary files /dev/null and b/cpp/prog.bin differ diff --git a/cpp/prog.lst b/cpp/prog.lst new file mode 100644 index 0000000..5b1dec7 --- /dev/null +++ b/cpp/prog.lst @@ -0,0 +1,4083 @@ + +prog: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 80011197 auipc x3,0x80011 +80000004: 80018193 addi x3,x3,-2048 # 10800 <__global_pointer$> +80000008: 80020137 lui x2,0x80020 +8000000c: 80010517 auipc x10,0x80010 +80000010: 01450513 addi x10,x10,20 # 10020 <__BSS_END__> +80000014: 80010597 auipc x11,0x80010 +80000018: 00c58593 addi x11,x11,12 # 10020 <__BSS_END__> +8000001c: 0140006f jal x0,80000030 + +80000020 : +80000020: 00b57863 bgeu x10,x11,80000030 +80000024: 00050023 sb x0,0(x10) +80000028: 00150513 addi x10,x10,1 +8000002c: fe000ae3 beq x0,x0,80000020 + +80000030 : +80000030: 00000013 addi x0,x0,0 +80000034: 00000097 auipc x1,0x0 +80000038: 064080e7 jalr x1,100(x1) # 80000098
+8000003c: 00000013 addi x0,x0,0 +80000040: 00100073 ebreak + +80000044 <_Z9my_strlenPKc>: +80000044: fd010113 addi x2,x2,-48 # 8001ffd0 +80000048: 02812623 sw x8,44(x2) +8000004c: 03010413 addi x8,x2,48 +80000050: fca42e23 sw x10,-36(x8) +80000054: fe042623 sw x0,-20(x8) +80000058: 0100006f jal x0,80000068 <_Z9my_strlenPKc+0x24> +8000005c: fec42783 lw x15,-20(x8) +80000060: 00178793 addi x15,x15,1 +80000064: fef42623 sw x15,-20(x8) +80000068: fdc42783 lw x15,-36(x8) +8000006c: 00178713 addi x14,x15,1 +80000070: fce42e23 sw x14,-36(x8) +80000074: 0007c783 lbu x15,0(x15) +80000078: 00f037b3 sltu x15,x0,x15 +8000007c: 0ff7f793 andi x15,x15,255 +80000080: fc079ee3 bne x15,x0,8000005c <_Z9my_strlenPKc+0x18> +80000084: fec42783 lw x15,-20(x8) +80000088: 00078513 addi x10,x15,0 +8000008c: 02c12403 lw x8,44(x2) +80000090: 03010113 addi x2,x2,48 +80000094: 00008067 jalr x0,0(x1) + +80000098
: +80000098: fe010113 addi x2,x2,-32 +8000009c: 00112e23 sw x1,28(x2) +800000a0: 00812c23 sw x8,24(x2) +800000a4: 02010413 addi x8,x2,32 +800000a8: 800007b7 lui x15,0x80000 +800000ac: 72c78793 addi x15,x15,1836 # 8000072c +800000b0: fef42623 sw x15,-20(x8) +800000b4: fec42503 lw x10,-20(x8) +800000b8: 00000097 auipc x1,0x0 +800000bc: f8c080e7 jalr x1,-116(x1) # 80000044 <_Z9my_strlenPKc> +800000c0: fea42423 sw x10,-24(x8) +800000c4: 00000793 addi x15,x0,0 +800000c8: 00078513 addi x10,x15,0 +800000cc: 01c12083 lw x1,28(x2) +800000d0: 01812403 lw x8,24(x2) +800000d4: 02010113 addi x2,x2,32 +800000d8: 00008067 jalr x0,0(x1) + +800000dc <_ZL9my_strlenPKc>: +800000dc: fd010113 addi x2,x2,-48 +800000e0: 02812623 sw x8,44(x2) +800000e4: 03010413 addi x8,x2,48 +800000e8: fca42e23 sw x10,-36(x8) +800000ec: fe042623 sw x0,-20(x8) +800000f0: 0100006f jal x0,80000100 <_ZL9my_strlenPKc+0x24> +800000f4: fec42783 lw x15,-20(x8) +800000f8: 00178793 addi x15,x15,1 +800000fc: fef42623 sw x15,-20(x8) +80000100: fec42783 lw x15,-20(x8) +80000104: fdc42703 lw x14,-36(x8) +80000108: 00f707b3 add x15,x14,x15 +8000010c: 0007c783 lbu x15,0(x15) +80000110: fe0792e3 bne x15,x0,800000f4 <_ZL9my_strlenPKc+0x18> +80000114: fec42783 lw x15,-20(x8) +80000118: 00078513 addi x10,x15,0 +8000011c: 02c12403 lw x8,44(x2) +80000120: 03010113 addi x2,x2,48 +80000124: 00008067 jalr x0,0(x1) + +80000128 <_Z16count_charactersPKcS0_Ph>: +80000128: fd010113 addi x2,x2,-48 +8000012c: 02112623 sw x1,44(x2) +80000130: 02812423 sw x8,40(x2) +80000134: 03010413 addi x8,x2,48 +80000138: fca42e23 sw x10,-36(x8) +8000013c: fcb42c23 sw x11,-40(x8) +80000140: fcc42a23 sw x12,-44(x8) +80000144: fdc42503 lw x10,-36(x8) +80000148: 00000097 auipc x1,0x0 +8000014c: f94080e7 jalr x1,-108(x1) # 800000dc <_ZL9my_strlenPKc> +80000150: fea42023 sw x10,-32(x8) +80000154: fe042623 sw x0,-20(x8) +80000158: 0200006f jal x0,80000178 <_Z16count_charactersPKcS0_Ph+0x50> +8000015c: fec42783 lw x15,-20(x8) +80000160: fd442703 lw x14,-44(x8) +80000164: 00f707b3 add x15,x14,x15 +80000168: 00078023 sb x0,0(x15) +8000016c: fec42783 lw x15,-20(x8) +80000170: 00178793 addi x15,x15,1 +80000174: fef42623 sw x15,-20(x8) +80000178: fec42703 lw x14,-20(x8) +8000017c: fe042783 lw x15,-32(x8) +80000180: fcf74ee3 blt x14,x15,8000015c <_Z16count_charactersPKcS0_Ph+0x34> +80000184: fe042423 sw x0,-24(x8) +80000188: 0780006f jal x0,80000200 <_Z16count_charactersPKcS0_Ph+0xd8> +8000018c: fe042223 sw x0,-28(x8) +80000190: 0500006f jal x0,800001e0 <_Z16count_charactersPKcS0_Ph+0xb8> +80000194: fe842783 lw x15,-24(x8) +80000198: fdc42703 lw x14,-36(x8) +8000019c: 00f707b3 add x15,x14,x15 +800001a0: 0007c703 lbu x14,0(x15) +800001a4: fe442783 lw x15,-28(x8) +800001a8: fd842683 lw x13,-40(x8) +800001ac: 00f687b3 add x15,x13,x15 +800001b0: 0007c783 lbu x15,0(x15) +800001b4: 02f71063 bne x14,x15,800001d4 <_Z16count_charactersPKcS0_Ph+0xac> +800001b8: fe842783 lw x15,-24(x8) +800001bc: fd442703 lw x14,-44(x8) +800001c0: 00f707b3 add x15,x14,x15 +800001c4: 0007c703 lbu x14,0(x15) +800001c8: 00170713 addi x14,x14,1 +800001cc: 0ff77713 andi x14,x14,255 +800001d0: 00e78023 sb x14,0(x15) +800001d4: fe442783 lw x15,-28(x8) +800001d8: 00178793 addi x15,x15,1 +800001dc: fef42223 sw x15,-28(x8) +800001e0: fe442783 lw x15,-28(x8) +800001e4: fd842703 lw x14,-40(x8) +800001e8: 00f707b3 add x15,x14,x15 +800001ec: 0007c783 lbu x15,0(x15) +800001f0: fa0792e3 bne x15,x0,80000194 <_Z16count_charactersPKcS0_Ph+0x6c> +800001f4: fe842783 lw x15,-24(x8) +800001f8: 00178793 addi x15,x15,1 +800001fc: fef42423 sw x15,-24(x8) +80000200: fe842703 lw x14,-24(x8) +80000204: fe042783 lw x15,-32(x8) +80000208: f8f742e3 blt x14,x15,8000018c <_Z16count_charactersPKcS0_Ph+0x64> +8000020c: 00000013 addi x0,x0,0 +80000210: 00000013 addi x0,x0,0 +80000214: 02c12083 lw x1,44(x2) +80000218: 02812403 lw x8,40(x2) +8000021c: 03010113 addi x2,x2,48 +80000220: 00008067 jalr x0,0(x1) + +80000224 <_ZL9my_strlenPKc>: +80000224: fd010113 addi x2,x2,-48 +80000228: 02812623 sw x8,44(x2) +8000022c: 03010413 addi x8,x2,48 +80000230: fca42e23 sw x10,-36(x8) +80000234: fe042623 sw x0,-20(x8) +80000238: 0100006f jal x0,80000248 <_ZL9my_strlenPKc+0x24> +8000023c: fec42783 lw x15,-20(x8) +80000240: 00178793 addi x15,x15,1 +80000244: fef42623 sw x15,-20(x8) +80000248: fec42783 lw x15,-20(x8) +8000024c: fdc42703 lw x14,-36(x8) +80000250: 00f707b3 add x15,x14,x15 +80000254: 0007c783 lbu x15,0(x15) +80000258: fe0792e3 bne x15,x0,8000023c <_ZL9my_strlenPKc+0x18> +8000025c: fec42783 lw x15,-20(x8) +80000260: 00078513 addi x10,x15,0 +80000264: 02c12403 lw x8,44(x2) +80000268: 03010113 addi x2,x2,48 +8000026c: 00008067 jalr x0,0(x1) + +80000270 <_Z22count_charactersStructP14ZliczaczStruct>: +80000270: fd010113 addi x2,x2,-48 +80000274: 02112623 sw x1,44(x2) +80000278: 02812423 sw x8,40(x2) +8000027c: 03010413 addi x8,x2,48 +80000280: fca42e23 sw x10,-36(x8) +80000284: fdc42783 lw x15,-36(x8) +80000288: 0007a783 lw x15,0(x15) +8000028c: 00078513 addi x10,x15,0 +80000290: 00000097 auipc x1,0x0 +80000294: f94080e7 jalr x1,-108(x1) # 80000224 <_ZL9my_strlenPKc> +80000298: fea42023 sw x10,-32(x8) +8000029c: fe042623 sw x0,-20(x8) +800002a0: 0240006f jal x0,800002c4 <_Z22count_charactersStructP14ZliczaczStruct+0x54> +800002a4: fdc42783 lw x15,-36(x8) +800002a8: 0087a703 lw x14,8(x15) +800002ac: fec42783 lw x15,-20(x8) +800002b0: 00f707b3 add x15,x14,x15 +800002b4: 00078023 sb x0,0(x15) +800002b8: fec42783 lw x15,-20(x8) +800002bc: 00178793 addi x15,x15,1 +800002c0: fef42623 sw x15,-20(x8) +800002c4: fec42703 lw x14,-20(x8) +800002c8: fe042783 lw x15,-32(x8) +800002cc: fcf74ce3 blt x14,x15,800002a4 <_Z22count_charactersStructP14ZliczaczStruct+0x34> +800002d0: fe042423 sw x0,-24(x8) +800002d4: 0880006f jal x0,8000035c <_Z22count_charactersStructP14ZliczaczStruct+0xec> +800002d8: fe042223 sw x0,-28(x8) +800002dc: 05c0006f jal x0,80000338 <_Z22count_charactersStructP14ZliczaczStruct+0xc8> +800002e0: fdc42783 lw x15,-36(x8) +800002e4: 0007a703 lw x14,0(x15) +800002e8: fe842783 lw x15,-24(x8) +800002ec: 00f707b3 add x15,x14,x15 +800002f0: 0007c703 lbu x14,0(x15) +800002f4: fdc42783 lw x15,-36(x8) +800002f8: 0047a683 lw x13,4(x15) +800002fc: fe442783 lw x15,-28(x8) +80000300: 00f687b3 add x15,x13,x15 +80000304: 0007c783 lbu x15,0(x15) +80000308: 02f71263 bne x14,x15,8000032c <_Z22count_charactersStructP14ZliczaczStruct+0xbc> +8000030c: fdc42783 lw x15,-36(x8) +80000310: 0087a703 lw x14,8(x15) +80000314: fe842783 lw x15,-24(x8) +80000318: 00f707b3 add x15,x14,x15 +8000031c: 0007c703 lbu x14,0(x15) +80000320: 00170713 addi x14,x14,1 +80000324: 0ff77713 andi x14,x14,255 +80000328: 00e78023 sb x14,0(x15) +8000032c: fe442783 lw x15,-28(x8) +80000330: 00178793 addi x15,x15,1 +80000334: fef42223 sw x15,-28(x8) +80000338: fdc42783 lw x15,-36(x8) +8000033c: 0047a703 lw x14,4(x15) +80000340: fe442783 lw x15,-28(x8) +80000344: 00f707b3 add x15,x14,x15 +80000348: 0007c783 lbu x15,0(x15) +8000034c: f8079ae3 bne x15,x0,800002e0 <_Z22count_charactersStructP14ZliczaczStruct+0x70> +80000350: fe842783 lw x15,-24(x8) +80000354: 00178793 addi x15,x15,1 +80000358: fef42423 sw x15,-24(x8) +8000035c: fe842703 lw x14,-24(x8) +80000360: fe042783 lw x15,-32(x8) +80000364: f6f74ae3 blt x14,x15,800002d8 <_Z22count_charactersStructP14ZliczaczStruct+0x68> +80000368: 00000013 addi x0,x0,0 +8000036c: 00000013 addi x0,x0,0 +80000370: 02c12083 lw x1,44(x2) +80000374: 02812403 lw x8,40(x2) +80000378: 03010113 addi x2,x2,48 +8000037c: 00008067 jalr x0,0(x1) + +80000380 <_ZL9my_strlenPKc>: +80000380: fd010113 addi x2,x2,-48 +80000384: 02812623 sw x8,44(x2) +80000388: 03010413 addi x8,x2,48 +8000038c: fca42e23 sw x10,-36(x8) +80000390: fe042623 sw x0,-20(x8) +80000394: 0100006f jal x0,800003a4 <_ZL9my_strlenPKc+0x24> +80000398: fec42783 lw x15,-20(x8) +8000039c: 00178793 addi x15,x15,1 +800003a0: fef42623 sw x15,-20(x8) +800003a4: fec42783 lw x15,-20(x8) +800003a8: fdc42703 lw x14,-36(x8) +800003ac: 00f707b3 add x15,x14,x15 +800003b0: 0007c783 lbu x15,0(x15) +800003b4: fe0792e3 bne x15,x0,80000398 <_ZL9my_strlenPKc+0x18> +800003b8: fec42783 lw x15,-20(x8) +800003bc: 00078513 addi x10,x15,0 +800003c0: 02c12403 lw x8,44(x2) +800003c4: 03010113 addi x2,x2,48 +800003c8: 00008067 jalr x0,0(x1) + +800003cc <_ZL25count_charactersStructOOPP17ZliczaczStructOOP>: +800003cc: fd010113 addi x2,x2,-48 +800003d0: 02112623 sw x1,44(x2) +800003d4: 02812423 sw x8,40(x2) +800003d8: 03010413 addi x8,x2,48 +800003dc: fca42e23 sw x10,-36(x8) +800003e0: fdc42783 lw x15,-36(x8) +800003e4: 0007a783 lw x15,0(x15) +800003e8: 00078513 addi x10,x15,0 +800003ec: 00000097 auipc x1,0x0 +800003f0: f94080e7 jalr x1,-108(x1) # 80000380 <_ZL9my_strlenPKc> +800003f4: fea42023 sw x10,-32(x8) +800003f8: fe042623 sw x0,-20(x8) +800003fc: 0240006f jal x0,80000420 <_ZL25count_charactersStructOOPP17ZliczaczStructOOP+0x54> +80000400: fdc42783 lw x15,-36(x8) +80000404: 0087a703 lw x14,8(x15) +80000408: fec42783 lw x15,-20(x8) +8000040c: 00f707b3 add x15,x14,x15 +80000410: 00078023 sb x0,0(x15) +80000414: fec42783 lw x15,-20(x8) +80000418: 00178793 addi x15,x15,1 +8000041c: fef42623 sw x15,-20(x8) +80000420: fec42703 lw x14,-20(x8) +80000424: fe042783 lw x15,-32(x8) +80000428: fcf74ce3 blt x14,x15,80000400 <_ZL25count_charactersStructOOPP17ZliczaczStructOOP+0x34> +8000042c: fe042423 sw x0,-24(x8) +80000430: 0880006f jal x0,800004b8 <_ZL25count_charactersStructOOPP17ZliczaczStructOOP+0xec> +80000434: fe042223 sw x0,-28(x8) +80000438: 05c0006f jal x0,80000494 <_ZL25count_charactersStructOOPP17ZliczaczStructOOP+0xc8> +8000043c: fdc42783 lw x15,-36(x8) +80000440: 0007a703 lw x14,0(x15) +80000444: fe842783 lw x15,-24(x8) +80000448: 00f707b3 add x15,x14,x15 +8000044c: 0007c703 lbu x14,0(x15) +80000450: fdc42783 lw x15,-36(x8) +80000454: 0047a683 lw x13,4(x15) +80000458: fe442783 lw x15,-28(x8) +8000045c: 00f687b3 add x15,x13,x15 +80000460: 0007c783 lbu x15,0(x15) +80000464: 02f71263 bne x14,x15,80000488 <_ZL25count_charactersStructOOPP17ZliczaczStructOOP+0xbc> +80000468: fdc42783 lw x15,-36(x8) +8000046c: 0087a703 lw x14,8(x15) +80000470: fe842783 lw x15,-24(x8) +80000474: 00f707b3 add x15,x14,x15 +80000478: 0007c703 lbu x14,0(x15) +8000047c: 00170713 addi x14,x14,1 +80000480: 0ff77713 andi x14,x14,255 +80000484: 00e78023 sb x14,0(x15) +80000488: fe442783 lw x15,-28(x8) +8000048c: 00178793 addi x15,x15,1 +80000490: fef42223 sw x15,-28(x8) +80000494: fdc42783 lw x15,-36(x8) +80000498: 0047a703 lw x14,4(x15) +8000049c: fe442783 lw x15,-28(x8) +800004a0: 00f707b3 add x15,x14,x15 +800004a4: 0007c783 lbu x15,0(x15) +800004a8: f8079ae3 bne x15,x0,8000043c <_ZL25count_charactersStructOOPP17ZliczaczStructOOP+0x70> +800004ac: fe842783 lw x15,-24(x8) +800004b0: 00178793 addi x15,x15,1 +800004b4: fef42423 sw x15,-24(x8) +800004b8: fe842703 lw x14,-24(x8) +800004bc: fe042783 lw x15,-32(x8) +800004c0: f6f74ae3 blt x14,x15,80000434 <_ZL25count_charactersStructOOPP17ZliczaczStructOOP+0x68> +800004c4: 00000013 addi x0,x0,0 +800004c8: 00000013 addi x0,x0,0 +800004cc: 02c12083 lw x1,44(x2) +800004d0: 02812403 lw x8,40(x2) +800004d4: 03010113 addi x2,x2,48 +800004d8: 00008067 jalr x0,0(x1) + +800004dc <_Z27initializeZliczaczStructOOPP17ZliczaczStructOOPPKcS2_Ph>: +800004dc: fe010113 addi x2,x2,-32 +800004e0: 00812e23 sw x8,28(x2) +800004e4: 02010413 addi x8,x2,32 +800004e8: fea42623 sw x10,-20(x8) +800004ec: feb42423 sw x11,-24(x8) +800004f0: fec42223 sw x12,-28(x8) +800004f4: fed42023 sw x13,-32(x8) +800004f8: fec42783 lw x15,-20(x8) +800004fc: fe842703 lw x14,-24(x8) +80000500: 00e7a023 sw x14,0(x15) +80000504: fec42783 lw x15,-20(x8) +80000508: fe442703 lw x14,-28(x8) +8000050c: 00e7a223 sw x14,4(x15) +80000510: fec42783 lw x15,-20(x8) +80000514: fe042703 lw x14,-32(x8) +80000518: 00e7a423 sw x14,8(x15) +8000051c: fec42783 lw x15,-20(x8) +80000520: 80000737 lui x14,0x80000 +80000524: 3cc70713 addi x14,x14,972 # 800003cc <_ZL25count_charactersStructOOPP17ZliczaczStructOOP> +80000528: 00e7a623 sw x14,12(x15) +8000052c: 00000013 addi x0,x0,0 +80000530: 01c12403 lw x8,28(x2) +80000534: 02010113 addi x2,x2,32 +80000538: 00008067 jalr x0,0(x1) + +8000053c <_ZN9MyfuncOOPC1EPKcS1_Ph>: +8000053c: fe010113 addi x2,x2,-32 +80000540: 00812e23 sw x8,28(x2) +80000544: 02010413 addi x8,x2,32 +80000548: fea42623 sw x10,-20(x8) +8000054c: feb42423 sw x11,-24(x8) +80000550: fec42223 sw x12,-28(x8) +80000554: fed42023 sw x13,-32(x8) +80000558: fec42783 lw x15,-20(x8) +8000055c: fe842703 lw x14,-24(x8) +80000560: 00e7a023 sw x14,0(x15) +80000564: fec42783 lw x15,-20(x8) +80000568: fe442703 lw x14,-28(x8) +8000056c: 00e7a223 sw x14,4(x15) +80000570: fec42783 lw x15,-20(x8) +80000574: fe042703 lw x14,-32(x8) +80000578: 00e7a423 sw x14,8(x15) +8000057c: 00000013 addi x0,x0,0 +80000580: 01c12403 lw x8,28(x2) +80000584: 02010113 addi x2,x2,32 +80000588: 00008067 jalr x0,0(x1) + +8000058c <_ZN9MyfuncOOP15countCharactersEv>: +8000058c: fd010113 addi x2,x2,-48 +80000590: 02112623 sw x1,44(x2) +80000594: 02812423 sw x8,40(x2) +80000598: 03010413 addi x8,x2,48 +8000059c: fca42e23 sw x10,-36(x8) +800005a0: fdc42783 lw x15,-36(x8) +800005a4: 0007a783 lw x15,0(x15) +800005a8: 00078513 addi x10,x15,0 +800005ac: 00000097 auipc x1,0x0 +800005b0: 118080e7 jalr x1,280(x1) # 800006c4 <_ZN9MyfuncOOP8myStrlenEPKc> +800005b4: fea42023 sw x10,-32(x8) +800005b8: fe042623 sw x0,-20(x8) +800005bc: 0240006f jal x0,800005e0 <_ZN9MyfuncOOP15countCharactersEv+0x54> +800005c0: fdc42783 lw x15,-36(x8) +800005c4: 0087a703 lw x14,8(x15) +800005c8: fec42783 lw x15,-20(x8) +800005cc: 00f707b3 add x15,x14,x15 +800005d0: 00078023 sb x0,0(x15) +800005d4: fec42783 lw x15,-20(x8) +800005d8: 00178793 addi x15,x15,1 +800005dc: fef42623 sw x15,-20(x8) +800005e0: fec42703 lw x14,-20(x8) +800005e4: fe042783 lw x15,-32(x8) +800005e8: fcf74ce3 blt x14,x15,800005c0 <_ZN9MyfuncOOP15countCharactersEv+0x34> +800005ec: fe042423 sw x0,-24(x8) +800005f0: 0880006f jal x0,80000678 <_ZN9MyfuncOOP15countCharactersEv+0xec> +800005f4: fe042223 sw x0,-28(x8) +800005f8: 05c0006f jal x0,80000654 <_ZN9MyfuncOOP15countCharactersEv+0xc8> +800005fc: fdc42783 lw x15,-36(x8) +80000600: 0007a703 lw x14,0(x15) +80000604: fe842783 lw x15,-24(x8) +80000608: 00f707b3 add x15,x14,x15 +8000060c: 0007c703 lbu x14,0(x15) +80000610: fdc42783 lw x15,-36(x8) +80000614: 0047a683 lw x13,4(x15) +80000618: fe442783 lw x15,-28(x8) +8000061c: 00f687b3 add x15,x13,x15 +80000620: 0007c783 lbu x15,0(x15) +80000624: 02f71263 bne x14,x15,80000648 <_ZN9MyfuncOOP15countCharactersEv+0xbc> +80000628: fdc42783 lw x15,-36(x8) +8000062c: 0087a703 lw x14,8(x15) +80000630: fe842783 lw x15,-24(x8) +80000634: 00f707b3 add x15,x14,x15 +80000638: 0007c703 lbu x14,0(x15) +8000063c: 00170713 addi x14,x14,1 +80000640: 0ff77713 andi x14,x14,255 +80000644: 00e78023 sb x14,0(x15) +80000648: fe442783 lw x15,-28(x8) +8000064c: 00178793 addi x15,x15,1 +80000650: fef42223 sw x15,-28(x8) +80000654: fdc42783 lw x15,-36(x8) +80000658: 0047a703 lw x14,4(x15) +8000065c: fe442783 lw x15,-28(x8) +80000660: 00f707b3 add x15,x14,x15 +80000664: 0007c783 lbu x15,0(x15) +80000668: f8079ae3 bne x15,x0,800005fc <_ZN9MyfuncOOP15countCharactersEv+0x70> +8000066c: fe842783 lw x15,-24(x8) +80000670: 00178793 addi x15,x15,1 +80000674: fef42423 sw x15,-24(x8) +80000678: fe842703 lw x14,-24(x8) +8000067c: fe042783 lw x15,-32(x8) +80000680: f6f74ae3 blt x14,x15,800005f4 <_ZN9MyfuncOOP15countCharactersEv+0x68> +80000684: 00000013 addi x0,x0,0 +80000688: 00000013 addi x0,x0,0 +8000068c: 02c12083 lw x1,44(x2) +80000690: 02812403 lw x8,40(x2) +80000694: 03010113 addi x2,x2,48 +80000698: 00008067 jalr x0,0(x1) + +8000069c <_ZNK9MyfuncOOP10getResultsEv>: +8000069c: fe010113 addi x2,x2,-32 +800006a0: 00812e23 sw x8,28(x2) +800006a4: 02010413 addi x8,x2,32 +800006a8: fea42623 sw x10,-20(x8) +800006ac: fec42783 lw x15,-20(x8) +800006b0: 0087a783 lw x15,8(x15) +800006b4: 00078513 addi x10,x15,0 +800006b8: 01c12403 lw x8,28(x2) +800006bc: 02010113 addi x2,x2,32 +800006c0: 00008067 jalr x0,0(x1) + +800006c4 <_ZN9MyfuncOOP8myStrlenEPKc>: +800006c4: fd010113 addi x2,x2,-48 +800006c8: 02812623 sw x8,44(x2) +800006cc: 03010413 addi x8,x2,48 +800006d0: fca42e23 sw x10,-36(x8) +800006d4: fe042623 sw x0,-20(x8) +800006d8: 0100006f jal x0,800006e8 <_ZN9MyfuncOOP8myStrlenEPKc+0x24> +800006dc: fec42783 lw x15,-20(x8) +800006e0: 00178793 addi x15,x15,1 +800006e4: fef42623 sw x15,-20(x8) +800006e8: fec42783 lw x15,-20(x8) +800006ec: fdc42703 lw x14,-36(x8) +800006f0: 00f707b3 add x15,x14,x15 +800006f4: 0007c783 lbu x15,0(x15) +800006f8: fe0792e3 bne x15,x0,800006dc <_ZN9MyfuncOOP8myStrlenEPKc+0x18> +800006fc: fec42783 lw x15,-20(x8) +80000700: 00078513 addi x10,x15,0 +80000704: 02c12403 lw x8,44(x2) +80000708: 03010113 addi x2,x2,48 +8000070c: 00008067 jalr x0,0(x1) + +Disassembly of section .data: + +00010000 <__DATA_BEGIN__>: + 10000: 706d .2byte 0x706d + 10002: 6261 .2byte 0x6261 + 10004: 0069 .2byte 0x69 + ... + +Disassembly of section .rodata: + +80000710 : +80000710: 6261 .2byte 0x6261 +80000712: 66656463 bltu x10,x6,80000d7a +80000716: 6a696867 .4byte 0x6a696867 +8000071a: 6e6d6c6b .4byte 0x6e6d6c6b +8000071e: 7271706f jal x0,80018644 +80000722: 77757473 .4byte 0x77757473 +80000726: 7978 .2byte 0x7978 +80000728: 007a .2byte 0x7a + +8000072a : +8000072a: 0000 .2byte 0x0 +8000072c: 6548 .2byte 0x6548 +8000072e: 6c6c .2byte 0x6c6c +80000730: 77202c6f jal x24,80002ea2 +80000734: 646c726f jal x4,800c7d7a +80000738: 0021 .2byte 0x21 + +Disassembly of section .eh_frame: + +8000073c <__SDATA_BEGIN__+0x7fff071c>: +8000073c: 0010 .2byte 0x10 +8000073e: 0000 .2byte 0x0 +80000740: 0000 .2byte 0x0 +80000742: 0000 .2byte 0x0 +80000744: 00527a03 .4byte 0x527a03 +80000748: 7c01 .2byte 0x7c01 +8000074a: 0101 .2byte 0x101 +8000074c: 00020d1b .4byte 0x20d1b +80000750: 0020 .2byte 0x20 +80000752: 0000 .2byte 0x0 +80000754: 0018 .2byte 0x18 +80000756: 0000 .2byte 0x0 +80000758: f8ec .2byte 0xf8ec +8000075a: ffff .2byte 0xffff +8000075c: 0054 .2byte 0x54 +8000075e: 0000 .2byte 0x0 +80000760: 4400 .2byte 0x4400 +80000762: 300e .2byte 0x300e +80000764: 8844 .2byte 0x8844 +80000766: 4401 .2byte 0x4401 +80000768: 080c .2byte 0x80c +8000076a: 0200 .2byte 0x200 +8000076c: c840 .2byte 0xc840 +8000076e: 020c .2byte 0x20c +80000770: 4430 .2byte 0x4430 +80000772: 000e .2byte 0xe +80000774: 0024 .2byte 0x24 +80000776: 0000 .2byte 0x0 +80000778: 003c .2byte 0x3c +8000077a: 0000 .2byte 0x0 +8000077c: f91c .2byte 0xf91c +8000077e: ffff .2byte 0xffff +80000780: 0044 .2byte 0x44 +80000782: 0000 .2byte 0x0 +80000784: 4400 .2byte 0x4400 +80000786: 200e .2byte 0x200e +80000788: 8148 .2byte 0x8148 +8000078a: 8801 .2byte 0x8801 +8000078c: 4402 .2byte 0x4402 +8000078e: 080c .2byte 0x80c +80000790: 6800 .2byte 0x6800 +80000792: 44c1 .2byte 0x44c1 +80000794: 0cc8 .2byte 0xcc8 +80000796: 2002 .2byte 0x2002 +80000798: 0e44 .2byte 0xe44 +8000079a: 0000 .2byte 0x0 +8000079c: 0020 .2byte 0x20 +8000079e: 0000 .2byte 0x0 +800007a0: 0064 .2byte 0x64 +800007a2: 0000 .2byte 0x0 +800007a4: f938 .2byte 0xf938 +800007a6: ffff .2byte 0xffff +800007a8: 004c .2byte 0x4c +800007aa: 0000 .2byte 0x0 +800007ac: 4400 .2byte 0x4400 +800007ae: 300e .2byte 0x300e +800007b0: 8844 .2byte 0x8844 +800007b2: 4401 .2byte 0x4401 +800007b4: 080c .2byte 0x80c +800007b6: 7800 .2byte 0x7800 +800007b8: 0cc8 .2byte 0xcc8 +800007ba: 3002 .2byte 0x3002 +800007bc: 0e44 .2byte 0xe44 +800007be: 0000 .2byte 0x0 +800007c0: 0024 .2byte 0x24 +800007c2: 0000 .2byte 0x0 +800007c4: 0088 .2byte 0x88 +800007c6: 0000 .2byte 0x0 +800007c8: f960 .2byte 0xf960 +800007ca: ffff .2byte 0xffff +800007cc: 00fc .2byte 0xfc +800007ce: 0000 .2byte 0x0 +800007d0: 4400 .2byte 0x4400 +800007d2: 300e .2byte 0x300e +800007d4: 8148 .2byte 0x8148 +800007d6: 8801 .2byte 0x8801 +800007d8: 4402 .2byte 0x4402 +800007da: 080c .2byte 0x80c +800007dc: 0200 .2byte 0x200 +800007de: c1e0 .2byte 0xc1e0 +800007e0: c844 .2byte 0xc844 +800007e2: 020c .2byte 0x20c +800007e4: 4430 .2byte 0x4430 +800007e6: 000e .2byte 0xe +800007e8: 0020 .2byte 0x20 +800007ea: 0000 .2byte 0x0 +800007ec: 00b0 .2byte 0xb0 +800007ee: 0000 .2byte 0x0 +800007f0: fa34 .2byte 0xfa34 +800007f2: ffff .2byte 0xffff +800007f4: 004c .2byte 0x4c +800007f6: 0000 .2byte 0x0 +800007f8: 4400 .2byte 0x4400 +800007fa: 300e .2byte 0x300e +800007fc: 8844 .2byte 0x8844 +800007fe: 4401 .2byte 0x4401 +80000800: 080c .2byte 0x80c +80000802: 7800 .2byte 0x7800 +80000804: 0cc8 .2byte 0xcc8 +80000806: 3002 .2byte 0x3002 +80000808: 0e44 .2byte 0xe44 +8000080a: 0000 .2byte 0x0 +8000080c: 0024 .2byte 0x24 +8000080e: 0000 .2byte 0x0 +80000810: 00d4 .2byte 0xd4 +80000812: 0000 .2byte 0x0 +80000814: fa5c .2byte 0xfa5c +80000816: ffff .2byte 0xffff +80000818: 0110 .2byte 0x110 +8000081a: 0000 .2byte 0x0 +8000081c: 4400 .2byte 0x4400 +8000081e: 300e .2byte 0x300e +80000820: 8148 .2byte 0x8148 +80000822: 8801 .2byte 0x8801 +80000824: 4402 .2byte 0x4402 +80000826: 080c .2byte 0x80c +80000828: 0200 .2byte 0x200 +8000082a: c1f4 .2byte 0xc1f4 +8000082c: c844 .2byte 0xc844 +8000082e: 020c .2byte 0x20c +80000830: 4430 .2byte 0x4430 +80000832: 000e .2byte 0xe +80000834: 0020 .2byte 0x20 +80000836: 0000 .2byte 0x0 +80000838: 00fc .2byte 0xfc +8000083a: 0000 .2byte 0x0 +8000083c: fb44 .2byte 0xfb44 +8000083e: ffff .2byte 0xffff +80000840: 004c .2byte 0x4c +80000842: 0000 .2byte 0x0 +80000844: 4400 .2byte 0x4400 +80000846: 300e .2byte 0x300e +80000848: 8844 .2byte 0x8844 +8000084a: 4401 .2byte 0x4401 +8000084c: 080c .2byte 0x80c +8000084e: 7800 .2byte 0x7800 +80000850: 0cc8 .2byte 0xcc8 +80000852: 3002 .2byte 0x3002 +80000854: 0e44 .2byte 0xe44 +80000856: 0000 .2byte 0x0 +80000858: 0024 .2byte 0x24 +8000085a: 0000 .2byte 0x0 +8000085c: 0120 .2byte 0x120 +8000085e: 0000 .2byte 0x0 +80000860: fb6c .2byte 0xfb6c +80000862: ffff .2byte 0xffff +80000864: 0110 .2byte 0x110 +80000866: 0000 .2byte 0x0 +80000868: 4400 .2byte 0x4400 +8000086a: 300e .2byte 0x300e +8000086c: 8148 .2byte 0x8148 +8000086e: 8801 .2byte 0x8801 +80000870: 4402 .2byte 0x4402 +80000872: 080c .2byte 0x80c +80000874: 0200 .2byte 0x200 +80000876: c1f4 .2byte 0xc1f4 +80000878: c844 .2byte 0xc844 +8000087a: 020c .2byte 0x20c +8000087c: 4430 .2byte 0x4430 +8000087e: 000e .2byte 0xe +80000880: 0020 .2byte 0x20 +80000882: 0000 .2byte 0x0 +80000884: 0148 .2byte 0x148 +80000886: 0000 .2byte 0x0 +80000888: fc54 .2byte 0xfc54 +8000088a: ffff .2byte 0xffff +8000088c: 0060 .2byte 0x60 +8000088e: 0000 .2byte 0x0 +80000890: 4400 .2byte 0x4400 +80000892: 200e .2byte 0x200e +80000894: 8844 .2byte 0x8844 +80000896: 4401 .2byte 0x4401 +80000898: 080c .2byte 0x80c +8000089a: 0200 .2byte 0x200 +8000089c: c84c .2byte 0xc84c +8000089e: 020c .2byte 0x20c +800008a0: 4420 .2byte 0x4420 +800008a2: 000e .2byte 0xe +800008a4: 0020 .2byte 0x20 +800008a6: 0000 .2byte 0x0 +800008a8: 016c .2byte 0x16c +800008aa: 0000 .2byte 0x0 +800008ac: fc90 .2byte 0xfc90 +800008ae: ffff .2byte 0xffff +800008b0: 0050 .2byte 0x50 +800008b2: 0000 .2byte 0x0 +800008b4: 4400 .2byte 0x4400 +800008b6: 200e .2byte 0x200e +800008b8: 8844 .2byte 0x8844 +800008ba: 4401 .2byte 0x4401 +800008bc: 080c .2byte 0x80c +800008be: 7c00 .2byte 0x7c00 +800008c0: 0cc8 .2byte 0xcc8 +800008c2: 2002 .2byte 0x2002 +800008c4: 0e44 .2byte 0xe44 +800008c6: 0000 .2byte 0x0 +800008c8: 0024 .2byte 0x24 +800008ca: 0000 .2byte 0x0 +800008cc: 0190 .2byte 0x190 +800008ce: 0000 .2byte 0x0 +800008d0: fcbc .2byte 0xfcbc +800008d2: ffff .2byte 0xffff +800008d4: 0110 .2byte 0x110 +800008d6: 0000 .2byte 0x0 +800008d8: 4400 .2byte 0x4400 +800008da: 300e .2byte 0x300e +800008dc: 8148 .2byte 0x8148 +800008de: 8801 .2byte 0x8801 +800008e0: 4402 .2byte 0x4402 +800008e2: 080c .2byte 0x80c +800008e4: 0200 .2byte 0x200 +800008e6: c1f4 .2byte 0xc1f4 +800008e8: c844 .2byte 0xc844 +800008ea: 020c .2byte 0x20c +800008ec: 4430 .2byte 0x4430 +800008ee: 000e .2byte 0xe +800008f0: 0020 .2byte 0x20 +800008f2: 0000 .2byte 0x0 +800008f4: 01b8 .2byte 0x1b8 +800008f6: 0000 .2byte 0x0 +800008f8: fda4 .2byte 0xfda4 +800008fa: ffff .2byte 0xffff +800008fc: 0028 .2byte 0x28 +800008fe: 0000 .2byte 0x0 +80000900: 4400 .2byte 0x4400 +80000902: 200e .2byte 0x200e +80000904: 8844 .2byte 0x8844 +80000906: 4401 .2byte 0x4401 +80000908: 080c .2byte 0x80c +8000090a: 5400 .2byte 0x5400 +8000090c: 0cc8 .2byte 0xcc8 +8000090e: 2002 .2byte 0x2002 +80000910: 0e44 .2byte 0xe44 +80000912: 0000 .2byte 0x0 +80000914: 0020 .2byte 0x20 +80000916: 0000 .2byte 0x0 +80000918: 01dc .2byte 0x1dc +8000091a: 0000 .2byte 0x0 +8000091c: fda8 .2byte 0xfda8 +8000091e: ffff .2byte 0xffff +80000920: 004c .2byte 0x4c +80000922: 0000 .2byte 0x0 +80000924: 4400 .2byte 0x4400 +80000926: 300e .2byte 0x300e +80000928: 8844 .2byte 0x8844 +8000092a: 4401 .2byte 0x4401 +8000092c: 080c .2byte 0x80c +8000092e: 7800 .2byte 0x7800 +80000930: 0cc8 .2byte 0xcc8 +80000932: 3002 .2byte 0x3002 +80000934: 0e44 .2byte 0xe44 + ... + +Disassembly of section .comment: + +00000000 <.comment>: + 0: 3a434347 .4byte 0x3a434347 + 4: 2820 .2byte 0x2820 + 6: 2029 .2byte 0x2029 + 8: 3231 .2byte 0x3231 + a: 322e .2byte 0x322e + c: 302e .2byte 0x302e + ... + +Disassembly of section .riscv.attributes: + +00000000 <.riscv.attributes>: + 0: 1b41 .2byte 0x1b41 + 2: 0000 .2byte 0x0 + 4: 7200 .2byte 0x7200 + 6: 7369 .2byte 0x7369 + 8: 01007663 bgeu x0,x16,14 <__DATA_BEGIN__-0xffec> + c: 0011 .2byte 0x11 + e: 0000 .2byte 0x0 + 10: 1004 .2byte 0x1004 + 12: 7205 .2byte 0x7205 + 14: 3376 .2byte 0x3376 + 16: 6932 .2byte 0x6932 + 18: 7032 .2byte 0x7032 + 1a: 0031 .2byte 0x31 + +Disassembly of section .debug_aranges: + +00000000 <.debug_aranges>: + 0: 001c .2byte 0x1c + 2: 0000 .2byte 0x0 + 4: 0002 .2byte 0x2 + 6: 0000 .2byte 0x0 + 8: 0000 .2byte 0x0 + a: 0004 .2byte 0x4 + c: 0000 .2byte 0x0 + e: 0000 .2byte 0x0 + 10: 0000 .2byte 0x0 + 12: 8000 .2byte 0x8000 + 14: 0044 .2byte 0x44 + ... + 1e: 0000 .2byte 0x0 + 20: 001c .2byte 0x1c + 22: 0000 .2byte 0x0 + 24: 0002 .2byte 0x2 + 26: 0024 .2byte 0x24 + 28: 0000 .2byte 0x0 + 2a: 0004 .2byte 0x4 + 2c: 0000 .2byte 0x0 + 2e: 0000 .2byte 0x0 + 30: 0044 .2byte 0x44 + 32: 8000 .2byte 0x8000 + 34: 0098 .2byte 0x98 + ... + 3e: 0000 .2byte 0x0 + 40: 001c .2byte 0x1c + 42: 0000 .2byte 0x0 + 44: 0002 .2byte 0x2 + 46: 0000012b .4byte 0x12b + 4a: 0004 .2byte 0x4 + 4c: 0000 .2byte 0x0 + 4e: 0000 .2byte 0x0 + 50: 00dc .2byte 0xdc + 52: 8000 .2byte 0x8000 + 54: 0148 .2byte 0x148 + ... + 5e: 0000 .2byte 0x0 + 60: 001c .2byte 0x1c + 62: 0000 .2byte 0x0 + 64: 0002 .2byte 0x2 + 66: 0282 .2byte 0x282 + 68: 0000 .2byte 0x0 + 6a: 0004 .2byte 0x4 + 6c: 0000 .2byte 0x0 + 6e: 0000 .2byte 0x0 + 70: 0224 .2byte 0x224 + 72: 8000 .2byte 0x8000 + 74: 015c .2byte 0x15c + ... + 7e: 0000 .2byte 0x0 + 80: 001c .2byte 0x1c + 82: 0000 .2byte 0x0 + 84: 0002 .2byte 0x2 + 86: 0404 .2byte 0x404 + 88: 0000 .2byte 0x0 + 8a: 0004 .2byte 0x4 + 8c: 0000 .2byte 0x0 + 8e: 0000 .2byte 0x0 + 90: 0380 .2byte 0x380 + 92: 8000 .2byte 0x8000 + 94: 01bc .2byte 0x1bc + ... + 9e: 0000 .2byte 0x0 + a0: 001c .2byte 0x1c + a2: 0000 .2byte 0x0 + a4: 0002 .2byte 0x2 + a6: 05f5 .2byte 0x5f5 + a8: 0000 .2byte 0x0 + aa: 0004 .2byte 0x4 + ac: 0000 .2byte 0x0 + ae: 0000 .2byte 0x0 + b0: 053c .2byte 0x53c + b2: 8000 .2byte 0x8000 + b4: 01d4 .2byte 0x1d4 + ... + +Disassembly of section .debug_info: + +00000000 <.debug_info>: + 0: 0020 .2byte 0x20 + 2: 0000 .2byte 0x0 + 4: 0005 .2byte 0x5 + 6: 0401 .2byte 0x401 + 8: 0000 .2byte 0x0 + a: 0000 .2byte 0x0 + c: 0001 .2byte 0x1 + e: 0000 .2byte 0x0 + 10: 0000 .2byte 0x0 + 12: 0000 .2byte 0x0 + 14: 4480 .2byte 0x4480 + 16: 0000 .2byte 0x0 + 18: 0000 .2byte 0x0 + 1a: 0008 .2byte 0x8 + 1c: 0000 .2byte 0x0 + 1e: 0025 .2byte 0x25 + 20: 0000 .2byte 0x0 + 22: 8001 .2byte 0x8001 + 24: 00000103 lb x2,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 28: 0005 .2byte 0x5 + 2a: 0401 .2byte 0x401 + 2c: 0014 .2byte 0x14 + 2e: 0000 .2byte 0x0 + 30: 00009a03 lh x20,0(x1) + 34: 2100 .2byte 0x2100 + 36: 0025 .2byte 0x25 + 38: 0000 .2byte 0x0 + 3a: 0000 .2byte 0x0 + 3c: 0000 .2byte 0x0 + 3e: 0044 .2byte 0x44 + 40: 8000 .2byte 0x8000 + 42: 0098 .2byte 0x98 + 44: 0000 .2byte 0x0 + 46: 008c .2byte 0x8c + 48: 0000 .2byte 0x0 + 4a: 0101 .2byte 0x101 + 4c: 8406 .2byte 0x8406 + 4e: 0000 .2byte 0x0 + 50: 0100 .2byte 0x100 + 52: 0801 .2byte 0x801 + 54: 0082 .2byte 0x82 + 56: 0000 .2byte 0x0 + 58: 0201 .2byte 0x201 + 5a: 3705 .2byte 0x3705 + 5c: 0001 .2byte 0x1 + 5e: 0100 .2byte 0x100 + 60: 0702 .2byte 0x702 + 62: 0108 .2byte 0x108 + 64: 0000 .2byte 0x0 + 66: 0401 .2byte 0x401 + 68: 3805 .2byte 0x3805 + 6a: 0000 .2byte 0x0 + 6c: 0100 .2byte 0x100 + 6e: 0704 .2byte 0x704 + 70: 0064 .2byte 0x64 + 72: 0000 .2byte 0x0 + 74: 0801 .2byte 0x801 + 76: 3305 .2byte 0x3305 + 78: 0000 .2byte 0x0 + 7a: 0100 .2byte 0x100 + 7c: 0708 .2byte 0x708 + 7e: 005f 0000 0404 .byte 0x5f, 0x00, 0x00, 0x00, 0x04, 0x04 + 84: 6905 .2byte 0x6905 + 86: 746e .2byte 0x746e + 88: 0100 .2byte 0x100 + 8a: 0704 .2byte 0x704 + 8c: 0069 .2byte 0x69 + 8e: 0000 .2byte 0x0 + 90: 4105 .2byte 0x4105 + 92: 0000 .2byte 0x0 + 94: 0200 .2byte 0x200 + 96: 17d6 .2byte 0x17d6 + 98: 0065 .2byte 0x65 + 9a: 0000 .2byte 0x0 + 9c: 1001 .2byte 0x1001 + 9e: 2b04 .2byte 0x2b04 + a0: 0001 .2byte 0x1 + a2: 0600 .2byte 0x600 + a4: 0048 .2byte 0x48 + a6: 0000 .2byte 0x0 + a8: 0101 .2byte 0x101 + aa: 8b08 .2byte 0x8b08 + ac: 0000 .2byte 0x0 + ae: 0700 .2byte 0x700 + b0: 0084 .2byte 0x84 + b2: 0000 .2byte 0x0 + b4: 0408 .2byte 0x408 + b6: 0000008b .4byte 0x8b + ba: 5a09 .2byte 0x5a09 + bc: 0000 .2byte 0x0 + be: 0100 .2byte 0x100 + c0: 005e050b .4byte 0x5e050b + c4: 0000 .2byte 0x0 + c6: 0098 .2byte 0x98 + c8: 8000 .2byte 0x8000 + ca: 0044 .2byte 0x44 + cc: 0000 .2byte 0x0 + ce: 9c01 .2byte 0x9c01 + d0: 00cd .2byte 0xcd + d2: 0000 .2byte 0x0 + d4: 7602 .2byte 0x7602 + d6: 0000 .2byte 0x0 + d8: 0c00 .2byte 0xc00 + da: 9011 .2byte 0x9011 + dc: 0000 .2byte 0x0 + de: 0200 .2byte 0x200 + e0: 6c91 .2byte 0x6c91 + e2: 4902 .2byte 0x4902 + e4: 0001 .2byte 0x1 + e6: 0d00 .2byte 0xd00 + e8: 6c0c .2byte 0x6c0c + ea: 0000 .2byte 0x0 + ec: 0200 .2byte 0x200 + ee: 6891 .2byte 0x6891 + f0: 0a00 .2byte 0xa00 + f2: 0090 .2byte 0x90 + f4: 0000 .2byte 0x0 + f6: 0301 .2byte 0x301 + f8: 1b08 .2byte 0x1b08 + fa: 0001 .2byte 0x1 + fc: 6c00 .2byte 0x6c00 + fe: 0000 .2byte 0x0 + 100: 4400 .2byte 0x4400 + 102: 0000 .2byte 0x0 + 104: 5480 .2byte 0x5480 + 106: 0000 .2byte 0x0 + 108: 0100 .2byte 0x100 + 10a: 0b9c .2byte 0xb9c + 10c: 00727473 .4byte 0x727473 + 110: 0301 .2byte 0x301 + 112: 901e .2byte 0x901e + 114: 0000 .2byte 0x0 + 116: 0200 .2byte 0x200 + 118: 5c91 .2byte 0x5c91 + 11a: 6c0c .2byte 0x6c0c + 11c: 6e65 .2byte 0x6e65 + 11e: 0100 .2byte 0x100 + 120: 0c04 .2byte 0xc04 + 122: 006c .2byte 0x6c + 124: 0000 .2byte 0x0 + 126: 9102 .2byte 0x9102 + 128: 006c .2byte 0x6c + 12a: 5300 .2byte 0x5300 + 12c: 0001 .2byte 0x1 + 12e: 0500 .2byte 0x500 + 130: 0100 .2byte 0x100 + 132: ce04 .2byte 0xce04 + 134: 0000 .2byte 0x0 + 136: 0700 .2byte 0x700 + 138: 009a .2byte 0x9a + 13a: 0000 .2byte 0x0 + 13c: 7c21 .2byte 0x7c21 + 13e: 0000 .2byte 0x0 + 140: 0000 .2byte 0x0 + 142: 0000 .2byte 0x0 + 144: dc00 .2byte 0xdc00 + 146: 0000 .2byte 0x0 + 148: 4880 .2byte 0x4880 + 14a: 0001 .2byte 0x1 + 14c: 3900 .2byte 0x3900 + 14e: 0001 .2byte 0x1 + 150: 0100 .2byte 0x100 + 152: 0601 .2byte 0x601 + 154: 0084 .2byte 0x84 + 156: 0000 .2byte 0x0 + 158: 0201 .2byte 0x201 + 15a: 3705 .2byte 0x3705 + 15c: 0001 .2byte 0x1 + 15e: 0100 .2byte 0x100 + 160: 0504 .2byte 0x504 + 162: 0038 .2byte 0x38 + 164: 0000 .2byte 0x0 + 166: 0801 .2byte 0x801 + 168: 3305 .2byte 0x3305 + 16a: 0000 .2byte 0x0 + 16c: 0800 .2byte 0x800 + 16e: 0175 .2byte 0x175 + 170: 0000 .2byte 0x0 + 172: 2e02 .2byte 0x2e02 + 174: 4e18 .2byte 0x4e18 + 176: 0000 .2byte 0x0 + 178: 0100 .2byte 0x100 + 17a: 0801 .2byte 0x801 + 17c: 0082 .2byte 0x82 + 17e: 0000 .2byte 0x0 + 180: 0201 .2byte 0x201 + 182: 00010807 .4byte 0x10807 + 186: 0100 .2byte 0x100 + 188: 0704 .2byte 0x704 + 18a: 0064 .2byte 0x64 + 18c: 0000 .2byte 0x0 + 18e: 0801 .2byte 0x801 + 190: 00005f07 .4byte 0x5f07 + 194: 0900 .2byte 0x900 + 196: 0504 .2byte 0x504 + 198: 6e69 .2byte 0x6e69 + 19a: 0074 .2byte 0x74 + 19c: 0401 .2byte 0x401 + 19e: 00006907 .4byte 0x6907 + 1a2: 0a00 .2byte 0xa00 + 1a4: 0189 .2byte 0x189 + 1a6: 0000 .2byte 0x0 + 1a8: 0c01 .2byte 0xc01 + 1aa: 5006 .2byte 0x5006 + 1ac: 0001 .2byte 0x1 + 1ae: 2800 .2byte 0x2800 + 1b0: 0001 .2byte 0x1 + 1b2: fc80 .2byte 0xfc80 + 1b4: 0000 .2byte 0x0 + 1b6: 0100 .2byte 0x100 + 1b8: 0d9c .2byte 0xd9c + 1ba: 0001 .2byte 0x1 + 1bc: 0200 .2byte 0x200 + 1be: 016d .2byte 0x16d + 1c0: 0000 .2byte 0x0 + 1c2: 00010d23 sb x0,26(x2) + 1c6: 0200 .2byte 0x200 + 1c8: 5c91 .2byte 0x5c91 + 1ca: 8302 .2byte 0x8302 + 1cc: 0001 .2byte 0x1 + 1ce: 3800 .2byte 0x3800 + 1d0: 010d .2byte 0x10d + 1d2: 0000 .2byte 0x0 + 1d4: 9102 .2byte 0x9102 + 1d6: 0258 .2byte 0x258 + 1d8: 017d .2byte 0x17d + 1da: 0000 .2byte 0x0 + 1dc: 1e48 .2byte 0x1e48 + 1de: 0001 .2byte 0x1 + 1e0: 0200 .2byte 0x200 + 1e2: 5491 .2byte 0x5491 + 1e4: 4104 .2byte 0x4104 + 1e6: 0001 .2byte 0x1 + 1e8: 0e00 .2byte 0xe00 + 1ea: 006a .2byte 0x6a + 1ec: 0000 .2byte 0x0 + 1ee: 9102 .2byte 0x9102 + 1f0: 0b60 .2byte 0xb60 + 1f2: 0154 .2byte 0x154 + 1f4: 8000 .2byte 0x8000 + 1f6: 0030 .2byte 0x30 + 1f8: 0000 .2byte 0x0 + 1fa: 00e0 .2byte 0xe0 + 1fc: 0000 .2byte 0x0 + 1fe: 10006903 .4byte 0x10006903 + 202: 6a0e .2byte 0x6a0e + 204: 0000 .2byte 0x0 + 206: 0200 .2byte 0x200 + 208: 6c91 .2byte 0x6c91 + 20a: 0500 .2byte 0x500 + 20c: 0184 .2byte 0x184 + 20e: 8000 .2byte 0x8000 + 210: 0088 .2byte 0x88 + 212: 0000 .2byte 0x0 + 214: 14006903 .4byte 0x14006903 + 218: 6a0e .2byte 0x6a0e + 21a: 0000 .2byte 0x0 + 21c: 0200 .2byte 0x200 + 21e: 6891 .2byte 0x6891 + 220: 8c05 .2byte 0x8c05 + 222: 0001 .2byte 0x1 + 224: 6880 .2byte 0x6880 + 226: 0000 .2byte 0x0 + 228: 0300 .2byte 0x300 + 22a: 006a .2byte 0x6a + 22c: 1215 .2byte 0x1215 + 22e: 006a .2byte 0x6a + 230: 0000 .2byte 0x0 + 232: 9102 .2byte 0x9102 + 234: 0064 .2byte 0x64 + 236: 0000 .2byte 0x0 + 238: 1906 .2byte 0x1906 + 23a: 0001 .2byte 0x1 + 23c: 0100 .2byte 0x100 + 23e: 0801 .2byte 0x801 + 240: 0000008b .4byte 0x8b + 244: 120c .2byte 0x120c + 246: 0001 .2byte 0x1 + 248: 0600 .2byte 0x600 + 24a: 0042 .2byte 0x42 + 24c: 0000 .2byte 0x0 + 24e: 900d .2byte 0x900d + 250: 0000 .2byte 0x0 + 252: 0100 .2byte 0x100 + 254: 0c04 .2byte 0xc04 + 256: 006a .2byte 0x6a + 258: 0000 .2byte 0x0 + 25a: 00dc .2byte 0xdc + 25c: 8000 .2byte 0x8000 + 25e: 004c .2byte 0x4c + 260: 0000 .2byte 0x0 + 262: 9c01 .2byte 0x9c01 + 264: 730e .2byte 0x730e + 266: 7274 .2byte 0x7274 + 268: 0100 .2byte 0x100 + 26a: 2204 .2byte 0x2204 + 26c: 010d .2byte 0x10d + 26e: 0000 .2byte 0x0 + 270: 9102 .2byte 0x9102 + 272: 045c .2byte 0x45c + 274: 0149 .2byte 0x149 + 276: 0000 .2byte 0x0 + 278: 6a05 .2byte 0x6a05 + 27a: 0000 .2byte 0x0 + 27c: 0200 .2byte 0x200 + 27e: 6c91 .2byte 0x6c91 + 280: 0000 .2byte 0x0 + 282: 017e .2byte 0x17e + 284: 0000 .2byte 0x0 + 286: 0005 .2byte 0x5 + 288: 0401 .2byte 0x401 + 28a: 000001a7 .4byte 0x1a7 + 28e: 9a08 .2byte 0x9a08 + 290: 0000 .2byte 0x0 + 292: 2100 .2byte 0x2100 + 294: 0094 .2byte 0x94 + 296: 0000 .2byte 0x0 + 298: 0000 .2byte 0x0 + 29a: 0000 .2byte 0x0 + 29c: 0224 .2byte 0x224 + 29e: 8000 .2byte 0x8000 + 2a0: 015c .2byte 0x15c + 2a2: 0000 .2byte 0x0 + 2a4: 02d4 .2byte 0x2d4 + 2a6: 0000 .2byte 0x0 + 2a8: 0101 .2byte 0x101 + 2aa: 8406 .2byte 0x8406 + 2ac: 0000 .2byte 0x0 + 2ae: 0100 .2byte 0x100 + 2b0: 0502 .2byte 0x502 + 2b2: 00000137 lui x2,0x0 + 2b6: 0401 .2byte 0x401 + 2b8: 3805 .2byte 0x3805 + 2ba: 0000 .2byte 0x0 + 2bc: 0100 .2byte 0x100 + 2be: 0508 .2byte 0x508 + 2c0: 00000033 add x0,x0,x0 + 2c4: 7505 .2byte 0x7505 + 2c6: 0001 .2byte 0x1 + 2c8: 0300 .2byte 0x300 + 2ca: 182e .2byte 0x182e + 2cc: 004e .2byte 0x4e + 2ce: 0000 .2byte 0x0 + 2d0: 0101 .2byte 0x101 + 2d2: 8208 .2byte 0x8208 + 2d4: 0000 .2byte 0x0 + 2d6: 0100 .2byte 0x100 + 2d8: 0702 .2byte 0x702 + 2da: 0108 .2byte 0x108 + 2dc: 0000 .2byte 0x0 + 2de: 0401 .2byte 0x401 + 2e0: 00006407 .4byte 0x6407 + 2e4: 0100 .2byte 0x100 + 2e6: 0708 .2byte 0x708 + 2e8: 005f 0000 0409 .byte 0x5f, 0x00, 0x00, 0x00, 0x09, 0x04 + 2ee: 6905 .2byte 0x6905 + 2f0: 746e .2byte 0x746e + 2f2: 0100 .2byte 0x100 + 2f4: 0704 .2byte 0x704 + 2f6: 0069 .2byte 0x69 + 2f8: 0000 .2byte 0x0 + 2fa: 0c0a .2byte 0xc0a + 2fc: 0602 .2byte 0x602 + 2fe: be10 .2byte 0xbe10 + 300: 0001 .2byte 0x1 + 302: aa00 .2byte 0xaa00 + 304: 0000 .2byte 0x0 + 306: 0200 .2byte 0x200 + 308: 016d .2byte 0x16d + 30a: 0000 .2byte 0x0 + 30c: 00aa1107 .4byte 0xaa1107 + 310: 0000 .2byte 0x0 + 312: 0200 .2byte 0x200 + 314: 00000183 lb x3,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 318: 1108 .2byte 0x1108 + 31a: 00aa .2byte 0xaa + 31c: 0000 .2byte 0x0 + 31e: 0204 .2byte 0x204 + 320: 017d .2byte 0x17d + 322: 0000 .2byte 0x0 + 324: 0e09 .2byte 0xe09 + 326: 000000bb .4byte 0xbb + 32a: 0008 .2byte 0x8 + 32c: 0000b603 .4byte 0xb603 + 330: 0100 .2byte 0x100 + 332: 0801 .2byte 0x801 + 334: 0000008b .4byte 0x8b + 338: 0000af0b .4byte 0xaf0b + 33c: 0300 .2byte 0x300 + 33e: 0042 .2byte 0x42 + 340: 0000 .2byte 0x0 + 342: c005 .2byte 0xc005 + 344: 0001 .2byte 0x1 + 346: 0200 .2byte 0x200 + 348: 030a .2byte 0x30a + 34a: 0078 .2byte 0x78 + 34c: 0000 .2byte 0x0 + 34e: cf0c .2byte 0xcf0c + 350: 0001 .2byte 0x1 + 352: 0100 .2byte 0x100 + 354: 060d .2byte 0x60d + 356: 000001a3 sb x0,3(x0) # 3 <__DATA_BEGIN__-0xfffd> + 35a: 0270 .2byte 0x270 + 35c: 8000 .2byte 0x8000 + 35e: 0110 .2byte 0x110 + 360: 0000 .2byte 0x0 + 362: 9c01 .2byte 0x9c01 + 364: 0149 .2byte 0x149 + 366: 0000 .2byte 0x0 + 368: 9a0d .2byte 0x9a0d + 36a: 0001 .2byte 0x1 + 36c: 0100 .2byte 0x100 + 36e: 2d0d .2byte 0x2d0d + 370: 0149 .2byte 0x149 + 372: 0000 .2byte 0x0 + 374: 9102 .2byte 0x9102 + 376: 065c .2byte 0x65c + 378: 0141 .2byte 0x141 + 37a: 0000 .2byte 0x0 + 37c: 6a0e .2byte 0x6a0e + 37e: 0000 .2byte 0x0 + 380: 0200 .2byte 0x200 + 382: 6091 .2byte 0x6091 + 384: 9c0e .2byte 0x9c0e + 386: 0002 .2byte 0x2 + 388: 3480 .2byte 0x3480 + 38a: 0000 .2byte 0x0 + 38c: 1c00 .2byte 0x1c00 + 38e: 0001 .2byte 0x1 + 390: 0400 .2byte 0x400 + 392: 0069 .2byte 0x69 + 394: 0e11 .2byte 0xe11 + 396: 006a .2byte 0x6a + 398: 0000 .2byte 0x0 + 39a: 9102 .2byte 0x9102 + 39c: 006c .2byte 0x6c + 39e: 0002d007 .4byte 0x2d007 + 3a2: 9880 .2byte 0x9880 + 3a4: 0000 .2byte 0x0 + 3a6: 0400 .2byte 0x400 + 3a8: 0069 .2byte 0x69 + 3aa: 0e16 .2byte 0xe16 + 3ac: 006a .2byte 0x6a + 3ae: 0000 .2byte 0x0 + 3b0: 9102 .2byte 0x9102 + 3b2: 0768 .2byte 0x768 + 3b4: 02d8 .2byte 0x2d8 + 3b6: 8000 .2byte 0x8000 + 3b8: 0078 .2byte 0x78 + 3ba: 0000 .2byte 0x0 + 3bc: 6a04 .2byte 0x6a04 + 3be: 1700 .2byte 0x1700 + 3c0: 6a12 .2byte 0x6a12 + 3c2: 0000 .2byte 0x0 + 3c4: 0200 .2byte 0x200 + 3c6: 6491 .2byte 0x6491 + 3c8: 0000 .2byte 0x0 + 3ca: 0300 .2byte 0x300 + 3cc: 00c0 .2byte 0xc0 + 3ce: 0000 .2byte 0x0 + 3d0: 0000900f .4byte 0x900f + 3d4: 0100 .2byte 0x100 + 3d6: 0c04 .2byte 0xc04 + 3d8: 006a .2byte 0x6a + 3da: 0000 .2byte 0x0 + 3dc: 0224 .2byte 0x224 + 3de: 8000 .2byte 0x8000 + 3e0: 004c .2byte 0x4c + 3e2: 0000 .2byte 0x0 + 3e4: 9c01 .2byte 0x9c01 + 3e6: 7310 .2byte 0x7310 + 3e8: 7274 .2byte 0x7274 + 3ea: 0100 .2byte 0x100 + 3ec: 2204 .2byte 0x2204 + 3ee: 00aa .2byte 0xaa + 3f0: 0000 .2byte 0x0 + 3f2: 9102 .2byte 0x9102 + 3f4: 065c .2byte 0x65c + 3f6: 0149 .2byte 0x149 + 3f8: 0000 .2byte 0x0 + 3fa: 6a05 .2byte 0x6a05 + 3fc: 0000 .2byte 0x0 + 3fe: 0200 .2byte 0x200 + 400: 6c91 .2byte 0x6c91 + 402: 0000 .2byte 0x0 + 404: 01ed .2byte 0x1ed + 406: 0000 .2byte 0x0 + 408: 0005 .2byte 0x5 + 40a: 0401 .2byte 0x401 + 40c: 02a1 .2byte 0x2a1 + 40e: 0000 .2byte 0x0 + 410: 9a09 .2byte 0x9a09 + 412: 0000 .2byte 0x0 + 414: 2100 .2byte 0x2100 + 416: 00b4 .2byte 0xb4 + 418: 0000 .2byte 0x0 + 41a: 0000 .2byte 0x0 + 41c: 0000 .2byte 0x0 + 41e: 0380 .2byte 0x380 + 420: 8000 .2byte 0x8000 + 422: 01bc .2byte 0x1bc + 424: 0000 .2byte 0x0 + 426: 04a4 .2byte 0x4a4 + 428: 0000 .2byte 0x0 + 42a: 0101 .2byte 0x101 + 42c: 8406 .2byte 0x8406 + 42e: 0000 .2byte 0x0 + 430: 0100 .2byte 0x100 + 432: 0502 .2byte 0x502 + 434: 00000137 lui x2,0x0 + 438: 0401 .2byte 0x401 + 43a: 3805 .2byte 0x3805 + 43c: 0000 .2byte 0x0 + 43e: 0100 .2byte 0x100 + 440: 0508 .2byte 0x508 + 442: 00000033 add x0,x0,x0 + 446: 7506 .2byte 0x7506 + 448: 0001 .2byte 0x1 + 44a: 0200 .2byte 0x200 + 44c: 182e .2byte 0x182e + 44e: 004e .2byte 0x4e + 450: 0000 .2byte 0x0 + 452: 0101 .2byte 0x101 + 454: 8208 .2byte 0x8208 + 456: 0000 .2byte 0x0 + 458: 0100 .2byte 0x100 + 45a: 0702 .2byte 0x702 + 45c: 0108 .2byte 0x108 + 45e: 0000 .2byte 0x0 + 460: 0401 .2byte 0x401 + 462: 00006407 .4byte 0x6407 + 466: 0100 .2byte 0x100 + 468: 0708 .2byte 0x708 + 46a: 005f 0000 040a .byte 0x5f, 0x00, 0x00, 0x00, 0x0a, 0x04 + 470: 6905 .2byte 0x6905 + 472: 746e .2byte 0x746e + 474: 0100 .2byte 0x100 + 476: 0704 .2byte 0x704 + 478: 0069 .2byte 0x69 + 47a: 0000 .2byte 0x0 + 47c: 4606 .2byte 0x4606 + 47e: 0002 .2byte 0x2 + 480: 0300 .2byte 0x300 + 482: 2206 .2byte 0x2206 + 484: 0084 .2byte 0x84 + 486: 0000 .2byte 0x0 + 488: 0002460b .4byte 0x2460b + 48c: 1000 .2byte 0x1000 + 48e: c2080803 lb x16,-992(x16) + 492: 0000 .2byte 0x0 + 494: 0400 .2byte 0x400 + 496: 016d .2byte 0x16d + 498: 0000 .2byte 0x0 + 49a: 110a .2byte 0x110a + 49c: 00c2 .2byte 0xc2 + 49e: 0000 .2byte 0x0 + 4a0: 0400 .2byte 0x400 + 4a2: 00000183 lb x3,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 4a6: 00c2110b .4byte 0xc2110b + 4aa: 0000 .2byte 0x0 + 4ac: 0404 .2byte 0x404 + 4ae: 017d .2byte 0x17d + 4b0: 0000 .2byte 0x0 + 4b2: 0e0c .2byte 0xe0c + 4b4: 000000d3 .4byte 0xd3 + 4b8: 0408 .2byte 0x408 + 4ba: 0189 .2byte 0x189 + 4bc: 0000 .2byte 0x0 + 4be: 00e80c0f .4byte 0xe80c0f + 4c2: 0000 .2byte 0x0 + 4c4: 000c .2byte 0xc + 4c6: ce02 .2byte 0xce02 + 4c8: 0000 .2byte 0x0 + 4ca: 0100 .2byte 0x100 + 4cc: 0801 .2byte 0x801 + 4ce: 0000008b .4byte 0x8b + 4d2: c70c .2byte 0xc70c + 4d4: 0000 .2byte 0x0 + 4d6: 0200 .2byte 0x200 + 4d8: 0042 .2byte 0x42 + 4da: 0000 .2byte 0x0 + 4dc: e30d .2byte 0xe30d + 4de: 0000 .2byte 0x0 + 4e0: 0e00 .2byte 0xe00 + 4e2: 000000e3 beq x0,x0,ce2 <__DATA_BEGIN__-0xf31e> + 4e6: 0200 .2byte 0x200 + 4e8: 0084 .2byte 0x84 + 4ea: 0000 .2byte 0x0 + 4ec: d802 .2byte 0xd802 + 4ee: 0000 .2byte 0x0 + 4f0: 0f00 .2byte 0xf00 + 4f2: 023c .2byte 0x23c + 4f4: 0000 .2byte 0x0 + 4f6: 2001 .2byte 0x2001 + 4f8: 0006 .2byte 0x6 + 4fa: 0002 .2byte 0x2 + 4fc: dc00 .2byte 0xdc00 + 4fe: 0004 .2byte 0x4 + 500: 6080 .2byte 0x6080 + 502: 0000 .2byte 0x0 + 504: 0100 .2byte 0x100 + 506: 409c .2byte 0x409c + 508: 0001 .2byte 0x1 + 50a: 0300 .2byte 0x300 + 50c: 019a .2byte 0x19a + 50e: 0000 .2byte 0x0 + 510: 3520 .2byte 0x3520 + 512: 0140 .2byte 0x140 + 514: 0000 .2byte 0x0 + 516: 9102 .2byte 0x9102 + 518: 036c .2byte 0x36c + 51a: 016d .2byte 0x16d + 51c: 0000 .2byte 0x0 + 51e: 4b20 .2byte 0x4b20 + 520: 00c2 .2byte 0xc2 + 522: 0000 .2byte 0x0 + 524: 9102 .2byte 0x9102 + 526: 0368 .2byte 0x368 + 528: 00000183 lb x3,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 52c: 6020 .2byte 0x6020 + 52e: 00c2 .2byte 0xc2 + 530: 0000 .2byte 0x0 + 532: 9102 .2byte 0x9102 + 534: 0364 .2byte 0x364 + 536: 017d .2byte 0x17d + 538: 0000 .2byte 0x0 + 53a: 7020 .2byte 0x7020 + 53c: 000000d3 .4byte 0xd3 + 540: 9102 .2byte 0x9102 + 542: 0060 .2byte 0x60 + 544: 7802 .2byte 0x7802 + 546: 0000 .2byte 0x0 + 548: 1000 .2byte 0x1000 + 54a: 01e6 .2byte 0x1e6 + 54c: 0000 .2byte 0x0 + 54e: 0d01 .2byte 0xd01 + 550: cc0d .2byte 0xcc0d + 552: 10800003 lb x0,264(x0) # 108 <__DATA_BEGIN__-0xfef8> + 556: 0001 .2byte 0x1 + 558: 0100 .2byte 0x100 + 55a: bd9c .2byte 0xbd9c + 55c: 0001 .2byte 0x1 + 55e: 0300 .2byte 0x300 + 560: 019a .2byte 0x19a + 562: 0000 .2byte 0x0 + 564: 3a0d .2byte 0x3a0d + 566: 0140 .2byte 0x140 + 568: 0000 .2byte 0x0 + 56a: 9102 .2byte 0x9102 + 56c: 075c .2byte 0x75c + 56e: 0141 .2byte 0x141 + 570: 0000 .2byte 0x0 + 572: 6a0e .2byte 0x6a0e + 574: 0000 .2byte 0x0 + 576: 0200 .2byte 0x200 + 578: 6091 .2byte 0x6091 + 57a: f811 .2byte 0xf811 + 57c: 34800003 lb x0,840(x0) # 348 <__DATA_BEGIN__-0xfcb8> + 580: 0000 .2byte 0x0 + 582: 9000 .2byte 0x9000 + 584: 0001 .2byte 0x1 + 586: 0500 .2byte 0x500 + 588: 0069 .2byte 0x69 + 58a: 0e11 .2byte 0xe11 + 58c: 006a .2byte 0x6a + 58e: 0000 .2byte 0x0 + 590: 9102 .2byte 0x9102 + 592: 006c .2byte 0x6c + 594: 2c08 .2byte 0x2c08 + 596: 0004 .2byte 0x4 + 598: 9880 .2byte 0x9880 + 59a: 0000 .2byte 0x0 + 59c: 0500 .2byte 0x500 + 59e: 0069 .2byte 0x69 + 5a0: 0e16 .2byte 0xe16 + 5a2: 006a .2byte 0x6a + 5a4: 0000 .2byte 0x0 + 5a6: 9102 .2byte 0x9102 + 5a8: 0868 .2byte 0x868 + 5aa: 0434 .2byte 0x434 + 5ac: 8000 .2byte 0x8000 + 5ae: 0078 .2byte 0x78 + 5b0: 0000 .2byte 0x0 + 5b2: 6a05 .2byte 0x6a05 + 5b4: 1700 .2byte 0x1700 + 5b6: 6a12 .2byte 0x6a12 + 5b8: 0000 .2byte 0x0 + 5ba: 0200 .2byte 0x200 + 5bc: 6491 .2byte 0x6491 + 5be: 0000 .2byte 0x0 + 5c0: 1200 .2byte 0x1200 + 5c2: 0090 .2byte 0x90 + 5c4: 0000 .2byte 0x0 + 5c6: 0401 .2byte 0x401 + 5c8: 6a0c .2byte 0x6a0c + 5ca: 0000 .2byte 0x0 + 5cc: 8000 .2byte 0x8000 + 5ce: 4c800003 lb x0,1224(x0) # 4c8 <__DATA_BEGIN__-0xfb38> + 5d2: 0000 .2byte 0x0 + 5d4: 0100 .2byte 0x100 + 5d6: 139c .2byte 0x139c + 5d8: 00727473 .4byte 0x727473 + 5dc: 0401 .2byte 0x401 + 5de: c222 .2byte 0xc222 + 5e0: 0000 .2byte 0x0 + 5e2: 0200 .2byte 0x200 + 5e4: 5c91 .2byte 0x5c91 + 5e6: 00014907 .4byte 0x14907 + 5ea: 0500 .2byte 0x500 + 5ec: 006a .2byte 0x6a + 5ee: 0000 .2byte 0x0 + 5f0: 9102 .2byte 0x9102 + 5f2: 006c .2byte 0x6c + 5f4: 7900 .2byte 0x7900 + 5f6: 0004 .2byte 0x4 + 5f8: 0500 .2byte 0x500 + 5fa: 0100 .2byte 0x100 + 5fc: c104 .2byte 0xc104 + 5fe: 10000003 lb x0,256(x0) # 100 <__DATA_BEGIN__-0xff00> + 602: 009a .2byte 0x9a + 604: 0000 .2byte 0x0 + 606: da21 .2byte 0xda21 + 608: 0000 .2byte 0x0 + 60a: 0000 .2byte 0x0 + 60c: 0000 .2byte 0x0 + 60e: 3c00 .2byte 0x3c00 + 610: 0005 .2byte 0x5 + 612: d480 .2byte 0xd480 + 614: 0001 .2byte 0x1 + 616: a200 .2byte 0xa200 + 618: 0006 .2byte 0x6 + 61a: 0100 .2byte 0x100 + 61c: 0176 .2byte 0x176 + 61e: 0000 .2byte 0x0 + 620: 1722 .2byte 0x1722 + 622: 0031 .2byte 0x31 + 624: 0000 .2byte 0x0 + 626: 84060103 lb x2,-1984(x12) + 62a: 0000 .2byte 0x0 + 62c: 0100 .2byte 0x100 + 62e: 035e .2byte 0x35e + 630: 0000 .2byte 0x0 + 632: 1825 .2byte 0x1825 + 634: 00000043 .4byte 0x43 + 638: 37050203 lb x4,880(x10) + 63c: 0001 .2byte 0x1 + 63e: 0100 .2byte 0x100 + 640: 00000367 jalr x6,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 644: 1828 .2byte 0x1828 + 646: 0055 .2byte 0x55 + 648: 0000 .2byte 0x0 + 64a: 38050403 lb x8,896(x10) + 64e: 0000 .2byte 0x0 + 650: 0100 .2byte 0x100 + 652: 029e .2byte 0x29e + 654: 0000 .2byte 0x0 + 656: 0067182b .4byte 0x67182b + 65a: 0000 .2byte 0x0 + 65c: 33050803 lb x16,816(x10) + 660: 0000 .2byte 0x0 + 662: 0100 .2byte 0x100 + 664: 0175 .2byte 0x175 + 666: 0000 .2byte 0x0 + 668: 182e .2byte 0x182e + 66a: 007e .2byte 0x7e + 66c: 0000 .2byte 0x0 + 66e: 6e04 .2byte 0x6e04 + 670: 0000 .2byte 0x0 + 672: 0300 .2byte 0x300 + 674: 0801 .2byte 0x801 + 676: 0082 .2byte 0x82 + 678: 0000 .2byte 0x0 + 67a: 5d01 .2byte 0x5d01 + 67c: 31000003 lb x0,784(x0) # 310 <__DATA_BEGIN__-0xfcf0> + 680: 9019 .2byte 0x9019 + 682: 0000 .2byte 0x0 + 684: 0300 .2byte 0x300 + 686: 0702 .2byte 0x702 + 688: 0108 .2byte 0x108 + 68a: 0000 .2byte 0x0 + 68c: 6601 .2byte 0x6601 + 68e: 34000003 lb x0,832(x0) # 340 <__DATA_BEGIN__-0xfcc0> + 692: a219 .2byte 0xa219 + 694: 0000 .2byte 0x0 + 696: 0300 .2byte 0x300 + 698: 0704 .2byte 0x704 + 69a: 0064 .2byte 0x64 + 69c: 0000 .2byte 0x0 + 69e: 9d01 .2byte 0x9d01 + 6a0: 0002 .2byte 0x2 + 6a2: 3700 .2byte 0x3700 + 6a4: b419 .2byte 0xb419 + 6a6: 0000 .2byte 0x0 + 6a8: 0300 .2byte 0x300 + 6aa: 0708 .2byte 0x708 + 6ac: 005f 0000 0501 .byte 0x5f, 0x00, 0x00, 0x00, 0x01, 0x05 + 6b2: 3c000003 lb x0,960(x0) # 3c0 <__DATA_BEGIN__-0xfc40> + 6b6: 311d .2byte 0x311d + 6b8: 0000 .2byte 0x0 + 6ba: 0100 .2byte 0x100 + 6bc: 02f6 .2byte 0x2f6 + 6be: 0000 .2byte 0x0 + 6c0: 1e3d .2byte 0x1e3d + 6c2: 00000043 .4byte 0x43 + 6c6: 7f01 .2byte 0x7f01 + 6c8: 0002 .2byte 0x2 + 6ca: 3e00 .2byte 0x3e00 + 6cc: 551e .2byte 0x551e + 6ce: 0000 .2byte 0x0 + 6d0: 0100 .2byte 0x100 + 6d2: 0259 .2byte 0x259 + 6d4: 0000 .2byte 0x0 + 6d6: 00671e3f 04010000 .8byte 0x401000000671e3f + 6de: 40000003 lb x0,1024(x0) # 400 <__DATA_BEGIN__-0xfc00> + 6e2: 7e1e .2byte 0x7e1e + 6e4: 0000 .2byte 0x0 + 6e6: 0100 .2byte 0x100 + 6e8: 02f5 .2byte 0x2f5 + 6ea: 0000 .2byte 0x0 + 6ec: 1f41 .2byte 0x1f41 + 6ee: 0090 .2byte 0x90 + 6f0: 0000 .2byte 0x0 + 6f2: 7e01 .2byte 0x7e01 + 6f4: 0002 .2byte 0x2 + 6f6: 4200 .2byte 0x4200 + 6f8: a21f 0000 0100 .byte 0x1f, 0xa2, 0x00, 0x00, 0x00, 0x01 + 6fe: 0258 .2byte 0x258 + 700: 0000 .2byte 0x0 + 702: 00b41f43 .4byte 0xb41f43 + 706: 0000 .2byte 0x0 + 708: 7201 .2byte 0x7201 + 70a: 0002 .2byte 0x2 + 70c: 4700 .2byte 0x4700 + 70e: 1e1c .2byte 0x1e1c + 710: 0001 .2byte 0x1 + 712: 1100 .2byte 0x1100 + 714: 0504 .2byte 0x504 + 716: 6e69 .2byte 0x6e69 + 718: 0074 .2byte 0x74 + 71a: 3501 .2byte 0x3501 + 71c: 48000003 lb x0,1152(x0) # 480 <__DATA_BEGIN__-0xfb80> + 720: 1e1d .2byte 0x1e1d + 722: 0001 .2byte 0x1 + 724: 0100 .2byte 0x100 + 726: 02c1 .2byte 0x2c1 + 728: 0000 .2byte 0x0 + 72a: 1d49 .2byte 0x1d49 + 72c: 011e .2byte 0x11e + 72e: 0000 .2byte 0x0 + 730: 8901 .2byte 0x8901 + 732: 4a000003 lb x0,1184(x0) # 4a0 <__DATA_BEGIN__-0xfb60> + 736: 671d .2byte 0x671d + 738: 0000 .2byte 0x0 + 73a: 0100 .2byte 0x100 + 73c: 0271 .2byte 0x271 + 73e: 0000 .2byte 0x0 + 740: 01511d4b .4byte 0x1511d4b + 744: 0000 .2byte 0x0 + 746: 69070403 lb x8,1680(x14) + 74a: 0000 .2byte 0x0 + 74c: 0100 .2byte 0x100 + 74e: 0334 .2byte 0x334 + 750: 0000 .2byte 0x0 + 752: 1e4c .2byte 0x1e4c + 754: 0151 .2byte 0x151 + 756: 0000 .2byte 0x0 + 758: c001 .2byte 0xc001 + 75a: 0002 .2byte 0x2 + 75c: 4d00 .2byte 0x4d00 + 75e: 511e .2byte 0x511e + 760: 0001 .2byte 0x1 + 762: 0100 .2byte 0x100 + 764: 0388 .2byte 0x388 + 766: 0000 .2byte 0x0 + 768: 1e4e .2byte 0x1e4e + 76a: 00b4 .2byte 0xb4 + 76c: 0000 .2byte 0x0 + 76e: 6801 .2byte 0x6801 + 770: 0002 .2byte 0x2 + 772: 5300 .2byte 0x5300 + 774: 1e19 .2byte 0x1e19 + 776: 0001 .2byte 0x1 + 778: 0100 .2byte 0x100 + 77a: 00000267 jalr x4,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 77e: 1a56 .2byte 0x1a56 + 780: 0151 .2byte 0x151 + 782: 0000 .2byte 0x0 + 784: cf01 .2byte 0xcf01 + 786: 0002 .2byte 0x2 + 788: 5b00 .2byte 0x5b00 + 78a: 6719 .2byte 0x6719 + 78c: 0000 .2byte 0x0 + 78e: 0100 .2byte 0x100 + 790: 02ce .2byte 0x2ce + 792: 0000 .2byte 0x0 + 794: 1a5c .2byte 0x1a5c + 796: 00b4 .2byte 0xb4 + 798: 0000 .2byte 0x0 + 79a: 7312 .2byte 0x7312 + 79c: 6474 .2byte 0x6474 + 79e: 0500 .2byte 0x500 + 7a0: 0128 .2byte 0x128 + 7a2: 00025b0b .4byte 0x25b0b + 7a6: 0200 .2byte 0x200 + 7a8: 0000262f .4byte 0x262f + 7ac: 0200 .2byte 0x200 + 7ae: 3830 .2byte 0x3830 + 7b0: 0000 .2byte 0x0 + 7b2: 0200 .2byte 0x200 + 7b4: 4a31 .2byte 0x4a31 + 7b6: 0000 .2byte 0x0 + 7b8: 0200 .2byte 0x200 + 7ba: 5c32 .2byte 0x5c32 + 7bc: 0000 .2byte 0x0 + 7be: 0200 .2byte 0x200 + 7c0: 1334 .2byte 0x1334 + 7c2: 0001 .2byte 0x1 + 7c4: 0200 .2byte 0x200 + 7c6: 2535 .2byte 0x2535 + 7c8: 0001 .2byte 0x1 + 7ca: 0200 .2byte 0x200 + 7cc: 3036 .2byte 0x3036 + 7ce: 0001 .2byte 0x1 + 7d0: 0200 .2byte 0x200 + 7d2: 00013b37 lui x22,0x13 + 7d6: 0200 .2byte 0x200 + 7d8: bb39 .2byte 0xbb39 + 7da: 0000 .2byte 0x0 + 7dc: 0200 .2byte 0x200 + 7de: c63a .2byte 0xc63a + 7e0: 0000 .2byte 0x0 + 7e2: 0200 .2byte 0x200 + 7e4: 0000d13b .4byte 0xd13b + 7e8: 0200 .2byte 0x200 + 7ea: dc3c .2byte 0xdc3c + 7ec: 0000 .2byte 0x0 + 7ee: 0200 .2byte 0x200 + 7f0: 8f3e .2byte 0x8f3e + 7f2: 0001 .2byte 0x1 + 7f4: 0200 .2byte 0x200 + 7f6: 0001793f 6e410200 .8byte 0x6e4102000001793f + 7fe: 0000 .2byte 0x0 + 800: 0200 .2byte 0x200 + 802: 8542 .2byte 0x8542 + 804: 0000 .2byte 0x0 + 806: 0200 .2byte 0x200 + 808: 00009743 .4byte 0x9743 + 80c: 0200 .2byte 0x200 + 80e: a944 .2byte 0xa944 + 810: 0000 .2byte 0x0 + 812: 0200 .2byte 0x200 + 814: 4646 .2byte 0x4646 + 816: 0001 .2byte 0x1 + 818: 0200 .2byte 0x200 + 81a: 00015847 .4byte 0x15847 + 81e: 0200 .2byte 0x200 + 820: 6348 .2byte 0x6348 + 822: 0001 .2byte 0x1 + 824: 0200 .2byte 0x200 + 826: 6e49 .2byte 0x6e49 + 828: 0001 .2byte 0x1 + 82a: 0200 .2byte 0x200 + 82c: 0000e74b .4byte 0xe74b + 830: 0200 .2byte 0x200 + 832: f24c .2byte 0xf24c + 834: 0000 .2byte 0x0 + 836: 0200 .2byte 0x200 + 838: fd4d .2byte 0xfd4d + 83a: 0000 .2byte 0x0 + 83c: 0200 .2byte 0x200 + 83e: 084e .2byte 0x84e + 840: 0001 .2byte 0x1 + 842: 0200 .2byte 0x200 + 844: 9a50 .2byte 0x9a50 + 846: 0001 .2byte 0x1 + 848: 0200 .2byte 0x200 + 84a: 8451 .2byte 0x8451 + 84c: 0001 .2byte 0x1 + 84e: 0000 .2byte 0x0 + 850: 0002b113 sltiu x2,x5,0 + 854: 0c00 .2byte 0xc00 + 856: 0604 .2byte 0x604 + 858: 00030307 .4byte 0x30307 + 85c: 0c00 .2byte 0xc00 + 85e: 02b1 .2byte 0x2b1 + 860: 0000 .2byte 0x0 + 862: 0508 .2byte 0x508 + 864: 0000031b .4byte 0x31b + 868: 0000027b .4byte 0x27b + 86c: 0290 .2byte 0x290 + 86e: 0000 .2byte 0x0 + 870: 0808 .2byte 0x808 + 872: 06000003 lb x0,96(x0) # 60 <__DATA_BEGIN__-0xffa0> + 876: 0312 .2byte 0x312 + 878: 0000 .2byte 0x0 + 87a: 1206 .2byte 0x1206 + 87c: 06000003 lb x0,96(x0) # 60 <__DATA_BEGIN__-0xffa0> + 880: 00000323 sb x0,6(x0) # 6 <__DATA_BEGIN__-0xfffa> + 884: 0c00 .2byte 0xc00 + 886: 028d .2byte 0x28d + 888: 0000 .2byte 0x0 + 88a: 0a0a .2byte 0xa0a + 88c: 0396 .2byte 0x396 + 88e: 0000 .2byte 0x0 + 890: 000002a3 sb x0,5(x0) # 5 <__DATA_BEGIN__-0xfffb> + 894: 02a9 .2byte 0x2a9 + 896: 0000 .2byte 0x0 + 898: 0808 .2byte 0x808 + 89a: 00000003 lb x0,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 89e: a614 .2byte 0xa614 + 8a0: 0002 .2byte 0x2 + 8a2: 0400 .2byte 0x400 + 8a4: 140c .2byte 0x140c + 8a6: 02d8 .2byte 0x2d8 + 8a8: 0000 .2byte 0x0 + 8aa: 0328 .2byte 0x328 + 8ac: 0000 .2byte 0x0 + 8ae: c201 .2byte 0xc201 + 8b0: 0002 .2byte 0x2 + 8b2: c800 .2byte 0xc800 + 8b4: 0002 .2byte 0x2 + 8b6: 0800 .2byte 0x800 + 8b8: 032d .2byte 0x32d + 8ba: 0000 .2byte 0x0 + 8bc: 0900 .2byte 0x900 + 8be: 016d .2byte 0x16d + 8c0: 0000 .2byte 0x0 + 8c2: 0312110f .4byte 0x312110f + 8c6: 0000 .2byte 0x0 + 8c8: 0900 .2byte 0x900 + 8ca: 00000183 lb x3,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 8ce: 1110 .2byte 0x1110 + 8d0: 0312 .2byte 0x312 + 8d2: 0000 .2byte 0x0 + 8d4: 0904 .2byte 0x904 + 8d6: 017d .2byte 0x17d + 8d8: 0000 .2byte 0x0 + 8da: 0e11 .2byte 0xe11 + 8dc: 00000323 sb x0,6(x0) # 6 <__DATA_BEGIN__-0xfffa> + 8e0: 1508 .2byte 0x1508 + 8e2: 0312 .2byte 0x312 + 8e4: 0000 .2byte 0x0 + 8e6: 1304 .2byte 0x1304 + 8e8: 4210 .2byte 0x4210 + 8ea: 1e000003 lb x0,480(x0) # 1e0 <__DATA_BEGIN__-0xfe20> + 8ee: 0001 .2byte 0x1 + 8f0: 0600 .2byte 0x600 + 8f2: 0312 .2byte 0x312 + 8f4: 0000 .2byte 0x0 + 8f6: 0000 .2byte 0x0 + 8f8: 5b04 .2byte 0x5b04 + 8fa: 0002 .2byte 0x2 + 8fc: 0500 .2byte 0x500 + 8fe: 0000025b .4byte 0x25b + 902: 0804 .2byte 0x804 + 904: 05000003 lb x0,80(x0) # 50 <__DATA_BEGIN__-0xffb0> + 908: 031e .2byte 0x31e + 90a: 0000 .2byte 0x0 + 90c: 8b080103 lb x2,-1872(x16) + 910: 0000 .2byte 0x0 + 912: 0400 .2byte 0x400 + 914: 00000317 auipc x6,0x0 + 918: 6e05 .2byte 0x6e05 + 91a: 0000 .2byte 0x0 + 91c: 0500 .2byte 0x500 + 91e: 0079 .2byte 0x79 + 920: 0000 .2byte 0x0 + 922: 0305 .2byte 0x305 + 924: 04000003 lb x0,64(x0) # 40 <__DATA_BEGIN__-0xffc0> + 928: 032d .2byte 0x32d + 92a: 0000 .2byte 0x0 + 92c: ec16 .2byte 0xec16 + 92e: 0002 .2byte 0x2 + 930: 0100 .2byte 0x100 + 932: 06c4051b .4byte 0x6c4051b + 936: 8000 .2byte 0x8000 + 938: 004c .2byte 0x4c + 93a: 0000 .2byte 0x0 + 93c: 9c01 .2byte 0x9c01 + 93e: 036a .2byte 0x36a + 940: 0000 .2byte 0x0 + 942: 72747317 auipc x6,0x72747 + 946: 0100 .2byte 0x100 + 948: 0312251b .4byte 0x312251b + 94c: 0000 .2byte 0x0 + 94e: 9102 .2byte 0x9102 + 950: 0d5c .2byte 0xd5c + 952: 0149 .2byte 0x149 + 954: 0000 .2byte 0x0 + 956: 1e1c .2byte 0x1e1c + 958: 0001 .2byte 0x1 + 95a: 0200 .2byte 0x200 + 95c: 6c91 .2byte 0x6c91 + 95e: 1800 .2byte 0x1800 + 960: 02a9 .2byte 0x2a9 + 962: 0000 .2byte 0x0 + 964: 1701 .2byte 0x1701 + 966: 8410 .2byte 0x8410 + 968: 9c000003 lb x0,-1600(x0) # fffff9c0 + 96c: 0006 .2byte 0x6 + 96e: 2880 .2byte 0x2880 + 970: 0000 .2byte 0x0 + 972: 0100 .2byte 0x100 + 974: 919c .2byte 0x919c + 976: 0e000003 lb x0,224(x0) # e0 <__DATA_BEGIN__-0xff20> + 97a: 000002bb .4byte 0x2bb + 97e: 0332 .2byte 0x332 + 980: 0000 .2byte 0x0 + 982: 9102 .2byte 0x9102 + 984: 006c .2byte 0x6c + 986: 9019 .2byte 0x9019 + 988: 0002 .2byte 0x2 + 98a: 0100 .2byte 0x100 + 98c: 03ab0607 .4byte 0x3ab0607 + 990: 0000 .2byte 0x0 + 992: 058c .2byte 0x58c + 994: 8000 .2byte 0x8000 + 996: 0110 .2byte 0x110 + 998: 0000 .2byte 0x0 + 99a: 9c01 .2byte 0x9c01 + 99c: 0000040b .4byte 0x40b + 9a0: bb0e .2byte 0xbb0e + 9a2: 0002 .2byte 0x2 + 9a4: 0d00 .2byte 0xd00 + 9a6: 02000003 lb x0,32(x0) # 20 <__DATA_BEGIN__-0xffe0> + 9aa: 5c91 .2byte 0x5c91 + 9ac: 410d .2byte 0x410d + 9ae: 0001 .2byte 0x1 + 9b0: 0800 .2byte 0x800 + 9b2: 011e .2byte 0x11e + 9b4: 0000 .2byte 0x0 + 9b6: 9102 .2byte 0x9102 + 9b8: 1a60 .2byte 0x1a60 + 9ba: 05b8 .2byte 0x5b8 + 9bc: 8000 .2byte 0x8000 + 9be: 0034 .2byte 0x34 + 9c0: 0000 .2byte 0x0 + 9c2: 03de .2byte 0x3de + 9c4: 0000 .2byte 0x0 + 9c6: 690a .2byte 0x690a + 9c8: 0a00 .2byte 0xa00 + 9ca: 1e0e .2byte 0x1e0e + 9cc: 0001 .2byte 0x1 + 9ce: 0200 .2byte 0x200 + 9d0: 6c91 .2byte 0x6c91 + 9d2: 0f00 .2byte 0xf00 + 9d4: 05ec .2byte 0x5ec + 9d6: 8000 .2byte 0x8000 + 9d8: 0098 .2byte 0x98 + 9da: 0000 .2byte 0x0 + 9dc: 690a .2byte 0x690a + 9de: 0e00 .2byte 0xe00 + 9e0: 1e0e .2byte 0x1e0e + 9e2: 0001 .2byte 0x1 + 9e4: 0200 .2byte 0x200 + 9e6: 6891 .2byte 0x6891 + 9e8: 0005f40f .4byte 0x5f40f + 9ec: 7880 .2byte 0x7880 + 9ee: 0000 .2byte 0x0 + 9f0: 0a00 .2byte 0xa00 + 9f2: 006a .2byte 0x6a + 9f4: 011e120f .4byte 0x11e120f + 9f8: 0000 .2byte 0x0 + 9fa: 9102 .2byte 0x9102 + 9fc: 0064 .2byte 0x64 + 9fe: 0000 .2byte 0x0 + a00: 0002681b .4byte 0x2681b + a04: 0100 .2byte 0x100 + a06: 041c0103 lb x2,65(x24) + a0a: 0000 .2byte 0x0 + a0c: 4400 .2byte 0x4400 + a0e: 0004 .2byte 0x4 + a10: 1c00 .2byte 0x1c00 + a12: 000002bb .4byte 0x2bb + a16: 030d .2byte 0x30d + a18: 0000 .2byte 0x0 + a1a: 00016d0b .4byte 0x16d0b + a1e: 2200 .2byte 0x2200 + a20: 0312 .2byte 0x312 + a22: 0000 .2byte 0x0 + a24: 0001830b .4byte 0x1830b + a28: 3700 .2byte 0x3700 + a2a: 0312 .2byte 0x312 + a2c: 0000 .2byte 0x0 + a2e: 00017d0b .4byte 0x17d0b + a32: 4700 .2byte 0x4700 + a34: 00000323 sb x0,6(x0) # 6 <__DATA_BEGIN__-0xfffa> + a38: 1d00 .2byte 0x1d00 + a3a: 0000040b .4byte 0x40b + a3e: 0000036f jal x6,a3e <__DATA_BEGIN__-0xf5c2> + a42: 0000045b .4byte 0x45b + a46: 053c .2byte 0x53c + a48: 8000 .2byte 0x8000 + a4a: 0050 .2byte 0x50 + a4c: 0000 .2byte 0x0 + a4e: 9c01 .2byte 0x9c01 + a50: 00041c07 .4byte 0x41c07 + a54: 0200 .2byte 0x200 + a56: 6c91 .2byte 0x6c91 + a58: 00042507 .4byte 0x42507 + a5c: 0200 .2byte 0x200 + a5e: 6891 .2byte 0x6891 + a60: 00042f07 .4byte 0x42f07 + a64: 0200 .2byte 0x200 + a66: 6491 .2byte 0x6491 + a68: 00043907 .4byte 0x43907 + a6c: 0200 .2byte 0x200 + a6e: 6091 .2byte 0x6091 + ... + +Disassembly of section .debug_abbrev: + +00000000 <.debug_abbrev>: + 0: 1101 .2byte 0x1101 + 2: 1000 .2byte 0x1000 + 4: 12011117 auipc x2,0x12011 + 8: 1b0e030f .4byte 0x1b0e030f + c: 250e .2byte 0x250e + e: 130e .2byte 0x130e + 10: 0005 .2byte 0x5 + 12: 0000 .2byte 0x0 + 14: 2401 .2byte 0x2401 + 16: 0b00 .2byte 0xb00 + 18: 030b3e0b .4byte 0x30b3e0b + 1c: 000e .2byte 0xe + 1e: 0200 .2byte 0x200 + 20: 0034 .2byte 0x34 + 22: 213a0e03 lb x28,531(x20) + 26: 3b01 .2byte 0x3b01 + 28: 490b390b .4byte 0x490b390b + 2c: 00180213 addi x4,x16,1 + 30: 0300 .2byte 0x300 + 32: 0111 .2byte 0x111 + 34: 0e25 .2byte 0xe25 + 36: 1f030b13 addi x22,x6,496 # 72747b32 <__global_pointer$+0x72737332> + 3a: 01111f1b .4byte 0x1111f1b + 3e: 0612 .2byte 0x612 + 40: 1710 .2byte 0x1710 + 42: 0000 .2byte 0x0 + 44: 2404 .2byte 0x2404 + 46: 0b00 .2byte 0xb00 + 48: 030b3e0b .4byte 0x30b3e0b + 4c: 0008 .2byte 0x8 + 4e: 0500 .2byte 0x500 + 50: 0016 .2byte 0x16 + 52: 0b3a0e03 lb x28,179(x20) + 56: 0b390b3b .4byte 0xb390b3b + 5a: 1349 .2byte 0x1349 + 5c: 0000 .2byte 0x0 + 5e: 3b06 .2byte 0x3b06 + 60: 0300 .2byte 0x300 + 62: 000e .2byte 0xe + 64: 0700 .2byte 0x700 + 66: 0026 .2byte 0x26 + 68: 1349 .2byte 0x1349 + 6a: 0000 .2byte 0x0 + 6c: 0f08 .2byte 0xf08 + 6e: 0b00 .2byte 0xb00 + 70: 0013490b .4byte 0x13490b + 74: 0900 .2byte 0x900 + 76: 012e .2byte 0x12e + 78: 0e03193f 0b3b0b3a .8byte 0xb3b0b3a0e03193f + 80: 0b39 .2byte 0xb39 + 82: 1349 .2byte 0x1349 + 84: 0111 .2byte 0x111 + 86: 0612 .2byte 0x612 + 88: 1840 .2byte 0x1840 + 8a: 197c .2byte 0x197c + 8c: 1301 .2byte 0x1301 + 8e: 0000 .2byte 0x0 + 90: 2e0a .2byte 0x2e0a + 92: 3f01 .2byte 0x3f01 + 94: 0319 .2byte 0x319 + 96: 3a0e .2byte 0x3a0e + 98: 390b3b0b .4byte 0x390b3b0b + 9c: 490e6e0b .4byte 0x490e6e0b + a0: 12011113 .4byte 0x12011113 + a4: 4006 .2byte 0x4006 + a6: 7a18 .2byte 0x7a18 + a8: 0019 .2byte 0x19 + aa: 0b00 .2byte 0xb00 + ac: 0005 .2byte 0x5 + ae: 0b3a0803 lb x16,179(x20) + b2: 0b390b3b .4byte 0xb390b3b + b6: 1349 .2byte 0x1349 + b8: 1802 .2byte 0x1802 + ba: 0000 .2byte 0x0 + bc: 340c .2byte 0x340c + be: 0300 .2byte 0x300 + c0: 3a08 .2byte 0x3a08 + c2: 390b3b0b .4byte 0x390b3b0b + c6: 0213490b .4byte 0x213490b + ca: 0018 .2byte 0x18 + cc: 0000 .2byte 0x0 + ce: 2401 .2byte 0x2401 + d0: 0b00 .2byte 0xb00 + d2: 030b3e0b .4byte 0x30b3e0b + d6: 000e .2byte 0xe + d8: 0200 .2byte 0x200 + da: 0005 .2byte 0x5 + dc: 213a0e03 lb x28,531(x20) + e0: 3b01 .2byte 0x3b01 + e2: 0c21 .2byte 0xc21 + e4: 0b39 .2byte 0xb39 + e6: 1349 .2byte 0x1349 + e8: 1802 .2byte 0x1802 + ea: 0000 .2byte 0x0 + ec: 03003403 .4byte 0x3003403 + f0: 3a08 .2byte 0x3a08 + f2: 0121 .2byte 0x121 + f4: 0b390b3b .4byte 0xb390b3b + f8: 1349 .2byte 0x1349 + fa: 1802 .2byte 0x1802 + fc: 0000 .2byte 0x0 + fe: 3404 .2byte 0x3404 + 100: 0300 .2byte 0x300 + 102: 3a0e .2byte 0x3a0e + 104: 0121 .2byte 0x121 + 106: 21390b3b .4byte 0x21390b3b + 10a: 4909 .2byte 0x4909 + 10c: 00180213 addi x4,x16,1 + 110: 0500 .2byte 0x500 + 112: 0111010b .4byte 0x111010b + 116: 0612 .2byte 0x612 + 118: 0000 .2byte 0x0 + 11a: 0f06 .2byte 0xf06 + 11c: 0b00 .2byte 0xb00 + 11e: 0421 .2byte 0x421 + 120: 1349 .2byte 0x1349 + 122: 0000 .2byte 0x0 + 124: 25011107 .4byte 0x25011107 + 128: 130e .2byte 0x130e + 12a: 1b1f030b .4byte 0x1b1f030b + 12e: 111f 1201 1006 .byte 0x1f, 0x11, 0x01, 0x12, 0x06, 0x10 + 134: 08000017 auipc x0,0x8000 + 138: 0016 .2byte 0x16 + 13a: 0b3a0e03 lb x28,179(x20) + 13e: 0b390b3b .4byte 0xb390b3b + 142: 1349 .2byte 0x1349 + 144: 0000 .2byte 0x0 + 146: 2409 .2byte 0x2409 + 148: 0b00 .2byte 0xb00 + 14a: 030b3e0b .4byte 0x30b3e0b + 14e: 0008 .2byte 0x8 + 150: 0a00 .2byte 0xa00 + 152: 012e .2byte 0x12e + 154: 0e03193f 0b3b0b3a .8byte 0xb3b0b3a0e03193f + 15c: 0b39 .2byte 0xb39 + 15e: 0e6e .2byte 0xe6e + 160: 0111 .2byte 0x111 + 162: 0612 .2byte 0x612 + 164: 1840 .2byte 0x1840 + 166: 197c .2byte 0x197c + 168: 1301 .2byte 0x1301 + 16a: 0000 .2byte 0x0 + 16c: 11010b0b .4byte 0x11010b0b + 170: 1201 .2byte 0x1201 + 172: 0106 .2byte 0x106 + 174: 0c000013 addi x0,x0,192 + 178: 0026 .2byte 0x26 + 17a: 1349 .2byte 0x1349 + 17c: 0000 .2byte 0x0 + 17e: 2e0d .2byte 0x2e0d + 180: 0301 .2byte 0x301 + 182: 3a0e .2byte 0x3a0e + 184: 390b3b0b .4byte 0x390b3b0b + 188: 1113490b .4byte 0x1113490b + 18c: 1201 .2byte 0x1201 + 18e: 4006 .2byte 0x4006 + 190: 7a18 .2byte 0x7a18 + 192: 0019 .2byte 0x19 + 194: 0e00 .2byte 0xe00 + 196: 0005 .2byte 0x5 + 198: 0b3a0803 lb x16,179(x20) + 19c: 0b390b3b .4byte 0xb390b3b + 1a0: 1349 .2byte 0x1349 + 1a2: 1802 .2byte 0x1802 + 1a4: 0000 .2byte 0x0 + 1a6: 0100 .2byte 0x100 + 1a8: 0024 .2byte 0x24 + 1aa: 0b3e0b0b .4byte 0xb3e0b0b + 1ae: 00000e03 lb x28,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 1b2: 0d02 .2byte 0xd02 + 1b4: 0300 .2byte 0x300 + 1b6: 3a0e .2byte 0x3a0e + 1b8: 0221 .2byte 0x221 + 1ba: 0b390b3b .4byte 0xb390b3b + 1be: 1349 .2byte 0x1349 + 1c0: 0b38 .2byte 0xb38 + 1c2: 0000 .2byte 0x0 + 1c4: 0b000f03 lb x30,176(x0) # b0 <__DATA_BEGIN__-0xff50> + 1c8: 0421 .2byte 0x421 + 1ca: 1349 .2byte 0x1349 + 1cc: 0000 .2byte 0x0 + 1ce: 3404 .2byte 0x3404 + 1d0: 0300 .2byte 0x300 + 1d2: 3a08 .2byte 0x3a08 + 1d4: 0121 .2byte 0x121 + 1d6: 0b390b3b .4byte 0xb390b3b + 1da: 1349 .2byte 0x1349 + 1dc: 1802 .2byte 0x1802 + 1de: 0000 .2byte 0x0 + 1e0: 1605 .2byte 0x1605 + 1e2: 0300 .2byte 0x300 + 1e4: 3a0e .2byte 0x3a0e + 1e6: 390b3b0b .4byte 0x390b3b0b + 1ea: 0013490b .4byte 0x13490b + 1ee: 0600 .2byte 0x600 + 1f0: 0034 .2byte 0x34 + 1f2: 213a0e03 lb x28,531(x20) + 1f6: 3b01 .2byte 0x3b01 + 1f8: 0921390b .4byte 0x921390b + 1fc: 1349 .2byte 0x1349 + 1fe: 1802 .2byte 0x1802 + 200: 0000 .2byte 0x0 + 202: 11010b07 .4byte 0x11010b07 + 206: 1201 .2byte 0x1201 + 208: 0006 .2byte 0x6 + 20a: 0800 .2byte 0x800 + 20c: 0111 .2byte 0x111 + 20e: 0e25 .2byte 0xe25 + 210: 1f030b13 addi x22,x6,496 + 214: 01111f1b .4byte 0x1111f1b + 218: 0612 .2byte 0x612 + 21a: 1710 .2byte 0x1710 + 21c: 0000 .2byte 0x0 + 21e: 2409 .2byte 0x2409 + 220: 0b00 .2byte 0xb00 + 222: 030b3e0b .4byte 0x30b3e0b + 226: 0008 .2byte 0x8 + 228: 0a00 .2byte 0xa00 + 22a: 0b0b0113 addi x2,x22,176 # 130b0 <__global_pointer$+0x28b0> + 22e: 0b3a .2byte 0xb3a + 230: 0b390b3b .4byte 0xb390b3b + 234: 0e6e .2byte 0xe6e + 236: 1301 .2byte 0x1301 + 238: 0000 .2byte 0x0 + 23a: 4900260b .4byte 0x4900260b + 23e: 0c000013 addi x0,x0,192 + 242: 012e .2byte 0x12e + 244: 0e03193f 0b3b0b3a .8byte 0xb3b0b3a0e03193f + 24c: 0b39 .2byte 0xb39 + 24e: 0e6e .2byte 0xe6e + 250: 0111 .2byte 0x111 + 252: 0612 .2byte 0x612 + 254: 1840 .2byte 0x1840 + 256: 197c .2byte 0x197c + 258: 1301 .2byte 0x1301 + 25a: 0000 .2byte 0x0 + 25c: 050d .2byte 0x50d + 25e: 0300 .2byte 0x300 + 260: 3a0e .2byte 0x3a0e + 262: 390b3b0b .4byte 0x390b3b0b + 266: 0213490b .4byte 0x213490b + 26a: 0018 .2byte 0x18 + 26c: 0e00 .2byte 0xe00 + 26e: 0111010b .4byte 0x111010b + 272: 0612 .2byte 0x612 + 274: 1301 .2byte 0x1301 + 276: 0000 .2byte 0x0 + 278: 03012e0f .4byte 0x3012e0f + 27c: 3a0e .2byte 0x3a0e + 27e: 390b3b0b .4byte 0x390b3b0b + 282: 1113490b .4byte 0x1113490b + 286: 1201 .2byte 0x1201 + 288: 4006 .2byte 0x4006 + 28a: 7a18 .2byte 0x7a18 + 28c: 0019 .2byte 0x19 + 28e: 1000 .2byte 0x1000 + 290: 0005 .2byte 0x5 + 292: 0b3a0803 lb x16,179(x20) + 296: 0b390b3b .4byte 0xb390b3b + 29a: 1349 .2byte 0x1349 + 29c: 1802 .2byte 0x1802 + 29e: 0000 .2byte 0x0 + 2a0: 0100 .2byte 0x100 + 2a2: 0024 .2byte 0x24 + 2a4: 0b3e0b0b .4byte 0xb3e0b0b + 2a8: 00000e03 lb x28,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 2ac: 0f02 .2byte 0xf02 + 2ae: 0b00 .2byte 0xb00 + 2b0: 0421 .2byte 0x421 + 2b2: 1349 .2byte 0x1349 + 2b4: 0000 .2byte 0x0 + 2b6: 03000503 lb x10,48(x0) # 30 <__DATA_BEGIN__-0xffd0> + 2ba: 3a0e .2byte 0x3a0e + 2bc: 0121 .2byte 0x121 + 2be: 0b390b3b .4byte 0xb390b3b + 2c2: 1349 .2byte 0x1349 + 2c4: 1802 .2byte 0x1802 + 2c6: 0000 .2byte 0x0 + 2c8: 0d04 .2byte 0xd04 + 2ca: 0300 .2byte 0x300 + 2cc: 3a0e .2byte 0x3a0e + 2ce: 0321 .2byte 0x321 + 2d0: 0b390b3b .4byte 0xb390b3b + 2d4: 1349 .2byte 0x1349 + 2d6: 0b38 .2byte 0xb38 + 2d8: 0000 .2byte 0x0 + 2da: 3405 .2byte 0x3405 + 2dc: 0300 .2byte 0x300 + 2de: 3a08 .2byte 0x3a08 + 2e0: 0121 .2byte 0x121 + 2e2: 0b390b3b .4byte 0xb390b3b + 2e6: 1349 .2byte 0x1349 + 2e8: 1802 .2byte 0x1802 + 2ea: 0000 .2byte 0x0 + 2ec: 1606 .2byte 0x1606 + 2ee: 0300 .2byte 0x300 + 2f0: 3a0e .2byte 0x3a0e + 2f2: 390b3b0b .4byte 0x390b3b0b + 2f6: 0013490b .4byte 0x13490b + 2fa: 0700 .2byte 0x700 + 2fc: 0034 .2byte 0x34 + 2fe: 213a0e03 lb x28,531(x20) + 302: 3b01 .2byte 0x3b01 + 304: 0921390b .4byte 0x921390b + 308: 1349 .2byte 0x1349 + 30a: 1802 .2byte 0x1802 + 30c: 0000 .2byte 0x0 + 30e: 0b08 .2byte 0xb08 + 310: 1101 .2byte 0x1101 + 312: 1201 .2byte 0x1201 + 314: 0006 .2byte 0x6 + 316: 0900 .2byte 0x900 + 318: 0111 .2byte 0x111 + 31a: 0e25 .2byte 0xe25 + 31c: 1f030b13 addi x22,x6,496 + 320: 01111f1b .4byte 0x1111f1b + 324: 0612 .2byte 0x612 + 326: 1710 .2byte 0x1710 + 328: 0000 .2byte 0x0 + 32a: 240a .2byte 0x240a + 32c: 0b00 .2byte 0xb00 + 32e: 030b3e0b .4byte 0x30b3e0b + 332: 0008 .2byte 0x8 + 334: 0b00 .2byte 0xb00 + 336: 0e030113 addi x2,x6,224 + 33a: 0b3a0b0b .4byte 0xb3a0b0b + 33e: 0b390b3b .4byte 0xb390b3b + 342: 1301 .2byte 0x1301 + 344: 0000 .2byte 0x0 + 346: 260c .2byte 0x260c + 348: 4900 .2byte 0x4900 + 34a: 0d000013 addi x0,x0,208 + 34e: 0115 .2byte 0x115 + 350: 1301 .2byte 0x1301 + 352: 0000 .2byte 0x0 + 354: 050e .2byte 0x50e + 356: 4900 .2byte 0x4900 + 358: 0f000013 addi x0,x0,240 + 35c: 012e .2byte 0x12e + 35e: 0e03193f 0b3b0b3a .8byte 0xb3b0b3a0e03193f + 366: 0b39 .2byte 0xb39 + 368: 0e6e .2byte 0xe6e + 36a: 0111 .2byte 0x111 + 36c: 0612 .2byte 0x612 + 36e: 1840 .2byte 0x1840 + 370: 197a .2byte 0x197a + 372: 1301 .2byte 0x1301 + 374: 0000 .2byte 0x0 + 376: 2e10 .2byte 0x2e10 + 378: 0301 .2byte 0x301 + 37a: 3a0e .2byte 0x3a0e + 37c: 390b3b0b .4byte 0x390b3b0b + 380: 1201110b .4byte 0x1201110b + 384: 4006 .2byte 0x4006 + 386: 7c18 .2byte 0x7c18 + 388: 0119 .2byte 0x119 + 38a: 11000013 addi x0,x0,272 + 38e: 0111010b .4byte 0x111010b + 392: 0612 .2byte 0x612 + 394: 1301 .2byte 0x1301 + 396: 0000 .2byte 0x0 + 398: 2e12 .2byte 0x2e12 + 39a: 0301 .2byte 0x301 + 39c: 3a0e .2byte 0x3a0e + 39e: 390b3b0b .4byte 0x390b3b0b + 3a2: 1113490b .4byte 0x1113490b + 3a6: 1201 .2byte 0x1201 + 3a8: 4006 .2byte 0x4006 + 3aa: 7a18 .2byte 0x7a18 + 3ac: 0019 .2byte 0x19 + 3ae: 1300 .2byte 0x1300 + 3b0: 0005 .2byte 0x5 + 3b2: 0b3a0803 lb x16,179(x20) + 3b6: 0b390b3b .4byte 0xb390b3b + 3ba: 1349 .2byte 0x1349 + 3bc: 1802 .2byte 0x1802 + 3be: 0000 .2byte 0x0 + 3c0: 0100 .2byte 0x100 + 3c2: 0016 .2byte 0x16 + 3c4: 213a0e03 lb x28,531(x20) + 3c8: 3b02 .2byte 0x3b02 + 3ca: 490b390b .4byte 0x490b390b + 3ce: 02000013 addi x0,x0,32 + 3d2: 0008 .2byte 0x8 + 3d4: 213a .2byte 0x213a + 3d6: 390b3b03 .4byte 0x390b3b03 + 3da: 0b21 .2byte 0xb21 + 3dc: 1318 .2byte 0x1318 + 3de: 0000 .2byte 0x0 + 3e0: 0b002403 lw x8,176(x0) # b0 <__DATA_BEGIN__-0xff50> + 3e4: 030b3e0b .4byte 0x30b3e0b + 3e8: 000e .2byte 0xe + 3ea: 0400 .2byte 0x400 + 3ec: 0026 .2byte 0x26 + 3ee: 1349 .2byte 0x1349 + 3f0: 0000 .2byte 0x0 + 3f2: 0f05 .2byte 0xf05 + 3f4: 0b00 .2byte 0xb00 + 3f6: 0421 .2byte 0x421 + 3f8: 1349 .2byte 0x1349 + 3fa: 0000 .2byte 0x0 + 3fc: 0506 .2byte 0x506 + 3fe: 4900 .2byte 0x4900 + 400: 07000013 addi x0,x0,112 + 404: 0005 .2byte 0x5 + 406: 1331 .2byte 0x1331 + 408: 1802 .2byte 0x1802 + 40a: 0000 .2byte 0x0 + 40c: 0508 .2byte 0x508 + 40e: 4900 .2byte 0x4900 + 410: 00193413 sltiu x8,x18,1 + 414: 0900 .2byte 0x900 + 416: 000d .2byte 0xd + 418: 213a0e03 lb x28,531(x20) + 41c: 3b04 .2byte 0x3b04 + 41e: 490b390b .4byte 0x490b390b + 422: 000b3813 sltiu x16,x22,0 + 426: 0a00 .2byte 0xa00 + 428: 0034 .2byte 0x34 + 42a: 213a0803 lb x16,531(x20) + 42e: 3b01 .2byte 0x3b01 + 430: 490b390b .4byte 0x490b390b + 434: 00180213 addi x4,x16,1 + 438: 0b00 .2byte 0xb00 + 43a: 0005 .2byte 0x5 + 43c: 213a0e03 lb x28,531(x20) + 440: 3b01 .2byte 0x3b01 + 442: 0321 .2byte 0x321 + 444: 0b39 .2byte 0xb39 + 446: 1349 .2byte 0x1349 + 448: 0000 .2byte 0x0 + 44a: 2e0c .2byte 0x2e0c + 44c: 3f01 .2byte 0x3f01 + 44e: 0319 .2byte 0x319 + 450: 3a0e .2byte 0x3a0e + 452: 0421 .2byte 0x421 + 454: 0b390b3b .4byte 0xb390b3b + 458: 0e6e .2byte 0xe6e + 45a: 2132 .2byte 0x2132 + 45c: 3c01 .2byte 0x3c01 + 45e: 6419 .2byte 0x6419 + 460: 00130113 addi x2,x6,1 + 464: 0d00 .2byte 0xd00 + 466: 0034 .2byte 0x34 + 468: 213a0e03 lb x28,531(x20) + 46c: 3b01 .2byte 0x3b01 + 46e: 0921390b .4byte 0x921390b + 472: 1349 .2byte 0x1349 + 474: 1802 .2byte 0x1802 + 476: 0000 .2byte 0x0 + 478: 050e .2byte 0x50e + 47a: 0300 .2byte 0x300 + 47c: 490e .2byte 0x490e + 47e: 02193413 sltiu x8,x18,33 + 482: 0018 .2byte 0x18 + 484: 0f00 .2byte 0xf00 + 486: 0111010b .4byte 0x111010b + 48a: 0612 .2byte 0x612 + 48c: 0000 .2byte 0x0 + 48e: 1110 .2byte 0x1110 + 490: 2501 .2byte 0x2501 + 492: 130e .2byte 0x130e + 494: 1b1f030b .4byte 0x1b1f030b + 498: 111f 1201 1006 .byte 0x1f, 0x11, 0x01, 0x12, 0x06, 0x10 + 49e: 11000017 auipc x0,0x11000 + 4a2: 0024 .2byte 0x24 + 4a4: 0b3e0b0b .4byte 0xb3e0b0b + 4a8: 00000803 lb x16,0(x0) # 0 <__DATA_BEGIN__-0x10000> + 4ac: 3912 .2byte 0x3912 + 4ae: 0301 .2byte 0x301 + 4b0: 3a08 .2byte 0x3a08 + 4b2: 39053b0b .4byte 0x39053b0b + 4b6: 0013010b .4byte 0x13010b + 4ba: 1300 .2byte 0x1300 + 4bc: 0102 .2byte 0x102 + 4be: 0b0b0e03 lb x28,176(x22) + 4c2: 0b3a .2byte 0xb3a + 4c4: 0b390b3b .4byte 0xb390b3b + 4c8: 1301 .2byte 0x1301 + 4ca: 0000 .2byte 0x0 + 4cc: 2e14 .2byte 0x2e14 + 4ce: 3f01 .2byte 0x3f01 + 4d0: 0319 .2byte 0x319 + 4d2: 3a0e .2byte 0x3a0e + 4d4: 390b3b0b .4byte 0x390b3b0b + 4d8: 490e6e0b .4byte 0x490e6e0b + 4dc: 3c0b3213 sltiu x4,x22,960 + 4e0: 6419 .2byte 0x6419 + 4e2: 00130113 addi x2,x6,1 + 4e6: 1500 .2byte 0x1500 + 4e8: 012e .2byte 0x12e + 4ea: 0e03193f 0b3b0b3a .8byte 0xb3b0b3a0e03193f + 4f2: 0b39 .2byte 0xb39 + 4f4: 0e6e .2byte 0xe6e + 4f6: 1349 .2byte 0x1349 + 4f8: 193c .2byte 0x193c + 4fa: 0000 .2byte 0x0 + 4fc: 2e16 .2byte 0x2e16 + 4fe: 4701 .2byte 0x4701 + 500: 3b0b3a13 sltiu x20,x22,944 + 504: 110b390b .4byte 0x110b390b + 508: 1201 .2byte 0x1201 + 50a: 4006 .2byte 0x4006 + 50c: 7a18 .2byte 0x7a18 + 50e: 0119 .2byte 0x119 + 510: 17000013 addi x0,x0,368 + 514: 0005 .2byte 0x5 + 516: 0b3a0803 lb x16,179(x20) + 51a: 0b390b3b .4byte 0xb390b3b + 51e: 1349 .2byte 0x1349 + 520: 1802 .2byte 0x1802 + 522: 0000 .2byte 0x0 + 524: 2e18 .2byte 0x2e18 + 526: 4701 .2byte 0x4701 + 528: 3b0b3a13 sltiu x20,x22,944 + 52c: 640b390b .4byte 0x640b390b + 530: 12011113 .4byte 0x12011113 + 534: 4006 .2byte 0x4006 + 536: 7a18 .2byte 0x7a18 + 538: 0119 .2byte 0x119 + 53a: 19000013 addi x0,x0,400 + 53e: 012e .2byte 0x12e + 540: 0b3a1347 .4byte 0xb3a1347 + 544: 0b390b3b .4byte 0xb390b3b + 548: 1364 .2byte 0x1364 + 54a: 0111 .2byte 0x111 + 54c: 0612 .2byte 0x612 + 54e: 1840 .2byte 0x1840 + 550: 197c .2byte 0x197c + 552: 1301 .2byte 0x1301 + 554: 0000 .2byte 0x0 + 556: 0b1a .2byte 0xb1a + 558: 1101 .2byte 0x1101 + 55a: 1201 .2byte 0x1201 + 55c: 0106 .2byte 0x106 + 55e: 1b000013 addi x0,x0,432 + 562: 012e .2byte 0x12e + 564: 0b3a1347 .4byte 0xb3a1347 + 568: 0b390b3b .4byte 0xb390b3b + 56c: 1364 .2byte 0x1364 + 56e: 0b20 .2byte 0xb20 + 570: 1301 .2byte 0x1301 + 572: 0000 .2byte 0x0 + 574: 051c .2byte 0x51c + 576: 0300 .2byte 0x300 + 578: 490e .2byte 0x490e + 57a: 00193413 sltiu x8,x18,1 + 57e: 1d00 .2byte 0x1d00 + 580: 012e .2byte 0x12e + 582: 1331 .2byte 0x1331 + 584: 0e6e .2byte 0xe6e + 586: 1364 .2byte 0x1364 + 588: 0111 .2byte 0x111 + 58a: 0612 .2byte 0x612 + 58c: 1840 .2byte 0x1840 + 58e: 197a .2byte 0x197a + 590: 0000 .2byte 0x0 + ... + +Disassembly of section .debug_line: + +00000000 <.debug_line>: + 0: 0088 .2byte 0x88 + 2: 0000 .2byte 0x0 + 4: 0005 .2byte 0x5 + 6: 0004 .2byte 0x4 + 8: 002a .2byte 0x2a + a: 0000 .2byte 0x0 + c: 0101 .2byte 0x101 + e: fb01 .2byte 0xfb01 + 10: 0d0e .2byte 0xd0e + 12: 0100 .2byte 0x100 + 14: 0101 .2byte 0x101 + 16: 0001 .2byte 0x1 + 18: 0000 .2byte 0x0 + 1a: 0001 .2byte 0x1 + 1c: 0100 .2byte 0x100 + 1e: 0101 .2byte 0x101 + 20: 011f 0000 0000 .byte 0x1f, 0x01, 0x00, 0x00, 0x00, 0x00 + 26: 0102 .2byte 0x102 + 28: 021f 020f 001d .byte 0x1f, 0x02, 0x0f, 0x02, 0x1d, 0x00 + 2e: 0000 .2byte 0x0 + 30: 1d00 .2byte 0x1d00 + 32: 0000 .2byte 0x0 + 34: 0000 .2byte 0x0 + 36: 0500 .2byte 0x500 + 38: 0002 .2byte 0x2 + 3a: 0000 .2byte 0x0 + 3c: 1a80 .2byte 0x1a80 + 3e: 08090303 lb x6,128(x18) + 42: 0100 .2byte 0x100 + 44: 04090203 lb x4,64(x18) + 48: 0100 .2byte 0x100 + 4a: 08090103 lb x2,128(x18) + 4e: 0100 .2byte 0x100 + 50: 08090203 lb x4,128(x18) + 54: 0100 .2byte 0x100 + 56: 04090203 lb x4,64(x18) + 5a: 0100 .2byte 0x100 + 5c: 04090103 lb x2,64(x18) + 60: 0100 .2byte 0x100 + 62: 04090103 lb x2,64(x18) + 66: 0100 .2byte 0x100 + 68: 04090103 lb x2,64(x18) + 6c: 0100 .2byte 0x100 + 6e: 04090303 lb x6,64(x18) + 72: 0100 .2byte 0x100 + 74: 04090203 lb x4,64(x18) + 78: 0100 .2byte 0x100 + 7a: 08090203 lb x4,128(x18) + 7e: 0100 .2byte 0x100 + 80: 04090303 lb x6,64(x18) + 84: 0100 .2byte 0x100 + 86: 0409 .2byte 0x409 + 88: 0000 .2byte 0x0 + 8a: 0101 .2byte 0x101 + 8c: 00a9 .2byte 0xa9 + 8e: 0000 .2byte 0x0 + 90: 0005 .2byte 0x5 + 92: 0004 .2byte 0x4 + 94: 00000033 add x0,x0,x0 + 98: 0101 .2byte 0x101 + 9a: fb01 .2byte 0xfb01 + 9c: 0d0e .2byte 0xd0e + 9e: 0100 .2byte 0x100 + a0: 0101 .2byte 0x101 + a2: 0001 .2byte 0x1 + a4: 0000 .2byte 0x0 + a6: 0001 .2byte 0x1 + a8: 0100 .2byte 0x100 + aa: 0101 .2byte 0x101 + ac: 021f 0000 0000 .byte 0x1f, 0x02, 0x00, 0x00, 0x00, 0x00 + b2: 0031 .2byte 0x31 + b4: 0000 .2byte 0x0 + b6: 0102 .2byte 0x102 + b8: 021f 030f 0025 .byte 0x1f, 0x02, 0x0f, 0x03, 0x25, 0x00 + be: 0000 .2byte 0x0 + c0: 2500 .2byte 0x2500 + c2: 0000 .2byte 0x0 + c4: 0000 .2byte 0x0 + c6: 00000073 ecall + ca: 0501 .2byte 0x501 + cc: 02050023 sb x0,32(x10) + d0: 0044 .2byte 0x44 + d2: 8000 .2byte 0x8000 + d4: 0514 .2byte 0x514 + d6: 030c .2byte 0x30c + d8: 0901 .2byte 0x901 + da: 0010 .2byte 0x10 + dc: 0501 .2byte 0x501 + de: 0305 .2byte 0x305 + e0: 0901 .2byte 0x901 + e2: 0004 .2byte 0x4 + e4: 0501 .2byte 0x501 + e6: 030c .2byte 0x30c + e8: 0901 .2byte 0x901 + ea: 0004 .2byte 0x4 + ec: 0501 .2byte 0x501 + ee: 0310 .2byte 0x310 + f0: 097f 000c 0501 030c .byte 0x7f, 0x09, 0x0c, 0x00, 0x01, 0x05, 0x0c, 0x03, 0x00, 0x09 + f8: 0900 + fa: 000c .2byte 0xc + fc: 0301 .2byte 0x301 + fe: 00100903 lb x18,1(x0) # 1 <__DATA_BEGIN__-0xffff> + 102: 0501 .2byte 0x501 + 104: 0301 .2byte 0x301 + 106: 0901 .2byte 0x901 + 108: 0004 .2byte 0x4 + 10a: 0501 .2byte 0x501 + 10c: 030c .2byte 0x30c + 10e: 0902 .2byte 0x902 + 110: 0010 .2byte 0x10 + 112: 0501 .2byte 0x501 + 114: 0311 .2byte 0x311 + 116: 0901 .2byte 0x901 + 118: 0010 .2byte 0x10 + 11a: 0501 .2byte 0x501 + 11c: 031e .2byte 0x31e + 11e: 0901 .2byte 0x901 + 120: 000c .2byte 0xc + 122: 0501 .2byte 0x501 + 124: 030c .2byte 0x30c + 126: 00100903 lb x18,1(x0) # 1 <__DATA_BEGIN__-0xffff> + 12a: 0501 .2byte 0x501 + 12c: 0301 .2byte 0x301 + 12e: 0901 .2byte 0x901 + 130: 0004 .2byte 0x4 + 132: 0901 .2byte 0x901 + 134: 0014 .2byte 0x14 + 136: 0100 .2byte 0x100 + 138: 9701 .2byte 0x9701 + 13a: 0001 .2byte 0x1 + 13c: 0500 .2byte 0x500 + 13e: 0400 .2byte 0x400 + 140: 3300 .2byte 0x3300 + 142: 0000 .2byte 0x0 + 144: 0100 .2byte 0x100 + 146: 0101 .2byte 0x101 + 148: 000d0efb .4byte 0xd0efb + 14c: 0101 .2byte 0x101 + 14e: 0101 .2byte 0x101 + 150: 0000 .2byte 0x0 + 152: 0100 .2byte 0x100 + 154: 0000 .2byte 0x0 + 156: 0101 .2byte 0x101 + 158: 1f01 .2byte 0x1f01 + 15a: 0002 .2byte 0x2 + 15c: 0000 .2byte 0x0 + 15e: 3100 .2byte 0x3100 + 160: 0000 .2byte 0x0 + 162: 0200 .2byte 0x200 + 164: 1f01 .2byte 0x1f01 + 166: 0f02 .2byte 0xf02 + 168: 00007c03 .4byte 0x7c03 + 16c: 0000 .2byte 0x0 + 16e: 007c .2byte 0x7c + 170: 0000 .2byte 0x0 + 172: 8700 .2byte 0x8700 + 174: 0000 .2byte 0x0 + 176: 0100 .2byte 0x100 + 178: 2705 .2byte 0x2705 + 17a: 0500 .2byte 0x500 + 17c: dc02 .2byte 0xdc02 + 17e: 0000 .2byte 0x0 + 180: 1580 .2byte 0x1580 + 182: 0905 .2byte 0x905 + 184: 10090103 lb x2,256(x18) + 188: 0100 .2byte 0x100 + 18a: 0505 .2byte 0x505 + 18c: 04090103 lb x2,64(x18) + 190: 0100 .2byte 0x100 + 192: 0f05 .2byte 0xf05 + 194: 04090103 lb x2,64(x18) + 198: 0100 .2byte 0x100 + 19a: 1005 .2byte 0x1005 + 19c: 0c097f03 .4byte 0xc097f03 + 1a0: 0100 .2byte 0x100 + 1a2: 1605 .2byte 0x1605 + 1a4: 04090003 lb x0,64(x18) + 1a8: 0100 .2byte 0x100 + 1aa: 1805 .2byte 0x1805 + 1ac: 0c090003 lb x0,192(x18) + 1b0: 0100 .2byte 0x100 + 1b2: 0c05 .2byte 0xc05 + 1b4: 04090303 lb x6,64(x18) + 1b8: 0100 .2byte 0x100 + 1ba: 0105 .2byte 0x105 + 1bc: 04090103 lb x2,64(x18) + 1c0: 0100 .2byte 0x100 + 1c2: 4f05 .2byte 0x4f05 + 1c4: 10090203 lb x4,256(x18) + 1c8: 0100 .2byte 0x100 + 1ca: 2305 .2byte 0x2305 + 1cc: 1c090203 lb x4,448(x18) + 1d0: 0100 .2byte 0x100 + 1d2: 0e05 .2byte 0xe05 + 1d4: 10090203 lb x4,256(x18) + 1d8: 0100 .2byte 0x100 + 1da: 0505 .2byte 0x505 + 1dc: 04090003 lb x0,64(x18) + 1e0: 0100 .2byte 0x100 + 1e2: 0f05 .2byte 0xf05 + 1e4: 0200 .2byte 0x200 + 1e6: 0304 .2byte 0x304 + 1e8: 04090103 lb x2,64(x18) + 1ec: 0100 .2byte 0x100 + 1ee: 1005 .2byte 0x1005 + 1f0: 0200 .2byte 0x200 + 1f2: 0304 .2byte 0x304 + 1f4: 04090003 lb x0,64(x18) + 1f8: 0100 .2byte 0x100 + 1fa: 1205 .2byte 0x1205 + 1fc: 0200 .2byte 0x200 + 1fe: 0304 .2byte 0x304 + 200: 08090003 lb x0,128(x18) + 204: 0100 .2byte 0x100 + 206: 0505 .2byte 0x505 + 208: 0200 .2byte 0x200 + 20a: 0304 .2byte 0x304 + 20c: 04097f03 .4byte 0x4097f03 + 210: 0100 .2byte 0x100 + 212: 1705 .2byte 0x1705 + 214: 0200 .2byte 0x200 + 216: 0104 .2byte 0x104 + 218: 0c090003 lb x0,192(x18) + 21c: 0100 .2byte 0x100 + 21e: 0e05 .2byte 0xe05 + 220: 0c090403 lb x8,192(x18) + 224: 0100 .2byte 0x100 + 226: 0505 .2byte 0x505 + 228: 04090003 lb x0,64(x18) + 22c: 0100 .2byte 0x100 + 22e: 1205 .2byte 0x1205 + 230: 04090103 lb x2,64(x18) + 234: 0100 .2byte 0x100 + 236: 0905 .2byte 0x905 + 238: 04090003 lb x0,64(x18) + 23c: 0100 .2byte 0x100 + 23e: 1905 .2byte 0x1905 + 240: 04090103 lb x2,64(x18) + 244: 0100 .2byte 0x100 + 246: 1a05 .2byte 0x1a05 + 248: 04090003 lb x0,64(x18) + 24c: 0100 .2byte 0x100 + 24e: 2505 .2byte 0x2505 + 250: 0c090003 lb x0,192(x18) + 254: 0100 .2byte 0x100 + 256: 2605 .2byte 0x2605 + 258: 04090003 lb x0,64(x18) + 25c: 0100 .2byte 0x100 + 25e: 0d05 .2byte 0xd05 + 260: 0c090003 lb x0,192(x18) + 264: 0100 .2byte 0x100 + 266: 1705 .2byte 0x1705 + 268: 04090103 lb x2,64(x18) + 26c: 0100 .2byte 0x100 + 26e: 1805 .2byte 0x1805 + 270: 04090003 lb x0,64(x18) + 274: 0100 .2byte 0x100 + 276: 1905 .2byte 0x1905 + 278: 0c090003 lb x0,192(x18) + 27c: 0100 .2byte 0x100 + 27e: 0905 .2byte 0x905 + 280: 0200 .2byte 0x200 + 282: 0204 .2byte 0x204 + 284: 0c097e03 .4byte 0xc097e03 + 288: 0100 .2byte 0x100 + 28a: 1f05 .2byte 0x1f05 + 28c: 0200 .2byte 0x200 + 28e: 0104 .2byte 0x104 + 290: 0c090003 lb x0,192(x18) + 294: 0100 .2byte 0x100 + 296: 2005 .2byte 0x2005 + 298: 0200 .2byte 0x200 + 29a: 0104 .2byte 0x104 + 29c: 04090003 lb x0,64(x18) + 2a0: 0100 .2byte 0x100 + 2a2: 2205 .2byte 0x2205 + 2a4: 0200 .2byte 0x200 + 2a6: 0104 .2byte 0x104 + 2a8: 0c090003 lb x0,192(x18) + 2ac: 0100 .2byte 0x100 + 2ae: 0505 .2byte 0x505 + 2b0: 0200 .2byte 0x200 + 2b2: 0204 .2byte 0x204 + 2b4: 04097f03 .4byte 0x4097f03 + 2b8: 0100 .2byte 0x100 + 2ba: 1705 .2byte 0x1705 + 2bc: 0200 .2byte 0x200 + 2be: 0104 .2byte 0x104 + 2c0: 0c090003 lb x0,192(x18) + 2c4: 0100 .2byte 0x100 + 2c6: 0105 .2byte 0x105 + 2c8: 0c090703 lb x14,192(x18) + 2cc: 0100 .2byte 0x100 + 2ce: 1809 .2byte 0x1809 + 2d0: 0000 .2byte 0x0 + 2d2: 0101 .2byte 0x101 + 2d4: 01cc .2byte 0x1cc + 2d6: 0000 .2byte 0x0 + 2d8: 0005 .2byte 0x5 + 2da: 0004 .2byte 0x4 + 2dc: 0038 .2byte 0x38 + 2de: 0000 .2byte 0x0 + 2e0: 0101 .2byte 0x101 + 2e2: fb01 .2byte 0xfb01 + 2e4: 0d0e .2byte 0xd0e + 2e6: 0100 .2byte 0x100 + 2e8: 0101 .2byte 0x101 + 2ea: 0001 .2byte 0x1 + 2ec: 0000 .2byte 0x0 + 2ee: 0001 .2byte 0x1 + 2f0: 0100 .2byte 0x100 + 2f2: 0101 .2byte 0x101 + 2f4: 021f 0000 0000 .byte 0x1f, 0x02, 0x00, 0x00, 0x00, 0x00 + 2fa: 0031 .2byte 0x31 + 2fc: 0000 .2byte 0x0 + 2fe: 0102 .2byte 0x102 + 300: 021f 040f 0094 .byte 0x1f, 0x02, 0x0f, 0x04, 0x94, 0x00 + 306: 0000 .2byte 0x0 + 308: 9400 .2byte 0x9400 + 30a: 0000 .2byte 0x0 + 30c: 0000 .2byte 0x0 + 30e: 00a5 .2byte 0xa5 + 310: 0000 .2byte 0x0 + 312: 8700 .2byte 0x8700 + 314: 0000 .2byte 0x0 + 316: 0100 .2byte 0x100 + 318: 2705 .2byte 0x2705 + 31a: 0500 .2byte 0x500 + 31c: 2402 .2byte 0x2402 + 31e: 0002 .2byte 0x2 + 320: 1580 .2byte 0x1580 + 322: 0905 .2byte 0x905 + 324: 10090103 lb x2,256(x18) + 328: 0100 .2byte 0x100 + 32a: 0505 .2byte 0x505 + 32c: 04090103 lb x2,64(x18) + 330: 0100 .2byte 0x100 + 332: 0f05 .2byte 0xf05 + 334: 04090103 lb x2,64(x18) + 338: 0100 .2byte 0x100 + 33a: 1005 .2byte 0x1005 + 33c: 0c097f03 .4byte 0xc097f03 + 340: 0100 .2byte 0x100 + 342: 1605 .2byte 0x1605 + 344: 04090003 lb x0,64(x18) + 348: 0100 .2byte 0x100 + 34a: 1805 .2byte 0x1805 + 34c: 0c090003 lb x0,192(x18) + 350: 0100 .2byte 0x100 + 352: 0c05 .2byte 0xc05 + 354: 04090303 lb x6,64(x18) + 358: 0100 .2byte 0x100 + 35a: 0105 .2byte 0x105 + 35c: 04090103 lb x2,64(x18) + 360: 0100 .2byte 0x100 + 362: 3705 .2byte 0x3705 + 364: 10090303 lb x6,256(x18) + 368: 0100 .2byte 0x100 + 36a: 2305 .2byte 0x2305 + 36c: 14090103 lb x2,320(x18) + 370: 0100 .2byte 0x100 + 372: 0e05 .2byte 0xe05 + 374: 18090303 lb x6,384(x18) + 378: 0100 .2byte 0x100 + 37a: 0505 .2byte 0x505 + 37c: 04090003 lb x0,64(x18) + 380: 0100 .2byte 0x100 + 382: 1305 .2byte 0x1305 + 384: 0200 .2byte 0x200 + 386: 0304 .2byte 0x304 + 388: 04090103 lb x2,64(x18) + 38c: 0100 .2byte 0x100 + 38e: 1905 .2byte 0x1905 + 390: 0200 .2byte 0x200 + 392: 0304 .2byte 0x304 + 394: 08090003 lb x0,128(x18) + 398: 0100 .2byte 0x100 + 39a: 1a05 .2byte 0x1a05 + 39c: 0200 .2byte 0x200 + 39e: 0304 .2byte 0x304 + 3a0: 04090003 lb x0,64(x18) + 3a4: 0100 .2byte 0x100 + 3a6: 1c05 .2byte 0x1c05 + 3a8: 0200 .2byte 0x200 + 3aa: 0304 .2byte 0x304 + 3ac: 04090003 lb x0,64(x18) + 3b0: 0100 .2byte 0x100 + 3b2: 0505 .2byte 0x505 + 3b4: 0200 .2byte 0x200 + 3b6: 0304 .2byte 0x304 + 3b8: 04097f03 .4byte 0x4097f03 + 3bc: 0100 .2byte 0x100 + 3be: 1705 .2byte 0x1705 + 3c0: 0200 .2byte 0x200 + 3c2: 0104 .2byte 0x104 + 3c4: 0c090003 lb x0,192(x18) + 3c8: 0100 .2byte 0x100 + 3ca: 0e05 .2byte 0xe05 + 3cc: 0c090503 lb x10,192(x18) + 3d0: 0100 .2byte 0x100 + 3d2: 0505 .2byte 0x505 + 3d4: 04090003 lb x0,64(x18) + 3d8: 0100 .2byte 0x100 + 3da: 1205 .2byte 0x1205 + 3dc: 04090103 lb x2,64(x18) + 3e0: 0100 .2byte 0x100 + 3e2: 0905 .2byte 0x905 + 3e4: 04090003 lb x0,64(x18) + 3e8: 0100 .2byte 0x100 + 3ea: 1b05 .2byte 0x1b05 + 3ec: 04090103 lb x2,64(x18) + 3f0: 0100 .2byte 0x100 + 3f2: 2305 .2byte 0x2305 + 3f4: 08090003 lb x0,128(x18) + 3f8: 0100 .2byte 0x100 + 3fa: 2405 .2byte 0x2405 + 3fc: 04090003 lb x0,64(x18) + 400: 0100 .2byte 0x100 + 402: 3305 .2byte 0x3305 + 404: 08090003 lb x0,128(x18) + 408: 0100 .2byte 0x100 + 40a: 3905 .2byte 0x3905 + 40c: 08090003 lb x0,128(x18) + 410: 0100 .2byte 0x100 + 412: 3a05 .2byte 0x3a05 + 414: 04090003 lb x0,64(x18) + 418: 0100 .2byte 0x100 + 41a: 0d05 .2byte 0xd05 + 41c: 08090003 lb x0,128(x18) + 420: 0100 .2byte 0x100 + 422: 1b05 .2byte 0x1b05 + 424: 04090103 lb x2,64(x18) + 428: 0100 .2byte 0x100 + 42a: 2105 .2byte 0x2105 + 42c: 08090003 lb x0,128(x18) + 430: 0100 .2byte 0x100 + 432: 2205 .2byte 0x2205 + 434: 04090003 lb x0,64(x18) + 438: 0100 .2byte 0x100 + 43a: 2305 .2byte 0x2305 + 43c: 08090003 lb x0,128(x18) + 440: 0100 .2byte 0x100 + 442: 0905 .2byte 0x905 + 444: 0200 .2byte 0x200 + 446: 0204 .2byte 0x204 + 448: 0c097e03 .4byte 0xc097e03 + 44c: 0100 .2byte 0x100 + 44e: 2305 .2byte 0x2305 + 450: 0200 .2byte 0x200 + 452: 0104 .2byte 0x104 + 454: 0c090003 lb x0,192(x18) + 458: 0100 .2byte 0x100 + 45a: 2905 .2byte 0x2905 + 45c: 0200 .2byte 0x200 + 45e: 0104 .2byte 0x104 + 460: 08090003 lb x0,128(x18) + 464: 0100 .2byte 0x100 + 466: 2a05 .2byte 0x2a05 + 468: 0200 .2byte 0x200 + 46a: 0104 .2byte 0x104 + 46c: 04090003 lb x0,64(x18) + 470: 0100 .2byte 0x100 + 472: 2c05 .2byte 0x2c05 + 474: 0200 .2byte 0x200 + 476: 0104 .2byte 0x104 + 478: 08090003 lb x0,128(x18) + 47c: 0100 .2byte 0x100 + 47e: 0505 .2byte 0x505 + 480: 0200 .2byte 0x200 + 482: 0204 .2byte 0x204 + 484: 04097f03 .4byte 0x4097f03 + 488: 0100 .2byte 0x100 + 48a: 1705 .2byte 0x1705 + 48c: 0200 .2byte 0x200 + 48e: 0104 .2byte 0x104 + 490: 0c090003 lb x0,192(x18) + 494: 0100 .2byte 0x100 + 496: 0105 .2byte 0x105 + 498: 0c090703 lb x14,192(x18) + 49c: 0100 .2byte 0x100 + 49e: 1809 .2byte 0x1809 + 4a0: 0000 .2byte 0x0 + 4a2: 0101 .2byte 0x101 + 4a4: 01fa .2byte 0x1fa + 4a6: 0000 .2byte 0x0 + 4a8: 0005 .2byte 0x5 + 4aa: 0004 .2byte 0x4 + 4ac: 0038 .2byte 0x38 + 4ae: 0000 .2byte 0x0 + 4b0: 0101 .2byte 0x101 + 4b2: fb01 .2byte 0xfb01 + 4b4: 0d0e .2byte 0xd0e + 4b6: 0100 .2byte 0x100 + 4b8: 0101 .2byte 0x101 + 4ba: 0001 .2byte 0x1 + 4bc: 0000 .2byte 0x0 + 4be: 0001 .2byte 0x1 + 4c0: 0100 .2byte 0x100 + 4c2: 0101 .2byte 0x101 + 4c4: 021f 0000 0000 .byte 0x1f, 0x02, 0x00, 0x00, 0x00, 0x00 + 4ca: 0031 .2byte 0x31 + 4cc: 0000 .2byte 0x0 + 4ce: 0102 .2byte 0x102 + 4d0: 021f 040f 00b4 .byte 0x1f, 0x02, 0x0f, 0x04, 0xb4, 0x00 + 4d6: 0000 .2byte 0x0 + 4d8: b400 .2byte 0xb400 + 4da: 0000 .2byte 0x0 + 4dc: 0000 .2byte 0x0 + 4de: 00000087 .4byte 0x87 + 4e2: c801 .2byte 0xc801 + 4e4: 0000 .2byte 0x0 + 4e6: 0000 .2byte 0x0 + 4e8: 2705 .2byte 0x2705 + 4ea: 0500 .2byte 0x500 + 4ec: 8002 .2byte 0x8002 + 4ee: 15800003 lb x0,344(x0) # 158 <__DATA_BEGIN__-0xfea8> + 4f2: 0905 .2byte 0x905 + 4f4: 10090103 lb x2,256(x18) + 4f8: 0100 .2byte 0x100 + 4fa: 0505 .2byte 0x505 + 4fc: 04090103 lb x2,64(x18) + 500: 0100 .2byte 0x100 + 502: 0f05 .2byte 0xf05 + 504: 04090103 lb x2,64(x18) + 508: 0100 .2byte 0x100 + 50a: 1005 .2byte 0x1005 + 50c: 0c097f03 .4byte 0xc097f03 + 510: 0100 .2byte 0x100 + 512: 1605 .2byte 0x1605 + 514: 04090003 lb x0,64(x18) + 518: 0100 .2byte 0x100 + 51a: 1805 .2byte 0x1805 + 51c: 0c090003 lb x0,192(x18) + 520: 0100 .2byte 0x100 + 522: 0c05 .2byte 0xc05 + 524: 04090303 lb x6,64(x18) + 528: 0100 .2byte 0x100 + 52a: 0105 .2byte 0x105 + 52c: 04090103 lb x2,64(x18) + 530: 0100 .2byte 0x100 + 532: 4405 .2byte 0x4405 + 534: 10090303 lb x6,256(x18) + 538: 0100 .2byte 0x100 + 53a: 2305 .2byte 0x2305 + 53c: 14090103 lb x2,320(x18) + 540: 0100 .2byte 0x100 + 542: 0e05 .2byte 0xe05 + 544: 18090303 lb x6,384(x18) + 548: 0100 .2byte 0x100 + 54a: 0505 .2byte 0x505 + 54c: 04090003 lb x0,64(x18) + 550: 0100 .2byte 0x100 + 552: 1305 .2byte 0x1305 + 554: 0200 .2byte 0x200 + 556: 0304 .2byte 0x304 + 558: 04090103 lb x2,64(x18) + 55c: 0100 .2byte 0x100 + 55e: 1905 .2byte 0x1905 + 560: 0200 .2byte 0x200 + 562: 0304 .2byte 0x304 + 564: 08090003 lb x0,128(x18) + 568: 0100 .2byte 0x100 + 56a: 1a05 .2byte 0x1a05 + 56c: 0200 .2byte 0x200 + 56e: 0304 .2byte 0x304 + 570: 04090003 lb x0,64(x18) + 574: 0100 .2byte 0x100 + 576: 1c05 .2byte 0x1c05 + 578: 0200 .2byte 0x200 + 57a: 0304 .2byte 0x304 + 57c: 04090003 lb x0,64(x18) + 580: 0100 .2byte 0x100 + 582: 0505 .2byte 0x505 + 584: 0200 .2byte 0x200 + 586: 0304 .2byte 0x304 + 588: 04097f03 .4byte 0x4097f03 + 58c: 0100 .2byte 0x100 + 58e: 1705 .2byte 0x1705 + 590: 0200 .2byte 0x200 + 592: 0104 .2byte 0x104 + 594: 0c090003 lb x0,192(x18) + 598: 0100 .2byte 0x100 + 59a: 0e05 .2byte 0xe05 + 59c: 0c090503 lb x10,192(x18) + 5a0: 0100 .2byte 0x100 + 5a2: 0505 .2byte 0x505 + 5a4: 04090003 lb x0,64(x18) + 5a8: 0100 .2byte 0x100 + 5aa: 1205 .2byte 0x1205 + 5ac: 04090103 lb x2,64(x18) + 5b0: 0100 .2byte 0x100 + 5b2: 0905 .2byte 0x905 + 5b4: 04090003 lb x0,64(x18) + 5b8: 0100 .2byte 0x100 + 5ba: 1b05 .2byte 0x1b05 + 5bc: 04090103 lb x2,64(x18) + 5c0: 0100 .2byte 0x100 + 5c2: 2305 .2byte 0x2305 + 5c4: 08090003 lb x0,128(x18) + 5c8: 0100 .2byte 0x100 + 5ca: 2405 .2byte 0x2405 + 5cc: 04090003 lb x0,64(x18) + 5d0: 0100 .2byte 0x100 + 5d2: 3305 .2byte 0x3305 + 5d4: 08090003 lb x0,128(x18) + 5d8: 0100 .2byte 0x100 + 5da: 3905 .2byte 0x3905 + 5dc: 08090003 lb x0,128(x18) + 5e0: 0100 .2byte 0x100 + 5e2: 3a05 .2byte 0x3a05 + 5e4: 04090003 lb x0,64(x18) + 5e8: 0100 .2byte 0x100 + 5ea: 0d05 .2byte 0xd05 + 5ec: 08090003 lb x0,128(x18) + 5f0: 0100 .2byte 0x100 + 5f2: 1b05 .2byte 0x1b05 + 5f4: 04090103 lb x2,64(x18) + 5f8: 0100 .2byte 0x100 + 5fa: 2105 .2byte 0x2105 + 5fc: 08090003 lb x0,128(x18) + 600: 0100 .2byte 0x100 + 602: 2205 .2byte 0x2205 + 604: 04090003 lb x0,64(x18) + 608: 0100 .2byte 0x100 + 60a: 2305 .2byte 0x2305 + 60c: 08090003 lb x0,128(x18) + 610: 0100 .2byte 0x100 + 612: 0905 .2byte 0x905 + 614: 0200 .2byte 0x200 + 616: 0204 .2byte 0x204 + 618: 0c097e03 .4byte 0xc097e03 + 61c: 0100 .2byte 0x100 + 61e: 2305 .2byte 0x2305 + 620: 0200 .2byte 0x200 + 622: 0104 .2byte 0x104 + 624: 0c090003 lb x0,192(x18) + 628: 0100 .2byte 0x100 + 62a: 2905 .2byte 0x2905 + 62c: 0200 .2byte 0x200 + 62e: 0104 .2byte 0x104 + 630: 08090003 lb x0,128(x18) + 634: 0100 .2byte 0x100 + 636: 2a05 .2byte 0x2a05 + 638: 0200 .2byte 0x200 + 63a: 0104 .2byte 0x104 + 63c: 04090003 lb x0,64(x18) + 640: 0100 .2byte 0x100 + 642: 2c05 .2byte 0x2c05 + 644: 0200 .2byte 0x200 + 646: 0104 .2byte 0x104 + 648: 08090003 lb x0,128(x18) + 64c: 0100 .2byte 0x100 + 64e: 0505 .2byte 0x505 + 650: 0200 .2byte 0x200 + 652: 0204 .2byte 0x204 + 654: 04097f03 .4byte 0x4097f03 + 658: 0100 .2byte 0x100 + 65a: 1705 .2byte 0x1705 + 65c: 0200 .2byte 0x200 + 65e: 0104 .2byte 0x104 + 660: 0c090003 lb x0,192(x18) + 664: 0100 .2byte 0x100 + 666: 0105 .2byte 0x105 + 668: 0c090703 lb x14,192(x18) + 66c: 0100 .2byte 0x100 + 66e: 7705 .2byte 0x7705 + 670: 18090303 lb x6,384(x18) + 674: 0100 .2byte 0x100 + 676: 1705 .2byte 0x1705 + 678: 1c090103 lb x2,448(x18) + 67c: 0100 .2byte 0x100 + 67e: 1505 .2byte 0x1505 + 680: 0c090103 lb x2,192(x18) + 684: 0100 .2byte 0x100 + 686: 0c090103 lb x2,192(x18) + 68a: 0100 .2byte 0x100 + 68c: 2005 .2byte 0x2005 + 68e: 0c090103 lb x2,192(x18) + 692: 0100 .2byte 0x100 + 694: 0105 .2byte 0x105 + 696: 10090103 lb x2,256(x18) + 69a: 0100 .2byte 0x100 + 69c: 1009 .2byte 0x1009 + 69e: 0000 .2byte 0x0 + 6a0: 0101 .2byte 0x101 + 6a2: 021e .2byte 0x21e + 6a4: 0000 .2byte 0x0 + 6a6: 0005 .2byte 0x5 + 6a8: 0004 .2byte 0x4 + 6aa: 004a .2byte 0x4a + 6ac: 0000 .2byte 0x0 + 6ae: 0101 .2byte 0x101 + 6b0: fb01 .2byte 0xfb01 + 6b2: 0d0e .2byte 0xd0e + 6b4: 0100 .2byte 0x100 + 6b6: 0101 .2byte 0x101 + 6b8: 0001 .2byte 0x1 + 6ba: 0000 .2byte 0x0 + 6bc: 0001 .2byte 0x1 + 6be: 0100 .2byte 0x100 + 6c0: 0101 .2byte 0x101 + 6c2: 041f 0000 0000 .byte 0x1f, 0x04, 0x00, 0x00, 0x00, 0x00 + 6c8: 0031 .2byte 0x31 + 6ca: 0000 .2byte 0x0 + 6cc: 00e8 .2byte 0xe8 + 6ce: 0000 .2byte 0x0 + 6d0: 0126 .2byte 0x126 + 6d2: 0000 .2byte 0x0 + 6d4: 0102 .2byte 0x102 + 6d6: 021f 060f 00da .byte 0x1f, 0x02, 0x0f, 0x06, 0xda, 0x00 + 6dc: 0000 .2byte 0x0 + 6de: da00 .2byte 0xda00 + 6e0: 0000 .2byte 0x0 + 6e2: 0000 .2byte 0x0 + 6e4: 00000087 .4byte 0x87 + 6e8: 7d01 .2byte 0x7d01 + 6ea: 0001 .2byte 0x1 + 6ec: 0200 .2byte 0x200 + 6ee: 0185 .2byte 0x185 + 6f0: 0000 .2byte 0x0 + 6f2: 9300 .2byte 0x9300 + 6f4: 0001 .2byte 0x1 + 6f6: 0300 .2byte 0x300 + 6f8: 0105 .2byte 0x105 + 6fa: 0500 .2byte 0x500 + 6fc: 3c02 .2byte 0x3c02 + 6fe: 0005 .2byte 0x5 + 700: 1480 .2byte 0x1480 + 702: 0705 .2byte 0x705 + 704: 1c090103 lb x2,448(x18) + 708: 0100 .2byte 0x100 + 70a: 1905 .2byte 0x1905 + 70c: 0c090003 lb x0,192(x18) + 710: 0100 .2byte 0x100 + 712: 2705 .2byte 0x2705 + 714: 0c090003 lb x0,192(x18) + 718: 0100 .2byte 0x100 + 71a: 0105 .2byte 0x105 + 71c: 0c090103 lb x2,192(x18) + 720: 0100 .2byte 0x100 + 722: 2305 .2byte 0x2305 + 724: 10090203 lb x4,256(x18) + 728: 0100 .2byte 0x100 + 72a: 2205 .2byte 0x2205 + 72c: 14090103 lb x2,320(x18) + 730: 0100 .2byte 0x100 + 732: 0e05 .2byte 0xe05 + 734: 18090203 lb x4,384(x18) + 738: 0100 .2byte 0x100 + 73a: 0505 .2byte 0x505 + 73c: 04090003 lb x0,64(x18) + 740: 0100 .2byte 0x100 + 742: 0905 .2byte 0x905 + 744: 0200 .2byte 0x200 + 746: 0304 .2byte 0x304 + 748: 04090103 lb x2,64(x18) + 74c: 0100 .2byte 0x100 + 74e: 0f05 .2byte 0xf05 + 750: 0200 .2byte 0x200 + 752: 0304 .2byte 0x304 + 754: 08090003 lb x0,128(x18) + 758: 0100 .2byte 0x100 + 75a: 1005 .2byte 0x1005 + 75c: 0200 .2byte 0x200 + 75e: 0304 .2byte 0x304 + 760: 04090003 lb x0,64(x18) + 764: 0100 .2byte 0x100 + 766: 1205 .2byte 0x1205 + 768: 0200 .2byte 0x200 + 76a: 0304 .2byte 0x304 + 76c: 04090003 lb x0,64(x18) + 770: 0100 .2byte 0x100 + 772: 0505 .2byte 0x505 + 774: 0200 .2byte 0x200 + 776: 0304 .2byte 0x304 + 778: 04097f03 .4byte 0x4097f03 + 77c: 0100 .2byte 0x100 + 77e: 1705 .2byte 0x1705 + 780: 0200 .2byte 0x200 + 782: 0104 .2byte 0x104 + 784: 0c090003 lb x0,192(x18) + 788: 0100 .2byte 0x100 + 78a: 0e05 .2byte 0xe05 + 78c: 0c090403 lb x8,192(x18) + 790: 0100 .2byte 0x100 + 792: 0505 .2byte 0x505 + 794: 04090003 lb x0,64(x18) + 798: 0100 .2byte 0x100 + 79a: 1205 .2byte 0x1205 + 79c: 04090103 lb x2,64(x18) + 7a0: 0100 .2byte 0x100 + 7a2: 0905 .2byte 0x905 + 7a4: 04090003 lb x0,64(x18) + 7a8: 0100 .2byte 0x100 + 7aa: 1105 .2byte 0x1105 + 7ac: 04090103 lb x2,64(x18) + 7b0: 0100 .2byte 0x100 + 7b2: 1905 .2byte 0x1905 + 7b4: 08090003 lb x0,128(x18) + 7b8: 0100 .2byte 0x100 + 7ba: 1a05 .2byte 0x1a05 + 7bc: 04090003 lb x0,64(x18) + 7c0: 0100 .2byte 0x100 + 7c2: 1f05 .2byte 0x1f05 + 7c4: 08090003 lb x0,128(x18) + 7c8: 0100 .2byte 0x100 + 7ca: 2505 .2byte 0x2505 + 7cc: 08090003 lb x0,128(x18) + 7d0: 0100 .2byte 0x100 + 7d2: 2605 .2byte 0x2605 + 7d4: 04090003 lb x0,64(x18) + 7d8: 0100 .2byte 0x100 + 7da: 0d05 .2byte 0xd05 + 7dc: 08090003 lb x0,128(x18) + 7e0: 0100 .2byte 0x100 + 7e2: 1105 .2byte 0x1105 + 7e4: 04090103 lb x2,64(x18) + 7e8: 0100 .2byte 0x100 + 7ea: 1705 .2byte 0x1705 + 7ec: 08090003 lb x0,128(x18) + 7f0: 0100 .2byte 0x100 + 7f2: 1805 .2byte 0x1805 + 7f4: 04090003 lb x0,64(x18) + 7f8: 0100 .2byte 0x100 + 7fa: 1905 .2byte 0x1905 + 7fc: 08090003 lb x0,128(x18) + 800: 0100 .2byte 0x100 + 802: 0905 .2byte 0x905 + 804: 0200 .2byte 0x200 + 806: 0204 .2byte 0x204 + 808: 0c097e03 .4byte 0xc097e03 + 80c: 0100 .2byte 0x100 + 80e: 1905 .2byte 0x1905 + 810: 0200 .2byte 0x200 + 812: 0104 .2byte 0x104 + 814: 0c090003 lb x0,192(x18) + 818: 0100 .2byte 0x100 + 81a: 1f05 .2byte 0x1f05 + 81c: 0200 .2byte 0x200 + 81e: 0104 .2byte 0x104 + 820: 08090003 lb x0,128(x18) + 824: 0100 .2byte 0x100 + 826: 2005 .2byte 0x2005 + 828: 0200 .2byte 0x200 + 82a: 0104 .2byte 0x104 + 82c: 04090003 lb x0,64(x18) + 830: 0100 .2byte 0x100 + 832: 2205 .2byte 0x2205 + 834: 0200 .2byte 0x200 + 836: 0104 .2byte 0x104 + 838: 08090003 lb x0,128(x18) + 83c: 0100 .2byte 0x100 + 83e: 0505 .2byte 0x505 + 840: 0200 .2byte 0x200 + 842: 0204 .2byte 0x204 + 844: 04097f03 .4byte 0x4097f03 + 848: 0100 .2byte 0x100 + 84a: 1705 .2byte 0x1705 + 84c: 0200 .2byte 0x200 + 84e: 0104 .2byte 0x104 + 850: 0c090003 lb x0,192(x18) + 854: 0100 .2byte 0x100 + 856: 0105 .2byte 0x105 + 858: 0c090703 lb x14,192(x18) + 85c: 0100 .2byte 0x100 + 85e: 2e05 .2byte 0x2e05 + 860: 18090203 lb x4,384(x18) + 864: 0100 .2byte 0x100 + 866: 0c05 .2byte 0xc05 + 868: 10090103 lb x2,256(x18) + 86c: 0100 .2byte 0x100 + 86e: 0105 .2byte 0x105 + 870: 08090103 lb x2,128(x18) + 874: 0100 .2byte 0x100 + 876: 2a05 .2byte 0x2a05 + 878: 10090203 lb x4,256(x18) + 87c: 0100 .2byte 0x100 + 87e: 0905 .2byte 0x905 + 880: 10090103 lb x2,256(x18) + 884: 0100 .2byte 0x100 + 886: 0505 .2byte 0x505 + 888: 04090103 lb x2,64(x18) + 88c: 0100 .2byte 0x100 + 88e: 0905 .2byte 0x905 + 890: 04090103 lb x2,64(x18) + 894: 0100 .2byte 0x100 + 896: 1005 .2byte 0x1005 + 898: 0c097f03 .4byte 0xc097f03 + 89c: 0100 .2byte 0x100 + 89e: 1605 .2byte 0x1605 + 8a0: 04090003 lb x0,64(x18) + 8a4: 0100 .2byte 0x100 + 8a6: 1805 .2byte 0x1805 + 8a8: 0c090003 lb x0,192(x18) + 8ac: 0100 .2byte 0x100 + 8ae: 0c05 .2byte 0xc05 + 8b0: 04090303 lb x6,64(x18) + 8b4: 0100 .2byte 0x100 + 8b6: 0105 .2byte 0x105 + 8b8: 04090103 lb x2,64(x18) + 8bc: 0100 .2byte 0x100 + 8be: 1009 .2byte 0x1009 + 8c0: 0000 .2byte 0x0 + 8c2: 0101 .2byte 0x101 + +Disassembly of section .debug_str: + +00000000 <.debug_str>: + 0: 635f 7472 2e30 .byte 0x5f, 0x63, 0x72, 0x74, 0x30, 0x2e + 6: 682f0053 .4byte 0x682f0053 + a: 2f656d6f jal x26,56300 <__global_pointer$+0x45b00> + e: 7375 .2byte 0x7375 + 10: 7265 .2byte 0x7265 + 12: 726f772f .4byte 0x726f772f + 16: 6f682f6b .4byte 0x6f682f6b + 1a: 656d .2byte 0x656d + 1c: 6b726f77 .4byte 0x6b726f77 + 20: 7070632f .4byte 0x7070632f + 24: 4700 .2byte 0x4700 + 26: 554e .2byte 0x554e + 28: 4120 .2byte 0x4120 + 2a: 2e322053 .4byte 0x2e322053 + 2e: 3034 .2byte 0x3034 + 30: 302e .2byte 0x302e + 32: 6c00 .2byte 0x6c00 + 34: 20676e6f jal x28,7623a <__global_pointer$+0x65a3a> + 38: 6f6c .2byte 0x6f6c + 3a: 676e .2byte 0x676e + 3c: 6920 .2byte 0x6920 + 3e: 746e .2byte 0x746e + 40: 7300 .2byte 0x7300 + 42: 7a69 .2byte 0x7a69 + 44: 5f65 .2byte 0x5f65 + 46: 0074 .2byte 0x74 + 48: 6564 .2byte 0x6564 + 4a: 79746c63 bltu x8,x23,7e2 <__DATA_BEGIN__-0xf81e> + 4e: 6570 .2byte 0x6570 + 50: 6e28 .2byte 0x6e28 + 52: 6c75 .2byte 0x6c75 + 54: 706c .2byte 0x706c + 56: 7274 .2byte 0x7274 + 58: 0029 .2byte 0x29 + 5a: 616d .2byte 0x616d + 5c: 6e69 .2byte 0x6e69 + 5e: 6c00 .2byte 0x6c00 + 60: 20676e6f jal x28,76266 <__global_pointer$+0x65a66> + 64: 6f6c .2byte 0x6f6c + 66: 676e .2byte 0x676e + 68: 7520 .2byte 0x7520 + 6a: 736e .2byte 0x736e + 6c: 6769 .2byte 0x6769 + 6e: 656e .2byte 0x656e + 70: 2064 .2byte 0x2064 + 72: 6e69 .2byte 0x6e69 + 74: 0074 .2byte 0x74 + 76: 6574 .2byte 0x6574 + 78: 735f7473 .4byte 0x735f7473 + 7c: 7274 .2byte 0x7274 + 7e: 6e69 .2byte 0x6e69 + 80: 6e750067 jalr x0,1767(x10) + 84: 6e676973 .4byte 0x6e676973 + 88: 6465 .2byte 0x6465 + 8a: 6320 .2byte 0x6320 + 8c: 6168 .2byte 0x6168 + 8e: 0072 .2byte 0x72 + 90: 796d .2byte 0x796d + 92: 735f 7274 656c .byte 0x5f, 0x73, 0x74, 0x72, 0x6c, 0x65 + 98: 006e .2byte 0x6e + 9a: 20554e47 .4byte 0x20554e47 + 9e: 312b2b43 .4byte 0x312b2b43 + a2: 32312037 lui x0,0x32312 + a6: 322e .2byte 0x322e + a8: 302e .2byte 0x302e + aa: 2d20 .2byte 0x2d20 + ac: 616d .2byte 0x616d + ae: 6962 .2byte 0x6962 + b0: 693d .2byte 0x693d + b2: 706c .2byte 0x706c + b4: 2d203233 .4byte 0x2d203233 + b8: 746d .2byte 0x746d + ba: 6e75 .2byte 0x6e75 + bc: 3d65 .2byte 0x3d65 + be: 6f72 .2byte 0x6f72 + c0: 74656b63 bltu x10,x6,816 <__DATA_BEGIN__-0xf7ea> + c4: 2d20 .2byte 0x2d20 + c6: 696d .2byte 0x696d + c8: 732d6173 .4byte 0x732d6173 + cc: 6570 .2byte 0x6570 + ce: 30323d63 .4byte 0x30323d63 + d2: 3931 .2byte 0x3931 + d4: 3231 .2byte 0x3231 + d6: 3331 .2byte 0x3331 + d8: 2d20 .2byte 0x2d20 + da: 616d .2byte 0x616d + dc: 6372 .2byte 0x6372 + de: 3d68 .2byte 0x3d68 + e0: 7672 .2byte 0x7672 + e2: 20693233 .4byte 0x20693233 + e6: 672d .2byte 0x672d + e8: 2d20 .2byte 0x2d20 + ea: 4f2d2067 .4byte 0x4f2d2067 + ee: 2030 .2byte 0x2030 + f0: 662d .2byte 0x662d + f2: 7266 .2byte 0x7266 + f4: 6565 .2byte 0x6565 + f6: 6e617473 .4byte 0x6e617473 + fa: 6964 .2byte 0x6964 + fc: 676e .2byte 0x676e + fe: 2d20 .2byte 0x2d20 + 100: 6e66 .2byte 0x6e66 + 102: 69702d6f jal x26,2f98 <__DATA_BEGIN__-0xd068> + 106: 68730063 beq x6,x7,786 <__DATA_BEGIN__-0xf87a> + 10a: 2074726f jal x4,47b10 <__global_pointer$+0x37310> + 10e: 6e75 .2byte 0x6e75 + 110: 6e676973 .4byte 0x6e676973 + 114: 6465 .2byte 0x6465 + 116: 6920 .2byte 0x6920 + 118: 746e .2byte 0x746e + 11a: 5f00 .2byte 0x5f00 + 11c: 395a .2byte 0x395a + 11e: 796d .2byte 0x796d + 120: 735f 7274 656c .byte 0x5f, 0x73, 0x74, 0x72, 0x6c, 0x65 + 126: 506e .2byte 0x506e + 128: 6c00634b .4byte 0x6c00634b + 12c: 20676e6f jal x28,76332 <__global_pointer$+0x65b32> + 130: 6f64 .2byte 0x6f64 + 132: 6275 .2byte 0x6275 + 134: 656c .2byte 0x656c + 136: 7300 .2byte 0x7300 + 138: 6f68 .2byte 0x6f68 + 13a: 7472 .2byte 0x7472 + 13c: 6920 .2byte 0x6920 + 13e: 746e .2byte 0x746e + 140: 6100 .2byte 0x6100 + 142: 666c .2byte 0x666c + 144: 6261 .2byte 0x6261 + 146: 7465 .2byte 0x7465 + 148: 6c5f 6e65 7467 .byte 0x5f, 0x6c, 0x65, 0x6e, 0x67, 0x74 + 14e: 0068 .2byte 0x68 + 150: 5a5f 3631 6f63 .byte 0x5f, 0x5a, 0x31, 0x36, 0x63, 0x6f + 156: 6e75 .2byte 0x6e75 + 158: 5f74 .2byte 0x5f74 + 15a: 72616863 bltu x2,x6,88a <__DATA_BEGIN__-0xf776> + 15e: 6361 .2byte 0x6361 + 160: 6574 .2byte 0x6574 + 162: 7372 .2byte 0x7372 + 164: 4b50 .2byte 0x4b50 + 166: 5f305363 bge x0,x19,74c <__DATA_BEGIN__-0xf8b4> + 16a: 6850 .2byte 0x6850 + 16c: 6100 .2byte 0x6100 + 16e: 666c .2byte 0x666c + 170: 6261 .2byte 0x6261 + 172: 7465 .2byte 0x7465 + 174: 7500 .2byte 0x7500 + 176: 6e69 .2byte 0x6e69 + 178: 3874 .2byte 0x3874 + 17a: 745f 7700 6e79 .byte 0x5f, 0x74, 0x00, 0x77, 0x79, 0x6e + 180: 6b69 .2byte 0x6b69 + 182: 7300 .2byte 0x7300 + 184: 6f6c .2byte 0x6f6c + 186: 63006f77 .4byte 0x63006f77 + 18a: 746e756f jal x10,e78d0 <__global_pointer$+0xd70d0> + 18e: 635f 6168 6172 .byte 0x5f, 0x63, 0x68, 0x61, 0x72, 0x61 + 194: 72657463 bgeu x10,x6,8bc <__DATA_BEGIN__-0xf744> + 198: 6c7a0073 .4byte 0x6c7a0073 + 19c: 6369 .2byte 0x6369 + 19e: 617a .2byte 0x617a + 1a0: 5f007a63 bgeu x0,x16,794 <__DATA_BEGIN__-0xf86c> + 1a4: 325a .2byte 0x325a + 1a6: 6332 .2byte 0x6332 + 1a8: 746e756f jal x10,e78ee <__global_pointer$+0xd70ee> + 1ac: 635f 6168 6172 .byte 0x5f, 0x63, 0x68, 0x61, 0x72, 0x61 + 1b2: 72657463 bgeu x10,x6,8da <__DATA_BEGIN__-0xf726> + 1b6: 72745373 .4byte 0x72745373 + 1ba: 6375 .2byte 0x6375 + 1bc: 5074 .2byte 0x5074 + 1be: 3431 .2byte 0x3431 + 1c0: 6c5a .2byte 0x6c5a + 1c2: 6369 .2byte 0x6369 + 1c4: 617a .2byte 0x617a + 1c6: 74537a63 bgeu x6,x5,91a <__DATA_BEGIN__-0xf6e6> + 1ca: 7572 .2byte 0x7572 + 1cc: 63007463 bgeu x0,x16,7f4 <__DATA_BEGIN__-0xf80c> + 1d0: 746e756f jal x10,e7916 <__global_pointer$+0xd7116> + 1d4: 635f 6168 6172 .byte 0x5f, 0x63, 0x68, 0x61, 0x72, 0x61 + 1da: 72657463 bgeu x10,x6,902 <__DATA_BEGIN__-0xf6fe> + 1de: 72745373 .4byte 0x72745373 + 1e2: 6375 .2byte 0x6375 + 1e4: 0074 .2byte 0x74 + 1e6: 6e756f63 bltu x10,x7,8e4 <__DATA_BEGIN__-0xf71c> + 1ea: 5f74 .2byte 0x5f74 + 1ec: 72616863 bltu x2,x6,91c <__DATA_BEGIN__-0xf6e4> + 1f0: 6361 .2byte 0x6361 + 1f2: 6574 .2byte 0x6574 + 1f4: 7372 .2byte 0x7372 + 1f6: 75727453 .4byte 0x75727453 + 1fa: 4f4f7463 bgeu x30,x20,6e2 <__DATA_BEGIN__-0xf91e> + 1fe: 0050 .2byte 0x50 + 200: 5a5f 3732 6e69 .byte 0x5f, 0x5a, 0x32, 0x37, 0x69, 0x6e + 206: 7469 .2byte 0x7469 + 208: 6169 .2byte 0x6169 + 20a: 696c .2byte 0x696c + 20c: 657a .2byte 0x657a + 20e: 6c5a .2byte 0x6c5a + 210: 6369 .2byte 0x6369 + 212: 617a .2byte 0x617a + 214: 74537a63 bgeu x6,x5,968 <__DATA_BEGIN__-0xf698> + 218: 7572 .2byte 0x7572 + 21a: 4f4f7463 bgeu x30,x20,702 <__DATA_BEGIN__-0xf8fe> + 21e: 5050 .2byte 0x5050 + 220: 3731 .2byte 0x3731 + 222: 6c5a .2byte 0x6c5a + 224: 6369 .2byte 0x6369 + 226: 617a .2byte 0x617a + 228: 74537a63 bgeu x6,x5,97c <__DATA_BEGIN__-0xf684> + 22c: 7572 .2byte 0x7572 + 22e: 4f4f7463 bgeu x30,x20,716 <__DATA_BEGIN__-0xf8ea> + 232: 5050 .2byte 0x5050 + 234: 3253634b .4byte 0x3253634b + 238: 505f 0068 6e69 .byte 0x5f, 0x50, 0x68, 0x00, 0x69, 0x6e + 23e: 7469 .2byte 0x7469 + 240: 6169 .2byte 0x6169 + 242: 696c .2byte 0x696c + 244: 657a .2byte 0x657a + 246: 6c5a .2byte 0x6c5a + 248: 6369 .2byte 0x6369 + 24a: 617a .2byte 0x617a + 24c: 74537a63 bgeu x6,x5,9a0 <__DATA_BEGIN__-0xf660> + 250: 7572 .2byte 0x7572 + 252: 4f4f7463 bgeu x30,x20,73a <__DATA_BEGIN__-0xf8c6> + 256: 0050 .2byte 0x50 + 258: 6975 .2byte 0x6975 + 25a: 746e .2byte 0x746e + 25c: 6c5f 6165 7473 .byte 0x5f, 0x6c, 0x65, 0x61, 0x73, 0x74 + 262: 3436 .2byte 0x3436 + 264: 745f 7500 6e69 .byte 0x5f, 0x74, 0x00, 0x75, 0x69, 0x6e + 26a: 7074 .2byte 0x7074 + 26c: 7274 .2byte 0x7274 + 26e: 745f 7500 6e69 .byte 0x5f, 0x74, 0x00, 0x75, 0x69, 0x6e + 274: 5f74 .2byte 0x5f74 + 276: 6166 .2byte 0x6166 + 278: 5f387473 .4byte 0x5f387473 + 27c: 0074 .2byte 0x74 + 27e: 6975 .2byte 0x6975 + 280: 746e .2byte 0x746e + 282: 6c5f 6165 7473 .byte 0x5f, 0x6c, 0x65, 0x61, 0x73, 0x74 + 288: 745f3233 .4byte 0x745f3233 + 28c: 6300 .2byte 0x6300 + 28e: 746e756f jal x10,e79d4 <__global_pointer$+0xd71d4> + 292: 72616843 .4byte 0x72616843 + 296: 6361 .2byte 0x6361 + 298: 6574 .2byte 0x6574 + 29a: 7372 .2byte 0x7372 + 29c: 7500 .2byte 0x7500 + 29e: 6e69 .2byte 0x6e69 + 2a0: 3674 .2byte 0x3674 + 2a2: 5f34 .2byte 0x5f34 + 2a4: 0074 .2byte 0x74 + 2a6: 52746567 .4byte 0x52746567 + 2aa: 7365 .2byte 0x7365 + 2ac: 6c75 .2byte 0x6c75 + 2ae: 7374 .2byte 0x7374 + 2b0: 4d00 .2byte 0x4d00 + 2b2: 6679 .2byte 0x6679 + 2b4: 6e75 .2byte 0x6e75 + 2b6: 504f4f63 blt x30,x4,7d4 <__DATA_BEGIN__-0xf82c> + 2ba: 7400 .2byte 0x7400 + 2bc: 6968 .2byte 0x6968 + 2be: 69750073 .4byte 0x69750073 + 2c2: 746e .2byte 0x746e + 2c4: 665f 7361 3374 .byte 0x5f, 0x66, 0x61, 0x73, 0x74, 0x33 + 2ca: 5f32 .2byte 0x5f32 + 2cc: 0074 .2byte 0x74 + 2ce: 6975 .2byte 0x6975 + 2d0: 746e .2byte 0x746e + 2d2: 616d .2byte 0x616d + 2d4: 5f78 .2byte 0x5f78 + 2d6: 0074 .2byte 0x74 + 2d8: 5a5f 4b4e 4d39 .byte 0x5f, 0x5a, 0x4e, 0x4b, 0x39, 0x4d + 2de: 6679 .2byte 0x6679 + 2e0: 6e75 .2byte 0x6e75 + 2e2: 504f4f63 blt x30,x4,800 <__DATA_BEGIN__-0xf800> + 2e6: 3031 .2byte 0x3031 + 2e8: 52746567 .4byte 0x52746567 + 2ec: 7365 .2byte 0x7365 + 2ee: 6c75 .2byte 0x6c75 + 2f0: 7374 .2byte 0x7374 + 2f2: 7645 .2byte 0x7645 + 2f4: 7500 .2byte 0x7500 + 2f6: 6e69 .2byte 0x6e69 + 2f8: 5f74 .2byte 0x5f74 + 2fa: 656c .2byte 0x656c + 2fc: 7361 .2byte 0x7361 + 2fe: 3174 .2byte 0x3174 + 300: 5f36 .2byte 0x5f36 + 302: 0074 .2byte 0x74 + 304: 6975 .2byte 0x6975 + 306: 746e .2byte 0x746e + 308: 6c5f 6165 7473 .byte 0x5f, 0x6c, 0x65, 0x61, 0x73, 0x74 + 30e: 5f38 .2byte 0x5f38 + 310: 0074 .2byte 0x74 + 312: 796d .2byte 0x796d + 314: 6c727453 .4byte 0x6c727453 + 318: 6e65 .2byte 0x6e65 + 31a: 5f00 .2byte 0x5f00 + 31c: 4e5a .2byte 0x4e5a + 31e: 4d39 .2byte 0x4d39 + 320: 6679 .2byte 0x6679 + 322: 6e75 .2byte 0x6e75 + 324: 504f4f63 blt x30,x4,842 <__DATA_BEGIN__-0xf7be> + 328: 50453443 .4byte 0x50453443 + 32c: 3153634b .4byte 0x3153634b + 330: 505f 0068 6975 .byte 0x5f, 0x50, 0x68, 0x00, 0x75, 0x69 + 336: 746e .2byte 0x746e + 338: 665f 7361 3174 .byte 0x5f, 0x66, 0x61, 0x73, 0x74, 0x31 + 33e: 5f36 .2byte 0x5f36 + 340: 0074 .2byte 0x74 + 342: 5a5f 394e 794d .byte 0x5f, 0x5a, 0x4e, 0x39, 0x4d, 0x79 + 348: 7566 .2byte 0x7566 + 34a: 636e .2byte 0x636e + 34c: 38504f4f .4byte 0x38504f4f + 350: 796d .2byte 0x796d + 352: 6c727453 .4byte 0x6c727453 + 356: 6e65 .2byte 0x6e65 + 358: 5045 .2byte 0x5045 + 35a: 7500634b .4byte 0x7500634b + 35e: 6e69 .2byte 0x6e69 + 360: 3174 .2byte 0x3174 + 362: 5f36 .2byte 0x5f36 + 364: 0074 .2byte 0x74 + 366: 6975 .2byte 0x6975 + 368: 746e .2byte 0x746e + 36a: 745f3233 .4byte 0x745f3233 + 36e: 5f00 .2byte 0x5f00 + 370: 4e5a .2byte 0x4e5a + 372: 4d39 .2byte 0x4d39 + 374: 6679 .2byte 0x6679 + 376: 6e75 .2byte 0x6e75 + 378: 504f4f63 blt x30,x4,896 <__DATA_BEGIN__-0xf76a> + 37c: 50453243 .4byte 0x50453243 + 380: 3153634b .4byte 0x3153634b + 384: 505f 0068 6975 .byte 0x5f, 0x50, 0x68, 0x00, 0x75, 0x69 + 38a: 746e .2byte 0x746e + 38c: 665f 7361 3674 .byte 0x5f, 0x66, 0x61, 0x73, 0x74, 0x36 + 392: 5f34 .2byte 0x5f34 + 394: 0074 .2byte 0x74 + 396: 5a5f 394e 794d .byte 0x5f, 0x5a, 0x4e, 0x39, 0x4d, 0x79 + 39c: 7566 .2byte 0x7566 + 39e: 636e .2byte 0x636e + 3a0: 31504f4f .4byte 0x31504f4f + 3a4: 6335 .2byte 0x6335 + 3a6: 746e756f jal x10,e7aec <__global_pointer$+0xd72ec> + 3aa: 72616843 .4byte 0x72616843 + 3ae: 6361 .2byte 0x6361 + 3b0: 6574 .2byte 0x6574 + 3b2: 7372 .2byte 0x7372 + 3b4: 7645 .2byte 0x7645 + ... + +Disassembly of section .debug_line_str: + +00000000 <.debug_line_str>: + 0: 6d6f682f .4byte 0x6d6f682f + 4: 2f65 .2byte 0x2f65 + 6: 7375 .2byte 0x7375 + 8: 7265 .2byte 0x7265 + a: 726f772f .4byte 0x726f772f + e: 6f682f6b .4byte 0x6f682f6b + 12: 656d .2byte 0x656d + 14: 6b726f77 .4byte 0x6b726f77 + 18: 7070632f .4byte 0x7070632f + 1c: 5f00 .2byte 0x5f00 + 1e: 30747263 bgeu x8,x7,322 <__DATA_BEGIN__-0xfcde> + 22: 532e .2byte 0x532e + 24: 5f00 .2byte 0x5f00 + 26: 7672 .2byte 0x7672 + 28: 616d .2byte 0x616d + 2a: 6e69 .2byte 0x6e69 + 2c: 632e .2byte 0x632e + 2e: 7070 .2byte 0x7070 + 30: 2f00 .2byte 0x2f00 + 32: 6f68 .2byte 0x6f68 + 34: 656d .2byte 0x656d + 36: 6573752f .4byte 0x6573752f + 3a: 2f72 .2byte 0x2f72 + 3c: 6972 .2byte 0x6972 + 3e: 2f766373 .4byte 0x2f766373 + 42: 6972 .2byte 0x6972 + 44: 2f766373 .4byte 0x2f766373 + 48: 696c .2byte 0x696c + 4a: 2f62 .2byte 0x2f62 + 4c: 2f636367 .4byte 0x2f636367 + 50: 6972 .2byte 0x6972 + 52: 36766373 .4byte 0x36766373 + 56: 2d34 .2byte 0x2d34 + 58: 6e75 .2byte 0x6e75 + 5a: 776f6e6b .4byte 0x776f6e6b + 5e: 2d6e .2byte 0x2d6e + 60: 6c65 .2byte 0x6c65 + 62: 2f66 .2byte 0x2f66 + 64: 3231 .2byte 0x3231 + 66: 322e .2byte 0x322e + 68: 302e .2byte 0x302e + 6a: 636e692f .4byte 0x636e692f + 6e: 756c .2byte 0x756c + 70: 6564 .2byte 0x6564 + 72: 7300 .2byte 0x7300 + 74: 6474 .2byte 0x6474 + 76: 6564 .2byte 0x6564 + 78: 2e66 .2byte 0x2e66 + 7a: 0068 .2byte 0x68 + 7c: 796d .2byte 0x796d + 7e: 7566 .2byte 0x7566 + 80: 636e .2byte 0x636e + 82: 632e .2byte 0x632e + 84: 7070 .2byte 0x7070 + 86: 7300 .2byte 0x7300 + 88: 6474 .2byte 0x6474 + 8a: 6e69 .2byte 0x6e69 + 8c: 2d74 .2byte 0x2d74 + 8e: 2e636367 .4byte 0x2e636367 + 92: 0068 .2byte 0x68 + 94: 796d .2byte 0x796d + 96: 7566 .2byte 0x7566 + 98: 636e .2byte 0x636e + 9a: 75727453 .4byte 0x75727453 + 9e: 632e7463 bgeu x28,x18,6c6 <__DATA_BEGIN__-0xf93a> + a2: 7070 .2byte 0x7070 + a4: 6d00 .2byte 0x6d00 + a6: 6679 .2byte 0x6679 + a8: 6e75 .2byte 0x6e75 + aa: 72745363 bge x8,x7,7d0 <__DATA_BEGIN__-0xf830> + ae: 6375 .2byte 0x6375 + b0: 2e74 .2byte 0x2e74 + b2: 0068 .2byte 0x68 + b4: 796d .2byte 0x796d + b6: 7566 .2byte 0x7566 + b8: 636e .2byte 0x636e + ba: 75727453 .4byte 0x75727453 + be: 4f4f7463 bgeu x30,x20,5a6 <__DATA_BEGIN__-0xfa5a> + c2: 2e50 .2byte 0x2e50 + c4: 00707063 bgeu x0,x7,c4 <__DATA_BEGIN__-0xff3c> + c8: 796d .2byte 0x796d + ca: 7566 .2byte 0x7566 + cc: 636e .2byte 0x636e + ce: 75727453 .4byte 0x75727453 + d2: 4f4f7463 bgeu x30,x20,5ba <__DATA_BEGIN__-0xfa46> + d6: 2e50 .2byte 0x2e50 + d8: 0068 .2byte 0x68 + da: 796d .2byte 0x796d + dc: 7566 .2byte 0x7566 + de: 636e .2byte 0x636e + e0: 2e504f4f .4byte 0x2e504f4f + e4: 00707063 bgeu x0,x7,e4 <__DATA_BEGIN__-0xff1c> + e8: 6d6f682f .4byte 0x6d6f682f + ec: 2f65 .2byte 0x2f65 + ee: 7375 .2byte 0x7375 + f0: 7265 .2byte 0x7265 + f2: 7369722f .4byte 0x7369722f + f6: 722f7663 bgeu x30,x2,822 <__DATA_BEGIN__-0xf7de> + fa: 7369 .2byte 0x7369 + fc: 722f7663 bgeu x30,x2,828 <__DATA_BEGIN__-0xf7d8> + 100: 7369 .2byte 0x7369 + 102: 34367663 bgeu x12,x3,44e <__DATA_BEGIN__-0xfbb2> + 106: 752d .2byte 0x752d + 108: 6b6e .2byte 0x6b6e + 10a: 6f6e .2byte 0x6f6e + 10c: 652d6e77 .4byte 0x652d6e77 + 110: 666c .2byte 0x666c + 112: 636e692f .4byte 0x636e692f + 116: 756c .2byte 0x756c + 118: 6564 .2byte 0x6564 + 11a: 2b2b632f .4byte 0x2b2b632f + 11e: 2e32312f .4byte 0x2e32312f + 122: 2e32 .2byte 0x2e32 + 124: 0030 .2byte 0x30 + 126: 6d6f682f .4byte 0x6d6f682f + 12a: 2f65 .2byte 0x2f65 + 12c: 7375 .2byte 0x7375 + 12e: 7265 .2byte 0x7265 + 130: 7369722f .4byte 0x7369722f + 134: 722f7663 bgeu x30,x2,860 <__DATA_BEGIN__-0xf7a0> + 138: 7369 .2byte 0x7369 + 13a: 722f7663 bgeu x30,x2,866 <__DATA_BEGIN__-0xf79a> + 13e: 7369 .2byte 0x7369 + 140: 34367663 bgeu x12,x3,48c <__DATA_BEGIN__-0xfb74> + 144: 752d .2byte 0x752d + 146: 6b6e .2byte 0x6b6e + 148: 6f6e .2byte 0x6f6e + 14a: 652d6e77 .4byte 0x652d6e77 + 14e: 666c .2byte 0x666c + 150: 636e692f .4byte 0x636e692f + 154: 756c .2byte 0x756c + 156: 6564 .2byte 0x6564 + 158: 2b2b632f .4byte 0x2b2b632f + 15c: 2e32312f .4byte 0x2e32312f + 160: 2e32 .2byte 0x2e32 + 162: 2f30 .2byte 0x2f30 + 164: 6972 .2byte 0x6972 + 166: 36766373 .4byte 0x36766373 + 16a: 2d34 .2byte 0x2d34 + 16c: 6e75 .2byte 0x6e75 + 16e: 776f6e6b .4byte 0x776f6e6b + 172: 2d6e .2byte 0x2d6e + 174: 6c65 .2byte 0x6c65 + 176: 2f66 .2byte 0x2f66 + 178: 6962 .2byte 0x6962 + 17a: 7374 .2byte 0x7374 + 17c: 6300 .2byte 0x6300 + 17e: 69647473 .4byte 0x69647473 + 182: 746e .2byte 0x746e + 184: 6d00 .2byte 0x6d00 + 186: 6679 .2byte 0x6679 + 188: 6e75 .2byte 0x6e75 + 18a: 504f4f63 blt x30,x4,6a8 <__DATA_BEGIN__-0xf958> + 18e: 682e .2byte 0x682e + 190: 7070 .2byte 0x7070 + 192: 6300 .2byte 0x6300 + 194: 6f632b2b .4byte 0x6f632b2b + 198: 666e .2byte 0x666e + 19a: 6769 .2byte 0x6769 + 19c: 682e .2byte 0x682e + ... diff --git a/cpp/program b/cpp/program new file mode 100755 index 0000000..eca7228 Binary files /dev/null and b/cpp/program differ diff --git a/cpp/tracked_files.txt b/cpp/tracked_files.txt new file mode 100644 index 0000000..fb2f94e --- /dev/null +++ b/cpp/tracked_files.txt @@ -0,0 +1,5 @@ +_crt0.S +main.cpp +myfunc.cpp +myfunc.h +_rvmain.cc diff --git a/cpp/try/3.py b/cpp/try/3.py new file mode 100644 index 0000000..d12e3b0 --- /dev/null +++ b/cpp/try/3.py @@ -0,0 +1,16 @@ +import asyncio +import websockets + +async def consume_ws_latest_records(): + uri = "ws://172.24.0.3:3333/ws_latest_records" + + async with websockets.connect(uri) as websocket: + while True: + message = input("Enter a message to send: ") + await websocket.send(message) + + response = await websocket.recv() + print(f"Received from server: {response}") + +if __name__ == "__main__": + asyncio.get_event_loop().run_until_complete(consume_ws_latest_records()) diff --git a/cpp/try/__os-build b/cpp/try/__os-build new file mode 100644 index 0000000..025913d --- /dev/null +++ b/cpp/try/__os-build @@ -0,0 +1 @@ +g++ -std=c++17 -o websocket-client-sync main.cpp myfunc.cpp -lboost_system -lboost_thread -lboost_coroutine -ljsoncpp diff --git a/cpp/try/__os-run b/cpp/try/__os-run new file mode 100644 index 0000000..b500c13 --- /dev/null +++ b/cpp/try/__os-run @@ -0,0 +1 @@ +./websocket-client-sync ws://localhost:3333/ws diff --git a/cpp/try/main.cpp b/cpp/try/main.cpp new file mode 100644 index 0000000..9f7dea1 --- /dev/null +++ b/cpp/try/main.cpp @@ -0,0 +1,155 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace beast = boost::beast; +namespace websocket = beast::websocket; +namespace net = boost::asio; +using tcp = boost::asio::ip::tcp; + +struct Person { + std::string name; + int age; + long long timestamp; +}; + +Json::Value serializePerson(const Person& person) { + Json::Value jsonPerson; + jsonPerson["name"] = person.name; + jsonPerson["age"] = person.age; + jsonPerson["timestamp"] = static_cast(person.timestamp); + return jsonPerson; +} + +std::tuple parseURI(const std::string& uri) { + std::regex uriRegex(R"(^ws://([^:/]+):(\d+)(/.+)$)"); + std::smatch match; + + if (std::regex_match(uri, match, uriRegex)) { + return std::make_tuple(match[1].str(), match[2].str(), match[3].str()); + } else { + throw std::invalid_argument("Nieprawidłowe URI"); + } +} + +template +T getInput(const std::string& prompt) { + T value; + while (true) { + std::cout << prompt; + std::cin >> value; + + if (std::cin.fail()) { + std::cin.clear(); + std::cin.ignore(std::numeric_limits::max(), '\n'); + std::cerr << "Błąd! Spróbuj ponownie." << std::endl; + } else { + std::cin.ignore(std::numeric_limits::max(), '\n'); + break; + } + } + + return value; +} + +void iterateCharBuffer(const char* charBuffer, std::size_t bufferSize) { + for (std::size_t i = 0; i < bufferSize; ++i) { + std::cout << charBuffer[i]; + } + std::cout << std::endl; + + // Example: Call the function you want to apply to the char buffer +} + +int main(int argc, char** argv) { + try { + if (argc != 2) { + std::cerr << "Sposób użycia: " << argv[0] << " \n"; + return EXIT_FAILURE; + } + + std::string uri = argv[1]; + auto uriParts = parseURI(uri); + std::string host, port, endpoint; + std::tie(host, port, endpoint) = uriParts; + + net::io_context io_context; + + websocket::stream ws(io_context); + tcp::resolver resolver(io_context); + auto endpoints = resolver.resolve(host, port); + net::connect(ws.next_layer(), endpoints); + + ws.handshake(host, endpoint); + + while (true) { + std::cout << "Menu:\n"; + std::cout << "1. Dodaj rekord\n"; + std::cout << "2. Zwróć ostatnie rekordy\n"; + std::cout << "3. Wyjście\n"; + + int choice = getInput("Wybierz opcję: "); + + if (choice == 1) { + + std::string name = getInput("Podaj imię: "); + int age = getInput("Podaj wiek: "); + + Person personToSend{name, age, std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()).count()}; + + Json::Value jsonPerson = serializePerson(personToSend); + + ws.write(net::buffer(Json::writeString(Json::StreamWriterBuilder(), jsonPerson))); + + } else if (choice == 2) { + + ws.write(net::buffer("get_latest_records")); + + beast::flat_buffer buffer; + ws.read(buffer); + + std::cout << "Otrzymano: " << beast::make_printable(buffer.data()) << std::endl; + + const char* bufferData = boost::asio::buffer_cast(buffer.data()); + std::size_t bufferSize = boost::asio::buffer_size(buffer.data()); + + char* charBuffer = new char[bufferSize + 1]; + std::memcpy(charBuffer, bufferData, bufferSize); + charBuffer[bufferSize] = '\0'; + + iterateCharBuffer(charBuffer, bufferSize); + + delete[] charBuffer; + + buffer.consume(buffer.size()); + + } else if (choice == 3) { + + std::cout << "Zamykanie programu...\n"; + break; + + } else { + + std::cout << "Nieprawidłowy wybór. Spróbuj ponownie.\n"; + + } + + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + } + + } catch (std::exception const& e) { + std::cerr << "Błąd: " << e.what() << std::endl; + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/cpp/try/uri.cpp b/cpp/try/uri.cpp new file mode 100644 index 0000000..cff7149 --- /dev/null +++ b/cpp/try/uri.cpp @@ -0,0 +1,53 @@ +#include +#include +#include + +#include +#include +#include + +namespace beast = boost::beast; +namespace websocket = beast::websocket; +namespace net = boost::asio; +using tcp = boost::asio::ip::tcp; + +std::tuple parseURI(const std::string& uri) { + std::regex uriRegex(R"(^ws://([^:/]+):(\d+)(/.+)$)"); + std::smatch match; + + if (std::regex_match(uri, match, uriRegex)) { + return std::make_tuple(match[1].str(), match[2].str(), match[3].str()); + } else { + throw std::invalid_argument("Nieprawidłowe URI"); + } +} + +int main() { + std::string uri = "ws://172.24.0.3:3333"; + std::cout << "Dostarczone URI: " << uri << std::endl; + + try { + auto uriParts = parseURI(uri); + std::string host, port, endpoint; + std::tie(host, port, endpoint) = uriParts; + + net::io_context io_context; + + // Utwórz obiekt WebSocket + websocket::stream ws(io_context); + + // Połącz z serwerem WebSocket + tcp::resolver resolver(io_context); + auto endpoints = resolver.resolve(host, port); + net::connect(ws.next_layer(), endpoints); + + // Wysyłanie danych na serwer WebSocket + ws.handshake(host, endpoint); + + } catch (const std::exception& e) { + std::cerr << "Błąd: " << e.what() << std::endl; + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/igit-borys.py b/igit-borys.py new file mode 100644 index 0000000..8c226d8 --- /dev/null +++ b/igit-borys.py @@ -0,0 +1,111 @@ +import argparse +import json +import sys +import subprocess +import os +from datetime import datetime + +DEFAULT_CONFIG = { + "user": "borysr", + "email": "borysr@gmail.com", + "remotes": [{ + "name": "r", # Zaktualizowano z "default" na "mpabi" + "protocol": "http", + "domain": "qstack.pl", + "port": "3000", + "token_name": "t", + "token": "8ee3f1b7980197aeceadee3cf4d980f817d44f06", + "group": "1i-2023", + "project": "homework" + }] +} + +def load_or_create_config(config_file, args): + config_exists = os.path.exists(config_file) and os.stat(config_file).st_size != 0 + if config_exists: + with open(config_file, 'r') as file: + config = json.load(file) + else: + config = DEFAULT_CONFIG.copy() + + # Znajdź istniejące zdalne repozytorium o podanej nazwie + remote = next((remote for remote in config['remotes'] if remote['name'] == args.remote), None) + + # Jeśli istnieje zdalne repozytorium i podano argumenty związane z konfiguracją zdalnego repozytorium + if remote: + for field in ['protocol', 'domain', 'port', 'token_name', 'token', 'group', 'project']: + # Aktualizuj tylko, jeśli argument został jawnie podany + if getattr(args, field, None) is not None: + remote[field] = getattr(args, field) + + # Jeśli zdalne repozytorium nie istnieje, ale podano nazwę, tworzymy nowe zdalne repozytorium + elif args.remote: + new_remote = {'name': args.remote} + for field in ['protocol', 'domain', 'port', 'token_name', 'token', 'group', 'project']: + new_remote[field] = getattr(args, field, DEFAULT_CONFIG['remotes'][0].get(field, '')) + if new_remote[field] == None: + new_remote[field] = DEFAULT_CONFIG['remotes'][0].get(field, '') + config['remotes'].append(new_remote) + + # Aktualizuj informacje o użytkowniku i email, tylko jeśli zostały podane + if getattr(args, 'user', None): + config['user'] = args.user + if getattr(args, 'email_domain', None): + config['email'] = f"{args.user}@{args.email_domain}" + + # Zapisz zmodyfikowaną konfigurację + with open(config_file, 'w') as file: + json.dump(config, file, indent=4) + + return config + + +def init_git_repo(config): + user_name = config['user'] + user_email = config['email'] + branch_name = f"{user_name}-{datetime.now().strftime('%Y-%m-%d')}" + + if subprocess.run(["git", "rev-parse", "--git-dir"], stderr=subprocess.DEVNULL).returncode != 0: + subprocess.run(["git", "init"]) + subprocess.run(["git", "config", "user.name", user_name]) + subprocess.run(["git", "config", "user.email", user_email]) + subprocess.run(["git", "checkout", "-b", branch_name]) + print("Git repository initialized.") + else: + print("Already inside a Git repository. Skipping initialization.") + + remotesFromList = str(subprocess.run(["git", "remote", "-v"], capture_output=True).stdout) + remotesFromList = remotesFromList.replace('b\'', "").replace('\'', "").split('\\n') + for rm in remotesFromList: + name = rm.split("\\t")[0] + subprocess.run(["git", "remote", "remove", name], stderr=subprocess.DEVNULL) + + for remote in config['remotes']: + remote_url = f"{remote['protocol']}://{remote['token_name']}:{remote['token']}@{remote['domain']}:{remote['port']}/{remote['group']}/{remote['project']}" + # Usunięcie i ponowne dodanie zdalnego repozytorium, jeśli jest zaktualizowane + #subprocess.run(["git", "remote", "remove", remote['name']], stderr=subprocess.DEVNULL) + subprocess.run(["git", "remote", "add", remote['name'], remote_url]) + print(f"Remote '{remote['name']}' added or updated.") + +def main(): + parser = argparse.ArgumentParser(description="Git repository initializer with custom configuration.") + parser.add_argument("--user", help="User name") + parser.add_argument("--email_domain", help="Email domain") + parser.add_argument("--config", help="Path to the JSON config file", default="conf.json") + parser.add_argument("--remote", help="Name of the remote to add or update") + parser.add_argument("--protocol", help="Remote protocol") + parser.add_argument("--domain", help="Remote domain") + parser.add_argument("--port", help="Remote port") + parser.add_argument("--token_name", help="Remote token name") + parser.add_argument("--token", help="Remote token") + parser.add_argument("--group", help="Group name") + parser.add_argument("--project", help="Project name") + + args = parser.parse_args() + + config = load_or_create_config(args.config, args) + init_git_repo(config) + print("Git repository initialized and configured based on the provided configuration.") + +if __name__ == "__main__": + main()