Similarity

0001c3c0
0001c3c0internal/byteorder.LEUint16: ; void internal/byteorder.LEUint16(struct []uint8 b)
0001c3c0ldr x16, [x28+16]
0001c3c4subs xzr, sp, x16
0001c3c8b.ls 0x1c400
0001c3ccstr x30, [sp-32]!
0001c3d0stur x29, [sp-8]
0001c3d4sub x29, sp, 8
0001c3d8str x0, [sp+40]
0001c3dcsubs xzr, x1, 1
0001c3e0b.ls 0x1c3f4
0001c3e4ldrh w0, [x0]
0001c3e8ldur x29, [sp-8]
0001c3ecldr x30, [sp], 32
0001c3f0ret x30
0001c3f4
0001c3f4loc_1c3f4:
0001c3f4orr x0, xzr, 1
0001c3f8bl runtime.panicIndex
0001c3fchint
0001c400
0001c400loc_1c400:
0001c400stp x0, x1, [sp+8]
0001c404str x2, [sp+24]
0001c408mov x3, x30
0001c40cbl runtime.morestack_noctxt.abi0
0001c410ldp x0, x1, [sp+8]
0001c414ldr x2, [sp+24]
0001c418b 0x1c3c0
0001c41cudf 0
0001c3c0

0001c420
0001c420internal/byteorder.LEUint32: ; void internal/byteorder.LEUint32(struct []uint8 b)
0001c420ldr x16, [x28+16]
0001c424subs xzr, sp, x16
0001c428b.ls 0x1c460
0001c42cstr x30, [sp-32]!
0001c430stur x29, [sp-8]
0001c434sub x29, sp, 8
0001c438str x0, [sp+40]
0001c43csubs xzr, x1, 3
0001c440b.ls 0x1c454
0001c444ldr w0, [x0]
0001c448ldur x29, [sp-8]
0001c44cldr x30, [sp], 32
0001c450ret x30
0001c454
0001c454loc_1c454:
0001c454orr x0, xzr, 3
0001c458bl runtime.panicIndex
0001c45chint
0001c460
0001c460loc_1c460:
0001c460stp x0, x1, [sp+8]
0001c464str x2, [sp+24]
0001c468mov x3, x30
0001c46cbl runtime.morestack_noctxt.abi0
0001c470ldp x0, x1, [sp+8]
0001c474ldr x2, [sp+24]
0001c478b 0x1c420
0001c47cudf 0
0001c420

0001c480
0001c480internal/byteorder.LEPutUint32: ; void internal/byteorder.LEPutUint32(struct []uint8 b, uint32 v)
0001c480ldr x16, [x28+16]
0001c484subs xzr, sp, x16
0001c488b.ls 0x1c4c0
0001c48cstr x30, [sp-32]!
0001c490stur x29, [sp-8]
0001c494sub x29, sp, 8
0001c498str x0, [sp+40]
0001c49csubs xzr, x1, 3
0001c4a0b.ls 0x1c4b4
0001c4a4str w3, [x0]
0001c4a8ldur x29, [sp-8]
0001c4acldr x30, [sp], 32
0001c4b0ret x30
0001c4b4
0001c4b4loc_1c4b4:
0001c4b4orr x0, xzr, 3
0001c4b8bl runtime.panicIndex
0001c4bchint
0001c4c0
0001c4c0loc_1c4c0:
0001c4c0stp x0, x1, [sp+8]
0001c4c4str x2, [sp+24]
0001c4c8str w3, [sp+32]
0001c4ccmov x3, x30
0001c4d0bl runtime.morestack_noctxt.abi0
0001c4d4ldp x0, x1, [sp+8]
0001c4d8ldr x2, [sp+24]
0001c4dcldr w3, [sp+32]
0001c4e0b 0x1c480
0001c4e4udf 0
0001c4e8udf 0
0001c4ecudf 0
0001c480

0001c4f0
0001c4f0internal/byteorder.LEUint64: ; void internal/byteorder.LEUint64(struct []uint8 b)
0001c4f0ldr x16, [x28+16]
0001c4f4subs xzr, sp, x16
0001c4f8b.ls 0x1c530
0001c4fcstr x30, [sp-32]!
0001c500stur x29, [sp-8]
0001c504sub x29, sp, 8
0001c508str x0, [sp+40]
0001c50csubs xzr, x1, 7
0001c510b.ls 0x1c524
0001c514ldr x0, [x0]
0001c518ldur x29, [sp-8]
0001c51cldr x30, [sp], 32
0001c520ret x30
0001c524
0001c524loc_1c524:
0001c524orr x0, xzr, 7
0001c528bl runtime.panicIndex
0001c52chint
0001c530
0001c530loc_1c530:
0001c530stp x0, x1, [sp+8]
0001c534str x2, [sp+24]
0001c538mov x3, x30
0001c53cbl runtime.morestack_noctxt.abi0
0001c540ldp x0, x1, [sp+8]
0001c544ldr x2, [sp+24]
0001c548b 0x1c4f0
0001c54cudf 0
0001c4f0

0001c550
0001c550internal/byteorder.LEPutUint64: ; void internal/byteorder.LEPutUint64(struct []uint8 b, uint64 v)
0001c550ldr x16, [x28+16]
0001c554subs xzr, sp, x16
0001c558b.ls 0x1c590
0001c55cstr x30, [sp-32]!
0001c560stur x29, [sp-8]
0001c564sub x29, sp, 8
0001c568str x0, [sp+40]
0001c56csubs xzr, x1, 7
0001c570b.ls 0x1c584
0001c574str x3, [x0]
0001c578ldur x29, [sp-8]
0001c57cldr x30, [sp], 32
0001c580ret x30
0001c584
0001c584loc_1c584:
0001c584orr x0, xzr, 7
0001c588bl runtime.panicIndex
0001c58chint
0001c590
0001c590loc_1c590:
0001c590stp x0, x1, [sp+8]
0001c594stp x2, x3, [sp+24]
0001c598mov x3, x30
0001c59cbl runtime.morestack_noctxt.abi0
0001c5a0ldp x0, x1, [sp+8]
0001c5a4ldp x2, x3, [sp+24]
0001c5a8b 0x1c550
0001c5acudf 0
0001c550

0001c5b0
0001c5b0internal/byteorder.BEUint16: ; void internal/byteorder.BEUint16(struct []uint8 b)
0001c5b0ldr x16, [x28+16]
0001c5b4subs xzr, sp, x16
0001c5b8b.ls 0x1c5f4
0001c5bcstr x30, [sp-32]!
0001c5c0stur x29, [sp-8]
0001c5c4sub x29, sp, 8
0001c5c8str x0, [sp+40]
0001c5ccsubs xzr, x1, 1
0001c5d0b.ls 0x1c5e8
0001c5d4ldrh w1, [x0]
0001c5d8rev16 w0, w1
0001c5dcldur x29, [sp-8]
0001c5e0ldr x30, [sp], 32
0001c5e4ret x30
0001c5e8
0001c5e8loc_1c5e8:
0001c5e8orr x0, xzr, 1
0001c5ecbl runtime.panicIndex
0001c5f0hint
0001c5f4
0001c5f4loc_1c5f4:
0001c5f4stp x0, x1, [sp+8]
0001c5f8str x2, [sp+24]
0001c5fcmov x3, x30
0001c600bl runtime.morestack_noctxt.abi0
0001c604ldp x0, x1, [sp+8]
0001c608ldr x2, [sp+24]
0001c60cb 0x1c5b0
0001c5b0

0001c610
0001c610internal/byteorder.BEAppendUint16: ; void internal/byteorder.BEAppendUint16(struct []uint8 b, uint16 v)
0001c610ldr x16, [x28+16]
0001c614subs xzr, sp, x16
0001c618b.ls 0x1c668
0001c61cstr x30, [sp-96]!
0001c620stur x29, [sp-8]
0001c624sub x29, sp, 8
0001c628str x0, [sp+104]
0001c62cadd x1, x1, 2
0001c630subs xzr, x2, x1
0001c634b.hs 0x1c650
0001c638strh w3, [sp+128]
0001c63corr x3, xzr, 2
0001c640adrp x4, 0x5d9000
0001c644add x4, x4, 3072
0001c648bl runtime.growslice
0001c64cldrh w3, [sp+128]
0001c650
0001c650loc_1c650:
0001c650rev16 w3, w3
0001c654sub x4, x1, 2
0001c658strh w3, [x0+x4]
0001c65cldur x29, [sp-8]
0001c660ldr x30, [sp], 96
0001c664ret x30
0001c668
0001c668loc_1c668:
0001c668stp x0, x1, [sp+8]
0001c66cstr x2, [sp+24]
0001c670strh w3, [sp+32]
0001c674mov x3, x30
0001c678bl runtime.morestack_noctxt.abi0
0001c67cldp x0, x1, [sp+8]
0001c680ldr x2, [sp+24]
0001c684ldrh w3, [sp+32]
0001c688b 0x1c610
0001c68cudf 0
0001c610

0001c690
0001c690internal/byteorder.BEUint32: ; void internal/byteorder.BEUint32(struct []uint8 b)
0001c690ldr x16, [x28+16]
0001c694subs xzr, sp, x16
0001c698b.ls 0x1c6d4
0001c69cstr x30, [sp-32]!
0001c6a0stur x29, [sp-8]
0001c6a4sub x29, sp, 8
0001c6a8str x0, [sp+40]
0001c6acsubs xzr, x1, 3
0001c6b0b.ls 0x1c6c8
0001c6b4ldr w1, [x0]
0001c6b8rev w0, w1
0001c6bcldur x29, [sp-8]
0001c6c0ldr x30, [sp], 32
0001c6c4ret x30
0001c6c8
0001c6c8loc_1c6c8:
0001c6c8orr x0, xzr, 3
0001c6ccbl runtime.panicIndex
0001c6d0hint
0001c6d4
0001c6d4loc_1c6d4:
0001c6d4stp x0, x1, [sp+8]
0001c6d8str x2, [sp+24]
0001c6dcmov x3, x30
0001c6e0bl runtime.morestack_noctxt.abi0
0001c6e4ldp x0, x1, [sp+8]
0001c6e8ldr x2, [sp+24]
0001c6ecb 0x1c690
0001c690

0001c6f0
0001c6f0internal/byteorder.BEPutUint32: ; void internal/byteorder.BEPutUint32(struct []uint8 b, uint32 v)
0001c6f0ldr x16, [x28+16]
0001c6f4subs xzr, sp, x16
0001c6f8b.ls 0x1c734
0001c6fcstr x30, [sp-32]!
0001c700stur x29, [sp-8]
0001c704sub x29, sp, 8
0001c708str x0, [sp+40]
0001c70csubs xzr, x1, 3
0001c710b.ls 0x1c728
0001c714rev w1, w3
0001c718str w1, [x0]
0001c71cldur x29, [sp-8]
0001c720ldr x30, [sp], 32
0001c724ret x30
0001c728
0001c728loc_1c728:
0001c728orr x0, xzr, 3
0001c72cbl runtime.panicIndex
0001c730hint
0001c734
0001c734loc_1c734:
0001c734stp x0, x1, [sp+8]
0001c738str x2, [sp+24]
0001c73cstr w3, [sp+32]
0001c740mov x3, x30
0001c744bl runtime.morestack_noctxt.abi0
0001c748ldp x0, x1, [sp+8]
0001c74cldr x2, [sp+24]
0001c750ldr w3, [sp+32]
0001c754b 0x1c6f0
0001c758udf 0
0001c75cudf 0
0001c6f0

0001c760
0001c760internal/byteorder.BEAppendUint32: ; void internal/byteorder.BEAppendUint32(struct []uint8 b, uint32 v)
0001c760ldr x16, [x28+16]
0001c764subs xzr, sp, x16
0001c768b.ls 0x1c7b8
0001c76cstr x30, [sp-96]!
0001c770stur x29, [sp-8]
0001c774sub x29, sp, 8
0001c778str x0, [sp+104]
0001c77cadd x1, x1, 4
0001c780subs xzr, x2, x1
0001c784b.hs 0x1c7a0
0001c788str w3, [sp+128]
0001c78corr x3, xzr, 4
0001c790adrp x4, 0x5d9000
0001c794add x4, x4, 3072
0001c798bl runtime.growslice
0001c79cldr w3, [sp+128]
0001c7a0
0001c7a0loc_1c7a0:
0001c7a0rev w3, w3
0001c7a4sub x4, x1, 4
0001c7a8str w3, [x0+x4]
0001c7acldur x29, [sp-8]
0001c7b0ldr x30, [sp], 96
0001c7b4ret x30
0001c7b8
0001c7b8loc_1c7b8:
0001c7b8stp x0, x1, [sp+8]
0001c7bcstr x2, [sp+24]
0001c7c0str w3, [sp+32]
0001c7c4mov x3, x30
0001c7c8bl runtime.morestack_noctxt.abi0
0001c7ccldp x0, x1, [sp+8]
0001c7d0ldr x2, [sp+24]
0001c7d4ldr w3, [sp+32]
0001c7d8b 0x1c760
0001c7dcudf 0
0001c760

