Similarity

000885f0
000885f0runtime.usleep.abi0: ; void runtime.usleep(void)
000885f0str x30, [sp-48]!
000885f4stur x29, [sp-8]
000885f8sub x29, sp, 8
000885fcldr w3, [sp+56]
00088600mov x5, x3
00088604movz w4, 16960
00088608movk w4, 0xf0000
0008860cudiv x3, x3, x4
00088610str x3, [sp+8]
00088614madd x4, x4, x3, xzr
00088618sub x5, x5, x4
0008861cmovz w4, 1000
00088620madd x5, x5, x4, xzr
00088624str x5, [sp+16]
00088628add x0, sp, 8
0008862cmov x1, xzr
00088630movz x8, 101
00088634svc 0
00088638add x29, sp, 40
0008863cadd sp, sp, 48
00088640ret x30
00088644udf 0
00088648udf 0
0008864cudf 0
000885f0

00088650
00088650runtime.gettid.abi0: ; void runtime.gettid(void)
00088650movz x8, 178
00088654svc 0
00088658str w0, [sp+8]
0008865cret x30
00088650

00088660
00088660runtime.raise.abi0: ; void runtime.raise(void)
00088660movz x8, 172
00088664svc 0
00088668sbfm x19, x0, 0, 31
0008866cmovz x8, 178
00088670svc 0
00088674sbfm x1, x0, 0, 31
00088678sbfm x0, x19, 0, 31
0008867cldrsw x2, [sp+8]
00088680movz x8, 131
00088684svc 0
00088688ret x30
0008868cudf 0
00088660

00088690
00088690runtime.raiseproc.abi0: ; void runtime.raiseproc(void)
00088690movz x8, 172
00088694svc 0
00088698sbfm x0, x0, 0, 31
0008869cldrsw x1, [sp+8]
000886a0movz x8, 129
000886a4svc 0
000886a8ret x30
000886acudf 0
00088690

000886b0
000886b0runtime.getpid.abi0: ; void runtime.getpid(void)
000886b0movz x8, 172
000886b4svc 0
000886b8str x0, [sp+8]
000886bcret x30
000886b0

000886c0
000886c0runtime.tgkill.abi0: ; void runtime.tgkill(void)
000886c0ldr x0, [sp+8]
000886c4ldr x1, [sp+16]
000886c8ldr x2, [sp+24]
000886ccmovz x8, 131
000886d0svc 0
000886d4ret x30
000886d8udf 0
000886dcudf 0
000886c0

000886e0
000886e0runtime.timer_create.abi0: ; void runtime.timer_create(void)
000886e0ldrsw x0, [sp+8]
000886e4ldr x1, [sp+16]
000886e8ldr x2, [sp+24]
000886ecmovz x8, 107
000886f0svc 0
000886f4str w0, [sp+32]
000886f8ret x30
000886fcudf 0
000886e0

00088700
00088700runtime.timer_settime.abi0: ; void runtime.timer_settime(void)
00088700ldrsw x0, [sp+8]
00088704ldrsw x1, [sp+12]
00088708ldr x2, [sp+16]
0008870cldr x3, [sp+24]
00088710movz x8, 110
00088714svc 0
00088718str w0, [sp+32]
0008871cret x30
00088700

00088720
00088720runtime.timer_delete.abi0: ; void runtime.timer_delete(void)
00088720ldrsw x0, [sp+8]
00088724movz x8, 111
00088728svc 0
0008872cstr w0, [sp+16]
00088730ret x30
00088734udf 0
00088738udf 0
0008873cudf 0
00088720

00088740
00088740runtime.mincore.abi0: ; void runtime.mincore(void)
00088740ldr x0, [sp+8]
00088744ldr x1, [sp+16]
00088748ldr x2, [sp+24]
0008874cmovz x8, 232
00088750svc 0
00088754str w0, [sp+32]
00088758ret x30
0008875cudf 0
00088740

00088760
00088760runtime.walltime.abi0: ; void runtime.walltime(void)
00088760str x30, [sp-48]!
00088764stur x29, [sp-8]
00088768sub x29, sp, 8
0008876cadd x20, sp, 0
00088770add x1, sp, 0
00088774ldr x21, [x28+48]
00088778ldr x2, [x21+888]
0008877cldr x3, [x21+880]
00088780str x2, [sp+8]
00088784str x3, [sp+16]
00088788add x2, sp, 48
0008878cstr x30, [x21+888]
00088790str x2, [x21+880]
00088794ldr x0, [x21+192]
00088798subs xzr, x0, x28
0008879cb.ne 0x887a8
000887a0ldr x3, [x21]
000887a4ldr x1, [x3+56]
000887a8
000887a8loc_887a8:
000887a8sub x1, x1, 16
000887acand x1, x1, -16
000887b0add sp, x1, 0
000887b4mov w0, wzr
000887b8adrp x27, 0x9c3000
000887bcldr x2, [x27+2416]
000887c0cbz x2, 0x887fc
000887c4adrp x27, 0x9c3000
000887c8ldrb w22, [x27+1585]
000887cccbnz x22, 0x887f4
000887d0ldr x22, [x21+80]
000887d4cbz x22, 0x887f4
000887d8subs xzr, x22, x28
000887dcb.eq 0x887f4
000887e0ldr x22, [x22]
000887e4str x28, [x22]
000887e8blr x2
000887ecstr xzr, [x22]
000887f0b 0x88804
000887f4
000887f4loc_887f4:
000887f4blr x2
000887f8b 0x88804
000887fc
000887fcloc_887fc:
000887fcmovz x8, 113
00088800svc 0
00088804
00088804loc_88804:
00088804ldr x3, [sp]
00088808ldr x5, [sp+8]
0008880cadd sp, x20, 0
00088810ldr x1, [sp+16]
00088814str x1, [x21+880]
00088818ldr x1, [sp+8]
0008881cstr x1, [x21+888]
00088820str x3, [sp+56]
00088824str w5, [sp+64]
00088828ldur x29, [sp-8]
0008882cldr x30, [sp], 48
00088830ret x30
00088834udf 0
00088838udf 0
0008883cudf 0
00088760

00088840
00088840runtime.nanotime1.abi0: ; void runtime.nanotime1(void)
00088840str x30, [sp-48]!
00088844stur x29, [sp-8]
00088848sub x29, sp, 8
0008884cadd x20, sp, 0
00088850add x1, sp, 0
00088854ldr x21, [x28+48]
00088858ldr x2, [x21+888]
0008885cldr x3, [x21+880]
00088860str x2, [sp+8]
00088864str x3, [sp+16]
00088868add x2, sp, 48
0008886cstr x30, [x21+888]
00088870str x2, [x21+880]
00088874ldr x0, [x21+192]
00088878subs xzr, x0, x28
0008887cb.ne 0x88888
00088880ldr x3, [x21]
00088884ldr x1, [x3+56]
00088888
00088888loc_88888:
00088888sub x1, x1, 32
0008888cand x1, x1, -16
00088890add sp, x1, 0
00088894orr w0, wzr, 1
00088898adrp x27, 0x9c3000
0008889cldr x2, [x27+2416]
000888a0cbz x2, 0x888dc
000888a4adrp x27, 0x9c3000
000888a8ldrb w22, [x27+1585]
000888accbnz x22, 0x888d4
000888b0ldr x22, [x21+80]
000888b4cbz x22, 0x888d4
000888b8subs xzr, x22, x28
000888bcb.eq 0x888d4
000888c0ldr x22, [x22]
000888c4str x28, [x22]
000888c8blr x2
000888ccstr xzr, [x22]
000888d0b 0x888e4
000888d4
000888d4loc_888d4:
000888d4blr x2
000888d8b 0x888e4
000888dc
000888dcloc_888dc:
000888dcmovz x8, 113
000888e0svc 0
000888e4
000888e4loc_888e4:
000888e4ldr x3, [sp]
000888e8ldr x5, [sp+8]
000888ecadd sp, x20, 0
000888f0ldr x1, [sp+16]
000888f4str x1, [x21+880]
000888f8ldr x1, [sp+8]
000888fcstr x1, [x21+888]
00088900movz x4, 51712
00088904movk x4, 0x3b9a0000
00088908madd x3, x3, x4, xzr
0008890cadd x3, x3, x5
00088910str x3, [sp+56]
00088914ldur x29, [sp-8]
00088918ldr x30, [sp], 48
0008891cret x30
00088840

00088920
00088920runtime.rtsigprocmask.abi0: ; void runtime.rtsigprocmask(void)
00088920ldrsw x0, [sp+8]
00088924ldr x1, [sp+16]
00088928ldr x2, [sp+24]
0008892cldrsw x3, [sp+32]
00088930movz x8, 135
00088934svc 0
00088938adds xzr, x0, 4095
0008893cb.lo 0x88948
00088940mov x0, xzr
00088944str x0, [x0]
00088948
00088948loc_88948:
00088948ret x30
0008894cudf 0
00088920

00088950
00088950runtime.rt_sigaction.abi0: ; void runtime.rt_sigaction(void)
00088950ldr x0, [sp+8]
00088954ldr x1, [sp+16]
00088958ldr x2, [sp+24]
0008895cldr x3, [sp+32]
00088960movz x8, 134
00088964svc 0
00088968str w0, [sp+40]
0008896cret x30
00088950

00088970
00088970runtime.callCgoSigaction.abi0: ; void runtime.callCgoSigaction(void)
00088970str x30, [sp-16]!
00088974stur x29, [sp-8]
00088978sub x29, sp, 8
0008897cldr x0, [sp+24]
00088980ldr x1, [sp+32]
00088984ldr x2, [sp+40]
00088988adrp x27, 0x999000
0008898cldr x3, [x27+944]
00088990sub sp, sp, 16
00088994blr x3
00088998add sp, sp, 16
0008899cstr w0, [sp+48]
000889a0ldur x29, [sp-8]
000889a4ldr x30, [sp], 16
000889a8ret x30
000889acudf 0
00088970

000889b0
000889b0runtime.sigfwd.abi0: ; void runtime.sigfwd(void)
000889b0str x30, [sp-16]!
000889b4stur x29, [sp-8]
000889b8sub x29, sp, 8
000889bcldrsw x0, [sp+32]
000889c0ldr x1, [sp+40]
000889c4ldr x2, [sp+48]
000889c8ldr x11, [sp+24]
000889ccblr x11
000889d0ldur x29, [sp-8]
000889d4ldr x30, [sp], 16
000889d8ret x30
000889dcudf 0
000889b0

000889e0
000889e0runtime.sigtramp.abi0: ; void runtime.sigtramp(void)
000889e0str x30, [sp-192]!
000889e4stur x29, [sp-8]
000889e8sub x29, sp, 8
000889ecstp x19, x20, [sp+32]
000889f0stp x21, x22, [sp+48]
000889f4stp x23, x24, [sp+64]
000889f8stp x25, x26, [sp+80]
000889fcstp x27, x28, [sp+96]
00088a00stp d8, d9, [sp+112]
00088a04stp d10, d11, [sp+128]
00088a08stp d12, d13, [sp+144]
00088a0cstp d14, d15, [sp+160]
00088a10str w0, [sp+8]
00088a14adrp x27, 0x9c3000
00088a18ldrb w0, [x27+1585]
00088a1ccbz x0, 0x88a24
00088a20bl runtime.load_g.abi0
00088a24
00088a24loc_88a24:
00088a24ldrsw x0, [sp+8]
00088a28adrp x3, 0xfffffffffffdc000
00088a2cadd x3, x3, 1232
00088a30blr x3
00088a34ldp x19, x20, [sp+32]
00088a38ldp x21, x22, [sp+48]
00088a3cldp x23, x24, [sp+64]
00088a40ldp x25, x26, [sp+80]
00088a44ldp x27, x28, [sp+96]
00088a48ldp d8, d9, [sp+112]
00088a4cldp d10, d11, [sp+128]
00088a50ldp d12, d13, [sp+144]
00088a54ldp d14, d15, [sp+160]
00088a58ldur x29, [sp-8]
00088a5cldr x30, [sp], 192
00088a60ret x30
00088a64udf 0
00088a68udf 0
00088a6cudf 0
000889e0

00088a70
00088a70runtime.cgoSigtramp.abi0: ; void runtime.cgoSigtramp(void)
00088a70mov x10, x30
00088a74mov x11, x27
00088a78mov x12, x28
00088a7cadrp x27, 0x998000
00088a80ldr x6, [x27+3112]
00088a84cbz x6, 0x88afc
00088a88adrp x27, 0x999000
00088a8cldr x7, [x27+888]
00088a90cbz x7, 0x88afc
00088a94mov x8, x0
00088a98bl runtime.load_g.abi0
00088a9cmov x0, x8
00088aa0cbz x28, 0x88b0c
00088aa4ldr x6, [x28+48]
00088aa8cbz x6, 0x88afc
00088aacldrsw x7, [x6+304]
00088ab0cbz w7, 0x88afc
00088ab4ldr x8, [x6+192]
00088ab8cbz x8, 0x88afc
00088abcldr x7, [x8+112]
00088ac0cbz x7, 0x88afc
00088ac4ldr x4, [x6+312]
00088ac8cbz x4, 0x88afc
00088accldrsw x8, [x6+308]
00088ad0cbnz w8, 0x88afc
00088ad4adrp x27, 0x998000
00088ad8ldr x3, [x27+3112]
00088adcadrp x5, 0
00088ae0add x5, x5, 2528
00088ae4adrp x27, 0x999000
00088ae8ldr x13, [x27+888]
00088aecmov x30, x10
00088af0mov x27, x11
00088af4mov x28, x12
00088af8br x13
00088afc
00088afcloc_88afc:
00088afcmov x30, x10
00088b00mov x27, x11
00088b04mov x28, x12
00088b08b 0x889e0
00088b0c
00088b0cloc_88b0c:
00088b0csubs wzr, w0, 27
00088b10b.ne 0x88afc
00088b14orr w7, wzr, 1
00088b18adrp x8, 0x9c3000
00088b1cadd x8, x8, 1664
00088b20
00088b20loc_88b20:
00088b20ldaxr w9, [x8]
00088b24cbnz w9, 0x88afc
00088b28stlxr w9, w7, [x8]
00088b2ccbnz x9, 0x88b20
00088b30adrp x27, 0x998000
00088b34ldr x3, [x27+3112]
00088b38adrp x4, 0x9c4000
00088b3cadd x4, x4, 480
00088b40adrp x5, 0
00088b44add x5, x5, 1216
00088b48adrp x27, 0x999000
00088b4cldr x13, [x27+888]
00088b50mov x30, x10
00088b54mov x27, x11
00088b58mov x28, x12
00088b5cbr x13
00088a70

00088b60
00088b60runtime.sysMmap.abi0: ; void runtime.sysMmap(void)
00088b60ldr x0, [sp+8]
00088b64ldr x1, [sp+16]
00088b68ldrsw x2, [sp+24]
00088b6cldrsw x3, [sp+28]
00088b70ldrsw x4, [sp+32]
00088b74ldrsw x5, [sp+36]
00088b78movz x8, 222
00088b7csvc 0
00088b80adds xzr, x0, 4095
00088b84b.lo 0x88b98
00088b88sub x0, xzr, x0
00088b8cstr xzr, [sp+40]
00088b90str x0, [sp+48]
00088b94ret x30
00088b98
00088b98loc_88b98:
00088b98str x0, [sp+40]
00088b9cstr xzr, [sp+48]
00088ba0ret x30
00088ba4udf 0
00088ba8udf 0
00088bacudf 0
00088b60

00088bb0
00088bb0runtime.callCgoMmap.abi0: ; void runtime.callCgoMmap(void)
00088bb0str x30, [sp-16]!
00088bb4stur x29, [sp-8]
00088bb8sub x29, sp, 8
00088bbcldr x0, [sp+24]
00088bc0ldr x1, [sp+32]
00088bc4ldrsw x2, [sp+40]
00088bc8ldrsw x3, [sp+44]
00088bccldrsw x4, [sp+48]
00088bd0ldrsw x5, [sp+52]
00088bd4adrp x27, 0x999000
00088bd8ldr x9, [x27+928]
00088bdcsub sp, sp, 16
00088be0blr x9
00088be4add sp, sp, 16
00088be8str x0, [sp+56]
00088becldur x29, [sp-8]
00088bf0ldr x30, [sp], 16
00088bf4ret x30
00088bf8udf 0
00088bfcudf 0
00088bb0

00088c00
00088c00runtime.sysMunmap.abi0: ; void runtime.sysMunmap(void)
00088c00ldr x0, [sp+8]
00088c04ldr x1, [sp+16]
00088c08movz x8, 215
00088c0csvc 0
00088c10adds xzr, x0, 4095
00088c14b.lo 0x88c1c
00088c18str x0, [x0+240]
00088c1c
00088c1cloc_88c1c:
00088c1cret x30
00088c00

00088c20
00088c20runtime.callCgoMunmap.abi0: ; void runtime.callCgoMunmap(void)
00088c20str x30, [sp-16]!
00088c24stur x29, [sp-8]
00088c28sub x29, sp, 8
00088c2cldr x0, [sp+24]
00088c30ldr x1, [sp+32]
00088c34adrp x27, 0x999000
00088c38ldr x9, [x27+936]
00088c3csub sp, sp, 16
00088c40blr x9
00088c44add sp, sp, 16
00088c48ldur x29, [sp-8]
00088c4cldr x30, [sp], 16
00088c50ret x30
00088c54udf 0
00088c58udf 0
00088c5cudf 0
00088c20

00088c60
00088c60runtime.madvise.abi0: ; void runtime.madvise(void)
00088c60ldr x0, [sp+8]
00088c64ldr x1, [sp+16]
00088c68ldrsw x2, [sp+24]
00088c6cmovz x8, 233
00088c70svc 0
00088c74str w0, [sp+32]
00088c78ret x30
00088c7cudf 0
00088c60

00088c80
00088c80runtime.futex.abi0: ; void runtime.futex(void)
00088c80ldr x0, [sp+8]
00088c84ldrsw x1, [sp+16]
00088c88ldrsw x2, [sp+20]
00088c8cldr x3, [sp+24]
00088c90ldr x4, [sp+32]
00088c94ldrsw x5, [sp+40]
00088c98movz x8, 98
00088c9csvc 0
00088ca0str w0, [sp+48]
00088ca4ret x30
00088ca8udf 0
00088cacudf 0
00088c80

00088cb0
00088cb0runtime.clone.abi0: ; void runtime.clone(void)
00088cb0ldrsw x0, [sp+8]
00088cb4ldr x1, [sp+16]
00088cb8ldr x10, [sp+24]
00088cbcldr x11, [sp+32]
00088cc0ldr x12, [sp+40]
00088cc4stur x10, [x1-8]
00088cc8stur x11, [x1-16]
00088cccstur x12, [x1-24]
00088cd0movz x10, 1234
00088cd4stur x10, [x1-32]
00088cd8movz x8, 220
00088cdcsvc 0
00088ce0subs xzr, x0, xzr
00088ce4b.eq 0x88cf0
00088ce8str w0, [sp+48]
00088cecret x30
00088cf0
00088cf0loc_88cf0:
00088cf0ldur x10, [sp-32]
00088cf4movz x0, 1234
00088cf8subs xzr, x10, x0
00088cfcb.eq 0x88d08
00088d00mov x0, xzr
00088d04str x0, [x0]
00088d08
00088d08loc_88d08:
00088d08movz x8, 178
00088d0csvc 0
00088d10ldur x12, [sp-24]
00088d14ldur x11, [sp-16]
00088d18ldur x10, [sp-8]
00088d1csubs xzr, x10, 0
00088d20b.eq 0x88d38
00088d24subs xzr, x11, 0
00088d28b.eq 0x88d38
00088d2cstr x0, [x10+72]
00088d30str x10, [x11+48]
00088d34mov x28, x11
00088d38
00088d38loc_88d38:
00088d38mov x0, x12
00088d3cblr x0
00088d40movz w0, 111
00088d44
00088d44loc_88d44:
00088d44movz x8, 93
00088d48svc 0
00088d4cb 0x88d44
00088cb0

00088d50
00088d50runtime.sigaltstack.abi0: ; void runtime.sigaltstack(void)
00088d50ldr x0, [sp+8]
00088d54ldr x1, [sp+16]
00088d58movz x8, 132
00088d5csvc 0
00088d60adds xzr, x0, 4095
00088d64b.lo 0x88d70
00088d68mov x0, xzr
00088d6cstr x0, [x0]
00088d70
00088d70loc_88d70:
00088d70ret x30
00088d74udf 0
00088d78udf 0
00088d7cudf 0
00088d50

00088d80
00088d80runtime.osyield.abi0:
00088d80orr x8, xzr, 124
00088d84svc 0
00088d88ret x30
00088d8cudf 0
00088d80

00088d90
00088d90runtime.sched_getaffinity.abi0: ; void runtime.sched_getaffinity(void)
00088d90ldr x0, [sp+8]
00088d94ldr x1, [sp+16]
00088d98ldr x2, [sp+24]
00088d9cmovz x8, 123
00088da0svc 0
00088da4str w0, [sp+32]
00088da8ret x30
00088dacudf 0
00088d90

00088db0
00088db0runtime.vgetrandom1: ; void runtime.vgetrandom1(void)
00088db0str x30, [sp-32]!
00088db4stur x29, [sp-8]
00088db8sub x29, sp, 8
00088dbcadd x20, sp, 0
00088dc0adrp x27, 0x9c3000
00088dc4ldr x8, [x27+2104]
00088dc8ldr x21, [x28+48]
00088dccldr x9, [x21+888]
00088dd0str x9, [sp+8]
00088dd4ldr x9, [x21+880]
00088dd8str x9, [sp+16]
00088ddcstr x30, [x21+888]
00088de0add x9, sp, 32
00088de4str x9, [x21+880]
00088de8add x9, sp, 0
00088decand x9, x9, -16
00088df0add sp, x9, 0
00088df4adrp x27, 0x9c3000
00088df8ldrb w9, [x27+1585]
00088dfccbnz x9, 0x88e24
00088e00ldr x9, [x21+80]
00088e04cbz x9, 0x88e24
00088e08subs xzr, x9, x28
00088e0cb.eq 0x88e24
00088e10ldr x22, [x9]
00088e14str x28, [x22]
00088e18blr x8
00088e1cstr xzr, [x22]
00088e20b 0x88e28
00088e24
00088e24loc_88e24:
00088e24blr x8
00088e28
00088e28loc_88e28:
00088e28add sp, x20, 0
00088e2cldr x1, [sp+16]
00088e30str x1, [x21+880]
00088e34ldr x1, [sp+8]
00088e38str x1, [x21+888]
00088e3cldur x29, [sp-8]
00088e40ldr x30, [sp], 32
00088e44ret x30
00088e48udf 0
00088e4cudf 0
00088db0

00088e50
00088e50runtime.load_g.abi0: ; void runtime.load_g(void)
00088e50adrp x27, 0x9c3000
00088e54ldrsb x0, [x27+1585]
00088e58cbz x0, 0x88e68
00088e5cmrs x0
00088e60movz x27, 16
00088e64ldr x28, [x0+x27]
00088e68
00088e68loc_88e68:
00088e68ret x30
00088e6cudf 0
00088e50

00088e70
00088e70runtime.save_g.abi0: ; void runtime.save_g(void)
00088e70adrp x27, 0x9c3000
00088e74ldrsb x0, [x27+1585]
00088e78cbz x0, 0x88e88
00088e7cmrs x0
00088e80movz x27, 16
00088e84str x28, [x0+x27]
00088e88
00088e88loc_88e88:
00088e88ret x30
00088e8cudf 0
00088e70

00088e90
00088e90internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.heap bool; runtime.rangefunc bool; runtime.sp uintptr; runtime.pc uintptr; runtime.fn func(); runtime.link *runtime._defer; runtime.head *internal/runtime/atomic.Pointer[runtime._defer] }]).CompareAndSwap: ; void internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.heap bool; runtime.rangefunc bool; runtime.sp uintptr; runtime.pc uintptr; runtime.fn func(); runtime.link *runtime._defer; runtime.head *internal/runtime/atomic.Pointer[runtime._defer] }]).CompareAndSwap(internal/runtime/atomic.Pointer[go.shape.struct { runtime.heap bool; runtime.rangefunc bool; runtime.sp uintptr; runtime.pc uintptr; runtime.fn func(); runtime.link *runtime._defer; runtime.head *internal/runtime/atomic.Pointer[runtime._defer] }] * p, int64_t old, int64_t new)
00088e90ldr x16, [x28+16]
00088e94subs xzr, sp, x16
00088e98b.ls 0x88ec4
00088e9cstr x30, [sp-48]!
00088ea0stur x29, [sp-8]
00088ea4sub x29, sp, 8
00088ea8ldrsb x27, [x0]
00088eacmov x1, x2
00088eb0mov x2, x3
00088eb4bl internal/runtime/atomic.(*UnsafePointer).CompareAndSwap
00088eb8ldur x29, [sp-8]
00088ebcldr x30, [sp], 48
00088ec0ret x30
00088ec4
00088ec4loc_88ec4:
00088ec4stp x0, x1, [sp+8]
00088ec8stp x2, x3, [sp+24]
00088eccmov x3, x30
00088ed0bl runtime.morestack_noctxt.abi0
00088ed4ldp x0, x1, [sp+8]
00088ed8ldp x2, x3, [sp+24]
00088edcb 0x88e90
00088e90

00088ee0
00088ee0internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.heap bool; runtime.rangefunc bool; runtime.sp uintptr; runtime.pc uintptr; runtime.fn func(); runtime.link *runtime._defer; runtime.head *internal/runtime/atomic.Pointer[runtime._defer] }]).Load: ; void internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.heap bool; runtime.rangefunc bool; runtime.sp uintptr; runtime.pc uintptr; runtime.fn func(); runtime.link *runtime._defer; runtime.head *internal/runtime/atomic.Pointer[runtime._defer] }]).Load(internal/runtime/atomic.Pointer[go.shape.struct { runtime.heap bool; runtime.rangefunc bool; runtime.sp uintptr; runtime.pc uintptr; runtime.fn func(); runtime.link *runtime._defer; runtime.head *internal/runtime/atomic.Pointer[runtime._defer] }] * p)
00088ee0str x30, [sp-32]!
00088ee4stur x29, [sp-8]
00088ee8sub x29, sp, 8
00088eecldrsb x27, [x0]
00088ef0bl internal/runtime/atomic.(*UnsafePointer).Load
00088ef4ldur x29, [sp-8]
00088ef8ldr x30, [sp], 32
00088efcret x30
00088ee0