0001c7e0
0001c7e0internal/byteorder.BEUint64: ; void internal/byteorder.BEUint64(struct []uint8 b)
0001c7e0ldr x16, [x28+16]
0001c7e4subs xzr, sp, x16
0001c7e8b.ls 0x1c824
0001c7ecstr x30, [sp-32]!
0001c7f0stur x29, [sp-8]
0001c7f4sub x29, sp, 8
0001c7f8str x0, [sp+40]
0001c7fcsubs xzr, x1, 7
0001c800b.ls 0x1c818
0001c804ldr x1, [x0]
0001c808rev x0, x1
0001c80cldur x29, [sp-8]
0001c810ldr x30, [sp], 32
0001c814ret x30
0001c818
0001c818loc_1c818:
0001c818orr x0, xzr, 7
0001c81cbl runtime.panicIndex
0001c820hint
0001c824
0001c824loc_1c824:
0001c824stp x0, x1, [sp+8]
0001c828str x2, [sp+24]
0001c82cmov x3, x30
0001c830bl runtime.morestack_noctxt.abi0
0001c834ldp x0, x1, [sp+8]
0001c838ldr x2, [sp+24]
0001c83cb 0x1c7e0
0001c7e0

0001c840
0001c840internal/byteorder.BEPutUint64: ; void internal/byteorder.BEPutUint64(struct []uint8 b, uint64 v)
0001c840ldr x16, [x28+16]
0001c844subs xzr, sp, x16
0001c848b.ls 0x1c884
0001c84cstr x30, [sp-32]!
0001c850stur x29, [sp-8]
0001c854sub x29, sp, 8
0001c858str x0, [sp+40]
0001c85csubs xzr, x1, 7
0001c860b.ls 0x1c878
0001c864rev x1, x3
0001c868str x1, [x0]
0001c86cldur x29, [sp-8]
0001c870ldr x30, [sp], 32
0001c874ret x30
0001c878
0001c878loc_1c878:
0001c878orr x0, xzr, 7
0001c87cbl runtime.panicIndex
0001c880hint
0001c884
0001c884loc_1c884:
0001c884stp x0, x1, [sp+8]
0001c888stp x2, x3, [sp+24]
0001c88cmov x3, x30
0001c890bl runtime.morestack_noctxt.abi0
0001c894ldp x0, x1, [sp+8]
0001c898ldp x2, x3, [sp+24]
0001c89cb 0x1c840
0001c840

0001c8a0
0001c8a0internal/byteorder.BEAppendUint64: ; void internal/byteorder.BEAppendUint64(struct []uint8 b, uint64 v)
0001c8a0ldr x16, [x28+16]
0001c8a4subs xzr, sp, x16
0001c8a8b.ls 0x1c8f8
0001c8acstr x30, [sp-96]!
0001c8b0stur x29, [sp-8]
0001c8b4sub x29, sp, 8
0001c8b8str x0, [sp+104]
0001c8bcadd x1, x1, 8
0001c8c0subs xzr, x2, x1
0001c8c4b.hs 0x1c8e0
0001c8c8str x3, [sp+128]
0001c8ccorr x3, xzr, 8
0001c8d0adrp x4, 0x5d9000
0001c8d4add x4, x4, 3072
0001c8d8bl runtime.growslice
0001c8dcldr x3, [sp+128]
0001c8e0
0001c8e0loc_1c8e0:
0001c8e0rev x3, x3
0001c8e4sub x4, x1, 8
0001c8e8str x3, [x0+x4]
0001c8ecldur x29, [sp-8]
0001c8f0ldr x30, [sp], 96
0001c8f4ret x30
0001c8f8
0001c8f8loc_1c8f8:
0001c8f8stp x0, x1, [sp+8]
0001c8fcstp x2, x3, [sp+24]
0001c900mov x3, x30
0001c904bl runtime.morestack_noctxt.abi0
0001c908ldp x0, x1, [sp+8]
0001c90cldp x2, x3, [sp+24]
0001c910b 0x1c8a0
0001c914udf 0
0001c918udf 0
0001c91cudf 0
0001c8a0

0001c920
0001c920internal/chacha8rand.(*State).Next: ; void internal/chacha8rand.(*State).Next(internal/chacha8rand.State * s)
0001c920ldr w2, [x0+288]
0001c924ldr w3, [x0+292]
0001c928subs wzr, w3, w2
0001c92cb.hi 0x1c93c
0001c930mov x0, xzr
0001c934mov x1, xzr
0001c938ret x30
0001c93c
0001c93cloc_1c93c:
0001c93cadd x3, x2, 1
0001c940str w3, [x0+288]
0001c944and x2, x2, 31
0001c948ldr x0, [x0+3*x2]
0001c94corr x1, xzr, 1
0001c950ret x30
0001c954udf 0
0001c958udf 0
0001c95cudf 0
0001c920

0001c960
0001c960internal/chacha8rand.(*State).Init: ; void internal/chacha8rand.(*State).Init(internal/chacha8rand.State * s, uint8[32] seed)
0001c960ldr x16, [x28+16]
0001c964subs xzr, sp, x16
0001c968b.ls 0x1c9f8
0001c96cstr x30, [sp-80]!
0001c970stur x29, [sp-8]
0001c974sub x29, sp, 8
0001c978str x0, [sp+120]
0001c97cadd x0, sp, 88
0001c980orr x1, xzr, 32
0001c984mov x2, x1
0001c988bl internal/byteorder.LEUint64
0001c98cstr x0, [sp+64]
0001c990add x0, sp, 96
0001c994orr x1, xzr, 24
0001c998mov x2, x1
0001c99cbl internal/byteorder.LEUint64
0001c9a0str x0, [sp+56]
0001c9a4add x0, sp, 104
0001c9a8orr x1, xzr, 16
0001c9acmov x2, x1
0001c9b0bl internal/byteorder.LEUint64
0001c9b4str x0, [sp+48]
0001c9b8add x0, sp, 112
0001c9bcorr x1, xzr, 8
0001c9c0mov x2, x1
0001c9c4bl internal/byteorder.LEUint64
0001c9c8ldr x3, [sp+64]
0001c9ccstr x3, [sp+8]
0001c9d0ldr x3, [sp+56]
0001c9d4str x3, [sp+16]
0001c9d8ldr x3, [sp+48]
0001c9dcstr x3, [sp+24]
0001c9e0str x0, [sp+32]
0001c9e4ldr x0, [sp+120]
0001c9e8bl internal/chacha8rand.(*State).Init64
0001c9ecldur x29, [sp-8]
0001c9f0ldr x30, [sp], 80
0001c9f4ret x30
0001c9f8
0001c9f8loc_1c9f8:
0001c9f8str x0, [sp+40]
0001c9fcmov x3, x30
0001ca00bl runtime.morestack_noctxt.abi0
0001ca04ldr x0, [sp+40]
0001ca08b 0x1c960
0001ca0cudf 0
0001c960

0001ca10
0001ca10internal/chacha8rand.(*State).Init64: ; void internal/chacha8rand.(*State).Init64(internal/chacha8rand.State * s, uint64[4] seed)
0001ca10ldr x16, [x28+16]
0001ca14subs xzr, sp, x16
0001ca18b.ls 0x1ca6c
0001ca1cstr x30, [sp-48]!
0001ca20stur x29, [sp-8]
0001ca24sub x29, sp, 8
0001ca28str x0, [sp+88]
0001ca2cldp x3, x4, [sp+56]
0001ca30ldp x5, x6, [sp+72]
0001ca34stp x3, x4, [x0+256]
0001ca38stp x5, x6, [x0+272]
0001ca3cadd x3, x0, 256
0001ca40mov x1, x0
0001ca44mov x2, xzr
0001ca48mov x0, x3
0001ca4cbl internal/chacha8rand.block
0001ca50ldr x3, [sp+88]
0001ca54str wzr, [x3+296]
0001ca58movz x4, 0x2000000000
0001ca5cstr x4, [x3+288]
0001ca60ldur x29, [sp-8]
0001ca64ldr x30, [sp], 48
0001ca68ret x30
0001ca6c
0001ca6cloc_1ca6c:
0001ca6cstr x0, [sp+40]
0001ca70mov x3, x30
0001ca74bl runtime.morestack_noctxt.abi0
0001ca78ldr x0, [sp+40]
0001ca7cb 0x1ca10
0001ca10

0001ca80
0001ca80internal/chacha8rand.(*State).Refill: ; void internal/chacha8rand.(*State).Refill(internal/chacha8rand.State * s)
0001ca80ldr x16, [x28+16]
0001ca84subs xzr, sp, x16
0001ca88b.ls 0x1cb14
0001ca8cstr x30, [sp-48]!
0001ca90stur x29, [sp-8]
0001ca94sub x29, sp, 8
0001ca98ldr w3, [x0+296]
0001ca9cadd x4, x3, 4
0001caa0str w4, [x0+296]
0001caa4subs wzr, w3, 12
0001caa8b.ne 0x1cad0
0001caacldr x3, [x0+224]
0001cab0str x3, [x0+256]
0001cab4ldr x3, [x0+232]
0001cab8str x3, [x0+264]
0001cabcldr x3, [x0+240]
0001cac0str x3, [x0+272]
0001cac4ldr x3, [x0+248]
0001cac8str x3, [x0+280]
0001caccstr wzr, [x0+296]
0001cad0
0001cad0loc_1cad0:
0001cad0str x0, [sp+56]
0001cad4add x3, x0, 256
0001cad8ldr w2, [x0+296]
0001cadcmov x1, x0
0001cae0mov x0, x3
0001cae4bl internal/chacha8rand.block
0001cae8movz x3, 0x2000000000
0001caecldr x4, [sp+56]
0001caf0str x3, [x4+288]
0001caf4ldr w3, [x4+296]
0001caf8subs wzr, w3, 12
0001cafcb.ne 0x1cb08
0001cb00orr x0, xzr, 28
0001cb04str w0, [x4+292]
0001cb08
0001cb08loc_1cb08:
0001cb08ldur x29, [sp-8]
0001cb0cldr x30, [sp], 48
0001cb10ret x30
0001cb14
0001cb14loc_1cb14:
0001cb14str x0, [sp+8]
0001cb18mov x3, x30
0001cb1cbl runtime.morestack_noctxt.abi0
0001cb20ldr x0, [sp+8]
0001cb24b 0x1ca80
0001cb28udf 0
0001cb2cudf 0
0001ca80

0001cb30
0001cb30internal/chacha8rand.(*State).Reseed: ; void internal/chacha8rand.(*State).Reseed(internal/chacha8rand.State * s)
0001cb30ldr x16, [x28+16]
0001cb34subs xzr, sp, x16
0001cb38b.ls 0x1cbb8
0001cb3cstr x30, [sp-96]!
0001cb40stur x29, [sp-8]
0001cb44sub x29, sp, 8
0001cb48str x0, [sp+104]
0001cb4cstp xzr, xzr, [sp+48]
0001cb50stp xzr, xzr, [sp+64]
0001cb54mov x1, xzr
0001cb58b 0x1cb70
0001cb5c
0001cb5cloc_1cb5c:
0001cb5cldr x2, [sp+80]
0001cb60add x3, sp, 48
0001cb64str x0, [x3+3*x2]
0001cb68add x1, x2, 1
0001cb6cldr x0, [sp+104]
0001cb70
0001cb70loc_1cb70:
0001cb70subs xzr, x1, 4
0001cb74b.ge 0x1cb80
0001cb78str x1, [sp+80]
0001cb7cb 0x1cbac
0001cb80
0001cb80loc_1cb80:
0001cb80ldp x1, x2, [sp+48]
0001cb84ldp x3, x4, [sp+64]
0001cb88stp x1, x2, [sp+8]
0001cb8cstp x3, x4, [sp+24]
0001cb90bl internal/chacha8rand.(*State).Init64
0001cb94ldur x29, [sp-8]
0001cb98ldr x30, [sp], 96
0001cb9cret x30
0001cba0
0001cba0loc_1cba0:
0001cba0ldr x0, [sp+104]
0001cba4bl internal/chacha8rand.(*State).Refill
0001cba8ldr x0, [sp+104]
0001cbac
0001cbacloc_1cbac:
0001cbacbl internal/chacha8rand.(*State).Next
0001cbb0tbz w1, 0, 0x1cba0
0001cbb4b 0x1cb5c
0001cbb8
0001cbb8loc_1cbb8:
0001cbb8str x0, [sp+8]
0001cbbcmov x3, x30
0001cbc0bl runtime.morestack_noctxt.abi0
0001cbc4ldr x0, [sp+8]
0001cbc8b 0x1cb30
0001cbccudf 0
0001cb30