00088f00
00088f00internal/runtime/atomic.(*Pointer[go.shape.func()]).CompareAndSwap: ; void internal/runtime/atomic.(*Pointer[go.shape.func()]).CompareAndSwap(internal/runtime/atomic.Pointer[go.shape.func()] * p, int64_t old, int64_t new)
00088f00ldr x16, [x28+16]
00088f04subs xzr, sp, x16
00088f08b.ls 0x88f34
00088f0cstr x30, [sp-48]!
00088f10stur x29, [sp-8]
00088f14sub x29, sp, 8
00088f18ldrsb x27, [x0]
00088f1cmov x1, x2
00088f20mov x2, x3
00088f24bl internal/runtime/atomic.(*UnsafePointer).CompareAndSwap
00088f28ldur x29, [sp-8]
00088f2cldr x30, [sp], 48
00088f30ret x30
00088f34
00088f34loc_88f34:
00088f34stp x0, x1, [sp+8]
00088f38stp x2, x3, [sp+24]
00088f3cmov x3, x30
00088f40bl runtime.morestack_noctxt.abi0
00088f44ldp x0, x1, [sp+8]
00088f48ldp x2, x3, [sp+24]
00088f4cb 0x88f00
00088f00

00088f50
00088f50internal/runtime/atomic.(*Pointer[go.shape.func()]).Load: ; void internal/runtime/atomic.(*Pointer[go.shape.func()]).Load(internal/runtime/atomic.Pointer[go.shape.func()] * p)
00088f50str x30, [sp-32]!
00088f54stur x29, [sp-8]
00088f58sub x29, sp, 8
00088f5cldrsb x27, [x0]
00088f60bl internal/runtime/atomic.(*UnsafePointer).Load
00088f64ldur x29, [sp-8]
00088f68ldr x30, [sp], 32
00088f6cret x30
00088f50

00088f70
00088f70internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.lfnode; runtime.popped internal/runtime/atomic.Uint32; runtime.spans [512]runtime.atomicMSpanPointer }]).StoreNoWB: ; void internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.lfnode; runtime.popped internal/runtime/atomic.Uint32; runtime.spans [512]runtime.atomicMSpanPointer }]).StoreNoWB(internal/runtime/atomic.Pointer[go.shape.struct { runtime.lfnode; runtime.popped internal/runtime/atomic.Uint32; runtime.spans [512]runtime.atomicMSpanPointer }] * p, int64_t value)
00088f70str x30, [sp-32]!
00088f74stur x29, [sp-8]
00088f78sub x29, sp, 8
00088f7cldrsb x27, [x0]
00088f80mov x1, x2
00088f84bl internal/runtime/atomic.(*UnsafePointer).StoreNoWB
00088f88ldur x29, [sp-8]
00088f8cldr x30, [sp], 32
00088f90ret x30
00088f94udf 0
00088f98udf 0
00088f9cudf 0
00088f70

00088fa0
00088fa0internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.lfnode; runtime.popped internal/runtime/atomic.Uint32; runtime.spans [512]runtime.atomicMSpanPointer }]).Load: ; void internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.lfnode; runtime.popped internal/runtime/atomic.Uint32; runtime.spans [512]runtime.atomicMSpanPointer }]).Load(internal/runtime/atomic.Pointer[go.shape.struct { runtime.lfnode; runtime.popped internal/runtime/atomic.Uint32; runtime.spans [512]runtime.atomicMSpanPointer }] * p)
00088fa0str x30, [sp-32]!
00088fa4stur x29, [sp-8]
00088fa8sub x29, sp, 8
00088facldrsb x27, [x0]
00088fb0bl internal/runtime/atomic.(*UnsafePointer).Load
00088fb4ldur x29, [sp-8]
00088fb8ldr x30, [sp], 32
00088fbcret x30
00088fa0

00088fc0
00088fc0internal/runtime/atomic.(*Pointer[go.shape.a0c91c71fd368b5d30f8a04d1e4f14a4186fd3423a1957aa58b1e03c3b3735dd]).CompareAndSwapNoWB: ; void internal/runtime/atomic.(*Pointer[go.shape.a0c91c71fd368b5d30f8a04d1e4f14a4186fd3423a1957aa58b1e03c3b3735dd]).CompareAndSwapNoWB(internal/runtime/atomic.Pointer_a0c91c71fd368b5d30f8a04d1e4f14a4186fd3423a1957aa58b1e03c3b3735dd * p, int64_t old, int64_t new)
00088fc0str x30, [sp-48]!
00088fc4stur x29, [sp-8]
00088fc8sub x29, sp, 8
00088fccldrsb x27, [x0]
00088fd0mov x1, x2
00088fd4mov x2, x3
00088fd8bl internal/runtime/atomic.(*UnsafePointer).CompareAndSwapNoWB
00088fdcldur x29, [sp-8]
00088fe0ldr x30, [sp], 48
00088fe4ret x30
00088fe8udf 0
00088fecudf 0
00088fc0

00088ff0
00088ff0internal/runtime/atomic.(*Pointer[go.shape.a0c91c71fd368b5d30f8a04d1e4f14a4186fd3423a1957aa58b1e03c3b3735dd]).Load: ; void internal/runtime/atomic.(*Pointer[go.shape.a0c91c71fd368b5d30f8a04d1e4f14a4186fd3423a1957aa58b1e03c3b3735dd]).Load(internal/runtime/atomic.Pointer_a0c91c71fd368b5d30f8a04d1e4f14a4186fd3423a1957aa58b1e03c3b3735dd * p)
00088ff0str x30, [sp-32]!
00088ff4stur x29, [sp-8]
00088ff8sub x29, sp, 8
00088ffcldrsb x27, [x0]
00089000bl internal/runtime/atomic.(*UnsafePointer).Load
00089004ldur x29, [sp-8]
00089008ldr x30, [sp], 32
0008900cret x30
00088ff0

00089010
00089010internal/runtime/atomic.(*Pointer[go.shape.func(string, string)]).Store: ; void internal/runtime/atomic.(*Pointer[go.shape.func(string, string)]).Store(internal/runtime/atomic.Pointer[go.shape.func(string, string)] * p, int64_t value)
00089010str x30, [sp-32]!
00089014stur x29, [sp-8]
00089018sub x29, sp, 8
0008901cldrsb x27, [x0]
00089020mov x1, x2
00089024bl internal/runtime/atomic.(*UnsafePointer).Store
00089028ldur x29, [sp-8]
0008902cldr x30, [sp], 32
00089030ret x30
00089034udf 0
00089038udf 0
0008903cudf 0
00089010

00089040
00089040internal/runtime/atomic.(*Pointer[go.shape.func(string, string)]).Load: ; void internal/runtime/atomic.(*Pointer[go.shape.func(string, string)]).Load(internal/runtime/atomic.Pointer[go.shape.func(string, string)] * p)
00089040str x30, [sp-32]!
00089044stur x29, [sp-8]
00089048sub x29, sp, 8
0008904cldrsb x27, [x0]
00089050bl internal/runtime/atomic.(*UnsafePointer).Load
00089054ldur x29, [sp-8]
00089058ldr x30, [sp], 32
0008905cret x30
00089040

00089060
00089060internal/runtime/atomic.(*Pointer[go.shape.string]).Store: ; void internal/runtime/atomic.(*Pointer[go.shape.string]).Store(internal/runtime/atomic.Pointer_string * p, uint64_t * dict, struct go_shape_string value)
00089060str x30, [sp-32]!
00089064stur x29, [sp-8]
00089068sub x29, sp, 8
0008906cldrsb x27, [x0]
00089070mov x1, x2
00089074bl internal/runtime/atomic.(*UnsafePointer).Store
00089078ldur x29, [sp-8]
0008907cldr x30, [sp], 32
00089080ret x30
00089084udf 0
00089088udf 0
0008908cudf 0
00089060

00089090
00089090internal/runtime/atomic.(*Pointer[go.shape.string]).Load: ; void internal/runtime/atomic.(*Pointer[go.shape.string]).Load(internal/runtime/atomic.Pointer_string * p, uint64_t * dict)
00089090str x30, [sp-32]!
00089094stur x29, [sp-8]
00089098sub x29, sp, 8
0008909cldrsb x27, [x0]
000890a0bl internal/runtime/atomic.(*UnsafePointer).Load
000890a4ldur x29, [sp-8]
000890a8ldr x30, [sp], 32
000890acret x30
00089090

000890b0
000890b0internal/runtime/atomic.(*Pointer[go.shape.func(string) func()]).Store: ; void internal/runtime/atomic.(*Pointer[go.shape.func(string) func()]).Store(internal/runtime/atomic.Pointer[go.shape.func(string) func()] * p, int64_t value)
000890b0str x30, [sp-32]!
000890b4stur x29, [sp-8]
000890b8sub x29, sp, 8
000890bcldrsb x27, [x0]
000890c0mov x1, x2
000890c4bl internal/runtime/atomic.(*UnsafePointer).Store
000890c8ldur x29, [sp-8]
000890ccldr x30, [sp], 32
000890d0ret x30
000890d4udf 0
000890d8udf 0
000890dcudf 0
000890b0

000890e0
000890e0internal/runtime/atomic.(*Pointer[go.shape.func(string) func()]).Load: ; void internal/runtime/atomic.(*Pointer[go.shape.func(string) func()]).Load(internal/runtime/atomic.Pointer[go.shape.func(string) func()] * p)
000890e0str x30, [sp-32]!
000890e4stur x29, [sp-8]
000890e8sub x29, sp, 8
000890ecldrsb x27, [x0]
000890f0bl internal/runtime/atomic.(*UnsafePointer).Load
000890f4ldur x29, [sp-8]
000890f8ldr x30, [sp], 32
000890fcret x30
000890e0

00089100
00089100internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.r runtime.profAtomic; runtime.w runtime.profAtomic; runtime.overflow internal/runtime/atomic.Uint64; runtime.overflowTime internal/runtime/atomic.Uint64; runtime.eof internal/runtime/atomic.Uint32; runtime.hdrsize uintptr; runtime.data []uint64; runtime.tags []unsafe.Pointer; runtime.rNext runtime.profIndex; runtime.overflowBuf []uint64; runtime.wait runtime.note }]).Store: ; void internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.r runtime.profAtomic; runtime.w runtime.profAtomic; runtime.overflow internal/runtime/atomic.Uint64; runtime.overflowTime internal/runtime/atomic.Uint64; runtime.eof internal/runtime/atomic.Uint32; runtime.hdrsize uintptr; runtime.data []uint64; runtime.tags []unsafe.Pointer; runtime.rNext runtime.profIndex; runtime.overflowBuf []uint64; runtime.wait runtime.note }]).Store(internal/runtime/atomic.Pointer[go.shape.struct { runtime.r runtime.profAtomic; runtime.w runtime.profAtomic; runtime.overflow internal/runtime/atomic.Uint64; runtime.overflowTime internal/runtime/atomic.Uint64; runtime.eof internal/runtime/atomic.Uint32; runtime.hdrsize uintptr; runtime.data []uint64; runtime.tags []unsafe.Pointer; runtime.rNext runtime.profIndex; runtime.overflowBuf []uint64; runtime.wait runtime.note }] * p, int64_t value)
00089100str x30, [sp-32]!
00089104stur x29, [sp-8]
00089108sub x29, sp, 8
0008910cldrsb x27, [x0]
00089110mov x1, x2
00089114bl internal/runtime/atomic.(*UnsafePointer).Store
00089118ldur x29, [sp-8]
0008911cldr x30, [sp], 32
00089120ret x30
00089124udf 0
00089128udf 0
0008912cudf 0
00089100

00089130
00089130internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.r runtime.profAtomic; runtime.w runtime.profAtomic; runtime.overflow internal/runtime/atomic.Uint64; runtime.overflowTime internal/runtime/atomic.Uint64; runtime.eof internal/runtime/atomic.Uint32; runtime.hdrsize uintptr; runtime.data []uint64; runtime.tags []unsafe.Pointer; runtime.rNext runtime.profIndex; runtime.overflowBuf []uint64; runtime.wait runtime.note }]).Load: ; void internal/runtime/atomic.(*Pointer[go.shape.struct { runtime.r runtime.profAtomic; runtime.w runtime.profAtomic; runtime.overflow internal/runtime/atomic.Uint64; runtime.overflowTime internal/runtime/atomic.Uint64; runtime.eof internal/runtime/atomic.Uint32; runtime.hdrsize uintptr; runtime.data []uint64; runtime.tags []unsafe.Pointer; runtime.rNext runtime.profIndex; runtime.overflowBuf []uint64; runtime.wait runtime.note }]).Load(internal/runtime/atomic.Pointer[go.shape.struct { runtime.r runtime.profAtomic; runtime.w runtime.profAtomic; runtime.overflow internal/runtime/atomic.Uint64; runtime.overflowTime internal/runtime/atomic.Uint64; runtime.eof internal/runtime/atomic.Uint32; runtime.hdrsize uintptr; runtime.data []uint64; runtime.tags []unsafe.Pointer; runtime.rNext runtime.profIndex; runtime.overflowBuf []uint64; runtime.wait runtime.note }] * p)
00089130str x30, [sp-32]!
00089134stur x29, [sp-8]
00089138sub x29, sp, 8
0008913cldrsb x27, [x0]
00089140bl internal/runtime/atomic.(*UnsafePointer).Load
00089144ldur x29, [sp-8]
00089148ldr x30, [sp], 32
0008914cret x30
00089130

00089150
00089150runtime.(*lockRank).String: ; void runtime.(*lockRank).String(runtime.lockRank * rank)
00089150ldr x16, [x28+16]
00089154subs xzr, sp, x16
00089158b.ls 0x89190
0008915cstr x30, [sp-32]!
00089160stur x29, [sp-8]
00089164sub x29, sp, 8
00089168ldr x16, [x28+32]
0008916ccbnz x16, 0x891a4
00089170
00089170loc_89170:
00089170cbz x0, 0x89188
00089174ldr x0, [x0]
00089178bl runtime.lockRank.String
0008917cldur x29, [sp-8]
00089180ldr x30, [sp], 32
00089184ret x30
00089188
00089188loc_89188:
00089188bl runtime.panicwrap
0008918chint
00089190
00089190loc_89190:
00089190str x0, [sp+8]
00089194mov x3, x30
00089198bl runtime.morestack_noctxt.abi0
0008919cldr x0, [sp+8]
000891a0b 0x89150
000891a4
000891a4loc_891a4:
000891a4ldr x17, [x16]
000891a8add x20, sp, 40
000891acsubs xzr, x20, x17
000891b0b.ne 0x89170
000891b4add x20, sp, 8
000891b8str x20, [x16]
000891bcb 0x89170
00089150

000891c0
000891c0runtime.(*plainError).Error: ; void runtime.(*plainError).Error(struct runtime.plainError * e)
000891c0ldr x16, [x28+16]
000891c4subs xzr, sp, x16
000891c8b.ls 0x89208
000891ccstr x30, [sp-32]!
000891d0stur x29, [sp-8]
000891d4sub x29, sp, 8
000891d8ldr x16, [x28+32]
000891dccbnz x16, 0x8921c
000891e0
000891e0loc_891e0:
000891e0cbz x0, 0x89200
000891e4ldr x2, [x0]
000891e8ldr x1, [x0+8]
000891ecmov x0, x2
000891f0bl runtime.plainError.Error
000891f4ldur x29, [sp-8]
000891f8ldr x30, [sp], 32
000891fcret x30
00089200
00089200loc_89200:
00089200bl runtime.panicwrap
00089204hint
00089208
00089208loc_89208:
00089208str x0, [sp+8]
0008920cmov x3, x30
00089210bl runtime.morestack_noctxt.abi0
00089214ldr x0, [sp+8]
00089218b 0x891c0
0008921c
0008921cloc_8921c:
0008921cldr x17, [x16]
00089220add x20, sp, 40
00089224subs xzr, x20, x17
00089228b.ne 0x891e0
0008922cadd x20, sp, 8
00089230str x20, [x16]
00089234b 0x891e0
00089238udf 0
0008923cudf 0
000891c0

00089240
00089240runtime.(*waitReason).String: ; void runtime.(*waitReason).String(runtime.waitReason * w)
00089240ldr x16, [x28+16]
00089244subs xzr, sp, x16
00089248b.ls 0x89280
0008924cstr x30, [sp-32]!
00089250stur x29, [sp-8]
00089254sub x29, sp, 8
00089258ldr x16, [x28+32]
0008925ccbnz x16, 0x89294
00089260
00089260loc_89260:
00089260cbz x0, 0x89278
00089264ldrb w0, [x0]
00089268bl runtime.waitReason.String
0008926cldur x29, [sp-8]
00089270ldr x30, [sp], 32
00089274ret x30
00089278
00089278loc_89278:
00089278bl runtime.panicwrap
0008927chint
00089280
00089280loc_89280:
00089280str x0, [sp+8]
00089284mov x3, x30
00089288bl runtime.morestack_noctxt.abi0
0008928cldr x0, [sp+8]
00089290b 0x89240
00089294
00089294loc_89294:
00089294ldr x17, [x16]
00089298add x20, sp, 40
0008929csubs xzr, x20, x17
000892a0b.ne 0x89260
000892a4add x20, sp, 8
000892a8str x20, [x16]
000892acb 0x89260
00089240

000892b0
000892b0runtime.(*errorString).Error: ; void runtime.(*errorString).Error(struct runtime.errorString * e)
000892b0ldr x16, [x28+16]
000892b4subs xzr, sp, x16
000892b8b.ls 0x892f8
000892bcstr x30, [sp-32]!
000892c0stur x29, [sp-8]
000892c4sub x29, sp, 8
000892c8ldr x16, [x28+32]
000892cccbnz x16, 0x8930c
000892d0
000892d0loc_892d0:
000892d0cbz x0, 0x892f0
000892d4ldr x2, [x0]
000892d8ldr x1, [x0+8]
000892dcmov x0, x2
000892e0bl runtime.errorString.Error
000892e4ldur x29, [sp-8]
000892e8ldr x30, [sp], 32
000892ecret x30
000892f0
000892f0loc_892f0:
000892f0bl runtime.panicwrap
000892f4hint
000892f8
000892f8loc_892f8:
000892f8str x0, [sp+8]
000892fcmov x3, x30
00089300bl runtime.morestack_noctxt.abi0
00089304ldr x0, [sp+8]
00089308b 0x892b0
0008930c
0008930cloc_8930c:
0008930cldr x17, [x16]
00089310add x20, sp, 40
00089314subs xzr, x20, x17
00089318b.ne 0x892d0
0008931cadd x20, sp, 8
00089320str x20, [x16]
00089324b 0x892d0
00089328udf 0
0008932cudf 0
000892b0

00089330
00089330runtime.(*errorAddressString).Error: ; void runtime.(*errorAddressString).Error(runtime.errorAddressString * e)
00089330ldr x16, [x28+16]
00089334subs xzr, sp, x16
00089338b.ls 0x8937c
0008933cstr x30, [sp-48]!
00089340stur x29, [sp-8]
00089344sub x29, sp, 8
00089348ldr x16, [x28+32]
0008934ccbnz x16, 0x89390
00089350
00089350loc_89350:
00089350cbz x0, 0x89374
00089354ldr x3, [x0]
00089358ldr x1, [x0+8]
0008935cldr x2, [x0+16]
00089360mov x0, x3
00089364bl runtime.errorAddressString.Error
00089368ldur x29, [sp-8]
0008936cldr x30, [sp], 48
00089370ret x30
00089374
00089374loc_89374:
00089374bl runtime.panicwrap
00089378hint
0008937c
0008937cloc_8937c:
0008937cstr x0, [sp+8]
00089380mov x3, x30
00089384bl runtime.morestack_noctxt.abi0
00089388ldr x0, [sp+8]
0008938cb 0x89330
00089390
00089390loc_89390:
00089390ldr x17, [x16]
00089394add x20, sp, 56
00089398subs xzr, x20, x17
0008939cb.ne 0x89350
000893a0add x20, sp, 8
000893a4str x20, [x16]
000893a8b 0x89350
000893acudf 0
00089330

000893b0
000893b0runtime.(*boundsError).Error: ; void runtime.(*boundsError).Error(runtime.boundsError * e)
000893b0ldr x16, [x28+16]
000893b4subs xzr, sp, x16
000893b8b.ls 0x89400
000893bcstr x30, [sp-48]!
000893c0stur x29, [sp-8]
000893c4sub x29, sp, 8
000893c8ldr x16, [x28+32]
000893cccbnz x16, 0x89414
000893d0
000893d0loc_893d0:
000893d0cbz x0, 0x893f8
000893d4ldr x4, [x0]
000893d8ldr x1, [x0+8]
000893dcldrb w2, [x0+16]
000893e0ldrb w3, [x0+17]
000893e4mov x0, x4
000893e8bl runtime.boundsError.Error
000893ecldur x29, [sp-8]
000893f0ldr x30, [sp], 48
000893f4ret x30
000893f8
000893f8loc_893f8:
000893f8bl runtime.panicwrap
000893fchint
00089400
00089400loc_89400:
00089400str x0, [sp+8]
00089404mov x3, x30
00089408bl runtime.morestack_noctxt.abi0
0008940cldr x0, [sp+8]
00089410b 0x893b0
00089414
00089414loc_89414:
00089414ldr x17, [x16]
00089418add x20, sp, 56
0008941csubs xzr, x20, x17
00089420b.ne 0x893d0
00089424add x20, sp, 8
00089428str x20, [x16]
0008942cb 0x893d0
000893b0

00089430
00089430runtime.metricReader.compute-fm: ; void runtime.metricReader.compute-fm(runtime.statAggregate * p0, runtime.metricValue * out)
00089430ldr x16, [x28+16]
00089434subs xzr, sp, x16
00089438b.ls 0x89470
0008943cstr x30, [sp-48]!
00089440stur x29, [sp-8]
00089444sub x29, sp, 8
00089448ldr x16, [x28+32]
0008944ccbnz x16, 0x89484
00089450
00089450loc_89450:
00089450ldr x3, [x26+8]
00089454mov x2, x1
00089458mov x1, x0
0008945cmov x0, x3
00089460bl runtime.metricReader.compute
00089464ldur x29, [sp-8]
00089468ldr x30, [sp], 48
0008946cret x30
00089470
00089470loc_89470:
00089470stp x0, x1, [sp+8]
00089474mov x3, x30
00089478bl runtime.morestack.abi0
0008947cldp x0, x1, [sp+8]
00089480b 0x89430
00089484
00089484loc_89484:
00089484ldr x17, [x16]
00089488add x20, sp, 56
0008948csubs xzr, x20, x17
00089490b.ne 0x89450
00089494add x20, sp, 8
00089498str x20, [x16]
0008949cb 0x89450
00089430

000894a0
000894a0runtime.(*itabTableType).add-fm: ; void runtime.(*itabTableType).add-fm(internal/abi.ITab * m)
000894a0ldr x16, [x28+16]
000894a4subs xzr, sp, x16
000894a8b.ls 0x894dc
000894acstr x30, [sp-32]!
000894b0stur x29, [sp-8]
000894b4sub x29, sp, 8
000894b8ldr x16, [x28+32]
000894bccbnz x16, 0x894f0
000894c0
000894c0loc_894c0:
000894c0ldr x2, [x26+8]
000894c4mov x1, x0
000894c8mov x0, x2
000894ccbl runtime.(*itabTableType).add
000894d0ldur x29, [sp-8]
000894d4ldr x30, [sp], 32
000894d8ret x30
000894dc
000894dcloc_894dc:
000894dcstr x0, [sp+8]
000894e0mov x3, x30
000894e4bl runtime.morestack.abi0
000894e8ldr x0, [sp+8]
000894ecb 0x894a0
000894f0
000894f0loc_894f0:
000894f0ldr x17, [x16]
000894f4add x20, sp, 40
000894f8subs xzr, x20, x17
000894fcb.ne 0x894c0
00089500add x20, sp, 8
00089504str x20, [x16]
00089508b 0x894c0
0008950cudf 0
000894a0

00089510
00089510runtime.debugCallCheck.abi0:
00089510str x30, [sp-32]!
00089514stur x29, [sp-8]
00089518sub x29, sp, 8
0008951cldr x0, [sp+40]
00089520bl runtime.debugCallCheck
00089524str x0, [sp+48]
00089528str x1, [sp+56]
0008952cldur x29, [sp-8]
00089530ldr x30, [sp], 32
00089534ret x30
00089538udf 0
0008953cudf 0
00089510

00089540
00089540runtime.debugCallWrap.abi0:
00089540str x30, [sp-32]!
00089544stur x29, [sp-8]
00089548sub x29, sp, 8
0008954cldr x0, [sp+40]
00089550bl runtime.debugCallWrap
00089554ldur x29, [sp-8]
00089558ldr x30, [sp], 32
0008955cret x30
00089540

00089560
00089560runtime.reflectcallmove.abi0:
00089560str x30, [sp-64]!
00089564stur x29, [sp-8]
00089568sub x29, sp, 8
0008956cldr x0, [sp+72]
00089570ldr x1, [sp+80]
00089574ldr x2, [sp+88]
00089578ldr x3, [sp+96]
0008957cldr x4, [sp+104]
00089580bl runtime.reflectcallmove
00089584ldur x29, [sp-8]
00089588ldr x30, [sp], 64
0008958cret x30
00089560

00089590
00089590runtime.wbBufFlush.abi0:
00089590b 0x48360
00089594udf 0
00089598udf 0
0008959cudf 0
00089590

000895a0
000895a0runtime.osinit.abi0:
000895a0b 0x4a4d0
000895a4udf 0
000895a8udf 0
000895acudf 0
000895a0