0001cbd0
0001cbd0internal/chacha8rand.Marshal: ; void internal/chacha8rand.Marshal(internal/chacha8rand.State * s)
0001cbd0ldr x16, [x28+16]
0001cbd4subs xzr, sp, x16
0001cbd8b.ls 0x1ccc8
0001cbdcstr x30, [sp-96]!
0001cbe0stur x29, [sp-8]
0001cbe4sub x29, sp, 8
0001cbe8str x0, [sp+104]
0001cbecadrp x0, 0x5d9000
0001cbf0add x0, x0, 3072
0001cbf4orr x1, xzr, 48
0001cbf8mov x2, x1
0001cbfcbl runtime.makeslice
0001cc00adrp x3, 0x695000
0001cc04add x3, x3, 1404
0001cc08subs xzr, x0, x3
0001cc0cb.eq 0x1cc24
0001cc10movz x4, 26723
0001cc14movk x4, 0x63610000
0001cc18movk x4, 0x616800000000
0001cc1cmovk x4, 0x3a38000000000000
0001cc20str x4, [x0]
0001cc24
0001cc24loc_1cc24:
0001cc24str x0, [sp+80]
0001cc28ldr x4, [sp+104]
0001cc2cldr w5, [x4+296]
0001cc30ubfm x5, x5, 2, 31
0001cc34ldr w4, [x4+288]
0001cc38add x4, x4, x5, lsl #5
0001cc3cadd x0, x0, 8
0001cc40mov w3, w4
0001cc44movz x1, 40
0001cc48mov x2, x1
0001cc4cbl internal/byteorder.BEPutUint64
0001cc50ldr x4, [sp+104]
0001cc54ldp x5, x6, [x4+256]
0001cc58ldp x4, x7, [x4+272]
0001cc5cstp x5, x6, [sp+48]
0001cc60stp x4, x7, [sp+64]
0001cc64mov x0, xzr
0001cc68b 0x1cca8
0001cc6c
0001cc6cloc_1cc6c:
0001cc6cstr x0, [sp+40]
0001cc70add x4, sp, 48
0001cc74ldr x3, [x4+3*x0]
0001cc78add x4, x0, 2
0001cc7corr x5, xzr, 48
0001cc80sub x2, x5, x4, lsl #3
0001cc84sub x5, xzr, x2
0001cc88sbfm x5, x5, 63, 63
0001cc8cand x4, x5, x4, lsl #3
0001cc90ldr x5, [sp+80]
0001cc94add x0, x5, x4
0001cc98mov x1, x2
0001cc9cbl internal/byteorder.LEPutUint64
0001cca0ldr x4, [sp+40]
0001cca4add x0, x4, 1
0001cca8
0001cca8loc_1cca8:
0001cca8subs xzr, x0, 4
0001ccacb.lt 0x1cc6c
0001ccb0ldr x0, [sp+80]
0001ccb4orr x1, xzr, 48
0001ccb8mov x2, x1
0001ccbcldur x29, [sp-8]
0001ccc0ldr x30, [sp], 96
0001ccc4ret x30
0001ccc8
0001ccc8loc_1ccc8:
0001ccc8str x0, [sp+8]
0001ccccmov x3, x30
0001ccd0bl runtime.morestack_noctxt.abi0
0001ccd4ldr x0, [sp+8]
0001ccd8b 0x1cbd0
0001ccdcudf 0
0001cbd0

0001cce0
0001cce0internal/chacha8rand.(*errUnmarshalChaCha8).Error: ; void internal/chacha8rand.(*errUnmarshalChaCha8).Error(internal/chacha8rand.errUnmarshalChaCha8 * p0)
0001cce0adrp x0, 0x69d000
0001cce4add x0, x0, 726
0001cce8orr x1, xzr, 24
0001ccecret x30
0001cce0

0001ccf0
0001ccf0internal/chacha8rand.Unmarshal: ; void internal/chacha8rand.Unmarshal(internal/chacha8rand.State * s, struct []uint8 data)
0001ccf0ldr x16, [x28+16]
0001ccf4subs xzr, sp, x16
0001ccf8b.ls 0x1ce48
0001ccfcstr x30, [sp-64]!
0001cd00stur x29, [sp-8]
0001cd04sub x29, sp, 8
0001cd08str x1, [sp+80]
0001cd0csubs xzr, x2, 48
0001cd10b.ne 0x1cd30
0001cd14ldr x4, [x1]
0001cd18movz x5, 26723
0001cd1cmovk x5, 0x63610000
0001cd20movk x5, 0x616800000000
0001cd24movk x5, 0x3a38000000000000
0001cd28subs xzr, x4, x5
0001cd2cb.eq 0x1cd4c
0001cd30
0001cd30loc_1cd30:
0001cd30adrp x0, 0x6f9000
0001cd34add x0, x0, 1184
0001cd38adrp x1, 0xa2f000
0001cd3cadd x1, x1, 1504
0001cd40ldur x29, [sp-8]
0001cd44ldr x30, [sp], 64
0001cd48ret x30
0001cd4c
0001cd4cloc_1cd4c:
0001cd4cstr x0, [sp+72]
0001cd50str x3, [sp+96]
0001cd54str x1, [sp+80]
0001cd58add x0, x1, 8
0001cd5csub x2, x3, 8
0001cd60movz x1, 40
0001cd64bl internal/byteorder.BEUint64
0001cd68subs xzr, x0, 124
0001cd6cb.hi 0x1cd7c
0001cd70str x0, [sp+40]
0001cd74mov x1, xzr
0001cd78b 0x1cde8
0001cd7c
0001cd7cloc_1cd7c:
0001cd7cadrp x0, 0x6f9000
0001cd80add x0, x0, 1184
0001cd84adrp x1, 0xa2f000
0001cd88add x1, x1, 1504
0001cd8cldur x29, [sp-8]
0001cd90ldr x30, [sp], 64
0001cd94ret x30
0001cd98
0001cd98loc_1cd98:
0001cd98str x1, [sp+48]
0001cd9cadd x3, x1, 2
0001cda0ldr x4, [sp+96]
0001cda4sub x2, x4, x3, lsl #3
0001cda8orr x4, xzr, 48
0001cdacsub x1, x4, x3, lsl #3
0001cdb0sub x4, xzr, x2
0001cdb4sbfm x4, x4, 63, 63
0001cdb8and x3, x4, x3, lsl #3
0001cdbcldr x4, [sp+80]
0001cdc0add x0, x4, x3
0001cdc4bl internal/byteorder.LEUint64
0001cdc8ldr x1, [sp+72]
0001cdccldrsb x27, [x1]
0001cdd0add x3, x1, 256
0001cdd4ldr x4, [sp+48]
0001cdd8str x0, [x3+3*x4]
0001cddcadd x3, x4, 1
0001cde0ldr x0, [sp+40]
0001cde4mov x1, x3
0001cde8
0001cde8loc_1cde8:
0001cde8subs xzr, x1, 4
0001cdecb.lt 0x1cd98
0001cdf0ubfm x3, x0, 5, 31
0001cdf4ubfm x2, x3, 62, 61
0001cdf8ldr x1, [sp+72]
0001cdfcstr w2, [x1+296]
0001ce00add x0, x1, 256
0001ce04bl internal/chacha8rand.block
0001ce08ldr x3, [sp+40]
0001ce0cand x3, x3, 31
0001ce10ldr x4, [sp+72]
0001ce14str w3, [x4+288]
0001ce18orr x3, xzr, 32
0001ce1cstr w3, [x4+292]
0001ce20ldr w3, [x4+296]
0001ce24subs wzr, w3, 12
0001ce28b.ne 0x1ce34
0001ce2corr x2, xzr, 28
0001ce30str w2, [x4+292]
0001ce34
0001ce34loc_1ce34:
0001ce34mov x0, xzr
0001ce38mov x1, xzr
0001ce3cldur x29, [sp-8]
0001ce40ldr x30, [sp], 64
0001ce44ret x30
0001ce48
0001ce48loc_1ce48:
0001ce48stp x0, x1, [sp+8]
0001ce4cstp x2, x3, [sp+24]
0001ce50mov x3, x30
0001ce54bl runtime.morestack_noctxt.abi0
0001ce58ldp x0, x1, [sp+8]
0001ce5cldp x2, x3, [sp+24]
0001ce60b 0x1ccf0
0001ce64udf 0
0001ce68udf 0
0001ce6cudf 0
0001ccf0