000895b0
000895b0runtime.osyield: ; void runtime.osyield(void)
000895b0b 0x88d80
000895b4udf 0
000895b8udf 0
000895bcudf 0
000895b0

000895c0
000895c0runtime.asyncPreempt2.abi0:
000895c0b 0x4ec80
000895c4udf 0
000895c8udf 0
000895ccudf 0
000895c0

000895d0
000895d0runtime.badmcall.abi0:
000895d0str x30, [sp-32]!
000895d4stur x29, [sp-8]
000895d8sub x29, sp, 8
000895dcldr x0, [sp+40]
000895e0bl runtime.badmcall
000895e4ldur x29, [sp-8]
000895e8ldr x30, [sp], 32
000895ecret x30
000895d0

000895f0
000895f0runtime.badmcall2.abi0:
000895f0str x30, [sp-32]!
000895f4stur x29, [sp-8]
000895f8sub x29, sp, 8
000895fcldr x0, [sp+40]
00089600bl runtime.badmcall2
00089604ldur x29, [sp-8]
00089608ldr x30, [sp], 32
0008960cret x30
000895f0

00089610
00089610runtime.badreflectcall.abi0:
00089610b 0x50b00
00089614udf 0
00089618udf 0
0008961cudf 0
00089610

00089620
00089620runtime.badmorestackg0.abi0:
00089620b 0x50b40
00089624udf 0
00089628udf 0
0008962cudf 0
00089620

00089630
00089630runtime.badmorestackgsignal.abi0:
00089630b 0x50c50
00089634udf 0
00089638udf 0
0008963cudf 0
00089630

00089640
00089640runtime.schedinit.abi0:
00089640b 0x51220
00089644udf 0
00089648udf 0
0008964cudf 0
00089640

00089650
00089650runtime.mstart0.abi0:
00089650b 0x52f50
00089654udf 0
00089658udf 0
0008965cudf 0
00089650

00089660
00089660runtime.goexit1.abi0:
00089660b 0x570b0
00089664udf 0
00089668udf 0
0008966cudf 0
00089660

00089670
00089670runtime.newproc.abi0:
00089670str x30, [sp-32]!
00089674stur x29, [sp-8]
00089678sub x29, sp, 8
0008967cldr x0, [sp+40]
00089680bl runtime.newproc
00089684ldur x29, [sp-8]
00089688ldr x30, [sp], 32
0008968cret x30
00089670

00089690
00089690runtime.args.abi0:
00089690str x30, [sp-32]!
00089694stur x29, [sp-8]
00089698sub x29, sp, 8
0008969cldrsw x0, [sp+40]
000896a0ldr x1, [sp+48]
000896a4bl runtime.args
000896a8ldur x29, [sp-8]
000896acldr x30, [sp], 32
000896b0ret x30
000896b4udf 0
000896b8udf 0
000896bcudf 0
00089690

000896c0
000896c0runtime.check.abi0:
000896c0b 0x5f7a0
000896c4udf 0
000896c8udf 0
000896ccudf 0
000896c0

000896d0
000896d0runtime.newstack.abi0:
000896d0b 0x67b90
000896d4udf 0
000896d8udf 0
000896dcudf 0
000896d0

000896e0
000896e0runtime.morestackc.abi0:
000896e0b 0x82d20
000896e4udf 0
000896e8udf 0
000896ecudf 0
000896e0

000896f0
000896f0runtime.badsystemstack.abi0:
000896f0b 0x6a7f0
000896f4udf 0
000896f8udf 0
000896fcudf 0
000896f0

00089700
00089700runtime.reflectcall: ; void runtime.reflectcall(internal/abi.Type * stackArgsType, void * fn, void * stackArgs, uint32 stackArgsSize, uint32 stackRetOffset, uint32 frameSize, internal/abi.RegArgs * regArgs)
00089700str x30, [sp-64]!
00089704stur x29, [sp-8]
00089708sub x29, sp, 8
0008970cldr x16, [x28+32]
00089710cbnz x16, 0x89740
00089714
00089714loc_89714:
00089714str x0, [sp+8]
00089718str x1, [sp+16]
0008971cstr x2, [sp+24]
00089720str w3, [sp+32]
00089724str w4, [sp+36]
00089728str w5, [sp+40]
0008972cstr x6, [sp+48]
00089730bl runtime.reflectcall.abi0
00089734ldur x29, [sp-8]
00089738ldr x30, [sp], 64
0008973cret x30
00089740
00089740loc_89740:
00089740ldr x17, [x16]
00089744add x20, sp, 72
00089748subs xzr, x20, x17
0008974cb.ne 0x89714
00089750add x20, sp, 8
00089754str x20, [x16]
00089758b 0x89714
0008975cudf 0
00089700

00089760
00089760runtime.asmcgocall: ; void runtime.asmcgocall(void * fn, void * arg)
00089760str x30, [sp-48]!
00089764stur x29, [sp-8]
00089768sub x29, sp, 8
0008976cstr x0, [sp+8]
00089770str x1, [sp+16]
00089774bl runtime.asmcgocall.abi0
00089778ldrsw x0, [sp+24]
0008977cldur x29, [sp-8]
00089780ldr x30, [sp], 48
00089784ret x30
00089788udf 0
0008978cudf 0
00089760

00089790
00089790type:.eq.runtime.Frame: ; void type:.eq.runtime.Frame(runtime.Frame * p, runtime.Frame * q)
00089790ldr x16, [x28+16]
00089794subs xzr, sp, x16
00089798b.ls 0x89848
0008979cstr x30, [sp-48]!
000897a0stur x29, [sp-8]
000897a4sub x29, sp, 8
000897a8ldr x3, [x1]
000897acldr x4, [x0]
000897b0subs xzr, x3, x4
000897b4b.ne 0x89838
000897b8ldr x3, [x0+8]
000897bcldr x4, [x1+8]
000897c0subs xzr, x4, x3
000897c4b.ne 0x89838
000897c8ldr x2, [x0+24]
000897ccldr x3, [x1+24]
000897d0subs xzr, x2, x3
000897d4b.ne 0x89838
000897d8ldr x3, [x1+40]
000897dcldr x4, [x0+40]
000897e0subs xzr, x4, x3
000897e4b.ne 0x89838
000897e8str x0, [sp+56]
000897ecstr x1, [sp+64]
000897f0ldr x1, [x1+16]
000897f4ldr x0, [x0+16]
000897f8bl runtime.memequal
000897fctbz w0, 0, 0x89838
00089800ldr x3, [sp+64]
00089804ldr x1, [x3+32]
00089808ldr x3, [sp+56]
0008980cldr x0, [x3+32]
00089810ldr x2, [x3+40]
00089814bl runtime.memequal
00089818tbz w0, 0, 0x89838
0008981cldr x3, [sp+56]
00089820add x0, x3, 48
00089824ldr x3, [sp+64]
00089828add x1, x3, 48
0008982cmovz x2, 40
00089830bl runtime.memequal
00089834b 0x8983c
00089838
00089838loc_89838:
00089838mov x0, xzr
0008983c
0008983cloc_8983c:
0008983cldur x29, [sp-8]
00089840ldr x30, [sp], 48
00089844ret x30
00089848
00089848loc_89848:
00089848stp x0, x1, [sp+8]
0008984cmov x3, x30
00089850bl runtime.morestack_noctxt.abi0
00089854ldp x0, x1, [sp+8]
00089858b 0x89790
0008985cudf 0
00089790

00089860
00089860type:.eq.runtime.modulehash: ; void type:.eq.runtime.modulehash(runtime.modulehash * p, runtime.modulehash * q)
00089860ldr x16, [x28+16]
00089864subs xzr, sp, x16
00089868b.ls 0x898ec
0008986cstr x30, [sp-48]!
00089870stur x29, [sp-8]
00089874sub x29, sp, 8
00089878ldr x3, [x1+8]
0008987cldr x2, [x0+8]
00089880subs xzr, x2, x3
00089884b.ne 0x898dc
00089888ldr x3, [x1+24]
0008988cldr x4, [x0+24]
00089890subs xzr, x4, x3
00089894b.ne 0x898dc
00089898ldr x3, [x0+32]
0008989cldr x4, [x1+32]
000898a0subs xzr, x4, x3
000898a4b.ne 0x898dc
000898a8str x0, [sp+56]
000898acstr x1, [sp+64]
000898b0ldr x1, [x1]
000898b4ldr x0, [x0]
000898b8bl runtime.memequal
000898bctbz w0, 0, 0x898dc
000898c0ldr x3, [sp+64]
000898c4ldr x1, [x3+16]
000898c8ldr x3, [sp+56]
000898ccldr x0, [x3+16]
000898d0ldr x2, [x3+24]
000898d4bl runtime.memequal
000898d8b 0x898e0
000898dc
000898dcloc_898dc:
000898dcmov x0, xzr
000898e0
000898e0loc_898e0:
000898e0ldur x29, [sp-8]
000898e4ldr x30, [sp], 48
000898e8ret x30
000898ec
000898ecloc_898ec:
000898ecstp x0, x1, [sp+8]
000898f0mov x3, x30
000898f4bl runtime.morestack_noctxt.abi0
000898f8ldp x0, x1, [sp+8]
000898fcb 0x89860
00089860

00089900
00089900type:.eq.runtime.bitvector: ; void type:.eq.runtime.bitvector(runtime.bitvector * p, runtime.bitvector * q)
00089900ldrsw x2, [x1]
00089904ldrsw x3, [x0]
00089908subs wzr, w2, w3
0008990cb.ne 0x89924
00089910ldr x2, [x0+8]
00089914ldr x1, [x1+8]
00089918subs xzr, x1, x2
0008991ccset x0, eq
00089920ret x30
00089924
00089924loc_89924:
00089924mov x0, xzr
00089928ret x30
0008992cudf 0
00089900

00089930
00089930type:.eq.runtime._func: ; void type:.eq.runtime._func(runtime._func * p, runtime._func * q)
00089930ldr x16, [x28+16]
00089934subs xzr, sp, x16
00089938b.ls 0x89974
0008993cstr x30, [sp-48]!
00089940stur x29, [sp-8]
00089944sub x29, sp, 8
00089948ldrb w3, [x1+43]
0008994cldrb w4, [x0+43]
00089950subs wzr, w3, w4
00089954b.eq 0x89960
00089958mov x0, xzr
0008995cb 0x89968
00089960
00089960loc_89960:
00089960movz x2, 42
00089964bl runtime.memequal
00089968
00089968loc_89968:
00089968ldur x29, [sp-8]
0008996cldr x30, [sp], 48
00089970ret x30
00089974
00089974loc_89974:
00089974stp x0, x1, [sp+8]
00089978mov x3, x30
0008997cbl runtime.morestack_noctxt.abi0
00089980ldp x0, x1, [sp+8]
00089984b 0x89930
00089988udf 0
0008998cudf 0
00089930

00089990
00089990type:.eq.runtime.PanicNilError: ; void type:.eq.runtime.PanicNilError(runtime.PanicNilError * p, runtime.PanicNilError * q)
00089990orr x0, xzr, 1
00089994ret x30
00089998udf 0
0008999cudf 0
00089990

000899a0
000899a0type:.eq.runtime.boundsError: ; void type:.eq.runtime.boundsError(runtime.boundsError * p, runtime.boundsError * q)
000899a0ldr x2, [x1]
000899a4ldr x3, [x0]
000899a8subs xzr, x2, x3
000899acb.ne 0x899e8
000899b0ldr x2, [x0+8]
000899b4ldr x3, [x1+8]
000899b8subs xzr, x3, x2
000899bcb.ne 0x899e8
000899c0ldrb w2, [x0+16]
000899c4ldrb w3, [x1+16]
000899c8eor x2, x2, x3
000899cceor x2, x2, 1
000899d0tbz w2, 0, 0x899e8
000899d4ldrb w2, [x0+17]
000899d8ldrb w1, [x1+17]
000899dcsubs wzr, w2, w1
000899e0cset x0, eq
000899e4ret x30
000899e8
000899e8loc_899e8:
000899e8mov x0, xzr
000899ecret x30
000899a0

000899f0
000899f0type:.eq.runtime._panic: ; void type:.eq.runtime._panic(runtime._panic * p, runtime._panic * q)
000899f0ldr x16, [x28+16]
000899f4subs xzr, sp, x16
000899f8b.ls 0x89a74
000899fcstr x30, [sp-48]!
00089a00stur x29, [sp-8]
00089a04sub x29, sp, 8
00089a08ldr x3, [x1]
00089a0cldr x4, [x0]
00089a10subs xzr, x3, x4
00089a14b.ne 0x89a64
00089a18ldr x3, [x0+8]
00089a1cldr x4, [x1+8]
00089a20subs xzr, x4, x3
00089a24b.ne 0x89a64
00089a28str x0, [sp+56]
00089a2cstr x1, [sp+64]
00089a30ldr x4, [x0+16]
00089a34ldr x2, [x1+16]
00089a38mov x0, x3
00089a3cmov x1, x4
00089a40bl runtime.efaceeq
00089a44tbz w0, 0, 0x89a64
00089a48ldr x3, [sp+56]
00089a4cadd x0, x3, 24
00089a50ldr x3, [sp+64]
00089a54add x1, x3, 24
00089a58movz x2, 75
00089a5cbl runtime.memequal
00089a60b 0x89a68
00089a64
00089a64loc_89a64:
00089a64mov x0, xzr
00089a68
00089a68loc_89a68:
00089a68ldur x29, [sp-8]
00089a6cldr x30, [sp], 48
00089a70ret x30
00089a74
00089a74loc_89a74:
00089a74stp x0, x1, [sp+8]
00089a78mov x3, x30
00089a7cbl runtime.morestack_noctxt.abi0
00089a80ldp x0, x1, [sp+8]
00089a84b 0x899f0
00089a88udf 0
00089a8cudf 0
000899f0

00089a90
00089a90type:.eq.runtime.mcache: ; void type:.eq.runtime.mcache(runtime.mcache * p, runtime.mcache * q)
00089a90ldr x16, [x28+16]
00089a94subs xzr, sp, x16
00089a98b.ls 0x89abc
00089a9cstr x30, [sp-48]!
00089aa0stur x29, [sp-8]
00089aa4sub x29, sp, 8
00089aa8movz x2, 1204
00089aacbl runtime.memequal
00089ab0ldur x29, [sp-8]
00089ab4ldr x30, [sp], 48
00089ab8ret x30
00089abc
00089abcloc_89abc:
00089abcstp x0, x1, [sp+8]
00089ac0mov x3, x30
00089ac4bl runtime.morestack_noctxt.abi0
00089ac8ldp x0, x1, [sp+8]
00089accb 0x89a90
00089a90

00089ad0
00089ad0type:.eq.runtime.mspan: ; void type:.eq.runtime.mspan(runtime.mspan * p, runtime.mspan * q)
00089ad0ldr x16, [x28+16]
00089ad4subs xzr, sp, x16
00089ad8b.ls 0x89b28
00089adcstr x30, [sp-48]!
00089ae0stur x29, [sp-8]
00089ae4sub x29, sp, 8
00089ae8str x0, [sp+56]
00089aecstr x1, [sp+64]
00089af0movz x2, 54
00089af4bl runtime.memequal
00089af8tbnz w0, 0, 0x89b04
00089afcmov x0, xzr
00089b00b 0x89b1c
00089b04
00089b04loc_89b04:
00089b04ldr x3, [sp+56]
00089b08add x0, x3, 56
00089b0cldr x3, [sp+64]
00089b10add x1, x3, 56
00089b14movz x2, 104
00089b18bl runtime.memequal
00089b1c
00089b1cloc_89b1c:
00089b1cldur x29, [sp-8]
00089b20ldr x30, [sp], 48
00089b24ret x30
00089b28
00089b28loc_89b28:
00089b28stp x0, x1, [sp+8]
00089b2cmov x3, x30
00089b30bl runtime.morestack_noctxt.abi0
00089b34ldp x0, x1, [sp+8]
00089b38b 0x89ad0
00089b3cudf 0
00089ad0

00089b40
00089b40type:.eq.runtime.mSpanList: ; void type:.eq.runtime.mSpanList(runtime.mSpanList * p, runtime.mSpanList * q)
00089b40ldr x2, [x1]
00089b44ldr x3, [x0]
00089b48subs xzr, x2, x3
00089b4cb.ne 0x89b64
00089b50ldr x2, [x0+8]
00089b54ldr x1, [x1+8]
00089b58subs xzr, x1, x2
00089b5ccset x0, eq
00089b60ret x30
00089b64
00089b64loc_89b64:
00089b64mov x0, xzr
00089b68ret x30
00089b6cudf 0
00089b40

00089b70
00089b70type:.eq.runtime.gcBits: ; void type:.eq.runtime.gcBits(runtime.gcBits * p, runtime.gcBits * q)
00089b70ldrb w1, [x1]
00089b74ldrb w2, [x0]
00089b78subs wzr, w1, w2
00089b7ccset x0, eq
00089b80ret x30
00089b84udf 0
00089b88udf 0
00089b8cudf 0
00089b70

00089b90
00089b90type:.eq.runtime.special: ; void type:.eq.runtime.special(runtime.special * p, runtime.special * q)
00089b90ldr x2, [x1]
00089b94ldr x3, [x0]
00089b98subs xzr, x2, x3
00089b9cb.ne 0x89bc4
00089ba0ldr x2, [x0+8]
00089ba4ldr x3, [x1+8]
00089ba8subs xzr, x3, x2
00089bacb.ne 0x89bc4
00089bb0ldrb w2, [x0+16]
00089bb4ldrb w1, [x1+16]
00089bb8subs wzr, w1, w2
00089bbccset x0, eq
00089bc0ret x30
00089bc4
00089bc4loc_89bc4:
00089bc4mov x0, xzr
00089bc8ret x30
00089bccudf 0
00089b90

00089bd0
00089bd0type:.eq.struct { runtime.gList; runtime.n int32 }: ; void type:.eq.struct { runtime.gList; runtime.n int32 }(struct struct { runtime.gList; runtime.n int32 } * p, struct struct { runtime.gList; runtime.n int32 } * q)
00089bd0ldr x2, [x1]
00089bd4ldr x3, [x0]
00089bd8subs xzr, x2, x3
00089bdcb.ne 0x89bf4
00089be0ldrsw x2, [x0+8]
00089be4ldrsw x1, [x1+8]
00089be8subs wzr, w1, w2
00089beccset x0, eq
00089bf0ret x30
00089bf4
00089bf4loc_89bf4:
00089bf4mov x0, xzr
00089bf8ret x30
00089bfcudf 0
00089bd0

00089c00
00089c00type:.eq.runtime.hchan: ; void type:.eq.runtime.hchan(runtime.hchan * p, runtime.hchan * q)
00089c00ldr x16, [x28+16]
00089c04subs xzr, sp, x16
00089c08b.ls 0x89c90
00089c0cstr x30, [sp-48]!
00089c10stur x29, [sp-8]
00089c14sub x29, sp, 8
00089c18ldr x3, [x1]
00089c1cldr x4, [x0]
00089c20subs xzr, x3, x4
00089c24b.ne 0x89c80
00089c28ldr x3, [x0+8]
00089c2cldr x4, [x1+8]
00089c30subs xzr, x4, x3
00089c34b.ne 0x89c80
00089c38ldr x3, [x0+16]
00089c3cldr x4, [x1+16]
00089c40subs xzr, x4, x3
00089c44b.ne 0x89c80
00089c48ldrh w3, [x0+24]
00089c4cldrh w4, [x1+24]
00089c50subs wzr, w3, w4
00089c54b.ne 0x89c80
00089c58ldrb w3, [x0+26]
00089c5cldrb w4, [x1+26]
00089c60eor x3, x3, x4
00089c64eor x3, x3, 1
00089c68tbz w3, 0, 0x89c80
00089c6cadd x0, x0, 28
00089c70add x1, x1, 28
00089c74movz x2, 76
00089c78bl runtime.memequal
00089c7cb 0x89c84
00089c80
00089c80loc_89c80:
00089c80mov x0, xzr
00089c84
00089c84loc_89c84:
00089c84ldur x29, [sp-8]
00089c88ldr x30, [sp], 48
00089c8cret x30
00089c90
00089c90loc_89c90:
00089c90stp x0, x1, [sp+8]
00089c94mov x3, x30
00089c98bl runtime.morestack_noctxt.abi0
00089c9cldp x0, x1, [sp+8]
00089ca0b 0x89c00
00089ca4udf 0
00089ca8udf 0
00089cacudf 0
00089c00

00089cb0
00089cb0type:.eq.runtime.pTraceState: ; void type:.eq.runtime.pTraceState(runtime.pTraceState * p, runtime.pTraceState * q)
00089cb0ldr x16, [x28+16]
00089cb4subs xzr, sp, x16
00089cb8b.ls 0x89d78
00089cbcstr x30, [sp-48]!
00089cc0stur x29, [sp-8]
00089cc4sub x29, sp, 8
00089cc8str x0, [sp+56]
00089cccstr x1, [sp+64]
00089cd0orr x2, xzr, 12
00089cd4bl runtime.memequal
00089cd8tbz w0, 0, 0x89d68
00089cdcldr x1, [sp+56]
00089ce0ldr x2, [x1+16]
00089ce4ldr x3, [sp+64]
00089ce8ldr x4, [x3+16]
00089cecsubs xzr, x4, x2
00089cf0b.ne 0x89d68
00089cf4ldr x2, [x1+24]
00089cf8ldr x4, [x3+24]
00089cfcsubs xzr, x4, x2
00089d00b.ne 0x89d68
00089d04ldr x2, [x1+32]
00089d08ldr x4, [x3+32]
00089d0csubs xzr, x4, x2
00089d10b.ne 0x89d68
00089d14ldrb w2, [x1+40]
00089d18ldrb w4, [x3+40]
00089d1ceor x2, x4, x2
00089d20eor x2, x2, 1
00089d24tbz w2, 0, 0x89d68
00089d28ldrb w2, [x1+41]
00089d2cldrb w4, [x3+41]
00089d30eor x2, x4, x2
00089d34eor x2, x2, 1
00089d38tbz w2, 0, 0x89d68
00089d3cldr x2, [x1+48]
00089d40ldr x4, [x3+48]
00089d44subs xzr, x4, x2
00089d48b.ne 0x89d68
00089d4cldr x1, [x1+56]
00089d50ldr x2, [x3+56]
00089d54subs xzr, x2, x1
00089d58cset x0, eq
00089d5cldur x29, [sp-8]
00089d60ldr x30, [sp], 48
00089d64ret x30
00089d68
00089d68loc_89d68:
00089d68mov x0, xzr
00089d6cldur x29, [sp-8]
00089d70ldr x30, [sp], 48
00089d74ret x30
00089d78
00089d78loc_89d78:
00089d78stp x0, x1, [sp+8]
00089d7cmov x3, x30
00089d80bl runtime.morestack_noctxt.abi0
00089d84ldp x0, x1, [sp+8]
00089d88b 0x89cb0
00089d8cudf 0
00089cb0

00089d90
00089d90type:.eq.runtime.traceSchedResourceState: ; void type:.eq.runtime.traceSchedResourceState(runtime.traceSchedResourceState * p, runtime.traceSchedResourceState * q)
00089d90ldr x16, [x28+16]
00089d94subs xzr, sp, x16
00089d98b.ls 0x89e0c
00089d9cstr x30, [sp-48]!
00089da0stur x29, [sp-8]
00089da4sub x29, sp, 8
00089da8str x0, [sp+56]
00089dacstr x1, [sp+64]
00089db0orr x2, xzr, 12
00089db4bl runtime.memequal
00089db8tbz w0, 0, 0x89dfc
00089dbcldr x1, [sp+56]
00089dc0ldr x2, [x1+16]
00089dc4ldr x3, [sp+64]
00089dc8ldr x4, [x3+16]
00089dccsubs xzr, x4, x2
00089dd0b.ne 0x89de8
00089dd4ldr x1, [x1+24]
00089dd8ldr x2, [x3+24]
00089ddcsubs xzr, x2, x1
00089de0cset x1, eq
00089de4b 0x89dec
00089de8
00089de8loc_89de8:
00089de8mov x1, xzr
00089dec
00089decloc_89dec:
00089decmov x0, x1
00089df0ldur x29, [sp-8]
00089df4ldr x30, [sp], 48
00089df8ret x30
00089dfc
00089dfcloc_89dfc:
00089dfcmov x0, xzr
00089e00ldur x29, [sp-8]
00089e04ldr x30, [sp], 48
00089e08ret x30
00089e0c
00089e0cloc_89e0c:
00089e0cstp x0, x1, [sp+8]
00089e10mov x3, x30
00089e14bl runtime.morestack_noctxt.abi0
00089e18ldp x0, x1, [sp+8]
00089e1cb 0x89d90
00089d90

00089e20
00089e20type:.eq.runtime.notInHeap: ; void type:.eq.runtime.notInHeap(runtime.notInHeap * p, runtime.notInHeap * q)
00089e20orr x0, xzr, 1
00089e24ret x30
00089e28udf 0
00089e2cudf 0
00089e20

00089e30
00089e30type:.eq.runtime.limiterEvent: ; void type:.eq.runtime.limiterEvent(runtime.limiterEvent * p, runtime.limiterEvent * q)
00089e30ldr x2, [x0]
00089e34ldr x1, [x1]
00089e38subs xzr, x1, x2
00089e3ccset x0, eq
00089e40ret x30
00089e44udf 0
00089e48udf 0
00089e4cudf 0
00089e30

00089e50
00089e50type:.eq.runtime.gcWork: ; void type:.eq.runtime.gcWork(runtime.gcWork * p, runtime.gcWork * q)
00089e50ldr x16, [x28+16]
00089e54subs xzr, sp, x16
00089e58b.ls 0x89e7c
00089e5cstr x30, [sp-48]!
00089e60stur x29, [sp-8]
00089e64sub x29, sp, 8
00089e68movz x2, 33
00089e6cbl runtime.memequal
00089e70ldur x29, [sp-8]
00089e74ldr x30, [sp], 48
00089e78ret x30
00089e7c
00089e7cloc_89e7c:
00089e7cstp x0, x1, [sp+8]
00089e80mov x3, x30
00089e84bl runtime.morestack_noctxt.abi0
00089e88ldp x0, x1, [sp+8]
00089e8cb 0x89e50
00089e50