0001ce70
0001ce70internal/chacha8rand.block: ; void internal/chacha8rand.block(void)
0001ce70str x30, [sp-32]!
0001ce74stur x29, [sp-8]
0001ce78sub x29, sp, 8
0001ce7cadrp x10, 0x6f9000
0001ce80add x10, x10, 1216
0001ce84ld4r
0001ce88adrp x11, 0x6f9000
0001ce8cadd x11, x11, 1248
0001ce90ld1
0001ce94ld4r
0001ce98ld4r
0001ce9cstr w2, [sp]
0001cea0ld1r
0001cea4add v12.4s, v12.4s, v30.4s
0001cea8eor v13.16b, v13.16b, v13.16b
0001ceaceor v14.16b, v14.16b, v14.16b
0001ceb0eor v15.16b, v15.16b, v15.16b
0001ceb4orr v20.16b, v4.16b, v4.16b
0001ceb8orr v21.16b, v5.16b, v5.16b
0001cebcorr v22.16b, v6.16b, v6.16b
0001cec0orr v23.16b, v7.16b, v7.16b
0001cec4orr v24.16b, v8.16b, v8.16b
0001cec8orr v25.16b, v9.16b, v9.16b
0001ceccorr v26.16b, v10.16b, v10.16b
0001ced0orr v27.16b, v11.16b, v11.16b
0001ced4orr x0, xzr, 4
0001ced8
0001ced8loc_1ced8:
0001ced8add v0.4s, v4.4s, v0.4s
0001cedceor v12.16b, v0.16b, v12.16b
0001cee0rev32 v12.8h, v12.8h
0001cee4add v8.4s, v12.4s, v8.4s
0001cee8eor v30.16b, v8.16b, v4.16b
0001ceecshl v4.4s, v30.4s, 12
0001cef0sri v4.4s, v30.4s, 20
0001cef4add v0.4s, v4.4s, v0.4s
0001cef8eor v12.16b, v0.16b, v12.16b
0001cefctbl v12.16b
0001cf00add v8.4s, v12.4s, v8.4s
0001cf04eor v30.16b, v8.16b, v4.16b
0001cf08shl v4.4s, v30.4s, 7
0001cf0csri v4.4s, v30.4s, 25
0001cf10add v1.4s, v5.4s, v1.4s
0001cf14eor v13.16b, v1.16b, v13.16b
0001cf18rev32 v13.8h, v13.8h
0001cf1cadd v9.4s, v13.4s, v9.4s
0001cf20eor v30.16b, v9.16b, v5.16b
0001cf24shl v5.4s, v30.4s, 12
0001cf28sri v5.4s, v30.4s, 20
0001cf2cadd v1.4s, v5.4s, v1.4s
0001cf30eor v13.16b, v1.16b, v13.16b
0001cf34tbl v13.16b
0001cf38add v9.4s, v13.4s, v9.4s
0001cf3ceor v30.16b, v9.16b, v5.16b
0001cf40shl v5.4s, v30.4s, 7
0001cf44sri v5.4s, v30.4s, 25
0001cf48add v2.4s, v6.4s, v2.4s
0001cf4ceor v14.16b, v2.16b, v14.16b
0001cf50rev32 v14.8h, v14.8h
0001cf54add v10.4s, v14.4s, v10.4s
0001cf58eor v30.16b, v10.16b, v6.16b
0001cf5cshl v6.4s, v30.4s, 12
0001cf60sri v6.4s, v30.4s, 20
0001cf64add v2.4s, v6.4s, v2.4s
0001cf68eor v14.16b, v2.16b, v14.16b
0001cf6ctbl v14.16b
0001cf70add v10.4s, v14.4s, v10.4s
0001cf74eor v30.16b, v10.16b, v6.16b
0001cf78shl v6.4s, v30.4s, 7
0001cf7csri v6.4s, v30.4s, 25
0001cf80add v3.4s, v7.4s, v3.4s
0001cf84eor v15.16b, v3.16b, v15.16b
0001cf88rev32 v15.8h, v15.8h
0001cf8cadd v11.4s, v15.4s, v11.4s
0001cf90eor v30.16b, v11.16b, v7.16b
0001cf94shl v7.4s, v30.4s, 12
0001cf98sri v7.4s, v30.4s, 20
0001cf9cadd v3.4s, v7.4s, v3.4s
0001cfa0eor v15.16b, v3.16b, v15.16b
0001cfa4tbl v15.16b
0001cfa8add v11.4s, v15.4s, v11.4s
0001cfaceor v30.16b, v11.16b, v7.16b
0001cfb0shl v7.4s, v30.4s, 7
0001cfb4sri v7.4s, v30.4s, 25
0001cfb8add v0.4s, v5.4s, v0.4s
0001cfbceor v15.16b, v0.16b, v15.16b
0001cfc0rev32 v15.8h, v15.8h
0001cfc4add v10.4s, v15.4s, v10.4s
0001cfc8eor v30.16b, v10.16b, v5.16b
0001cfccshl v5.4s, v30.4s, 12
0001cfd0sri v5.4s, v30.4s, 20
0001cfd4add v0.4s, v5.4s, v0.4s
0001cfd8eor v15.16b, v0.16b, v15.16b
0001cfdctbl v15.16b
0001cfe0add v10.4s, v15.4s, v10.4s
0001cfe4eor v30.16b, v10.16b, v5.16b
0001cfe8shl v5.4s, v30.4s, 7
0001cfecsri v5.4s, v30.4s, 25
0001cff0add v1.4s, v6.4s, v1.4s
0001cff4eor v12.16b, v1.16b, v12.16b
0001cff8rev32 v12.8h, v12.8h
0001cffcadd v11.4s, v12.4s, v11.4s
0001d000eor v30.16b, v11.16b, v6.16b
0001d004shl v6.4s, v30.4s, 12
0001d008sri v6.4s, v30.4s, 20
0001d00cadd v1.4s, v6.4s, v1.4s
0001d010eor v12.16b, v1.16b, v12.16b
0001d014tbl v12.16b
0001d018add v11.4s, v12.4s, v11.4s
0001d01ceor v30.16b, v11.16b, v6.16b
0001d020shl v6.4s, v30.4s, 7
0001d024sri v6.4s, v30.4s, 25
0001d028add v2.4s, v7.4s, v2.4s
0001d02ceor v13.16b, v2.16b, v13.16b
0001d030rev32 v13.8h, v13.8h
0001d034add v8.4s, v13.4s, v8.4s
0001d038eor v30.16b, v8.16b, v7.16b
0001d03cshl v7.4s, v30.4s, 12
0001d040sri v7.4s, v30.4s, 20
0001d044add v2.4s, v7.4s, v2.4s
0001d048eor v13.16b, v2.16b, v13.16b
0001d04ctbl v13.16b
0001d050add v8.4s, v13.4s, v8.4s
0001d054eor v30.16b, v8.16b, v7.16b
0001d058shl v7.4s, v30.4s, 7
0001d05csri v7.4s, v30.4s, 25
0001d060add v3.4s, v4.4s, v3.4s
0001d064eor v14.16b, v3.16b, v14.16b
0001d068rev32 v14.8h, v14.8h
0001d06cadd v9.4s, v14.4s, v9.4s
0001d070eor v30.16b, v9.16b, v4.16b
0001d074shl v4.4s, v30.4s, 12
0001d078sri v4.4s, v30.4s, 20
0001d07cadd v3.4s, v4.4s, v3.4s
0001d080eor v14.16b, v3.16b, v14.16b
0001d084tbl v14.16b
0001d088add v9.4s, v14.4s, v9.4s
0001d08ceor v30.16b, v9.16b, v4.16b
0001d090shl v4.4s, v30.4s, 7
0001d094sri v4.4s, v30.4s, 25
0001d098sub x0, x0, 1
0001d09ccbnz x0, 0x1ced8
0001d0a0add v4.4s, v20.4s, v4.4s
0001d0a4add v5.4s, v21.4s, v5.4s
0001d0a8add v6.4s, v22.4s, v6.4s
0001d0acadd v7.4s, v23.4s, v7.4s
0001d0b0add v8.4s, v24.4s, v8.4s
0001d0b4add v9.4s, v25.4s, v9.4s
0001d0b8add v10.4s, v26.4s, v10.4s
0001d0bcadd v11.4s, v27.4s, v11.4s
0001d0c0st1
0001d0c4st1
0001d0c8st1
0001d0ccst1
0001d0d0add x29, sp, 24
0001d0d4add sp, sp, 32
0001d0d8ret x30
0001d0dcudf 0
0001ce70

0001d0e0
0001d0e0type:.eq.internal/chacha8rand.State: ; void type:.eq.internal/chacha8rand.State(internal/chacha8rand.State * p, internal/chacha8rand.State * q)
0001d0e0ldr x16, [x28+16]
0001d0e4subs xzr, sp, x16
0001d0e8b.ls 0x1d134
0001d0ecstr x30, [sp-64]!
0001d0f0stur x29, [sp-8]
0001d0f4sub x29, sp, 8
0001d0f8str x0, [sp+72]
0001d0fcstr x1, [sp+80]
0001d100strb wzr, [sp+39]
0001d104ldr x3, [sp+72]
0001d108str x3, [sp+48]
0001d10cldr x1, [sp+80]
0001d110str x1, [sp+40]
0001d114ldr x0, [sp+48]
0001d118movz x2, 300
0001d11cbl runtime.memequal
0001d120strb w0, [sp+39]
0001d124b 0x1d128
0001d128
0001d128loc_1d128:
0001d128ldur x29, [sp-8]
0001d12cldr x30, [sp], 64
0001d130ret x30
0001d134
0001d134loc_1d134:
0001d134stp x0, x1, [sp+8]
0001d138mov x3, x30
0001d13cbl runtime.morestack_noctxt.abi0
0001d140ldp x0, x1, [sp+8]
0001d144b 0x1d0e0
0001d148udf 0
0001d14cudf 0
0001d0e0

0001d150
0001d150runtime.init: ; void runtime.init(void)
0001d150ldr x16, [x28+16]
0001d154subs xzr, sp, x16
0001d158b.ls 0x1d314
0001d15cstr x30, [sp-32]!
0001d160stur x29, [sp-8]
0001d164sub x29, sp, 8
0001d168movz x0, 0x7ff0000000000000
0001d16cbl runtime.float64frombits
0001d170adrp x27, 0xa2e000
0001d174str d0, [x27+1744]
0001d178adrp x0, 0x9f0000
0001d17cadd x0, x0, 2128
0001d180bl runtime.efaceOf
0001d184ldr x1, [x0]
0001d188adrp x27, 0xa2e000
0001d18cldr w2, [x27+3056]
0001d190cbz w2, 0x1d1a8
0001d194bl runtime.gcWriteBarrier2
0001d198str x1, [x25]
0001d19cadrp x27, 0xa03000
0001d1a0ldr x2, [x27+2904]
0001d1a4str x2, [x25+8]
0001d1a8
0001d1a8loc_1d1a8:
0001d1a8adrp x27, 0xa03000
0001d1acstr x1, [x27+2904]
0001d1b0adrp x0, 0x9f0000
0001d1b4add x0, x0, 2144
0001d1b8bl runtime.efaceOf
0001d1bcldr x1, [x0]
0001d1c0adrp x27, 0xa2e000
0001d1c4ldr w2, [x27+3056]
0001d1c8cbz w2, 0x1d1e0
0001d1ccbl runtime.gcWriteBarrier2
0001d1d0str x1, [x25]
0001d1d4adrp x27, 0xa03000
0001d1d8ldr x2, [x27+2912]
0001d1dcstr x2, [x25+8]
0001d1e0
0001d1e0loc_1d1e0:
0001d1e0adrp x27, 0xa03000
0001d1e4str x1, [x27+2912]
0001d1e8adrp x0, 0x9f0000
0001d1ecadd x0, x0, 2160
0001d1f0bl runtime.efaceOf
0001d1f4ldr x1, [x0]
0001d1f8adrp x27, 0xa2e000
0001d1fcldr w2, [x27+3056]
0001d200cbz w2, 0x1d218
0001d204bl runtime.gcWriteBarrier2
0001d208str x1, [x25]
0001d20cadrp x27, 0xa03000
0001d210ldr x2, [x27+2920]
0001d214str x2, [x25+8]
0001d218
0001d218loc_1d218:
0001d218adrp x27, 0xa03000
0001d21cstr x1, [x27+2920]
0001d220adrp x0, 0x9f0000
0001d224add x0, x0, 2176
0001d228bl runtime.efaceOf
0001d22cldr x1, [x0]
0001d230adrp x27, 0xa2e000
0001d234ldr w2, [x27+3056]
0001d238cbz w2, 0x1d250
0001d23cbl runtime.gcWriteBarrier2
0001d240str x1, [x25]
0001d244adrp x27, 0xa03000
0001d248ldr x2, [x27+2928]
0001d24cstr x2, [x25+8]
0001d250
0001d250loc_1d250:
0001d250adrp x27, 0xa03000
0001d254str x1, [x27+2928]
0001d258adrp x0, 0x9f0000
0001d25cadd x0, x0, 2192
0001d260bl runtime.efaceOf
0001d264ldr x1, [x0]
0001d268adrp x27, 0xa2e000
0001d26cldr w2, [x27+3056]
0001d270cbz w2, 0x1d288
0001d274bl runtime.gcWriteBarrier2
0001d278str x1, [x25]
0001d27cadrp x27, 0xa03000
0001d280ldr x2, [x27+2936]
0001d284str x2, [x25+8]
0001d288
0001d288loc_1d288:
0001d288adrp x27, 0xa03000
0001d28cstr x1, [x27+2936]
0001d290adrp x0, 0x9f0000
0001d294add x0, x0, 2208
0001d298bl runtime.efaceOf
0001d29cldr x1, [x0]
0001d2a0adrp x27, 0xa2e000
0001d2a4ldr w2, [x27+3056]
0001d2a8cbz w2, 0x1d2c0
0001d2acbl runtime.gcWriteBarrier2
0001d2b0str x1, [x25]
0001d2b4adrp x27, 0xa03000
0001d2b8ldr x0, [x27+3008]
0001d2bcstr x0, [x25+8]
0001d2c0
0001d2c0loc_1d2c0:
0001d2c0adrp x27, 0xa03000
0001d2c4str x1, [x27+3008]
0001d2c8bl runtime.init.func2
0001d2ccldr x0, [sp+8]
0001d2d0adrp x27, 0xa2e000
0001d2d4str x0, [x27+2056]
0001d2d8adrp x27, 0x9a3000
0001d2dcldr x0, [x27+1728]
0001d2e0adrp x27, 0xa2e000
0001d2e4str x0, [x27+2072]
0001d2e8adrp x0, 4096
0001d2ecadd x0, x0, 3024
0001d2f0adrp x27, 0xa2e000
0001d2f4str x0, [x27+2040]
0001d2f8adrp x0, 8192
0001d2fcadd x0, x0, 1584
0001d300adrp x27, 0xa2e000
0001d304str x0, [x27+2048]
0001d308ldur x29, [sp-8]
0001d30cldr x30, [sp], 32
0001d310ret x30
0001d314
0001d314loc_1d314:
0001d314mov x3, x30
0001d318bl runtime.morestack_noctxt.abi0
0001d31cb 0x1d150
0001d150

0001d320
0001d320runtime.init.func1: ; void runtime.init.func1(void)
0001d320ldr x16, [x28+16]
0001d324subs xzr, sp, x16
0001d328b.ls 0x1d350
0001d32cstr x30, [sp-32]!
0001d330stur x29, [sp-8]
0001d334sub x29, sp, 8
0001d338adrp x0, 0x5fa000
0001d33cadd x0, x0, 1280
0001d340adrp x1, 0x6f4000
0001d344add x1, x1, 224
0001d348bl runtime.gopanic
0001d34chint
0001d350
0001d350loc_1d350:
0001d350mov x3, x30
0001d354bl runtime.morestack_noctxt.abi0
0001d358b 0x1d320
0001d35cudf 0
0001d320