00089e90
00089e90type:.eq.runtime.workbuf: ; void type:.eq.runtime.workbuf(runtime.workbuf * p, runtime.workbuf * q)
00089e90ldr x16, [x28+16]
00089e94subs xzr, sp, x16
00089e98b.ls 0x89ebc
00089e9cstr x30, [sp-48]!
00089ea0stur x29, [sp-8]
00089ea4sub x29, sp, 8
00089ea8orr x2, xzr, 2048
00089eacbl runtime.memequal
00089eb0ldur x29, [sp-8]
00089eb4ldr x30, [sp], 48
00089eb8ret x30
00089ebc
00089ebcloc_89ebc:
00089ebcstp x0, x1, [sp+8]
00089ec0mov x3, x30
00089ec4bl runtime.morestack_noctxt.abi0
00089ec8ldp x0, x1, [sp+8]
00089eccb 0x89e90
00089e90

00089ed0
00089ed0type:.eq.runtime.mTraceState: ; void type:.eq.runtime.mTraceState(runtime.mTraceState * p, runtime.mTraceState * q)
00089ed0ldr x16, [x28+16]
00089ed4subs xzr, sp, x16
00089ed8b.ls 0x89efc
00089edcstr x30, [sp-48]!
00089ee0stur x29, [sp-8]
00089ee4sub x29, sp, 8
00089ee8movz x2, 53
00089eecbl runtime.memequal
00089ef0ldur x29, [sp-8]
00089ef4ldr x30, [sp], 48
00089ef8ret x30
00089efc
00089efcloc_89efc:
00089efcstp x0, x1, [sp+8]
00089f00mov x3, x30
00089f04bl runtime.morestack_noctxt.abi0
00089f08ldp x0, x1, [sp+8]
00089f0cb 0x89ed0
00089ed0

00089f10
00089f10type:.eq.runtime.traceBuf: ; void type:.eq.runtime.traceBuf(runtime.traceBuf * p, runtime.traceBuf * q)
00089f10ldr x16, [x28+16]
00089f14subs xzr, sp, x16
00089f18b.ls 0x89f3c
00089f1cstr x30, [sp-48]!
00089f20stur x29, [sp-8]
00089f24sub x29, sp, 8
00089f28orr x2, xzr, 0x10000
00089f2cbl runtime.memequal
00089f30ldur x29, [sp-8]
00089f34ldr x30, [sp], 48
00089f38ret x30
00089f3c
00089f3cloc_89f3c:
00089f3cstp x0, x1, [sp+8]
00089f40mov x3, x30
00089f44bl runtime.morestack_noctxt.abi0
00089f48ldp x0, x1, [sp+8]
00089f4cb 0x89f10
00089f10

00089f50
00089f50type:.eq.runtime.mOS: ; void type:.eq.runtime.mOS(runtime.mOS * p, runtime.mOS * q)
00089f50ldrsw x2, [x1]
00089f54ldrsw x3, [x0]
00089f58subs wzr, w2, w3
00089f5cb.ne 0x89fa4
00089f60ldrb w2, [x0+4]
00089f64ldrb w3, [x1+4]
00089f68subs wzr, w2, w3
00089f6cb.ne 0x89fa4
00089f70ldrb w2, [x0+5]
00089f74ldrb w3, [x1+5]
00089f78subs wzr, w2, w3
00089f7cb.ne 0x89fa4
00089f80ldr x2, [x0+8]
00089f84ldr x3, [x1+8]
00089f88subs xzr, x3, x2
00089f8cb.ne 0x89fa4
00089f90ldr w2, [x0+16]
00089f94ldr w1, [x1+16]
00089f98subs wzr, w1, w2
00089f9ccset x0, eq
00089fa0ret x30
00089fa4
00089fa4loc_89fa4:
00089fa4mov x0, xzr
00089fa8ret x30
00089facudf 0
00089f50

00089fb0
00089fb0type:.eq.runtime.gTraceState: ; void type:.eq.runtime.gTraceState(runtime.gTraceState * p, runtime.gTraceState * q)
00089fb0ldr x16, [x28+16]
00089fb4subs xzr, sp, x16
00089fb8b.ls 0x8a024
00089fbcstr x30, [sp-48]!
00089fc0stur x29, [sp-8]
00089fc4sub x29, sp, 8
00089fc8str x0, [sp+56]
00089fccstr x1, [sp+64]
00089fd0orr x2, xzr, 12
00089fd4bl runtime.memequal
00089fd8tbz w0, 0, 0x8a010
00089fdcldr x1, [sp+56]
00089fe0ldr x2, [x1+16]
00089fe4ldr x3, [sp+64]
00089fe8ldr x4, [x3+16]
00089fecsubs xzr, x4, x2
00089ff0b.ne 0x8a008
00089ff4ldr x1, [x1+24]
00089ff8ldr x2, [x3+24]
00089ffcsubs xzr, x2, x1
0008a000cset x1, eq
0008a004b 0x8a014
0008a008
0008a008loc_8a008:
0008a008mov x1, xzr
0008a00cb 0x8a014
0008a010
0008a010loc_8a010:
0008a010mov x1, xzr
0008a014
0008a014loc_8a014:
0008a014mov x0, x1
0008a018ldur x29, [sp-8]
0008a01cldr x30, [sp], 48
0008a020ret x30
0008a024
0008a024loc_8a024:
0008a024stp x0, x1, [sp+8]
0008a028mov x3, x30
0008a02cbl runtime.morestack_noctxt.abi0
0008a030ldp x0, x1, [sp+8]
0008a034b 0x89fb0
0008a038udf 0
0008a03cudf 0
00089fb0

0008a040
0008a040type:.eq.runtime.errorAddressString: ; void type:.eq.runtime.errorAddressString(runtime.errorAddressString * p, runtime.errorAddressString * q)
0008a040ldr x16, [x28+16]
0008a044subs xzr, sp, x16
0008a048b.ls 0x8a098
0008a04cstr x30, [sp-48]!
0008a050stur x29, [sp-8]
0008a054sub x29, sp, 8
0008a058ldr x3, [x1+8]
0008a05cldr x2, [x0+8]
0008a060subs xzr, x3, x2
0008a064b.ne 0x8a088
0008a068ldr x3, [x0+16]
0008a06cldr x4, [x1+16]
0008a070subs xzr, x4, x3
0008a074b.ne 0x8a088
0008a078ldr x0, [x0]
0008a07cldr x1, [x1]
0008a080bl runtime.memequal
0008a084b 0x8a08c
0008a088
0008a088loc_8a088:
0008a088mov x0, xzr
0008a08c
0008a08cloc_8a08c:
0008a08cldur x29, [sp-8]
0008a090ldr x30, [sp], 48
0008a094ret x30
0008a098
0008a098loc_8a098:
0008a098stp x0, x1, [sp+8]
0008a09cmov x3, x30
0008a0a0bl runtime.morestack_noctxt.abi0
0008a0a4ldp x0, x1, [sp+8]
0008a0a8b 0x8a040
0008a0acudf 0
0008a040

0008a0b0
0008a0b0type:.eq.runtime.untracedG.4: ; void type:.eq.runtime.untracedG·4(runtime.untracedG·4 * p, runtime.untracedG·4 * q)
0008a0b0ldr x16, [x28+16]
0008a0b4subs xzr, sp, x16
0008a0b8b.ls 0x8a0dc
0008a0bcstr x30, [sp-48]!
0008a0c0stur x29, [sp-8]
0008a0c4sub x29, sp, 8
0008a0c8movz x2, 38
0008a0ccbl runtime.memequal
0008a0d0ldur x29, [sp-8]
0008a0d4ldr x30, [sp], 48
0008a0d8ret x30
0008a0dc
0008a0dcloc_8a0dc:
0008a0dcstp x0, x1, [sp+8]
0008a0e0mov x3, x30
0008a0e4bl runtime.morestack_noctxt.abi0
0008a0e8ldp x0, x1, [sp+8]
0008a0ecb 0x8a0b0
0008a0b0

0008a0f0
0008a0f0type:.eq.runtime.spanSetBlock: ; void type:.eq.runtime.spanSetBlock(runtime.spanSetBlock * p, runtime.spanSetBlock * q)
0008a0f0ldr x16, [x28+16]
0008a0f4subs xzr, sp, x16
0008a0f8b.ls 0x8a15c
0008a0fcstr x30, [sp-48]!
0008a100stur x29, [sp-8]
0008a104sub x29, sp, 8
0008a108ldr x3, [x1]
0008a10cldr x4, [x0]
0008a110subs xzr, x3, x4
0008a114b.ne 0x8a14c
0008a118ldr x3, [x0+8]
0008a11cldr x4, [x1+8]
0008a120subs xzr, x4, x3
0008a124b.ne 0x8a14c
0008a128ldr w3, [x0+16]
0008a12cldr w4, [x1+16]
0008a130subs wzr, w4, w3
0008a134b.ne 0x8a14c
0008a138add x0, x0, 24
0008a13cadd x1, x1, 24
0008a140orr x2, xzr, 4096
0008a144bl runtime.memequal
0008a148b 0x8a150
0008a14c
0008a14cloc_8a14c:
0008a14cmov x0, xzr
0008a150
0008a150loc_8a150:
0008a150ldur x29, [sp-8]
0008a154ldr x30, [sp], 48
0008a158ret x30
0008a15c
0008a15cloc_8a15c:
0008a15cstp x0, x1, [sp+8]
0008a160mov x3, x30
0008a164bl runtime.morestack_noctxt.abi0
0008a168ldp x0, x1, [sp+8]
0008a16cb 0x8a0f0
0008a0f0

0008a170
0008a170type:.eq.runtime.TypeAssertionError: ; void type:.eq.runtime.TypeAssertionError(runtime.TypeAssertionError * p, runtime.TypeAssertionError * q)
0008a170ldr x16, [x28+16]
0008a174subs xzr, sp, x16
0008a178b.ls 0x8a1e8
0008a17cstr x30, [sp-48]!
0008a180stur x29, [sp-8]
0008a184sub x29, sp, 8
0008a188ldr x3, [x1]
0008a18cldr x4, [x0]
0008a190subs xzr, x3, x4
0008a194b.ne 0x8a1d8
0008a198ldr x3, [x0+8]
0008a19cldr x4, [x1+8]
0008a1a0subs xzr, x4, x3
0008a1a4b.ne 0x8a1d8
0008a1a8ldr x3, [x0+16]
0008a1acldr x4, [x1+16]
0008a1b0subs xzr, x4, x3
0008a1b4b.ne 0x8a1d8
0008a1b8ldr x2, [x0+32]
0008a1bcldr x3, [x1+32]
0008a1c0subs xzr, x3, x2
0008a1c4b.ne 0x8a1d8
0008a1c8ldr x0, [x0+24]
0008a1ccldr x1, [x1+24]
0008a1d0bl runtime.memequal
0008a1d4b 0x8a1dc
0008a1d8
0008a1d8loc_8a1d8:
0008a1d8mov x0, xzr
0008a1dc
0008a1dcloc_8a1dc:
0008a1dcldur x29, [sp-8]
0008a1e0ldr x30, [sp], 48
0008a1e4ret x30
0008a1e8
0008a1e8loc_8a1e8:
0008a1e8stp x0, x1, [sp+8]
0008a1ecmov x3, x30
0008a1f0bl runtime.morestack_noctxt.abi0
0008a1f4ldp x0, x1, [sp+8]
0008a1f8b 0x8a170
0008a1fcudf 0
0008a170

0008a200
0008a200type:.eq.runtime.funcinl: ; void type:.eq.runtime.funcinl(runtime.funcinl * p, runtime.funcinl * q)
0008a200ldr x16, [x28+16]
0008a204subs xzr, sp, x16
0008a208b.ls 0x8a2bc
0008a20cstr x30, [sp-48]!
0008a210stur x29, [sp-8]
0008a214sub x29, sp, 8
0008a218ldr w3, [x1]
0008a21cldr w4, [x0]
0008a220subs wzr, w3, w4
0008a224b.ne 0x8a2ac
0008a228ldr x3, [x0+8]
0008a22cldr x4, [x1+8]
0008a230subs xzr, x4, x3
0008a234b.ne 0x8a2ac
0008a238ldr x2, [x0+24]
0008a23cldr x3, [x1+24]
0008a240subs xzr, x2, x3
0008a244b.ne 0x8a2ac
0008a248ldr x3, [x1+40]
0008a24cldr x4, [x0+40]
0008a250subs xzr, x4, x3
0008a254b.ne 0x8a2ac
0008a258ldrsw x3, [x0+48]
0008a25cldrsw x4, [x1+48]
0008a260subs wzr, w4, w3
0008a264b.ne 0x8a2ac
0008a268ldrsw x3, [x0+52]
0008a26cldrsw x4, [x1+52]
0008a270subs wzr, w4, w3
0008a274b.ne 0x8a2ac
0008a278str x0, [sp+56]
0008a27cstr x1, [sp+64]
0008a280ldr x1, [x1+16]
0008a284ldr x0, [x0+16]
0008a288bl runtime.memequal
0008a28ctbz w0, 0, 0x8a2ac
0008a290ldr x3, [sp+64]
0008a294ldr x1, [x3+32]
0008a298ldr x3, [sp+56]
0008a29cldr x0, [x3+32]
0008a2a0ldr x2, [x3+40]
0008a2a4bl runtime.memequal
0008a2a8b 0x8a2b0
0008a2ac
0008a2acloc_8a2ac:
0008a2acmov x0, xzr
0008a2b0
0008a2b0loc_8a2b0:
0008a2b0ldur x29, [sp-8]
0008a2b4ldr x30, [sp], 48
0008a2b8ret x30
0008a2bc
0008a2bcloc_8a2bc:
0008a2bcstp x0, x1, [sp+8]
0008a2c0mov x3, x30
0008a2c4bl runtime.morestack_noctxt.abi0
0008a2c8ldp x0, x1, [sp+8]
0008a2ccb 0x8a200
0008a200

0008a2d0
0008a2d0type:.eq.runtime.piController: ; void type:.eq.runtime.piController(runtime.piController * p, runtime.piController * q)
0008a2d0ldr d0, [x1]
0008a2d4ldr d1, [x0]
0008a2d8fcmp d0, d1
0008a2dcb.ne 0x8a358
0008a2e0ldr d0, [x0+8]
0008a2e4ldr d1, [x1+8]
0008a2e8fcmp d1, d0
0008a2ecb.ne 0x8a358
0008a2f0ldr d0, [x0+16]
0008a2f4ldr d1, [x1+16]
0008a2f8fcmp d1, d0
0008a2fcb.ne 0x8a358
0008a300ldr d0, [x0+24]
0008a304ldr d1, [x1+24]
0008a308fcmp d0, d1
0008a30cb.ne 0x8a358
0008a310ldr d0, [x0+32]
0008a314ldr d1, [x1+32]
0008a318fcmp d0, d1
0008a31cb.ne 0x8a358
0008a320ldr d0, [x0+40]
0008a324ldr d1, [x1+40]
0008a328fcmp d0, d1
0008a32cb.ne 0x8a358
0008a330ldrb w2, [x0+48]
0008a334ldrb w3, [x1+48]
0008a338eor x2, x3, x2
0008a33ceor x2, x2, 1
0008a340tbz w2, 0, 0x8a358
0008a344ldrb w2, [x0+49]
0008a348ldrb w1, [x1+49]
0008a34ceor x1, x1, x2
0008a350eor x0, x1, 1
0008a354ret x30
0008a358
0008a358loc_8a358:
0008a358mov x0, xzr
0008a35cret x30
0008a2d0

0008a360
0008a360type:.eq.[9]string: ; void type:.eq.[9]string(struct string[9] * p, struct string[9] * q)
0008a360ldr x16, [x28+16]
0008a364subs xzr, sp, x16
0008a368b.ls 0x8a500
0008a36cstr x30, [sp-96]!
0008a370stur x29, [sp-8]
0008a374sub x29, sp, 8
0008a378str x0, [sp+104]
0008a37cstr x1, [sp+112]
0008a380strb wzr, [sp+38]
0008a384str xzr, [sp+64]
0008a388b 0x8a38c
0008a38c
0008a38cloc_8a38c:
0008a38cldr x3, [sp+64]
0008a390subs xzr, x3, 9
0008a394b.lt 0x8a39c
0008a398b 0x8a458
0008a39c
0008a39cloc_8a39c:
0008a39cldr x3, [sp+64]
0008a3a0ldr x4, [sp+104]
0008a3a4add x3, x4, x3, lsl #4
0008a3a8ldr x3, [x3+8]
0008a3acstr x3, [sp+48]
0008a3b0ldr x4, [sp+64]
0008a3b4ldr x5, [sp+112]
0008a3b8add x4, x5, x4, lsl #4
0008a3bcldr x4, [x4+8]
0008a3c0str x4, [sp+40]
0008a3c4subs xzr, x3, x4
0008a3c8b.eq 0x8a3d0
0008a3ccb 0x8a454
0008a3d0
0008a3d0loc_8a3d0:
0008a3d0ldr x3, [sp+64]
0008a3d4add x4, x3, 1
0008a3d8str x4, [sp+64]
0008a3dcldr x5, [sp+104]
0008a3e0add x5, x5, x4, lsl #4
0008a3e4ldr x5, [x5+8]
0008a3e8str x5, [sp+40]
0008a3ecldr x6, [sp+112]
0008a3f0add x4, x6, x4, lsl #4
0008a3f4ldr x4, [x4+8]
0008a3f8str x4, [sp+48]
0008a3fcsubs xzr, x5, x4
0008a400b.eq 0x8a408
0008a404b 0x8a450
0008a408
0008a408loc_8a408:
0008a408add x4, x3, 2
0008a40cstr x4, [sp+64]
0008a410ldr x5, [sp+104]
0008a414add x5, x5, x4, lsl #4
0008a418ldr x5, [x5+8]
0008a41cstr x5, [sp+48]
0008a420ldr x6, [sp+112]
0008a424add x4, x6, x4, lsl #4
0008a428ldr x4, [x4+8]
0008a42cstr x4, [sp+40]
0008a430subs xzr, x5, x4
0008a434b.eq 0x8a43c
0008a438b 0x8a44c
0008a43c
0008a43cloc_8a43c:
0008a43cadd x3, x3, 3
0008a440str x3, [sp+64]
0008a444b 0x8a448
0008a448
0008a448loc_8a448:
0008a448b 0x8a38c
0008a44c
0008a44cloc_8a44c:
0008a44cb 0x8a4dc
0008a450
0008a450loc_8a450:
0008a450b 0x8a4dc
0008a454
0008a454loc_8a454:
0008a454b 0x8a4dc
0008a458
0008a458loc_8a458:
0008a458str xzr, [sp+56]
0008a45cb 0x8a460
0008a460
0008a460loc_8a460:
0008a460ldr x3, [sp+56]
0008a464subs xzr, x3, 9
0008a468b.lt 0x8a470
0008a46cb 0x8a4e4
0008a470
0008a470loc_8a470:
0008a470ldr x3, [sp+56]
0008a474ldr x4, [sp+104]
0008a478add x3, x4, x3, lsl #4
0008a47cldr x3, [x3+8]
0008a480str x3, [sp+40]
0008a484ldr x3, [sp+56]
0008a488ldr x4, [sp+104]
0008a48cubfm x3, x3, 60, 59
0008a490ldr x3, [x4+x3]
0008a494str x3, [sp+80]
0008a498ldr x3, [sp+56]
0008a49cldr x4, [sp+112]
0008a4a0ubfm x3, x3, 60, 59
0008a4a4ldr x1, [x4+x3]
0008a4a8str x1, [sp+72]
0008a4acldr x2, [sp+40]
0008a4b0ldr x0, [sp+80]
0008a4b4bl runtime.memequal
0008a4b8strb w0, [sp+39]
0008a4bctbnz w0, 0, 0x8a4c4
0008a4c0b 0x8a4d8
0008a4c4
0008a4c4loc_8a4c4:
0008a4c4ldr x3, [sp+56]
0008a4c8add x3, x3, 1
0008a4ccstr x3, [sp+56]
0008a4d0b 0x8a4d4
0008a4d4
0008a4d4loc_8a4d4:
0008a4d4b 0x8a460
0008a4d8
0008a4d8loc_8a4d8:
0008a4d8b 0x8a4dc
0008a4dc
0008a4dcloc_8a4dc:
0008a4dcstrb wzr, [sp+38]
0008a4e0b 0x8a4f0
0008a4e4
0008a4e4loc_8a4e4:
0008a4e4orr x1, xzr, 1
0008a4e8strb w1, [sp+38]
0008a4ecb 0x8a4f0
0008a4f0
0008a4f0loc_8a4f0:
0008a4f0ldrb w0, [sp+38]
0008a4f4ldur x29, [sp-8]
0008a4f8ldr x30, [sp], 96
0008a4fcret x30
0008a500
0008a500loc_8a500:
0008a500stp x0, x1, [sp+8]
0008a504mov x3, x30
0008a508bl runtime.morestack_noctxt.abi0
0008a50cldp x0, x1, [sp+8]
0008a510b 0x8a360
0008a514udf 0
0008a518udf 0
0008a51cudf 0
0008a360

0008a520
0008a520type:.eq.[4]string: ; void type:.eq.[4]string(struct string[4] * p, struct string[4] * q)
0008a520ldr x16, [x28+16]
0008a524subs xzr, sp, x16
0008a528b.ls 0x8a688
0008a52cstr x30, [sp-96]!
0008a530stur x29, [sp-8]
0008a534sub x29, sp, 8
0008a538str x0, [sp+104]
0008a53cstr x1, [sp+112]
0008a540strb wzr, [sp+46]
0008a544ldr x3, [sp+104]
0008a548ldr x3, [x3+8]
0008a54cstr x3, [sp+56]
0008a550ldr x4, [x1+8]
0008a554str x4, [sp+48]
0008a558subs xzr, x3, x4
0008a55cb.eq 0x8a564
0008a560b 0x8a5e4
0008a564
0008a564loc_8a564:
0008a564ldr x3, [sp+104]
0008a568ldr x3, [x3+24]
0008a56cstr x3, [sp+48]
0008a570ldr x4, [sp+112]
0008a574ldr x4, [x4+24]
0008a578str x4, [sp+56]
0008a57csubs xzr, x3, x4
0008a580b.eq 0x8a588
0008a584b 0x8a5e0
0008a588
0008a588loc_8a588:
0008a588ldr x3, [sp+104]
0008a58cldr x3, [x3+40]
0008a590str x3, [sp+56]
0008a594ldr x4, [sp+112]
0008a598ldr x4, [x4+40]
0008a59cstr x4, [sp+48]
0008a5a0subs xzr, x3, x4
0008a5a4b.eq 0x8a5ac
0008a5a8b 0x8a5dc
0008a5ac
0008a5acloc_8a5ac:
0008a5acldr x3, [sp+104]
0008a5b0ldr x3, [x3+56]
0008a5b4str x3, [sp+48]
0008a5b8ldr x4, [sp+112]
0008a5bcldr x4, [x4+56]
0008a5c0str x4, [sp+56]
0008a5c4subs xzr, x4, x3
0008a5c8b.eq 0x8a5d0
0008a5ccb 0x8a5d8
0008a5d0
0008a5d0loc_8a5d0:
0008a5d0str xzr, [sp+64]
0008a5d4b 0x8a600
0008a5d8
0008a5d8loc_8a5d8:
0008a5d8b 0x8a5e8
0008a5dc
0008a5dcloc_8a5dc:
0008a5dcb 0x8a5e8
0008a5e0
0008a5e0loc_8a5e0:
0008a5e0b 0x8a5e8
0008a5e4
0008a5e4loc_8a5e4:
0008a5e4b 0x8a5e8
0008a5e8
0008a5e8loc_8a5e8:
0008a5e8strb wzr, [sp+46]
0008a5ecb 0x8a5f0
0008a5f0
0008a5f0loc_8a5f0:
0008a5f0ldrb w0, [sp+46]
0008a5f4ldur x29, [sp-8]
0008a5f8ldr x30, [sp], 96
0008a5fcret x30
0008a600
0008a600loc_8a600:
0008a600ldr x3, [sp+64]
0008a604subs xzr, x3, 4
0008a608b.lt 0x8a610
0008a60cb 0x8a67c
0008a610
0008a610loc_8a610:
0008a610ldr x3, [sp+64]
0008a614ldr x4, [sp+104]
0008a618add x3, x4, x3, lsl #4
0008a61cldr x3, [x3+8]
0008a620str x3, [sp+56]
0008a624ldr x3, [sp+64]
0008a628ldr x4, [sp+104]
0008a62cubfm x3, x3, 60, 59
0008a630ldr x3, [x4+x3]
0008a634str x3, [sp+80]
0008a638ldr x3, [sp+64]
0008a63cldr x4, [sp+112]
0008a640ubfm x3, x3, 60, 59
0008a644ldr x1, [x4+x3]
0008a648str x1, [sp+72]
0008a64cldr x2, [sp+56]
0008a650ldr x0, [sp+80]
0008a654bl runtime.memequal
0008a658strb w0, [sp+47]
0008a65ctbnz w0, 0, 0x8a664
0008a660b 0x8a678
0008a664
0008a664loc_8a664:
0008a664ldr x3, [sp+64]
0008a668add x3, x3, 1
0008a66cstr x3, [sp+64]
0008a670b 0x8a674
0008a674
0008a674loc_8a674:
0008a674b 0x8a600
0008a678
0008a678loc_8a678:
0008a678b 0x8a5e8
0008a67c
0008a67cloc_8a67c:
0008a67corr x1, xzr, 1
0008a680strb w1, [sp+46]
0008a684b 0x8a5f0
0008a688
0008a688loc_8a688:
0008a688stp x0, x1, [sp+8]
0008a68cmov x3, x30
0008a690bl runtime.morestack_noctxt.abi0
0008a694ldp x0, x1, [sp+8]
0008a698b 0x8a520
0008a69cudf 0
0008a520