0001d360
0001d360runtime.init.func2: ; void runtime.init.func2(void)
0001d360ldr x16, [x28+16]
0001d364subs xzr, sp, x16
0001d368b.ls 0x1d3d4
0001d36cstr x30, [sp-48]!
0001d370stur x29, [sp-8]
0001d374sub x29, sp, 8
0001d378str xzr, [sp+56]
0001d37cadrp x27, 0x9a3000
0001d380ldr x2, [x27+1704]
0001d384str x2, [sp+32]
0001d388adrp x27, 0xa2e000
0001d38cldrb w2, [x27+1585]
0001d390tbz w2, 0, 0x1d3b8
0001d394add x0, sp, 32
0001d398orr x1, xzr, 32
0001d39cbl runtime.sigdelset
0001d3a0add x0, sp, 32
0001d3a4movz x1, 33
0001d3a8bl runtime.sigdelset
0001d3acadd x0, sp, 32
0001d3b0movz x1, 34
0001d3b4bl runtime.sigdelset
0001d3b8
0001d3b8loc_1d3b8:
0001d3b8ldr x0, [sp+32]
0001d3bcstr x0, [sp+56]
0001d3c0ldr x0, [sp+32]
0001d3c4str x0, [sp+56]
0001d3c8ldur x29, [sp-8]
0001d3ccldr x30, [sp], 48
0001d3d0ret x30
0001d3d4
0001d3d4loc_1d3d4:
0001d3d4mov x3, x30
0001d3d8bl runtime.morestack_noctxt.abi0
0001d3dcb 0x1d360
0001d360

0001d3e0
0001d3e0runtime.memhash8: ; void runtime.memhash8(void * p, uintptr h)
0001d3e0ldr x16, [x28+16]
0001d3e4subs xzr, sp, x16
0001d3e8b.ls 0x1d40c
0001d3ecstr x30, [sp-48]!
0001d3f0stur x29, [sp-8]
0001d3f4sub x29, sp, 8
0001d3f8orr x2, xzr, 1
0001d3fcbl runtime.memhash
0001d400ldur x29, [sp-8]
0001d404ldr x30, [sp], 48
0001d408ret x30
0001d40c
0001d40cloc_1d40c:
0001d40cstp x0, x1, [sp+8]
0001d410mov x3, x30
0001d414bl runtime.morestack_noctxt.abi0
0001d418ldp x0, x1, [sp+8]
0001d41cb 0x1d3e0
0001d3e0

0001d420
0001d420runtime.memhash16: ; void runtime.memhash16(void * p, uintptr h)
0001d420ldr x16, [x28+16]
0001d424subs xzr, sp, x16
0001d428b.ls 0x1d44c
0001d42cstr x30, [sp-48]!
0001d430stur x29, [sp-8]
0001d434sub x29, sp, 8
0001d438orr x2, xzr, 2
0001d43cbl runtime.memhash
0001d440ldur x29, [sp-8]
0001d444ldr x30, [sp], 48
0001d448ret x30
0001d44c
0001d44cloc_1d44c:
0001d44cstp x0, x1, [sp+8]
0001d450mov x3, x30
0001d454bl runtime.morestack_noctxt.abi0
0001d458ldp x0, x1, [sp+8]
0001d45cb 0x1d420
0001d420

0001d460
0001d460runtime.memhash128: ; void runtime.memhash128(void * p, uintptr h)
0001d460ldr x16, [x28+16]
0001d464subs xzr, sp, x16
0001d468b.ls 0x1d48c
0001d46cstr x30, [sp-48]!
0001d470stur x29, [sp-8]
0001d474sub x29, sp, 8
0001d478orr x2, xzr, 16
0001d47cbl runtime.memhash
0001d480ldur x29, [sp-8]
0001d484ldr x30, [sp], 48
0001d488ret x30
0001d48c
0001d48cloc_1d48c:
0001d48cstp x0, x1, [sp+8]
0001d490mov x3, x30
0001d494bl runtime.morestack_noctxt.abi0
0001d498ldp x0, x1, [sp+8]
0001d49cb 0x1d460
0001d460

0001d4a0
0001d4a0runtime.memhash_varlen: ; void runtime.memhash_varlen(void * p, uintptr h)
0001d4a0str x30, [sp-48]!
0001d4a4stur x29, [sp-8]
0001d4a8sub x29, sp, 8
0001d4acadd x3, x26, 8
0001d4b0ldr x2, [x3]
0001d4b4bl runtime.memhash
0001d4b8ldur x29, [sp-8]
0001d4bcldr x30, [sp], 48
0001d4c0ret x30
0001d4c4udf 0
0001d4c8udf 0
0001d4ccudf 0
0001d4a0

0001d4d0
0001d4d0runtime.strhashFallback: ; void runtime.strhashFallback(void * a, uintptr h)
0001d4d0ldr x16, [x28+16]
0001d4d4subs xzr, sp, x16
0001d4d8b.ls 0x1d504
0001d4dcstr x30, [sp-48]!
0001d4e0stur x29, [sp-8]
0001d4e4sub x29, sp, 8
0001d4e8ldr x3, [x0]
0001d4ecldr x2, [x0+8]
0001d4f0mov x0, x3
0001d4f4bl runtime.memhashFallback
0001d4f8ldur x29, [sp-8]
0001d4fcldr x30, [sp], 48
0001d500ret x30
0001d504
0001d504loc_1d504:
0001d504stp x0, x1, [sp+8]
0001d508mov x3, x30
0001d50cbl runtime.morestack_noctxt.abi0
0001d510ldp x0, x1, [sp+8]
0001d514b 0x1d4d0
0001d518udf 0
0001d51cudf 0
0001d4d0

0001d520
0001d520runtime.f32hash: ; void runtime.f32hash(void * p, uintptr h)
0001d520ldr x16, [x28+16]
0001d524subs xzr, sp, x16
0001d528b.ls 0x1d5d8
0001d52cstr x30, [sp-48]!
0001d530stur x29, [sp-8]
0001d534sub x29, sp, 8
0001d538ldr s0, [x0]
0001d53cfcmp s0
0001d540b.eq 0x1d5a4
0001d544fcmp s0, s0
0001d548b.eq 0x1d590
0001d54cstr x1, [sp+64]
0001d550bl runtime.rand
0001d554ldr x1, [sp+64]
0001d558eor x0, x1, x0
0001d55cmovz x1, 42529
0001d560movk x1, 0x6a560000
0001d564movk x1, 0x6ea100000000
0001d568movk x1, 0x75000000000000
0001d56ceor x0, x0, x1
0001d570movz x1, 25535
0001d574movk x1, 0xbb8f0000
0001d578movk x1, 0xef6b00000000
0001d57cmovk x1, 0x52000000000000
0001d580madd x0, x0, x1, xzr
0001d584ldur x29, [sp-8]
0001d588ldr x30, [sp], 48
0001d58cret x30
0001d590
0001d590loc_1d590:
0001d590orr x2, xzr, 4
0001d594bl runtime.memhash
0001d598ldur x29, [sp-8]
0001d59cldr x30, [sp], 48
0001d5a0ret x30
0001d5a4
0001d5a4loc_1d5a4:
0001d5a4movz x2, 42529
0001d5a8movk x2, 0x6a560000
0001d5acmovk x2, 0x6ea100000000
0001d5b0movk x2, 0x75000000000000
0001d5b4eor x1, x1, x2
0001d5b8movz x2, 25535
0001d5bcmovk x2, 0xbb8f0000
0001d5c0movk x2, 0xef6b00000000
0001d5c4movk x2, 0x52000000000000
0001d5c8madd x0, x1, x2, xzr
0001d5ccldur x29, [sp-8]
0001d5d0ldr x30, [sp], 48
0001d5d4ret x30
0001d5d8
0001d5d8loc_1d5d8:
0001d5d8stp x0, x1, [sp+8]
0001d5dcmov x3, x30
0001d5e0bl runtime.morestack_noctxt.abi0
0001d5e4ldp x0, x1, [sp+8]
0001d5e8b 0x1d520
0001d5ecudf 0
0001d520

0001d5f0
0001d5f0runtime.f64hash: ; void runtime.f64hash(void * p, uintptr h)
0001d5f0ldr x16, [x28+16]
0001d5f4subs xzr, sp, x16
0001d5f8b.ls 0x1d6a8
0001d5fcstr x30, [sp-48]!
0001d600stur x29, [sp-8]
0001d604sub x29, sp, 8
0001d608ldr d0, [x0]
0001d60cfcmp d0
0001d610b.eq 0x1d674
0001d614fcmp d0, d0
0001d618b.eq 0x1d660
0001d61cstr x1, [sp+64]
0001d620bl runtime.rand
0001d624ldr x1, [sp+64]
0001d628eor x0, x1, x0
0001d62cmovz x1, 42529
0001d630movk x1, 0x6a560000
0001d634movk x1, 0x6ea100000000
0001d638movk x1, 0x75000000000000
0001d63ceor x0, x0, x1
0001d640movz x1, 25535
0001d644movk x1, 0xbb8f0000
0001d648movk x1, 0xef6b00000000
0001d64cmovk x1, 0x52000000000000
0001d650madd x0, x0, x1, xzr
0001d654ldur x29, [sp-8]
0001d658ldr x30, [sp], 48
0001d65cret x30
0001d660
0001d660loc_1d660:
0001d660orr x2, xzr, 8
0001d664bl runtime.memhash
0001d668ldur x29, [sp-8]
0001d66cldr x30, [sp], 48
0001d670ret x30
0001d674
0001d674loc_1d674:
0001d674movz x2, 42529
0001d678movk x2, 0x6a560000
0001d67cmovk x2, 0x6ea100000000
0001d680movk x2, 0x75000000000000
0001d684eor x1, x1, x2
0001d688movz x2, 25535
0001d68cmovk x2, 0xbb8f0000
0001d690movk x2, 0xef6b00000000
0001d694movk x2, 0x52000000000000
0001d698madd x0, x1, x2, xzr
0001d69cldur x29, [sp-8]
0001d6a0ldr x30, [sp], 48
0001d6a4ret x30
0001d6a8
0001d6a8loc_1d6a8:
0001d6a8stp x0, x1, [sp+8]
0001d6acmov x3, x30
0001d6b0bl runtime.morestack_noctxt.abi0
0001d6b4ldp x0, x1, [sp+8]
0001d6b8b 0x1d5f0
0001d6bcudf 0
0001d5f0

0001d6c0
0001d6c0runtime.c64hash: ; void runtime.c64hash(void * p, uintptr h)
0001d6c0ldr x16, [x28+16]
0001d6c4subs xzr, sp, x16
0001d6c8b.ls 0x1d704
0001d6ccstr x30, [sp-32]!
0001d6d0stur x29, [sp-8]
0001d6d4sub x29, sp, 8
0001d6d8str x0, [sp+40]
0001d6dcldrsb x27, [x0]
0001d6e0bl runtime.f32hash
0001d6e4ldr x2, [sp+40]
0001d6e8add x2, x2, 4
0001d6ecmov x1, x0
0001d6f0mov x0, x2
0001d6f4bl runtime.f32hash
0001d6f8ldur x29, [sp-8]
0001d6fcldr x30, [sp], 32
0001d700ret x30
0001d704
0001d704loc_1d704:
0001d704stp x0, x1, [sp+8]
0001d708mov x3, x30
0001d70cbl runtime.morestack_noctxt.abi0
0001d710ldp x0, x1, [sp+8]
0001d714b 0x1d6c0
0001d718udf 0
0001d71cudf 0
0001d6c0

0001d720
0001d720runtime.c128hash: ; void runtime.c128hash(void * p, uintptr h)
0001d720ldr x16, [x28+16]
0001d724subs xzr, sp, x16
0001d728b.ls 0x1d764
0001d72cstr x30, [sp-32]!
0001d730stur x29, [sp-8]
0001d734sub x29, sp, 8
0001d738str x0, [sp+40]
0001d73cldrsb x27, [x0]
0001d740bl runtime.f64hash
0001d744ldr x2, [sp+40]
0001d748add x2, x2, 8
0001d74cmov x1, x0
0001d750mov x0, x2
0001d754bl runtime.f64hash
0001d758ldur x29, [sp-8]
0001d75cldr x30, [sp], 32
0001d760ret x30
0001d764
0001d764loc_1d764:
0001d764stp x0, x1, [sp+8]
0001d768mov x3, x30
0001d76cbl runtime.morestack_noctxt.abi0
0001d770ldp x0, x1, [sp+8]
0001d774b 0x1d720
0001d778udf 0
0001d77cudf 0
0001d720

0001d780
0001d780runtime.interhash: ; void runtime.interhash(void * p, uintptr h)
0001d780ldr x16, [x28+16]
0001d784subs xzr, sp, x16
0001d788b.ls 0x1d8a4
0001d78cstr x30, [sp-64]!
0001d790stur x29, [sp-8]
0001d794sub x29, sp, 8
0001d798ldr x2, [x0]
0001d79ccbz x2, 0x1d854
0001d7a0ldr x2, [x2+8]
0001d7a4ldr x3, [x2+24]
0001d7a8cbz x3, 0x1d864
0001d7acstr x0, [sp+72]
0001d7b0str x1, [sp+80]
0001d7b4str x2, [sp+48]
0001d7b8mov x0, x2
0001d7bcbl runtime.isDirectIface
0001d7c0tbz w0, 0, 0x1d80c
0001d7c4ldr x3, [sp+72]
0001d7c8add x1, x3, 8
0001d7ccldr x3, [sp+80]
0001d7d0movz x4, 42529
0001d7d4movk x4, 0x6a560000
0001d7d8movk x4, 0x6ea100000000
0001d7dcmovk x4, 0x75000000000000
0001d7e0eor x2, x3, x4
0001d7e4ldr x0, [sp+48]
0001d7e8bl runtime.typehash
0001d7ecmovz x3, 25535
0001d7f0movk x3, 0xbb8f0000
0001d7f4movk x3, 0xef6b00000000
0001d7f8movk x3, 0x52000000000000
0001d7fcmadd x0, x3, x0, xzr
0001d800ldur x29, [sp-8]
0001d804ldr x30, [sp], 64
0001d808ret x30
0001d80c
0001d80cloc_1d80c:
0001d80cldr x3, [sp+72]
0001d810ldr x1, [x3+8]
0001d814ldr x3, [sp+80]
0001d818movz x4, 42529
0001d81cmovk x4, 0x6a560000
0001d820movk x4, 0x6ea100000000
0001d824movk x4, 0x75000000000000
0001d828eor x2, x3, x4
0001d82cldr x0, [sp+48]
0001d830bl runtime.typehash
0001d834movz x3, 25535
0001d838movk x3, 0xbb8f0000
0001d83cmovk x3, 0xef6b00000000
0001d840movk x3, 0x52000000000000
0001d844madd x0, x0, x3, xzr
0001d848ldur x29, [sp-8]
0001d84cldr x30, [sp], 64
0001d850ret x30
0001d854
0001d854loc_1d854:
0001d854mov x0, x1
0001d858ldur x29, [sp-8]
0001d85cldr x30, [sp], 64
0001d860ret x30
0001d864
0001d864loc_1d864:
0001d864mov x0, x2
0001d868bl runtime.toRType
0001d86cbl runtime.rtype.string
0001d870orr x2, xzr, 24
0001d874mov x3, x0
0001d878mov x4, x1
0001d87cmov x0, xzr
0001d880adrp x1, 0x69b000
0001d884add x1, x1, 3886
0001d888bl runtime.concatstring2
0001d88cbl runtime.convTstring
0001d890mov x1, x0
0001d894adrp x0, 0x5fa000
0001d898add x0, x0, 1280
0001d89cbl runtime.gopanic
0001d8a0hint
0001d8a4
0001d8a4loc_1d8a4:
0001d8a4stp x0, x1, [sp+8]
0001d8a8mov x3, x30
0001d8acbl runtime.morestack_noctxt.abi0
0001d8b0ldp x0, x1, [sp+8]
0001d8b4b 0x1d780
0001d8b8udf 0
0001d8bcudf 0
0001d780

0001d8c0
0001d8c0runtime.mapKeyError: ; void runtime.mapKeyError(internal/abi.SwissMapType * t, void * p)
0001d8c0ldr x16, [x28+16]
0001d8c4subs xzr, sp, x16
0001d8c8b.ls 0x1d918
0001d8ccstr x30, [sp-32]!
0001d8d0stur x29, [sp-8]
0001d8d4sub x29, sp, 8
0001d8d8str x0, [sp+40]
0001d8dcstr x1, [sp+48]
0001d8e0bl internal/abi.(*SwissMapType).HashMightPanic
0001d8e4tbz w0, 0, 0x1d904
0001d8e8ldr x2, [sp+40]
0001d8ecldr x0, [x2+48]
0001d8f0ldr x1, [sp+48]
0001d8f4bl runtime.mapKeyError2
0001d8f8ldur x29, [sp-8]
0001d8fcldr x30, [sp], 32
0001d900ret x30
0001d904
0001d904loc_1d904:
0001d904mov x0, xzr
0001d908mov x1, xzr
0001d90cldur x29, [sp-8]
0001d910ldr x30, [sp], 32
0001d914ret x30
0001d918
0001d918loc_1d918:
0001d918stp x0, x1, [sp+8]
0001d91cmov x3, x30
0001d920bl runtime.morestack_noctxt.abi0
0001d924ldp x0, x1, [sp+8]
0001d928b 0x1d8c0
0001d92cudf 0
0001d8c0

0001d930
0001d930runtime.mapKeyError2: ; void runtime.mapKeyError2(internal/abi.Type * t, void * p)
0001d930ldr x16, [x28+16]
0001d934subs xzr, sp, x16
0001d938b.ls 0x1dbe8
0001d93cstr x30, [sp-112]!
0001d940stur x29, [sp-8]
0001d944sub x29, sp, 8
0001d948ldrb w2, [x0+20]
0001d94ctbnz w2, 3, 0x1dae8
0001d950str x1, [sp+128]
0001d954ldrb w2, [x0+23]
0001d958and x3, x2, 31
0001d95csubs wzr, w3, 17
0001d960b.ls 0x1da6c
0001d964subs wzr, w3, 20
0001d968b.eq 0x1d988
0001d96csubs wzr, w3, 24
0001d970b.eq 0x1da80
0001d974subs wzr, w3, 25
0001d978b.ne 0x1daa8
0001d97cldr x2, [x0+56]
0001d980ldr x3, [x0+64]
0001d984b 0x1db80
0001d988
0001d988loc_1d988:
0001d988ldr x2, [x0+64]
0001d98ccbnz x2, 0x1d9b4
0001d990ldr x2, [x1]
0001d994cbz x2, 0x1d9a0
0001d998add x1, x1, 8
0001d99cb 0x1d9c4
0001d9a0
0001d9a0loc_1d9a0:
0001d9a0mov x0, xzr
0001d9a4mov x1, xzr
0001d9a8ldur x29, [sp-8]
0001d9acldr x30, [sp], 112
0001d9b0ret x30
0001d9b4
0001d9b4loc_1d9b4:
0001d9b4ldr x2, [x1]
0001d9b8cbz x2, 0x1da58
0001d9bcldr x2, [x2+8]
0001d9c0add x1, x1, 8
0001d9c4
0001d9c4loc_1d9c4:
0001d9c4ldr x3, [x2+24]
0001d9c8cbz x3, 0x1da14
0001d9ccstr x2, [sp+72]
0001d9d0str x1, [sp+80]
0001d9d4mov x0, x2
0001d9d8bl runtime.isDirectIface
0001d9dctbz w0, 0, 0x1d9f8
0001d9e0ldr x0, [sp+72]
0001d9e4ldr x1, [sp+80]
0001d9e8bl runtime.mapKeyError2
0001d9ecldur x29, [sp-8]
0001d9f0ldr x30, [sp], 112
0001d9f4ret x30
0001d9f8
0001d9f8loc_1d9f8:
0001d9f8ldr x2, [sp+80]
0001d9fcldr x1, [x2]
0001da00ldr x0, [sp+72]
0001da04bl runtime.mapKeyError2
0001da08ldur x29, [sp-8]
0001da0cldr x30, [sp], 112
0001da10ret x30
0001da14
0001da14loc_1da14:
0001da14mov x0, x2
0001da18bl runtime.toRType
0001da1cbl runtime.rtype.string
0001da20orr x2, xzr, 24
0001da24mov x3, x0
0001da28mov x4, x1
0001da2cmov x0, xzr
0001da30adrp x1, 0x69b000
0001da34add x1, x1, 3886
0001da38bl runtime.concatstring2
0001da3cbl runtime.convTstring
0001da40mov x1, x0
0001da44adrp x0, 0x6f6000
0001da48add x0, x0, 2656
0001da4cldur x29, [sp-8]
0001da50ldr x30, [sp], 112
0001da54ret x30
0001da58
0001da58loc_1da58:
0001da58mov x0, xzr
0001da5cmov x1, xzr
0001da60ldur x29, [sp-8]
0001da64ldr x30, [sp], 112
0001da68ret x30
0001da6c
0001da6cloc_1da6c:
0001da6cand x2, x2, 31
0001da70sub x2, x2, 13
0001da74ubfm x2, x2, 0, 7
0001da78subs wzr, w2, 3
0001da7cb.hi 0x1da94
0001da80
0001da80loc_1da80:
0001da80mov x0, xzr
0001da84mov x1, xzr
0001da88ldur x29, [sp-8]
0001da8cldr x30, [sp], 112
0001da90ret x30
0001da94
0001da94loc_1da94:
0001da94subs wzr, w3, 17
0001da98b.ne 0x1daa8
0001da9cstr x0, [sp+120]
0001daa0mov x2, xzr
0001daa4b 0x1db0c
0001daa8
0001daa8loc_1daa8:
0001daa8bl runtime.toRType
0001daacbl runtime.rtype.string
0001dab0orr x2, xzr, 24
0001dab4mov x3, x0
0001dab8mov x4, x1
0001dabcmov x0, xzr
0001dac0adrp x1, 0x69b000
0001dac4add x1, x1, 3886
0001dac8bl runtime.concatstring2
0001daccbl runtime.convTstring
0001dad0mov x1, x0
0001dad4adrp x0, 0x6f6000
0001dad8add x0, x0, 2656
0001dadcldur x29, [sp-8]
0001dae0ldr x30, [sp], 112
0001dae4ret x30
0001dae8
0001dae8loc_1dae8:
0001dae8mov x0, xzr
0001daecmov x1, xzr
0001daf0ldur x29, [sp-8]
0001daf4ldr x30, [sp], 112
0001daf8ret x30
0001dafc
0001dafcloc_1dafc:
0001dafcldr x3, [sp+48]
0001db00add x2, x3, 1
0001db04ldr x0, [sp+120]
0001db08ldr x1, [sp+128]
0001db0c
0001db0cloc_1db0c:
0001db0cldr x3, [x0+64]
0001db10subs xzr, x2, x3
0001db14b.hs 0x1db58
0001db18str x2, [sp+48]
0001db1cldr x3, [x0+48]
0001db20ldr x3, [x3]
0001db24madd x2, x2, x3, xzr
0001db28mov x0, x1
0001db2cmov x1, x2
0001db30bl runtime.add
0001db34ldr x2, [sp+120]
0001db38ldr x2, [x2+48]
0001db3cmov x1, x0
0001db40mov x0, x2
0001db44bl runtime.mapKeyError2
0001db48cbz x0, 0x1dafc
0001db4cldur x29, [sp-8]
0001db50ldr x30, [sp], 112
0001db54ret x30
0001db58
0001db58loc_1db58:
0001db58mov x0, xzr
0001db5cmov x1, xzr
0001db60ldur x29, [sp-8]
0001db64ldr x30, [sp], 112
0001db68ret x30
0001db6c
0001db6cloc_1db6c:
0001db6cldr x4, [sp+96]
0001db70add x2, x4, 24
0001db74ldr x4, [sp+64]
0001db78sub x3, x4, 1
0001db7cldr x1, [sp+128]
0001db80
0001db80loc_1db80:
0001db80subs xzr, x3, 0
0001db84b.le 0x1dbd4
0001db88str x3, [sp+64]
0001db8cstr x2, [sp+96]
0001db90ldr x0, [x2]
0001db94ldr x1, [x2+8]
0001db98str x1, [sp+88]
0001db9cldr x1, [x2+16]
0001dba0str x1, [sp+56]
0001dba4bl internal/abi.Name.IsBlank
0001dba8tbnz w0, 0, 0x1db6c
0001dbacldr x0, [sp+128]
0001dbb0ldr x1, [sp+56]
0001dbb4bl runtime.add
0001dbb8mov x1, x0
0001dbbcldr x0, [sp+88]
0001dbc0bl runtime.mapKeyError2
0001dbc4cbz x0, 0x1db6c
0001dbc8ldur x29, [sp-8]
0001dbccldr x30, [sp], 112
0001dbd0ret x30
0001dbd4
0001dbd4loc_1dbd4:
0001dbd4mov x0, xzr
0001dbd8mov x1, xzr
0001dbdcldur x29, [sp-8]
0001dbe0ldr x30, [sp], 112
0001dbe4ret x30
0001dbe8
0001dbe8loc_1dbe8:
0001dbe8stp x0, x1, [sp+8]
0001dbecmov x3, x30
0001dbf0bl runtime.morestack_noctxt.abi0
0001dbf4ldp x0, x1, [sp+8]
0001dbf8b 0x1d930
0001dbfcudf 0
0001d930

0001dc00
0001dc00runtime.memequal0: ; void runtime.memequal0(void * p, void * q)
0001dc00orr x0, xzr, 1
0001dc04ret x30
0001dc08udf 0
0001dc0cudf 0
0001dc00

0001dc10
0001dc10runtime.memequal8: ; void runtime.memequal8(void * p, void * q)
0001dc10ldrsb x2, [x0]
0001dc14ubfm x2, x2, 0, 7
0001dc18ldrsb x1, [x1]
0001dc1cubfm x1, x1, 0, 7
0001dc20subs wzr, w1, w2
0001dc24cset x0, eq
0001dc28ret x30
0001dc2cudf 0
0001dc10

0001dc30
0001dc30runtime.memequal16: ; void runtime.memequal16(void * p, void * q)
0001dc30ldrsh x2, [x0]
0001dc34ubfm x2, x2, 0, 15
0001dc38ldrsh x1, [x1]
0001dc3cubfm x1, x1, 0, 15
0001dc40subs wzr, w1, w2
0001dc44cset x0, eq
0001dc48ret x30
0001dc4cudf 0
0001dc30

0001dc50
0001dc50runtime.memequal32: ; void runtime.memequal32(void * p, void * q)
0001dc50ldrsw x2, [x0]
0001dc54ldrsw x1, [x1]
0001dc58subs wzr, w1, w2
0001dc5ccset x0, eq
0001dc60ret x30
0001dc64udf 0
0001dc68udf 0
0001dc6cudf 0
0001dc50

0001dc70
0001dc70runtime.memequal64: ; void runtime.memequal64(void * p, void * q)
0001dc70ldr x2, [x0]
0001dc74ldr x1, [x1]
0001dc78subs xzr, x1, x2
0001dc7ccset x0, eq
0001dc80ret x30
0001dc84udf 0
0001dc88udf 0
0001dc8cudf 0
0001dc70

0001dc90
0001dc90runtime.memequal128: ; void runtime.memequal128(void * p, void * q)
0001dc90ldr x2, [x0]
0001dc94ldr x3, [x1]
0001dc98subs xzr, x3, x2
0001dc9cb.ne 0x1dcb4
0001dca0ldr x2, [x0+8]
0001dca4ldr x1, [x1+8]
0001dca8subs xzr, x1, x2
0001dcaccset x1, eq
0001dcb0b 0x1dcb8
0001dcb4
0001dcb4loc_1dcb4:
0001dcb4mov x1, xzr
0001dcb8
0001dcb8loc_1dcb8:
0001dcb8mov x0, x1
0001dcbcret x30
0001dc90

0001dcc0
0001dcc0runtime.f32equal: ; void runtime.f32equal(void * p, void * q)
0001dcc0ldr s0, [x0]
0001dcc4ldr s1, [x1]
0001dcc8fcmp s0, s1
0001dccccset x0, eq
0001dcd0ret x30
0001dcd4udf 0
0001dcd8udf 0
0001dcdcudf 0
0001dcc0

0001dce0
0001dce0runtime.f64equal: ; void runtime.f64equal(void * p, void * q)
0001dce0ldr d0, [x0]
0001dce4ldr d1, [x1]
0001dce8fcmp d0, d1
0001dceccset x0, eq
0001dcf0ret x30
0001dcf4udf 0
0001dcf8udf 0
0001dcfcudf 0
0001dce0

0001dd00
0001dd00runtime.c64equal: ; void runtime.c64equal(void * p, void * q)
0001dd00ldr s0, [x0]
0001dd04ldr s1, [x0+4]
0001dd08ldr s2, [x1]
0001dd0cldr s3, [x1+4]
0001dd10fcmp s0, s2
0001dd14cset x1, eq
0001dd18fcmp s1, s3
0001dd1ccset x2, eq
0001dd20and x0, x1, x2
0001dd24ret x30
0001dd28udf 0
0001dd2cudf 0
0001dd00

0001dd30
0001dd30runtime.c128equal: ; void runtime.c128equal(void * p, void * q)
0001dd30ldr d0, [x0]
0001dd34ldr d1, [x0+8]
0001dd38ldr d2, [x1]
0001dd3cldr d3, [x1+8]
0001dd40fcmp d0, d2
0001dd44cset x1, eq
0001dd48fcmp d1, d3
0001dd4ccset x2, eq
0001dd50and x0, x1, x2
0001dd54ret x30
0001dd58udf 0
0001dd5cudf 0
0001dd30

0001dd60
0001dd60runtime.strequal: ; void runtime.strequal(void * p, void * q)
0001dd60ldr x16, [x28+16]
0001dd64subs xzr, sp, x16
0001dd68b.ls 0x1dda8
0001dd6cstr x30, [sp-48]!
0001dd70stur x29, [sp-8]
0001dd74sub x29, sp, 8
0001dd78ldr x2, [x0+8]
0001dd7cldr x3, [x1+8]
0001dd80subs xzr, x2, x3
0001dd84b.eq 0x1dd90
0001dd88mov x0, xzr
0001dd8cb 0x1dd9c
0001dd90
0001dd90loc_1dd90:
0001dd90ldr x0, [x0]
0001dd94ldr x1, [x1]
0001dd98bl runtime.memequal
0001dd9c
0001dd9cloc_1dd9c:
0001dd9cldur x29, [sp-8]
0001dda0ldr x30, [sp], 48
0001dda4ret x30
0001dda8
0001dda8loc_1dda8:
0001dda8stp x0, x1, [sp+8]
0001ddacmov x3, x30
0001ddb0bl runtime.morestack_noctxt.abi0
0001ddb4ldp x0, x1, [sp+8]
0001ddb8b 0x1dd60
0001ddbcudf 0
0001dd60

0001ddc0
0001ddc0runtime.interequal: ; void runtime.interequal(void * p, void * q)
0001ddc0ldr x16, [x28+16]
0001ddc4subs xzr, sp, x16
0001ddc8b.ls 0x1de10
0001ddccstr x30, [sp-48]!
0001ddd0stur x29, [sp-8]
0001ddd4sub x29, sp, 8
0001ddd8ldr x3, [x0]
0001dddcldr x4, [x1]
0001dde0subs xzr, x4, x3
0001dde4b.eq 0x1ddf0
0001dde8mov x0, xzr
0001ddecb 0x1de04
0001ddf0
0001ddf0loc_1ddf0:
0001ddf0ldr x4, [x0+8]
0001ddf4ldr x2, [x1+8]
0001ddf8mov x0, x3
0001ddfcmov x1, x4
0001de00bl runtime.ifaceeq
0001de04
0001de04loc_1de04:
0001de04ldur x29, [sp-8]
0001de08ldr x30, [sp], 48
0001de0cret x30
0001de10
0001de10loc_1de10:
0001de10stp x0, x1, [sp+8]
0001de14mov x3, x30
0001de18bl runtime.morestack_noctxt.abi0
0001de1cldp x0, x1, [sp+8]
0001de20b 0x1ddc0
0001de24udf 0
0001de28udf 0
0001de2cudf 0
0001ddc0

0001de30
0001de30runtime.nilinterequal: ; void runtime.nilinterequal(void * p, void * q)
0001de30ldr x16, [x28+16]
0001de34subs xzr, sp, x16
0001de38b.ls 0x1de80
0001de3cstr x30, [sp-48]!
0001de40stur x29, [sp-8]
0001de44sub x29, sp, 8
0001de48ldr x3, [x0]
0001de4cldr x4, [x1]
0001de50subs xzr, x4, x3
0001de54b.eq 0x1de60
0001de58mov x0, xzr
0001de5cb 0x1de74
0001de60
0001de60loc_1de60:
0001de60ldr x4, [x0+8]
0001de64ldr x2, [x1+8]
0001de68mov x0, x3
0001de6cmov x1, x4
0001de70bl runtime.efaceeq
0001de74
0001de74loc_1de74:
0001de74ldur x29, [sp-8]
0001de78ldr x30, [sp], 48
0001de7cret x30
0001de80
0001de80loc_1de80:
0001de80stp x0, x1, [sp+8]
0001de84mov x3, x30
0001de88bl runtime.morestack_noctxt.abi0
0001de8cldp x0, x1, [sp+8]
0001de90b 0x1de30
0001de94udf 0
0001de98udf 0
0001de9cudf 0
0001de30

0001dea0
0001dea0runtime.efaceeq: ; void runtime.efaceeq(internal/abi.Type * t, void * x, void * y)
0001dea0ldr x16, [x28+16]
0001dea4subs xzr, sp, x16
0001dea8b.ls 0x1df60
0001deacstr x30, [sp-64]!
0001deb0stur x29, [sp-8]
0001deb4sub x29, sp, 8
0001deb8cbz x0, 0x1df14
0001debcldr x3, [x0+24]
0001dec0cbz x3, 0x1df24
0001dec4str x1, [sp+80]
0001dec8str x2, [sp+88]
0001deccstr x3, [sp+48]
0001ded0bl runtime.isDirectIface
0001ded4tbz w0, 0, 0x1def4
0001ded8ldr x1, [sp+88]
0001dedcldr x2, [sp+80]
0001dee0subs xzr, x1, x2
0001dee4cset x0, eq
0001dee8ldur x29, [sp-8]
0001deecldr x30, [sp], 64
0001def0ret x30
0001def4
0001def4loc_1def4:
0001def4ldr x26, [sp+48]
0001def8ldr x2, [x26]
0001defcldr x0, [sp+80]
0001df00ldr x1, [sp+88]
0001df04blr x2
0001df08ldur x29, [sp-8]
0001df0cldr x30, [sp], 64
0001df10ret x30
0001df14
0001df14loc_1df14:
0001df14orr x0, xzr, 1
0001df18ldur x29, [sp-8]
0001df1cldr x30, [sp], 64
0001df20ret x30
0001df24
0001df24loc_1df24:
0001df24bl runtime.toRType
0001df28bl runtime.rtype.string
0001df2corr x2, xzr, 28
0001df30mov x3, x0
0001df34mov x4, x1
0001df38mov x0, xzr
0001df3cadrp x1, 0x69e000
0001df40add x1, x1, 1864
0001df44bl runtime.concatstring2
0001df48bl runtime.convTstring
0001df4cmov x1, x0
0001df50adrp x0, 0x5fa000
0001df54add x0, x0, 1280
0001df58bl runtime.gopanic
0001df5chint
0001df60
0001df60loc_1df60:
0001df60stp x0, x1, [sp+8]
0001df64str x2, [sp+24]
0001df68mov x3, x30
0001df6cbl runtime.morestack_noctxt.abi0
0001df70ldp x0, x1, [sp+8]
0001df74ldr x2, [sp+24]
0001df78b 0x1dea0
0001df7cudf 0
0001dea0

0001df80
0001df80runtime.ifaceeq: ; void runtime.ifaceeq(internal/abi.ITab * tab, void * x, void * y)
0001df80ldr x16, [x28+16]
0001df84subs xzr, sp, x16
0001df88b.ls 0x1e044
0001df8cstr x30, [sp-64]!
0001df90stur x29, [sp-8]
0001df94sub x29, sp, 8
0001df98cbz x0, 0x1dff8
0001df9cldr x0, [x0+8]
0001dfa0ldr x3, [x0+24]
0001dfa4cbz x3, 0x1e008
0001dfa8str x1, [sp+80]
0001dfacstr x2, [sp+88]
0001dfb0str x3, [sp+48]
0001dfb4bl runtime.isDirectIface
0001dfb8tbz w0, 0, 0x1dfd8
0001dfbcldr x1, [sp+88]
0001dfc0ldr x2, [sp+80]
0001dfc4subs xzr, x1, x2
0001dfc8cset x0, eq
0001dfccldur x29, [sp-8]
0001dfd0ldr x30, [sp], 64
0001dfd4ret x30
0001dfd8
0001dfd8loc_1dfd8:
0001dfd8ldr x26, [sp+48]
0001dfdcldr x2, [x26]
0001dfe0ldr x0, [sp+80]
0001dfe4ldr x1, [sp+88]
0001dfe8blr x2
0001dfecldur x29, [sp-8]
0001dff0ldr x30, [sp], 64
0001dff4ret x30
0001dff8
0001dff8loc_1dff8:
0001dff8orr x0, xzr, 1
0001dffcldur x29, [sp-8]
0001e000ldr x30, [sp], 64
0001e004ret x30
0001e008
0001e008loc_1e008:
0001e008bl runtime.toRType
0001e00cbl runtime.rtype.string
0001e010orr x2, xzr, 28
0001e014mov x3, x0
0001e018mov x4, x1
0001e01cmov x0, xzr
0001e020adrp x1, 0x69d000
0001e024add x1, x1, 1864
0001e028bl runtime.concatstring2
0001e02cbl runtime.convTstring
0001e030mov x1, x0
0001e034adrp x0, 0x5f9000
0001e038add x0, x0, 1280
0001e03cbl runtime.gopanic
0001e040hint
0001e044
0001e044loc_1e044:
0001e044stp x0, x1, [sp+8]
0001e048str x2, [sp+24]
0001e04cmov x3, x30
0001e050bl runtime.morestack_noctxt.abi0
0001e054ldp x0, x1, [sp+8]
0001e058ldr x2, [sp+24]
0001e05cb 0x1df80
0001df80

0001e060
0001e060runtime.alginit: ; void runtime.alginit(void)
0001e060ldr x16, [x28+16]
0001e064subs xzr, sp, x16
0001e068b.ls 0x1e0cc
0001e06cstr x30, [sp-32]!
0001e070stur x29, [sp-8]
0001e074sub x29, sp, 8
0001e078adrp x27, 0xa2e000
0001e07cldrb w0, [x27+1408]
0001e080tbnz w0, 0, 0x1e08c
0001e084mov x0, xzr
0001e088b 0x1e0b8
0001e08c
0001e08cloc_1e08c:
0001e08cbl runtime.initAlgAES
0001e090ldur x29, [sp-8]
0001e094ldr x30, [sp], 32
0001e098ret x30
0001e09c
0001e09cloc_1e09c:
0001e09cstr x0, [sp+16]
0001e0a0bl runtime.bootstrapRand
0001e0a4ldr x1, [sp+16]
0001e0a8adrp x2, 0xa2d000
0001e0acadd x2, x2, 3424
0001e0b0str x0, [x2+3*x1]
0001e0b4add x0, x1, 1
0001e0b8
0001e0b8loc_1e0b8:
0001e0b8subs xzr, x0, 4
0001e0bcb.lt 0x1e09c
0001e0c0ldur x29, [sp-8]
0001e0c4ldr x30, [sp], 32
0001e0c8ret x30
0001e0cc
0001e0ccloc_1e0cc:
0001e0ccmov x3, x30
0001e0d0bl runtime.morestack_noctxt.abi0
0001e0d4b 0x1e060
0001e0d8udf 0
0001e0dcudf 0
0001e060

0001e0e0
0001e0e0runtime.initAlgAES: ; void runtime.initAlgAES(void)
0001e0e0ldr x16, [x28+16]
0001e0e4subs xzr, sp, x16
0001e0e8b.ls 0x1e13c
0001e0ecstr x30, [sp-32]!
0001e0f0stur x29, [sp-8]
0001e0f4sub x29, sp, 8
0001e0f8orr x0, xzr, 1
0001e0fcadrp x27, 0xa2d000
0001e100strb w0, [x27+1514]
0001e104mov x0, xzr
0001e108b 0x1e128
0001e10c
0001e10cloc_1e10c:
0001e10cstr x0, [sp+16]
0001e110bl runtime.bootstrapRand
0001e114ldr x1, [sp+16]
0001e118adrp x2, 0xa2e000
0001e11cadd x2, x2, 352
0001e120str x0, [x2+3*x1]
0001e124add x0, x1, 1
0001e128
0001e128loc_1e128:
0001e128subs xzr, x0, 16
0001e12cb.lt 0x1e10c
0001e130ldur x29, [sp-8]
0001e134ldr x30, [sp], 32
0001e138ret x30
0001e13c
0001e13cloc_1e13c:
0001e13cmov x3, x30
0001e140bl runtime.morestack_noctxt.abi0
0001e144b 0x1e0e0
0001e148udf 0
0001e14cudf 0
0001e0e0

0001e150
0001e150runtime.readUnaligned32: ; void runtime.readUnaligned32(void * p)
0001e150ldr w0, [x0]
0001e154ret x30
0001e158udf 0
0001e15cudf 0
0001e150

0001e160
0001e160runtime.readUnaligned64: ; void runtime.readUnaligned64(void * p)
0001e160ldr x0, [x0]
0001e164ret x30
0001e168udf 0
0001e16cudf 0
0001e160

0001e170
0001e170runtime.init.0: ; void runtime.init.0(void)
0001e170ldr x16, [x28+16]
0001e174subs xzr, sp, x16
0001e178b.ls 0x1e1d8
0001e17cstr x30, [sp-32]!
0001e180stur x29, [sp-8]
0001e184sub x29, sp, 8
0001e188adrp x27, 0xa2d000
0001e18cldr x2, [x27+1760]
0001e190cbz x2, 0x1e1d0
0001e194orr x3, xzr, 0x800000
0001e198udiv x27, x3, x2
0001e19cmsub x2, x27, x2, x3
0001e1a0cbnz x2, 0x1e1c0
0001e1a4adrp x0, 0xa05000
0001e1a8add x0, x0, 3552
0001e1acmovz x1, 33
0001e1b0bl runtime.lockInit
0001e1b4ldur x29, [sp-8]
0001e1b8ldr x30, [sp], 32
0001e1bcret x30
0001e1c0
0001e1c0loc_1e1c0:
0001e1c0adrp x0, 0x6af000
0001e1c4add x0, x0, 2313
0001e1c8movz x1, 65
0001e1ccbl runtime.throw
0001e1d0
0001e1d0loc_1e1d0:
0001e1d0bl runtime.panicdivide
0001e1d4hint
0001e1d8
0001e1d8loc_1e1d8:
0001e1d8mov x3, x30
0001e1dcbl runtime.morestack_noctxt.abi0
0001e1e0b 0x1e170
0001e1e4udf 0
0001e1e8udf 0
0001e1ecudf 0
0001e170

0001e1f0
0001e1f0runtime.(*mspan).setUserArenaChunkToFault: ; void runtime.(*mspan).setUserArenaChunkToFault(runtime.mspan * s)
0001e1f0ldr x16, [x28+16]
0001e1f4subs xzr, sp, x16
0001e1f8b.ls 0x1e3d0
0001e1fcstr x30, [sp-64]!
0001e200stur x29, [sp-8]
0001e204sub x29, sp, 8
0001e208ldrb w2, [x0+101]
0001e20ctbz w2, 0, 0x1e3bc
0001e210ldr x2, [x0+32]
0001e214ubfm x2, x2, 51, 50
0001e218subs xzr, x2, 0x800000
0001e21cb.ne 0x1e3ac
0001e220str x0, [sp+72]
0001e224mov x0, xzr
0001e228orr x1, xzr, 1
0001e22cbl runtime.makeSpanClass
0001e230ldr x2, [sp+72]
0001e234strb w0, [x2+98]
0001e238mov x0, x2
0001e23cbl runtime.(*mspan).base
0001e240ldr x2, [sp+72]
0001e244ldr x2, [x2+32]
0001e248ubfm x1, x2, 51, 50
0001e24cbl runtime.sysFault
0001e250ldr x2, [sp+72]
0001e254ldr x2, [x2+32]
0001e258sub x1, xzr, x2, lsl #13
0001e25cadrp x0, 0xa2e000
0001e260add x0, x0, 2768
0001e264bl runtime.(*sysMemStat).add
0001e268ldr x2, [sp+72]
0001e26cldr x1, [x2+104]
0001e270adrp x0, 0xa2e000
0001e274add x0, x0, 2800
0001e278bl internal/runtime/atomic.(*Uint64).Add
0001e27cadrp x0, 0xa32000
0001e280add x0, x0, 1056
0001e284bl runtime.(*consistentHeapStats).acquire
0001e288ldrsb x27, [x0]
0001e28cldr x2, [sp+72]
0001e290ldr x3, [x2+32]
0001e294sub x3, xzr, x3, lsl #13
0001e298adrp x27, 0xa2d000
0001e29cldrb w4, [x27+1516]
0001e2a0tbz w4, 0, 0x1e2b0
0001e2a4ldaddal x3, x1, [x0]
0001e2a8add x1, x1, x3
0001e2acb 0x1e2c0
0001e2b0
0001e2b0loc_1e2b0:
0001e2b0ldaxr x1, [x0]
0001e2b4add x1, x1, x3
0001e2b8stlxr w27, x1, [x0]
0001e2bccbnz x27, 0x1e2b0
0001e2c0
0001e2c0loc_1e2c0:
0001e2c0ldr x1, [x2+32]
0001e2c4add x3, x0, 16
0001e2c8sub x1, xzr, x1, lsl #13
0001e2ccadrp x27, 0xa2d000
0001e2d0ldrb w4, [x27+1516]
0001e2d4tbz w4, 0, 0x1e2e4
0001e2d8ldaddal x1, x4, [x3]
0001e2dcadd x4, x4, x1
0001e2e0b 0x1e2f4
0001e2e4
0001e2e4loc_1e2e4:
0001e2e4ldaxr x4, [x3]
0001e2e8add x4, x4, x1
0001e2ecstlxr w27, x4, [x3]
0001e2f0cbnz x27, 0x1e2e4
0001e2f4
0001e2f4loc_1e2f4:
0001e2f4add x1, x0, 624
0001e2f8adrp x27, 0xa2d000
0001e2fcldrb w3, [x27+1516]
0001e300tbz w3, 0, 0x1e314
0001e304orr x3, xzr, 1
0001e308ldaddal x3, x4, [x1]
0001e30cadd x4, x4, x3
0001e310b 0x1e328
0001e314
0001e314loc_1e314:
0001e314orr x3, xzr, 1
0001e318
0001e318loc_1e318:
0001e318ldaxr x4, [x1]
0001e31cadd x4, x4, x3
0001e320stlxr w27, x4, [x1]
0001e324cbnz x27, 0x1e318
0001e328
0001e328loc_1e328:
0001e328add x1, x0, 616
0001e32cldr x3, [x2+104]
0001e330adrp x27, 0xa2d000
0001e334ldrb w4, [x27+1516]
0001e338tbz w4, 0, 0x1e348
0001e33cldaddal x3, x4, [x1]
0001e340add x4, x4, x3
0001e344b 0x1e358
0001e348
0001e348loc_1e348:
0001e348ldaxr x4, [x1]
0001e34cadd x4, x4, x3
0001e350stlxr w27, x4, [x1]
0001e354cbnz x27, 0x1e348
0001e358
0001e358loc_1e358:
0001e358adrp x0, 0xa32000
0001e35cadd x0, x0, 1056
0001e360bl runtime.(*consistentHeapStats).release
0001e364ldr x1, [sp+72]
0001e368ldr x1, [x1+104]
0001e36csub x1, xzr, x1
0001e370adrp x0, 0xa2e000
0001e374add x0, x0, 2496
0001e378mov x2, xzr
0001e37cbl runtime.(*gcControllerState).update
0001e380adrp x1, 0
0001e384add x1, x1, 1008
0001e388str x1, [sp+40]
0001e38cldr x1, [sp+72]
0001e390str x1, [sp+48]
0001e394add x1, sp, 40
0001e398str x1, [sp+8]
0001e39cbl runtime.systemstack.abi0
0001e3a0ldur x29, [sp-8]
0001e3a4ldr x30, [sp], 64
0001e3a8ret x30
0001e3ac
0001e3acloc_1e3ac:
0001e3acadrp x0, 0x6a8000
0001e3b0add x0, x0, 936
0001e3b4movz x1, 44
0001e3b8bl runtime.throw
0001e3bc
0001e3bcloc_1e3bc:
0001e3bcadrp x0, 0x6a5000
0001e3c0add x0, x0, 3875
0001e3c4movz x1, 40
0001e3c8bl runtime.throw
0001e3cchint
0001e3d0
0001e3d0loc_1e3d0:
0001e3d0str x0, [sp+8]
0001e3d4mov x3, x30
0001e3d8bl runtime.morestack_noctxt.abi0
0001e3dcldr x0, [sp+8]
0001e3e0b 0x1e1f0
0001e3e4udf 0
0001e3e8udf 0
0001e3ecudf 0
0001e1f0