Similarity

0001a850
0001a850runtime.mapassign: ; void runtime.mapassign(internal/abi.SwissMapType * typ, internal/runtime/maps.Map * m, void * key)
0001a850ldr x16, [x28+16]
0001a854sub x17, sp, 64
0001a858subs xzr, x17, x16
0001a85cb.ls 0x1ad48
0001a860str x30, [sp-192]!
0001a864stur x29, [sp-8]
0001a868sub x29, sp, 8
0001a86ccbz x1, 0x1ad24
0001a870str x0, [sp+200]
0001a874str x1, [sp+208]
0001a878str x2, [sp+216]
0001a87cldrb w3, [x1+34]
0001a880cbz w3, 0x1a8a0
0001a884adrp x0, 0x69d000
0001a888add x0, x0, 1278
0001a88cmovz x1, 21
0001a890bl internal/runtime/maps.fatal
0001a894ldr x0, [sp+200]
0001a898ldr x1, [sp+208]
0001a89cldr x2, [sp+216]
0001a8a0
0001a8a0loc_1a8a0:
0001a8a0ldr x26, [x0+72]
0001a8a4ldr x3, [x26]
0001a8a8ldr x1, [x1+8]
0001a8acmov x0, x2
0001a8b0blr x3
0001a8b4str x0, [sp+88]
0001a8b8ldr x2, [sp+208]
0001a8bcldrb w3, [x2+34]
0001a8c0eor x3, x3, 1
0001a8c4strb w3, [x2+34]
0001a8c8ldr x3, [x2+16]
0001a8cccbnz x3, 0x1a8e4
0001a8d0mov x0, x2
0001a8d4ldr x1, [sp+200]
0001a8d8bl internal/runtime/maps.(*Map).growToSmall
0001a8dcldr x0, [sp+88]
0001a8e0ldr x2, [sp+208]
0001a8e4
0001a8e4loc_1a8e4:
0001a8e4ldr x4, [x2+24]
0001a8e8cbnz x4, 0x1a980
0001a8ecldr x4, [x2]
0001a8f0subs xzr, x4, 8
0001a8f4b.lo 0x1a910
0001a8f8mov x0, x2
0001a8fcldr x1, [sp+200]
0001a900bl internal/runtime/maps.(*Map).growToTable
0001a904ldr x0, [sp+88]
0001a908ldr x2, [sp+208]
0001a90cb 0x1a980
0001a910
0001a910loc_1a910:
0001a910ldr x1, [sp+200]
0001a914ldr x3, [sp+216]
0001a918mov x4, x0
0001a91cmov x0, x2
0001a920mov x2, x4
0001a924bl internal/runtime/maps.(*Map).putSlotSmall
0001a928ldr x4, [sp+208]
0001a92cldrb w5, [x4+34]
0001a930cbnz w5, 0x1a950
0001a934str x0, [sp+160]
0001a938adrp x0, 0x69d000
0001a93cadd x0, x0, 1278
0001a940movz x1, 21
0001a944bl internal/runtime/maps.fatal
0001a948ldr x0, [sp+160]
0001a94cldr x4, [sp+208]
0001a950
0001a950loc_1a950:
0001a950ldrb w1, [x4+34]
0001a954eor x1, x1, 1
0001a958strb w1, [x4+34]
0001a95cldur x29, [sp-8]
0001a960ldr x30, [sp], 192
0001a964ret x30
0001a968b 0x1a980
0001a96c
0001a96cloc_1a96c:
0001a96cldr x1, [sp+200]
0001a970ldr x2, [sp+208]
0001a974bl internal/runtime/maps.(*table).rehash
0001a978ldr x0, [sp+88]
0001a97cldr x2, [sp+208]
0001a980
0001a980loc_1a980:
0001a980mov x1, x0
0001a984mov x0, x2
0001a988bl internal/runtime/maps.(*Map).directoryIndex
0001a98cmov x1, x0
0001a990ldr x0, [sp+208]
0001a994bl internal/runtime/maps.(*Map).directoryAt
0001a998str x0, [sp+112]
0001a99cldr x0, [sp+88]
0001a9a0bl internal/runtime/maps.h1
0001a9a4ldr x2, [sp+112]
0001a9a8ldr x1, [x2+24]
0001a9acbl internal/runtime/maps.makeProbeSeq
0001a9b0mov x3, xzr
0001a9b4mov x4, xzr
0001a9b8b 0x1aa18
0001a9bc
0001a9bcloc_1a9bc:
0001a9bcldr x1, [sp+152]
0001a9c0cbz x1, 0x1a9e0
0001a9c4str x1, [sp+144]
0001a9c8ldr x0, [sp+112]
0001a9ccldrh w3, [x0+4]
0001a9d0add x3, x3, 1
0001a9d4strh w3, [x0+4]
0001a9d8ldr x1, [sp+96]
0001a9dcb 0x1a9ec
0001a9e0
0001a9e0loc_1a9e0:
0001a9e0bl internal/runtime/maps.bitset.first
0001a9e4mov x1, x0
0001a9e8ldr x0, [sp+112]
0001a9ec
0001a9ecloc_1a9ec:
0001a9ecldrh w3, [x0+4]
0001a9f0cbz w3, 0x1a96c
0001a9f4b 0x1aba4
0001a9f8
0001a9f8loc_1a9f8:
0001a9f8str x1, [sp+96]
0001a9fcstr x0, [sp+152]
0001aa00ldr x0, [sp+56]
0001aa04ldr x1, [sp+48]
0001aa08ldr x2, [sp+64]
0001aa0cbl internal/runtime/maps.probeSeq.next
0001aa10ldr x3, [sp+152]
0001aa14ldr x4, [sp+96]
0001aa18
0001aa18loc_1aa18:
0001aa18str x1, [sp+48]
0001aa1cstr x0, [sp+56]
0001aa20str x3, [sp+152]
0001aa24str x4, [sp+96]
0001aa28str x2, [sp+64]
0001aa2cldr x3, [sp+112]
0001aa30add x0, x3, 16
0001aa34mov x2, x1
0001aa38ldr x1, [sp+200]
0001aa3cbl internal/runtime/maps.(*groupsReference).group
0001aa40str x0, [sp+144]
0001aa44add x0, sp, 144
0001aa48bl internal/runtime/maps.(*groupReference).ctrls
0001aa4cstr x0, [sp+176]
0001aa50ldr x0, [sp+88]
0001aa54bl internal/runtime/maps.h2
0001aa58ldr x3, [sp+176]
0001aa5cldr x3, [x3]
0001aa60mov x1, x0
0001aa64mov x0, x3
0001aa68bl internal/runtime/maps.ctrlGroup.matchH2
0001aa6cb 0x1aad4
0001aa70
0001aa70loc_1aa70:
0001aa70add x0, sp, 144
0001aa74bl internal/runtime/maps.(*groupReference).ctrls
0001aa78ldr x0, [x0]
0001aa7cbl internal/runtime/maps.ctrlGroup.matchEmpty
0001aa80cbnz x0, 0x1a9bc
0001aa84ldr x0, [sp+152]
0001aa88cbz x0, 0x1aa94
0001aa8cldr x1, [sp+96]
0001aa90b 0x1a9f8
0001aa94
0001aa94loc_1aa94:
0001aa94add x0, sp, 144
0001aa98bl internal/runtime/maps.(*groupReference).ctrls
0001aa9cldr x0, [x0]
0001aaa0bl internal/runtime/maps.ctrlGroup.matchEmptyOrDeleted
0001aaa4cbnz x0, 0x1aab4
0001aaa8mov x0, xzr
0001aaacldr x1, [sp+96]
0001aab0b 0x1a9f8
0001aab4
0001aab4loc_1aab4:
0001aab4ldr x1, [sp+144]
0001aab8str x1, [sp+168]
0001aabcbl internal/runtime/maps.bitset.first
0001aac0mov x1, x0
0001aac4ldr x0, [sp+168]
0001aac8b 0x1a9f8
0001aacc
0001aaccloc_1aacc:
0001aaccldr x0, [sp+72]
0001aad0bl internal/runtime/maps.bitset.removeFirst
0001aad4
0001aad4loc_1aad4:
0001aad4cbz x0, 0x1aa70
0001aad8str x0, [sp+72]
0001aadcbl internal/runtime/maps.bitset.first
0001aae0ldr x1, [sp+200]
0001aae4mov x2, x0
0001aae8add x0, sp, 144
0001aaecbl internal/runtime/maps.(*groupReference).key
0001aaf0str x0, [sp+128]
0001aaf4ldr x0, [sp+200]
0001aaf8bl internal/abi.(*SwissMapType).IndirectKey
0001aafctbz w0, 0, 0x1ab0c
0001ab00ldr x2, [sp+128]
0001ab04ldr x0, [x2]
0001ab08b 0x1ab10
0001ab0c
0001ab0cloc_1ab0c:
0001ab0cldr x0, [sp+128]
0001ab10
0001ab10loc_1ab10:
0001ab10str x0, [sp+168]
0001ab14ldr x2, [sp+200]
0001ab18ldr x2, [x2+48]
0001ab1cldr x26, [x2+24]
0001ab20ldr x2, [x26]
0001ab24mov x1, x0
0001ab28ldr x0, [sp+216]
0001ab2cblr x2
0001ab30tbz w0, 0, 0x1aacc
0001ab34ldr x0, [sp+200]
0001ab38bl internal/abi.(*SwissMapType).NeedKeyUpdate
0001ab3ctbz w0, 0, 0x1ab54
0001ab40ldr x3, [sp+200]
0001ab44ldr x0, [x3+48]
0001ab48ldr x1, [sp+168]
0001ab4cldr x2, [sp+216]
0001ab50bl internal/runtime/maps.typedmemmove
0001ab54
0001ab54loc_1ab54:
0001ab54ldr x0, [sp+200]
0001ab58ldr x1, [x0+96]
0001ab5cstr x1, [sp+104]
0001ab60ldr x2, [sp+128]
0001ab64add x1, x1, x2
0001ab68str x1, [sp+136]
0001ab6cbl internal/abi.(*SwissMapType).IndirectElem
0001ab70tbz w0, 0, 0x1ab84
0001ab74ldr x3, [sp+104]
0001ab78ldr x4, [sp+128]
0001ab7cldr x1, [x4+x3]
0001ab80b 0x1ab88
0001ab84
0001ab84loc_1ab84:
0001ab84ldr x1, [sp+136]
0001ab88
0001ab88loc_1ab88:
0001ab88str x1, [sp+136]
0001ab8cldr x0, [sp+112]
0001ab90ldr x1, [sp+200]
0001ab94ldr x2, [sp+208]
0001ab98bl internal/runtime/maps.(*table).checkInvariants
0001ab9cldr x0, [sp+136]
0001aba0b 0x1ace4
0001aba4
0001aba4loc_1aba4:
0001aba4str x1, [sp+80]
0001aba8add x0, sp, 144
0001abacmov x2, x1
0001abb0ldr x1, [sp+200]
0001abb4bl internal/runtime/maps.(*groupReference).key
0001abb8str x0, [sp+120]
0001abbcldr x0, [sp+200]
0001abc0bl internal/abi.(*SwissMapType).IndirectKey
0001abc4tbnz w0, 0, 0x1abd0
0001abc8ldr x0, [sp+120]
0001abccb 0x1ac04
0001abd0
0001abd0loc_1abd0:
0001abd0ldr x1, [sp+200]
0001abd4ldr x0, [x1+48]
0001abd8bl internal/runtime/maps.newobject
0001abdcldr x1, [sp+120]
0001abe0ldrsb x27, [x1]
0001abe4adrp x27, 0xa31000
0001abe8ldr w2, [x27+3056]
0001abeccbz w2, 0x1ac00
0001abf0bl runtime.gcWriteBarrier2
0001abf4str x0, [x25]
0001abf8ldr x3, [x1]
0001abfcstr x3, [x25+8]
0001ac00
0001ac00loc_1ac00:
0001ac00str x0, [x1]
0001ac04
0001ac04loc_1ac04:
0001ac04ldr x3, [sp+200]
0001ac08ldr x3, [x3+48]
0001ac0cmov x1, x0
0001ac10ldr x2, [sp+216]
0001ac14mov x0, x3
0001ac18bl internal/runtime/maps.typedmemmove
0001ac1cldr x0, [sp+200]
0001ac20ldr x3, [x0+96]
0001ac24str x3, [sp+104]
0001ac28ldr x4, [sp+120]
0001ac2cadd x3, x3, x4
0001ac30str x3, [sp+136]
0001ac34bl internal/abi.(*SwissMapType).IndirectElem
0001ac38tbnz w0, 0, 0x1ac44
0001ac3cldr x0, [sp+136]
0001ac40b 0x1ac84
0001ac44
0001ac44loc_1ac44:
0001ac44ldr x1, [sp+200]
0001ac48ldr x0, [x1+56]
0001ac4cbl internal/runtime/maps.newobject
0001ac50adrp x27, 0xa31000
0001ac54ldr w1, [x27+3056]
0001ac58cbnz w1, 0x1ac68
0001ac5cldr x1, [sp+104]
0001ac60ldr x2, [sp+120]
0001ac64b 0x1ac80
0001ac68
0001ac68loc_1ac68:
0001ac68bl runtime.gcWriteBarrier2
0001ac6cstr x0, [x25]
0001ac70ldr x1, [sp+104]
0001ac74ldr x2, [sp+120]
0001ac78ldr x3, [x2+x1]
0001ac7cstr x3, [x25+8]
0001ac80
0001ac80loc_1ac80:
0001ac80str x0, [x2+x1]
0001ac84
0001ac84loc_1ac84:
0001ac84str x0, [sp+136]
0001ac88add x0, sp, 144
0001ac8cbl internal/runtime/maps.(*groupReference).ctrls
0001ac90str x0, [sp+176]
0001ac94ldr x0, [sp+88]
0001ac98bl internal/runtime/maps.h2
0001ac9cldr x1, [sp+80]
0001aca0mov x2, x0
0001aca4ldr x0, [sp+176]
0001aca8bl internal/runtime/maps.(*ctrlGroup).set
0001acacldr x0, [sp+112]
0001acb0ldrh w1, [x0+4]
0001acb4sub x1, x1, 1
0001acb8strh w1, [x0+4]
0001acbcldrh w1, [x0]
0001acc0add x1, x1, 1
0001acc4strh w1, [x0]
0001acc8ldr x2, [sp+208]
0001acccldr x1, [x2]
0001acd0add x1, x1, 1
0001acd4str x1, [x2]
0001acd8ldr x1, [sp+200]
0001acdcbl internal/runtime/maps.(*table).checkInvariants
0001ace0ldr x0, [sp+136]
0001ace4
0001ace4loc_1ace4:
0001ace4ldr x2, [sp+208]
0001ace8ldrb w3, [x2+34]
0001aceccbnz w3, 0x1ad0c
0001acf0str x0, [sp+136]
0001acf4adrp x0, 0x69d000
0001acf8add x0, x0, 1278
0001acfcmovz x1, 21
0001ad00bl internal/runtime/maps.fatal
0001ad04ldr x0, [sp+136]
0001ad08ldr x2, [sp+208]
0001ad0c
0001ad0cloc_1ad0c:
0001ad0cldrb w1, [x2+34]
0001ad10eor x1, x1, 1
0001ad14strb w1, [x2+34]
0001ad18ldur x29, [sp-8]
0001ad1cldr x30, [sp], 192
0001ad20ret x30
0001ad24
0001ad24loc_1ad24:
0001ad24adrp x27, 0x9f3000
0001ad28ldr x2, [x27+3296]
0001ad2ccbz x2, 0x1ad34
0001ad30ldr x2, [x2+8]
0001ad34
0001ad34loc_1ad34:
0001ad34adrp x27, 0x9f3000
0001ad38ldr x1, [x27+3304]
0001ad3cmov x0, x2
0001ad40bl runtime.gopanic
0001ad44hint
0001ad48
0001ad48loc_1ad48:
0001ad48stp x0, x1, [sp+8]
0001ad4cstr x2, [sp+24]
0001ad50mov x3, x30
0001ad54bl runtime.morestack_noctxt.abi0
0001ad58ldp x0, x1, [sp+8]
0001ad5cldr x2, [sp+24]
0001ad60b 0x1a850
0001ad64udf 0
0001ad68udf 0
0001ad6cudf 0
0001a850

0001ad70
0001ad70type:.eq.internal/runtime/maps.Map: ; void type:.eq.internal/runtime/maps.Map(internal/runtime/maps.Map * p, internal/runtime/maps.Map * q)
0001ad70ldr x16, [x28+16]
0001ad74subs xzr, sp, x16
0001ad78b.ls 0x1adb4
0001ad7cstr x30, [sp-48]!
0001ad80stur x29, [sp-8]
0001ad84sub x29, sp, 8
0001ad88ldr x3, [x1+40]
0001ad8cldr x4, [x0+40]
0001ad90subs xzr, x3, x4
0001ad94b.eq 0x1ada0
0001ad98mov x0, xzr
0001ad9cb 0x1ada8
0001ada0
0001ada0loc_1ada0:
0001ada0movz x2, 35
0001ada4bl runtime.memequal
0001ada8
0001ada8loc_1ada8:
0001ada8ldur x29, [sp-8]
0001adacldr x30, [sp], 48
0001adb0ret x30
0001adb4
0001adb4loc_1adb4:
0001adb4stp x0, x1, [sp+8]
0001adb8mov x3, x30
0001adbcbl runtime.morestack_noctxt.abi0
0001adc0ldp x0, x1, [sp+8]
0001adc4b 0x1ad70
0001adc8udf 0
0001adccudf 0
0001ad70

0001add0
0001add0type:.eq.internal/runtime/maps.table: ; void type:.eq.internal/runtime/maps.table(internal/runtime/maps.table * p, internal/runtime/maps.table * q)
0001add0ldrh w2, [x1]
0001add4ldrh w3, [x0]
0001add8subs wzr, w3, w2
0001addcb.ne 0x1ae50
0001ade0ldrh w2, [x0+2]
0001ade4ldrh w3, [x1+2]
0001ade8subs wzr, w2, w3
0001adecb.ne 0x1ae50
0001adf0ldrh w2, [x0+4]
0001adf4ldrh w3, [x1+4]
0001adf8subs wzr, w3, w2
0001adfcb.ne 0x1ae50
0001ae00ldrb w2, [x0+6]
0001ae04ldrb w3, [x1+6]
0001ae08subs wzr, w2, w3
0001ae0cb.ne 0x1ae50
0001ae10ldr x2, [x0+8]
0001ae14ldr x3, [x1+8]
0001ae18subs xzr, x3, x2
0001ae1cb.ne 0x1ae50
0001ae20ldr x2, [x0+16]
0001ae24ldr x3, [x1+16]
0001ae28subs xzr, x3, x2
0001ae2cb.ne 0x1ae44
0001ae30ldr x2, [x0+24]
0001ae34ldr x1, [x1+24]
0001ae38subs xzr, x1, x2
0001ae3ccset x1, eq
0001ae40b 0x1ae48
0001ae44
0001ae44loc_1ae44:
0001ae44mov x1, xzr
0001ae48
0001ae48loc_1ae48:
0001ae48mov x0, x1
0001ae4cret x30
0001ae50
0001ae50loc_1ae50:
0001ae50mov x0, xzr
0001ae54ret x30
0001ae58udf 0
0001ae5cudf 0
0001add0

0001ae60
0001ae60type:.eq.internal/runtime/maps.Iter: ; void type:.eq.internal/runtime/maps.Iter(internal/runtime/maps.Iter * p, internal/runtime/maps.Iter * q)
0001ae60ldr x16, [x28+16]
0001ae64subs xzr, sp, x16
0001ae68b.ls 0x1af40
0001ae6cstr x30, [sp-64]!
0001ae70stur x29, [sp-8]
0001ae74sub x29, sp, 8
0001ae78str x0, [sp+72]
0001ae7cstr x1, [sp+80]
0001ae80strb wzr, [sp+39]
0001ae84ldr x3, [sp+72]
0001ae88ldr x4, [sp+80]
0001ae8cldr x3, [x3+64]
0001ae90ldr x4, [x4+64]
0001ae94subs xzr, x4, x3
0001ae98b.eq 0x1aea0
0001ae9cb 0x1af24
0001aea0
0001aea0loc_1aea0:
0001aea0ldr x3, [sp+72]
0001aea4ldr x4, [sp+80]
0001aea8ldr x3, [x3+72]
0001aeacldr x4, [x4+72]
0001aeb0subs xzr, x4, x3
0001aeb4b.eq 0x1aebc
0001aeb8b 0x1af20
0001aebc
0001aebcloc_1aebc:
0001aebcldr x3, [sp+72]
0001aec0ldr x4, [sp+80]
0001aec4ldr x3, [x3+80]
0001aec8ldr x4, [x4+80]
0001aeccsubs xzr, x4, x3
0001aed0b.eq 0x1aed8
0001aed4b 0x1af1c
0001aed8
0001aed8loc_1aed8:
0001aed8ldr x3, [sp+72]
0001aedcldr x4, [sp+80]
0001aee0ldr x3, [x3+88]
0001aee4ldr x4, [x4+88]
0001aee8subs xzr, x4, x3
0001aeecb.eq 0x1aef4
0001aef0b 0x1af18
0001aef4
0001aef4loc_1aef4:
0001aef4ldr x3, [sp+72]
0001aef8str x3, [sp+48]
0001aefcldr x1, [sp+80]
0001af00str x1, [sp+40]
0001af04ldr x0, [sp+48]
0001af08movz x2, 57
0001af0cbl runtime.memequal
0001af10strb w0, [sp+39]
0001af14b 0x1af30
0001af18
0001af18loc_1af18:
0001af18b 0x1af28
0001af1c
0001af1cloc_1af1c:
0001af1cb 0x1af28
0001af20
0001af20loc_1af20:
0001af20b 0x1af28
0001af24
0001af24loc_1af24:
0001af24b 0x1af28
0001af28
0001af28loc_1af28:
0001af28strb wzr, [sp+39]
0001af2cb 0x1af30
0001af30
0001af30loc_1af30:
0001af30ldrb w0, [sp+39]
0001af34ldur x29, [sp-8]
0001af38ldr x30, [sp], 64
0001af3cret x30
0001af40
0001af40loc_1af40:
0001af40stp x0, x1, [sp+8]
0001af44mov x3, x30
0001af48bl runtime.morestack_noctxt.abi0
0001af4cldp x0, x1, [sp+8]
0001af50b 0x1ae60
0001af54udf 0
0001af58udf 0
0001af5cudf 0
0001ae60

0001af60
0001af60internal/godebugs.Lookup: ; void internal/godebugs.Lookup(struct string name)
0001af60ldr x16, [x28+16]
0001af64subs xzr, sp, x16
0001af68b.ls 0x1b098
0001af6cstr x30, [sp-96]!
0001af70stur x29, [sp-8]
0001af74sub x29, sp, 8
0001af78str x1, [sp+112]
0001af7cstr x0, [sp+104]
0001af80adrp x27, 0x9f4000
0001af84ldr x4, [x27+1560]
0001af88mov x2, xzr
0001af8cb 0x1afa0
0001af90
0001af90loc_1af90:
0001af90ldr x1, [sp+112]
0001af94ldr x5, [sp+104]
0001af98mov x4, x0
0001af9cmov x0, x5
0001afa0
0001afa0loc_1afa0:
0001afa0subs xzr, x4, x2
0001afa4b.le 0x1b070
0001afa8add x5, x2, x4
0001afacadrp x27, 0x9f4000
0001afb0ldr x6, [x27+1560]
0001afb4ubfm x7, x5, 1, 63
0001afb8subs xzr, x6, x5, lsr #1
0001afbcb.ls 0x1b088
0001afc0str x2, [sp+48]
0001afc4str x4, [sp+56]
0001afc8str x7, [sp+72]
0001afccubfm x6, x7, 58, 57
0001afd0adrp x27, 0x9f4000
0001afd4ldr x8, [x27+1552]
0001afd8add x9, x8, x7, lsl #6
0001afdcldr x3, [x9+8]
0001afe0ldr x6, [x8+x6]
0001afe4subs xzr, x1, x3
0001afe8b.ne 0x1b018
0001afecstr x5, [sp+64]
0001aff0str x3, [sp+40]
0001aff4str x6, [sp+80]
0001aff8mov x2, x1
0001affcmov x1, x6
0001b000bl runtime.memequal
0001b004tbnz w0, 0, 0x1b040
0001b008ldr x0, [sp+104]
0001b00cldr x1, [sp+112]
0001b010ldr x3, [sp+40]
0001b014ldr x6, [sp+80]
0001b018
0001b018loc_1b018:
0001b018mov x2, x6
0001b01cbl runtime.cmpstring
0001b020tbz x0, 63, 0x1b030
0001b024ldr x0, [sp+72]
0001b028ldr x2, [sp+48]
0001b02cb 0x1af90
0001b030
0001b030loc_1b030:
0001b030ldr x4, [sp+72]
0001b034add x2, x4, 1
0001b038ldr x0, [sp+56]
0001b03cb 0x1af90
0001b040
0001b040loc_1b040:
0001b040adrp x27, 0x9f3000
0001b044ldr x1, [x27+1560]
0001b048ldr x2, [sp+64]
0001b04csubs xzr, x1, x2, lsr #1
0001b050b.ls 0x1b080
0001b054adrp x27, 0x9f3000
0001b058ldr x1, [x27+1552]
0001b05cldr x2, [sp+72]
0001b060add x0, x1, x2, lsl #6
0001b064ldur x29, [sp-8]
0001b068ldr x30, [sp], 96
0001b06cret x30
0001b070
0001b070loc_1b070:
0001b070mov x0, xzr
0001b074ldur x29, [sp-8]
0001b078ldr x30, [sp], 96
0001b07cret x30
0001b080
0001b080loc_1b080:
0001b080ldr x0, [sp+72]
0001b084bl runtime.panicIndex
0001b088
0001b088loc_1b088:
0001b088mov x0, x7
0001b08cmov x1, x6
0001b090bl runtime.panicIndex
0001b094hint
0001b098
0001b098loc_1b098:
0001b098stp x0, x1, [sp+8]
0001b09cmov x3, x30
0001b0a0bl runtime.morestack_noctxt.abi0
0001b0a4ldp x0, x1, [sp+8]
0001b0a8b 0x1af60
0001b0acudf 0
0001af60

0001b0b0
0001b0b0type:.eq.internal/godebugs.Info: ; void type:.eq.internal/godebugs.Info(internal/godebugs.Info * p, internal/godebugs.Info * q)
0001b0b0ldr x16, [x28+16]
0001b0b4subs xzr, sp, x16
0001b0b8b.ls 0x1b17c
0001b0bcstr x30, [sp-48]!
0001b0c0stur x29, [sp-8]
0001b0c4sub x29, sp, 8
0001b0c8ldr x3, [x1+8]
0001b0ccldr x2, [x0+8]
0001b0d0subs xzr, x2, x3
0001b0d4b.ne 0x1b16c
0001b0d8ldr x3, [x1+24]
0001b0dcldr x4, [x0+24]
0001b0e0subs xzr, x4, x3
0001b0e4b.ne 0x1b16c
0001b0e8ldr x3, [x0+32]
0001b0ecldr x4, [x1+32]
0001b0f0subs xzr, x4, x3
0001b0f4b.ne 0x1b16c
0001b0f8ldr x3, [x1+48]
0001b0fcldr x4, [x0+48]
0001b100subs xzr, x4, x3
0001b104b.ne 0x1b16c
0001b108ldrb w3, [x0+56]
0001b10cldrb w4, [x1+56]
0001b110eor x3, x3, x4
0001b114eor x3, x3, 1
0001b118tbz w3, 0, 0x1b16c
0001b11cstr x0, [sp+56]
0001b120str x1, [sp+64]
0001b124ldr x1, [x1]
0001b128ldr x0, [x0]
0001b12cbl runtime.memequal
0001b130tbz w0, 0, 0x1b16c
0001b134ldr x3, [sp+64]
0001b138ldr x1, [x3+16]
0001b13cldr x3, [sp+56]
0001b140ldr x0, [x3+16]
0001b144ldr x2, [x3+24]
0001b148bl runtime.memequal
0001b14ctbz w0, 0, 0x1b16c
0001b150ldr x3, [sp+64]
0001b154ldr x1, [x3+40]
0001b158ldr x3, [sp+56]
0001b15cldr x0, [x3+40]
0001b160ldr x2, [x3+48]
0001b164bl runtime.memequal
0001b168b 0x1b170
0001b16c
0001b16cloc_1b16c:
0001b16cmov x0, xzr
0001b170
0001b170loc_1b170:
0001b170ldur x29, [sp-8]
0001b174ldr x30, [sp], 48
0001b178ret x30
0001b17c
0001b17cloc_1b17c:
0001b17cstp x0, x1, [sp+8]
0001b180mov x3, x30
0001b184bl runtime.morestack_noctxt.abi0
0001b188ldp x0, x1, [sp+8]
0001b18cb 0x1b0b0
0001b0b0

0001b190
0001b190internal/runtime/syscall.EpollCreate1: ; void internal/runtime/syscall.EpollCreate1(int32 flags)
0001b190ldr x16, [x28+16]
0001b194subs xzr, sp, x16
0001b198b.ls 0x1b1dc
0001b19cstr x30, [sp-96]!
0001b1a0stur x29, [sp-8]
0001b1a4sub x29, sp, 8
0001b1a8movz x1, 20
0001b1acstr x1, [sp+8]
0001b1b0sbfm x0, x0, 0, 31
0001b1b4str x0, [sp+16]
0001b1b8stp xzr, xzr, [sp+24]
0001b1bcstp xzr, xzr, [sp+40]
0001b1c0str xzr, [sp+56]
0001b1c4bl internal/runtime/syscall.Syscall6.abi0
0001b1c8ldr x0, [sp+64]
0001b1ccldr x1, [sp+80]
0001b1d0ldur x29, [sp-8]
0001b1d4ldr x30, [sp], 96
0001b1d8ret x30
0001b1dc
0001b1dcloc_1b1dc:
0001b1dcstr w0, [sp+8]
0001b1e0mov x3, x30
0001b1e4bl runtime.morestack_noctxt.abi0
0001b1e8ldrsw x0, [sp+8]
0001b1ecb 0x1b190
0001b190

0001b1f0
0001b1f0internal/runtime/syscall.EpollWait: ; void internal/runtime/syscall.EpollWait(int32 epfd, struct []internal/runtime/syscall.EpollEvent events, int32 maxev, int32 waitms)
0001b1f0ldr x16, [x28+16]
0001b1f4subs xzr, sp, x16
0001b1f8b.ls 0x1b25c
0001b1fcstr x30, [sp-112]!
0001b200stur x29, [sp-8]
0001b204sub x29, sp, 8
0001b208str x1, [sp+128]
0001b20ccbnz x2, 0x1b218
0001b210adrp x1, 0xa30000
0001b214add x1, x1, 2216
0001b218
0001b218loc_1b218:
0001b218sbfm x0, x0, 0, 31
0001b21cstr x1, [sp+96]
0001b220movz x2, 22
0001b224str x2, [sp+8]
0001b228str x0, [sp+16]
0001b22cstr x1, [sp+24]
0001b230sbfm x0, x4, 0, 31
0001b234str x0, [sp+32]
0001b238sbfm x0, x5, 0, 31
0001b23cstr x0, [sp+40]
0001b240stp xzr, xzr, [sp+48]
0001b244bl internal/runtime/syscall.Syscall6.abi0
0001b248ldr x0, [sp+64]
0001b24cldr x1, [sp+80]
0001b250ldur x29, [sp-8]
0001b254ldr x30, [sp], 112
0001b258ret x30
0001b25c
0001b25cloc_1b25c:
0001b25cstr w0, [sp+8]
0001b260stp x1, x2, [sp+16]
0001b264str x3, [sp+32]
0001b268stp w4, w5, [sp+40]
0001b26cmov x3, x30
0001b270bl runtime.morestack_noctxt.abi0
0001b274ldrsw x0, [sp+8]
0001b278ldp x1, x2, [sp+16]
0001b27cldr x3, [sp+32]
0001b280ldp w4, w5, [sp+40]
0001b284b 0x1b1f0
0001b288udf 0
0001b28cudf 0
0001b1f0

0001b290
0001b290internal/runtime/syscall.EpollCtl: ; void internal/runtime/syscall.EpollCtl(int32 epfd, int32 op, int32 fd, internal/runtime/syscall.EpollEvent * event)
0001b290ldr x16, [x28+16]
0001b294subs xzr, sp, x16
0001b298b.ls 0x1b2ec
0001b29cstr x30, [sp-112]!
0001b2a0stur x29, [sp-8]
0001b2a4sub x29, sp, 8
0001b2a8sbfm x0, x0, 0, 31
0001b2acsbfm x1, x1, 0, 31
0001b2b0sbfm x2, x2, 0, 31
0001b2b4str x3, [sp+96]
0001b2b8ldr x3, [sp+96]
0001b2bcmovz x4, 21
0001b2c0str x4, [sp+8]
0001b2c4str x0, [sp+16]
0001b2c8str x1, [sp+24]
0001b2ccstr x2, [sp+32]
0001b2d0str x3, [sp+40]
0001b2d4stp xzr, xzr, [sp+48]
0001b2d8bl internal/runtime/syscall.Syscall6.abi0
0001b2dcldr x0, [sp+80]
0001b2e0ldur x29, [sp-8]
0001b2e4ldr x30, [sp], 112
0001b2e8ret x30
0001b2ec
0001b2ecloc_1b2ec:
0001b2ecstp w0, w1, [sp+8]
0001b2f0str w2, [sp+16]
0001b2f4str x3, [sp+24]
0001b2f8mov x3, x30
0001b2fcbl runtime.morestack_noctxt.abi0
0001b300ldp w0, w1, [sp+8]
0001b304ldrsw x2, [sp+16]
0001b308ldr x3, [sp+24]
0001b30cb 0x1b290
0001b290

0001b310
0001b310internal/runtime/syscall.Eventfd: ; void internal/runtime/syscall.Eventfd(int32 initval, int32 flags)
0001b310ldr x16, [x28+16]
0001b314subs xzr, sp, x16
0001b318b.ls 0x1b360
0001b31cstr x30, [sp-96]!
0001b320stur x29, [sp-8]
0001b324sub x29, sp, 8
0001b328movz x2, 19
0001b32cstr x2, [sp+8]
0001b330sbfm x0, x0, 0, 31
0001b334str x0, [sp+16]
0001b338sbfm x0, x1, 0, 31
0001b33cstr x0, [sp+24]
0001b340stp xzr, xzr, [sp+32]
0001b344stp xzr, xzr, [sp+48]
0001b348bl internal/runtime/syscall.Syscall6.abi0
0001b34cldr x0, [sp+64]
0001b350ldr x1, [sp+80]
0001b354ldur x29, [sp-8]
0001b358ldr x30, [sp], 96
0001b35cret x30
0001b360
0001b360loc_1b360:
0001b360stp w0, w1, [sp+8]
0001b364mov x3, x30
0001b368bl runtime.morestack_noctxt.abi0
0001b36cldp w0, w1, [sp+8]
0001b370b 0x1b310
0001b374udf 0
0001b378udf 0
0001b37cudf 0
0001b310

0001b380
0001b380internal/runtime/syscall.Syscall6.abi0: ; void internal/runtime/syscall.Syscall6(void)
0001b380ldr x8, [sp+8]
0001b384ldr x0, [sp+16]
0001b388ldr x1, [sp+24]
0001b38cldr x2, [sp+32]
0001b390ldr x3, [sp+40]
0001b394ldr x4, [sp+48]
0001b398ldr x5, [sp+56]
0001b39csvc 0
0001b3a0adds xzr, x0, 4095
0001b3a4b.lo 0x1b3c0
0001b3a8movn x4, 0
0001b3acstr x4, [sp+64]
0001b3b0str xzr, [sp+72]
0001b3b4sub x0, xzr, x0
0001b3b8str x0, [sp+80]
0001b3bcret x30
0001b3c0
0001b3c0loc_1b3c0:
0001b3c0str x0, [sp+64]
0001b3c4str x1, [sp+72]
0001b3c8str xzr, [sp+80]
0001b3ccret x30
0001b380

0001b3d0
0001b3d0internal/stringslite.HasPrefix: ; void internal/stringslite.HasPrefix(struct string s, struct string prefix)
0001b3d0ldr x16, [x28+16]
0001b3d4subs xzr, sp, x16
0001b3d8b.ls 0x1b418
0001b3dcstr x30, [sp-48]!
0001b3e0stur x29, [sp-8]
0001b3e4sub x29, sp, 8
0001b3e8str x0, [sp+56]
0001b3ecstr x2, [sp+72]
0001b3f0subs xzr, x3, x1
0001b3f4b.le 0x1b400
0001b3f8mov x0, xzr
0001b3fcb 0x1b40c
0001b400
0001b400loc_1b400:
0001b400mov x1, x2
0001b404mov x2, x3
0001b408bl runtime.memequal
0001b40c
0001b40cloc_1b40c:
0001b40cldur x29, [sp-8]
0001b410ldr x30, [sp], 48
0001b414ret x30
0001b418
0001b418loc_1b418:
0001b418stp x0, x1, [sp+8]
0001b41cstp x2, x3, [sp+24]
0001b420mov x3, x30
0001b424bl runtime.morestack_noctxt.abi0
0001b428ldp x0, x1, [sp+8]
0001b42cldp x2, x3, [sp+24]
0001b430b 0x1b3d0
0001b434udf 0
0001b438udf 0
0001b43cudf 0
0001b3d0

0001b440
0001b440internal/stringslite.HasSuffix: ; void internal/stringslite.HasSuffix(struct string s, struct string suffix)
0001b440ldr x16, [x28+16]
0001b444subs xzr, sp, x16
0001b448b.ls 0x1b4c4
0001b44cstr x30, [sp-48]!
0001b450stur x29, [sp-8]
0001b454sub x29, sp, 8
0001b458str x0, [sp+56]
0001b45cstr x2, [sp+72]
0001b460subs xzr, x3, x1
0001b464b.gt 0x1b4a8
0001b468sub x4, x1, x3
0001b46csubs xzr, x1, x4
0001b470b.lo 0x1b4b8
0001b474add x5, x1, x3
0001b478sub x5, x5, x1
0001b47csub x6, xzr, x5
0001b480and x4, x4, x6, asr #63
0001b484add x0, x0, x4
0001b488subs xzr, x3, x5
0001b48cb.eq 0x1b498
0001b490mov x0, xzr
0001b494b 0x1b4ac
0001b498
0001b498loc_1b498:
0001b498mov x1, x2
0001b49cmov x2, x5
0001b4a0bl runtime.memequal
0001b4a4b 0x1b4ac
0001b4a8
0001b4a8loc_1b4a8:
0001b4a8mov x0, xzr
0001b4ac
0001b4acloc_1b4ac:
0001b4acldur x29, [sp-8]
0001b4b0ldr x30, [sp], 48
0001b4b4ret x30
0001b4b8
0001b4b8loc_1b4b8:
0001b4b8mov x0, x4
0001b4bcbl runtime.panicSliceB
0001b4c0hint
0001b4c4
0001b4c4loc_1b4c4:
0001b4c4stp x0, x1, [sp+8]
0001b4c8stp x2, x3, [sp+24]
0001b4ccmov x3, x30
0001b4d0bl runtime.morestack_noctxt.abi0
0001b4d4ldp x0, x1, [sp+8]
0001b4d8ldp x2, x3, [sp+24]
0001b4dcb 0x1b440
0001b440

0001b4e0
0001b4e0internal/stringslite.IndexByte: ; void internal/stringslite.IndexByte(struct string s, uint8 c)
0001b4e0ldr x16, [x28+16]
0001b4e4subs xzr, sp, x16
0001b4e8b.ls 0x1b51c
0001b4ecstr x30, [sp-48]!
0001b4f0stur x29, [sp-8]
0001b4f4sub x29, sp, 8
0001b4f8str x0, [sp+56]
0001b4fcstr x0, [sp+8]
0001b500str x1, [sp+16]
0001b504strb w2, [sp+24]
0001b508bl internal/bytealg.IndexByteString.abi0
0001b50cldr x0, [sp+32]
0001b510ldur x29, [sp-8]
0001b514ldr x30, [sp], 48
0001b518ret x30
0001b51c
0001b51cloc_1b51c:
0001b51cstp x0, x1, [sp+8]
0001b520strb w2, [sp+24]
0001b524mov x3, x30
0001b528bl runtime.morestack_noctxt.abi0
0001b52cldp x0, x1, [sp+8]
0001b530ldrb w2, [sp+24]
0001b534b 0x1b4e0
0001b538udf 0
0001b53cudf 0
0001b4e0

0001b540
0001b540internal/stringslite.Index: ; void internal/stringslite.Index(struct string s, struct string substr)
0001b540ldr x16, [x28+16]
0001b544subs xzr, sp, x16
0001b548b.ls 0x1ba48
0001b54cstr x30, [sp-128]!
0001b550stur x29, [sp-8]
0001b554sub x29, sp, 8
0001b558str x0, [sp+136]
0001b55cstr x2, [sp+152]
0001b560cbz x3, 0x1b66c
0001b564subs xzr, x3, 1
0001b568b.eq 0x1b658
0001b56csubs xzr, x1, x3
0001b570b.eq 0x1b624
0001b574b.lt 0x1b614
0001b578str x3, [sp+160]
0001b57cstr x2, [sp+152]
0001b580str x1, [sp+144]
0001b584str x0, [sp+136]
0001b588adrp x27, 0xa30000
0001b58cldr x5, [x27+2176]
0001b590subs xzr, x3, x5
0001b594b.le 0x1b5c0
0001b598sub x5, x1, x3
0001b59cldrb w6, [x2]
0001b5a0strb w6, [sp+54]
0001b5a4ldrb w7, [x2+1]
0001b5a8strb w7, [sp+52]
0001b5acadd x5, x5, 1
0001b5b0str x5, [sp+56]
0001b5b4mov x4, xzr
0001b5b8mov x8, xzr
0001b5bcb 0x1b870
0001b5c0
0001b5c0loc_1b5c0:
0001b5c0subs xzr, x1, 16
0001b5c4b.le 0x1b5f0
0001b5c8sub x4, x1, x3
0001b5ccldrb w5, [x2]
0001b5d0strb w5, [sp+55]
0001b5d4ldrb w6, [x2+1]
0001b5d8strb w6, [sp+53]
0001b5dcadd x4, x4, 1
0001b5e0str x4, [sp+64]
0001b5e4mov x7, xzr
0001b5e8mov x8, xzr
0001b5ecb 0x1b6a4
0001b5f0
0001b5f0loc_1b5f0:
0001b5f0str x0, [sp+8]
0001b5f4str x1, [sp+16]
0001b5f8str x2, [sp+24]
0001b5fcstr x3, [sp+32]
0001b600bl internal/bytealg.IndexString.abi0
0001b604ldr x0, [sp+40]
0001b608ldur x29, [sp-8]
0001b60cldr x30, [sp], 128
0001b610ret x30
0001b614
0001b614loc_1b614:
0001b614movn x0, 0
0001b618ldur x29, [sp-8]
0001b61cldr x30, [sp], 128
0001b620ret x30
0001b624
0001b624loc_1b624:
0001b624mov x1, x0
0001b628mov x0, x2
0001b62cmov x2, x3
0001b630bl runtime.memequal
0001b634tbz w0, 0, 0x1b648
0001b638mov x0, xzr
0001b63cldur x29, [sp-8]
0001b640ldr x30, [sp], 128
0001b644ret x30
0001b648
0001b648loc_1b648:
0001b648movn x0, 0
0001b64cldur x29, [sp-8]
0001b650ldr x30, [sp], 128
0001b654ret x30
0001b658
0001b658loc_1b658:
0001b658ldrb w2, [x2]
0001b65cbl internal/stringslite.IndexByte
0001b660ldur x29, [sp-8]
0001b664ldr x30, [sp], 128
0001b668ret x30
0001b66c
0001b66cloc_1b66c:
0001b66cmov x0, xzr
0001b670ldur x29, [sp-8]
0001b674ldr x30, [sp], 128
0001b678ret x30
0001b67c
0001b67cloc_1b67c:
0001b67cldr x4, [sp+64]
0001b680ldr x3, [sp+160]
0001b684ldr x2, [sp+152]
0001b688ldrb w6, [sp+53]
0001b68cldr x0, [sp+136]
0001b690ldr x9, [sp+144]
0001b694ldrb w5, [sp+55]
0001b698ldr x7, [sp+104]
0001b69cmov x8, x1
0001b6a0mov x1, x9
0001b6a4
0001b6a4loc_1b6a4:
0001b6a4subs xzr, x7, x4
0001b6a8b.ge 0x1b828
0001b6acsubs xzr, x1, x7
0001b6b0b.ls 0x1b864
0001b6b4str x8, [sp+96]
0001b6b8ldrb w9, [x0+x7]
0001b6bcmov x10, x5
0001b6c0subs wzr, w9, w10
0001b6c4b.eq 0x1b724
0001b6c8subs xzr, x1, x4
0001b6ccb.lo 0x1b858
0001b6d0str x7, [sp+80]
0001b6d4add x3, x3, x7
0001b6d8sub x1, x1, x3
0001b6dcsub x3, xzr, x1
0001b6e0add x4, x7, 1
0001b6e4and x3, x4, x3, asr #63
0001b6e8add x0, x0, x3
0001b6ecmov x2, x5
0001b6f0bl internal/stringslite.IndexByte
0001b6f4tbnz x0, 63, 0x1b798
0001b6f8ldr x3, [sp+80]
0001b6fcadd x3, x3, x0
0001b700add x7, x3, 1
0001b704ldr x0, [sp+136]
0001b708ldr x1, [sp+144]
0001b70cldr x2, [sp+152]
0001b710ldr x3, [sp+160]
0001b714ldr x4, [sp+64]
0001b718ldrb w5, [sp+55]
0001b71cldrb w6, [sp+53]
0001b720ldr x8, [sp+96]
0001b724
0001b724loc_1b724:
0001b724add x9, x7, 1
0001b728subs xzr, x1, x9
0001b72cb.ls 0x1b850
0001b730str x7, [sp+112]
0001b734str x9, [sp+104]
0001b738ldrb w10, [x0+x9]
0001b73cmov x11, x6
0001b740subs wzr, w11, w10
0001b744b.ne 0x1b77c
0001b748add x10, x3, x7
0001b74csubs xzr, x1, x10
0001b750b.lo 0x1b844
0001b754subs xzr, x7, x10
0001b758b.hi 0x1b838
0001b75csub x4, xzr, x3
0001b760and x4, x7, x4, asr #63
0001b764add x0, x0, x4
0001b768mov x1, x2
0001b76cmov x2, x3
0001b770bl runtime.memequal
0001b774tbnz w0, 0, 0x1b7a8
0001b778ldr x9, [sp+104]
0001b77c
0001b77cloc_1b77c:
0001b77cmov x0, x9
0001b780bl internal/bytealg.Cutover
0001b784ldr x1, [sp+96]
0001b788add x1, x1, 1
0001b78csubs xzr, x0, x1
0001b790b.ge 0x1b67c
0001b794b 0x1b7b8
0001b798
0001b798loc_1b798:
0001b798movn x0, 0
0001b79cldur x29, [sp-8]
0001b7a0ldr x30, [sp], 128
0001b7a4ret x30
0001b7a8
0001b7a8loc_1b7a8:
0001b7a8ldr x0, [sp+112]
0001b7acldur x29, [sp-8]
0001b7b0ldr x30, [sp], 128
0001b7b4ret x30
0001b7b8
0001b7b8loc_1b7b8:
0001b7b8ldr x0, [sp+144]
0001b7bcldr x1, [sp+112]
0001b7c0sub x0, x0, x1
0001b7c4sub x0, x0, 1
0001b7c8sub x1, xzr, x0
0001b7ccldr x2, [sp+104]
0001b7d0and x1, x2, x1, asr #63
0001b7d4ldr x2, [sp+136]
0001b7d8add x1, x2, x1
0001b7dcstr x1, [sp+8]
0001b7e0str x0, [sp+16]
0001b7e4ldr x0, [sp+152]
0001b7e8str x0, [sp+24]
0001b7ecldr x0, [sp+160]
0001b7f0str x0, [sp+32]
0001b7f4bl internal/bytealg.IndexString.abi0
0001b7f8ldr x0, [sp+40]
0001b7fctbnz x0, 63, 0x1b818
0001b800ldr x1, [sp+112]
0001b804add x1, x1, x0
0001b808add x0, x1, 1
0001b80cldur x29, [sp-8]
0001b810ldr x30, [sp], 128
0001b814ret x30
0001b818
0001b818loc_1b818:
0001b818movn x0, 0
0001b81cldur x29, [sp-8]
0001b820ldr x30, [sp], 128
0001b824ret x30
0001b828
0001b828loc_1b828:
0001b828movn x0, 0
0001b82cldur x29, [sp-8]
0001b830ldr x30, [sp], 128
0001b834ret x30
0001b838
0001b838loc_1b838:
0001b838mov x0, x7
0001b83cmov x1, x10
0001b840bl runtime.panicSliceB
0001b844
0001b844loc_1b844:
0001b844mov x2, x1
0001b848mov x1, x10
0001b84cbl runtime.panicSliceAlen
0001b850
0001b850loc_1b850:
0001b850mov x0, x9
0001b854bl runtime.panicIndex
0001b858
0001b858loc_1b858:
0001b858mov x2, x1
0001b85cmov x1, x4
0001b860bl runtime.panicSliceAlen
0001b864
0001b864loc_1b864:
0001b864mov x0, x7
0001b868bl runtime.panicIndex
0001b86c
0001b86cloc_1b86c:
0001b86cmov x4, x9
0001b870
0001b870loc_1b870:
0001b870subs xzr, x4, x5
0001b874b.ge 0x1ba00
0001b878subs xzr, x1, x4
0001b87cb.ls 0x1ba3c
0001b880str x8, [sp+88]
0001b884ldrb w9, [x0+x4]
0001b888mov x10, x6
0001b88csubs wzr, w9, w10
0001b890b.eq 0x1b8f0
0001b894subs xzr, x1, x5
0001b898b.lo 0x1ba30
0001b89cstr x4, [sp+72]
0001b8a0add x3, x3, x4
0001b8a4sub x1, x1, x3
0001b8a8sub x3, xzr, x1
0001b8acadd x4, x4, 1
0001b8b0and x3, x4, x3, asr #63
0001b8b4add x0, x0, x3
0001b8b8mov x2, x6
0001b8bcbl internal/stringslite.IndexByte
0001b8c0tbnz x0, 63, 0x1b9f0
0001b8c4ldr x5, [sp+72]
0001b8c8add x5, x5, x0
0001b8ccadd x4, x5, 1
0001b8d0ldr x0, [sp+136]
0001b8d4ldr x1, [sp+144]
0001b8d8ldr x2, [sp+152]
0001b8dcldr x3, [sp+160]
0001b8e0ldr x5, [sp+56]
0001b8e4ldrb w6, [sp+54]
0001b8e8ldrb w7, [sp+52]
0001b8ecldr x8, [sp+88]
0001b8f0
0001b8f0loc_1b8f0:
0001b8f0add x9, x4, 1
0001b8f4subs xzr, x1, x9
0001b8f8b.ls 0x1ba28
0001b8fcstr x4, [sp+112]
0001b900ldrb w10, [x0+x9]
0001b904mov x11, x7
0001b908subs wzr, w10, w11
0001b90cb.ne 0x1b96c
0001b910add x10, x3, x4
0001b914subs xzr, x1, x10
0001b918b.lo 0x1ba1c
0001b91csubs xzr, x4, x10
0001b920b.hi 0x1ba10
0001b924str x9, [sp+104]
0001b928sub x5, xzr, x3
0001b92cand x4, x4, x5, asr #63
0001b930add x0, x0, x4
0001b934mov x1, x2
0001b938mov x2, x3
0001b93cbl runtime.memequal
0001b940tbnz w0, 0, 0x1b9e0
0001b944ldr x0, [sp+136]
0001b948ldr x1, [sp+144]
0001b94cldr x2, [sp+152]
0001b950ldr x3, [sp+160]
0001b954ldr x4, [sp+112]
0001b958ldr x5, [sp+56]
0001b95cldrb w6, [sp+54]
0001b960ldrb w7, [sp+52]
0001b964ldr x8, [sp+88]
0001b968ldr x9, [sp+104]
0001b96c
0001b96cloc_1b96c:
0001b96cadd x8, x8, 1
0001b970sbfm x10, x9, 4, 63
0001b974add x10, x10, 4
0001b978subs xzr, x10, x8
0001b97cb.gt 0x1b86c
0001b980subs xzr, x9, x5
0001b984b.ge 0x1b86c
0001b988sub x5, x1, x4
0001b98csub x5, x5, 1
0001b990sub x6, xzr, x5
0001b994and x6, x9, x6, asr #63
0001b998add x1, x6, x0
0001b99cadrp x0, 0x6f8000
0001b9a0add x0, x0, 0
0001b9a4mov x4, x3
0001b9a8mov x3, x2
0001b9acmov x2, x5
0001b9b0bl internal/bytealg.IndexRabinKarp[go.shape.string]
0001b9b4tbz x0, 63, 0x1b9c8
0001b9b8movn x0, 0
0001b9bcldur x29, [sp-8]
0001b9c0ldr x30, [sp], 128
0001b9c4ret x30
0001b9c8
0001b9c8loc_1b9c8:
0001b9c8ldr x1, [sp+112]
0001b9ccadd x1, x1, x0
0001b9d0add x0, x1, 1
0001b9d4ldur x29, [sp-8]
0001b9d8ldr x30, [sp], 128
0001b9dcret x30
0001b9e0
0001b9e0loc_1b9e0:
0001b9e0ldr x0, [sp+112]
0001b9e4ldur x29, [sp-8]
0001b9e8ldr x30, [sp], 128
0001b9ecret x30
0001b9f0
0001b9f0loc_1b9f0:
0001b9f0movn x0, 0
0001b9f4ldur x29, [sp-8]
0001b9f8ldr x30, [sp], 128
0001b9fcret x30
0001ba00
0001ba00loc_1ba00:
0001ba00movn x0, 0
0001ba04ldur x29, [sp-8]
0001ba08ldr x30, [sp], 128
0001ba0cret x30
0001ba10
0001ba10loc_1ba10:
0001ba10mov x0, x4
0001ba14mov x1, x10
0001ba18bl runtime.panicSliceB
0001ba1c
0001ba1cloc_1ba1c:
0001ba1cmov x2, x1
0001ba20mov x1, x10
0001ba24bl runtime.panicSliceAlen
0001ba28
0001ba28loc_1ba28:
0001ba28mov x0, x9
0001ba2cbl runtime.panicIndex
0001ba30
0001ba30loc_1ba30:
0001ba30mov x2, x1
0001ba34mov x1, x5
0001ba38bl runtime.panicSliceAlen
0001ba3c
0001ba3cloc_1ba3c:
0001ba3cmov x0, x4
0001ba40bl runtime.panicIndex
0001ba44hint
0001ba48
0001ba48loc_1ba48:
0001ba48stp x0, x1, [sp+8]
0001ba4cstp x2, x3, [sp+24]
0001ba50mov x3, x30
0001ba54bl runtime.morestack_noctxt.abi0
0001ba58ldp x0, x1, [sp+8]
0001ba5cldp x2, x3, [sp+24]
0001ba60b 0x1b540
0001ba64udf 0
0001ba68udf 0
0001ba6cudf 0
0001b540

0001ba70
0001ba70internal/stringslite.Cut: ; void internal/stringslite.Cut(struct string s, struct string sep)
0001ba70ldr x16, [x28+16]
0001ba74subs xzr, sp, x16
0001ba78b.ls 0x1bb20
0001ba7cstr x30, [sp-48]!
0001ba80stur x29, [sp-8]
0001ba84sub x29, sp, 8
0001ba88str x2, [sp+72]
0001ba8cstr x3, [sp+80]
0001ba90str x1, [sp+64]
0001ba94str x0, [sp+56]
0001ba98bl internal/stringslite.Index
0001ba9ctbnz x0, 63, 0x1bae8
0001baa0ldr x2, [sp+64]
0001baa4subs xzr, x0, x2
0001baa8b.hi 0x1bb14
0001baacldr x5, [sp+80]
0001bab0add x5, x0, x5
0001bab4subs xzr, x2, x5
0001bab8b.lo 0x1bb08
0001babcsub x3, x2, x5
0001bac0sub x6, xzr, x3
0001bac4and x5, x5, x6, asr #63
0001bac8ldr x6, [sp+56]
0001baccadd x2, x6, x5
0001bad0mov x1, x0
0001bad4orr x4, xzr, 1
0001bad8mov x0, x6
0001badcldur x29, [sp-8]
0001bae0ldr x30, [sp], 48
0001bae4ret x30
0001bae8
0001bae8loc_1bae8:
0001bae8ldr x0, [sp+56]
0001baecldr x1, [sp+64]
0001baf0mov x2, xzr
0001baf4mov x3, xzr
0001baf8mov x4, xzr
0001bafcldur x29, [sp-8]
0001bb00ldr x30, [sp], 48
0001bb04ret x30
0001bb08
0001bb08loc_1bb08:
0001bb08mov x0, x5
0001bb0cmov x1, x2
0001bb10bl runtime.panicSliceB
0001bb14
0001bb14loc_1bb14:
0001bb14mov x1, x0
0001bb18bl runtime.panicSliceAlen
0001bb1chint
0001bb20
0001bb20loc_1bb20:
0001bb20stp x0, x1, [sp+8]
0001bb24stp x2, x3, [sp+24]
0001bb28mov x3, x30
0001bb2cbl runtime.morestack_noctxt.abi0
0001bb30ldp x0, x1, [sp+8]
0001bb34ldp x2, x3, [sp+24]
0001bb38b 0x1ba70
0001bb3cudf 0
0001ba70

0001bb40
0001bb40internal/stringslite.CutPrefix: ; void internal/stringslite.CutPrefix(struct string s, struct string prefix)
0001bb40ldr x16, [x28+16]
0001bb44subs xzr, sp, x16
0001bb48b.ls 0x1bbc4
0001bb4cstr x30, [sp-48]!
0001bb50stur x29, [sp-8]
0001bb54sub x29, sp, 8
0001bb58str x2, [sp+72]
0001bb5cstr x1, [sp+64]
0001bb60str x3, [sp+80]
0001bb64str x0, [sp+56]
0001bb68bl internal/stringslite.HasPrefix
0001bb6ctbz w0, 0, 0x1bba4
0001bb70ldr x0, [sp+80]
0001bb74ldr x1, [sp+64]
0001bb78subs xzr, x0, x1
0001bb7cb.hi 0x1bbbc
0001bb80sub x1, x1, x0
0001bb84sub x3, xzr, x1
0001bb88and x3, x0, x3, asr #63
0001bb8cldr x4, [sp+56]
0001bb90add x0, x4, x3
0001bb94orr x2, xzr, 1
0001bb98ldur x29, [sp-8]
0001bb9cldr x30, [sp], 48
0001bba0ret x30
0001bba4
0001bba4loc_1bba4:
0001bba4ldr x0, [sp+56]
0001bba8ldr x1, [sp+64]
0001bbacmov x2, xzr
0001bbb0ldur x29, [sp-8]
0001bbb4ldr x30, [sp], 48
0001bbb8ret x30
0001bbbc
0001bbbcloc_1bbbc:
0001bbbcbl runtime.panicSliceB
0001bbc0hint
0001bbc4
0001bbc4loc_1bbc4:
0001bbc4stp x0, x1, [sp+8]
0001bbc8stp x2, x3, [sp+24]
0001bbccmov x3, x30
0001bbd0bl runtime.morestack_noctxt.abi0
0001bbd4ldp x0, x1, [sp+8]
0001bbd8ldp x2, x3, [sp+24]
0001bbdcb 0x1bb40
0001bb40

0001bbe0
0001bbe0internal/stringslite.CutSuffix: ; void internal/stringslite.CutSuffix(struct string s, struct string suffix)
0001bbe0ldr x16, [x28+16]
0001bbe4subs xzr, sp, x16
0001bbe8b.ls 0x1bc58
0001bbecstr x30, [sp-48]!
0001bbf0stur x29, [sp-8]
0001bbf4sub x29, sp, 8
0001bbf8str x2, [sp+72]
0001bbfcstr x0, [sp+56]
0001bc00str x1, [sp+64]
0001bc04str x3, [sp+80]
0001bc08bl internal/stringslite.HasSuffix
0001bc0ctbz w0, 0, 0x1bc38
0001bc10ldr x2, [sp+64]
0001bc14ldr x3, [sp+80]
0001bc18sub x1, x2, x3
0001bc1csubs xzr, x2, x1
0001bc20b.lo 0x1bc50
0001bc24ldr x0, [sp+56]
0001bc28orr x2, xzr, 1
0001bc2cldur x29, [sp-8]
0001bc30ldr x30, [sp], 48
0001bc34ret x30
0001bc38
0001bc38loc_1bc38:
0001bc38ldr x0, [sp+56]
0001bc3cldr x1, [sp+64]
0001bc40mov x2, xzr
0001bc44ldur x29, [sp-8]
0001bc48ldr x30, [sp], 48
0001bc4cret x30
0001bc50
0001bc50loc_1bc50:
0001bc50bl runtime.panicSliceAlen
0001bc54hint
0001bc58
0001bc58loc_1bc58:
0001bc58stp x0, x1, [sp+8]
0001bc5cstp x2, x3, [sp+24]
0001bc60mov x3, x30
0001bc64bl runtime.morestack_noctxt.abi0
0001bc68ldp x0, x1, [sp+8]
0001bc6cldp x2, x3, [sp+24]
0001bc70b 0x1bbe0
0001bc74udf 0
0001bc78udf 0
0001bc7cudf 0
0001bbe0

0001bc80
0001bc80internal/stringslite.TrimPrefix: ; void internal/stringslite.TrimPrefix(struct string s, struct string prefix)
0001bc80ldr x16, [x28+16]
0001bc84subs xzr, sp, x16
0001bc88b.ls 0x1bcfc
0001bc8cstr x30, [sp-48]!
0001bc90stur x29, [sp-8]
0001bc94sub x29, sp, 8
0001bc98str x2, [sp+72]
0001bc9cstr x1, [sp+64]
0001bca0str x0, [sp+56]
0001bca4str x3, [sp+80]
0001bca8bl internal/stringslite.HasPrefix
0001bcactbz w0, 0, 0x1bce0
0001bcb0ldr x0, [sp+80]
0001bcb4ldr x1, [sp+64]
0001bcb8subs xzr, x0, x1
0001bcbcb.hi 0x1bcf4
0001bcc0sub x1, x1, x0
0001bcc4sub x2, xzr, x1
0001bcc8and x2, x0, x2, asr #63
0001bcccldr x3, [sp+56]
0001bcd0add x0, x3, x2
0001bcd4ldur x29, [sp-8]
0001bcd8ldr x30, [sp], 48
0001bcdcret x30
0001bce0
0001bce0loc_1bce0:
0001bce0ldr x0, [sp+56]
0001bce4ldr x1, [sp+64]
0001bce8ldur x29, [sp-8]
0001bcecldr x30, [sp], 48
0001bcf0ret x30
0001bcf4
0001bcf4loc_1bcf4:
0001bcf4bl runtime.panicSliceB
0001bcf8hint
0001bcfc
0001bcfcloc_1bcfc:
0001bcfcstp x0, x1, [sp+8]
0001bd00stp x2, x3, [sp+24]
0001bd04mov x3, x30
0001bd08bl runtime.morestack_noctxt.abi0
0001bd0cldp x0, x1, [sp+8]
0001bd10ldp x2, x3, [sp+24]
0001bd14b 0x1bc80
0001bd18udf 0
0001bd1cudf 0
0001bc80

0001bd20
0001bd20internal/stringslite.TrimSuffix: ; void internal/stringslite.TrimSuffix(struct string s, struct string suffix)
0001bd20ldr x16, [x28+16]
0001bd24subs xzr, sp, x16
0001bd28b.ls 0x1bd90
0001bd2cstr x30, [sp-48]!
0001bd30stur x29, [sp-8]
0001bd34sub x29, sp, 8
0001bd38str x2, [sp+72]
0001bd3cstr x0, [sp+56]
0001bd40str x1, [sp+64]
0001bd44str x3, [sp+80]
0001bd48bl internal/stringslite.HasSuffix
0001bd4ctbz w0, 0, 0x1bd74
0001bd50ldr x2, [sp+64]
0001bd54ldr x3, [sp+80]
0001bd58sub x1, x2, x3
0001bd5csubs xzr, x2, x1
0001bd60b.lo 0x1bd88
0001bd64ldr x0, [sp+56]
0001bd68ldur x29, [sp-8]
0001bd6cldr x30, [sp], 48
0001bd70ret x30
0001bd74
0001bd74loc_1bd74:
0001bd74ldr x0, [sp+56]
0001bd78ldr x1, [sp+64]
0001bd7cldur x29, [sp-8]
0001bd80ldr x30, [sp], 48
0001bd84ret x30
0001bd88
0001bd88loc_1bd88:
0001bd88bl runtime.panicSliceAlen
0001bd8chint
0001bd90
0001bd90loc_1bd90:
0001bd90stp x0, x1, [sp+8]
0001bd94stp x2, x3, [sp+24]
0001bd98mov x3, x30
0001bd9cbl runtime.morestack_noctxt.abi0
0001bda0ldp x0, x1, [sp+8]
0001bda4ldp x2, x3, [sp+24]
0001bda8b 0x1bd20
0001bdacudf 0
0001bd20

0001bdb0
0001bdb0internal/stringslite.Clone: ; void internal/stringslite.Clone(struct string s)
0001bdb0ldr x16, [x28+16]
0001bdb4subs xzr, sp, x16
0001bdb8b.ls 0x1be38
0001bdbcstr x30, [sp-48]!
0001bdc0stur x29, [sp-8]
0001bdc4sub x29, sp, 8
0001bdc8str x0, [sp+56]
0001bdcccbnz x1, 0x1bde4
0001bdd0mov x0, xzr
0001bdd4mov x1, xzr
0001bdd8ldur x29, [sp-8]
0001bddcldr x30, [sp], 48
0001bde0ret x30
0001bde4
0001bde4loc_1bde4:
0001bde4str x1, [sp+64]
0001bde8str x0, [sp+56]
0001bdecmov x0, x1
0001bdf0mov x1, xzr
0001bdf4mov x2, xzr
0001bdf8bl runtime.mallocgc
0001bdfcstr x0, [sp+32]
0001be00ldr x1, [sp+56]
0001be04ldr x2, [sp+64]
0001be08bl runtime.memmove
0001be0cldr x0, [sp+32]
0001be10mov x3, x0
0001be14sub x3, xzr, x3
0001be18ldr x1, [sp+64]
0001be1csubs xzr, x1, x3
0001be20b.hi 0x1be30
0001be24ldur x29, [sp-8]
0001be28ldr x30, [sp], 48
0001be2cret x30
0001be30
0001be30loc_1be30:
0001be30bl runtime.panicunsafestringlen
0001be34hint
0001be38
0001be38loc_1be38:
0001be38stp x0, x1, [sp+8]
0001be3cmov x3, x30
0001be40bl runtime.morestack_noctxt.abi0
0001be44ldp x0, x1, [sp+8]
0001be48b 0x1bdb0
0001be4cudf 0
0001bdb0

0001be50
0001be50internal/bytealg.IndexRabinKarp[go.shape.string]: ; void internal/bytealg.IndexRabinKarp[go.shape.string](uint64_t * dict, struct go_shape_string s, struct go_shape_string sep)
0001be50ldr x16, [x28+16]
0001be54subs xzr, sp, x16
0001be58b.ls 0x1c034
0001be5cstr x30, [sp-80]!
0001be60stur x29, [sp-8]
0001be64sub x29, sp, 8
0001be68str x4, [sp+120]
0001be6cstr x3, [sp+112]
0001be70str x2, [sp+104]
0001be74str x1, [sp+96]
0001be78ldr x0, [x0]
0001be7cmov x1, x3
0001be80mov x2, x4
0001be84bl internal/bytealg.HashStr[go.shape.string]
0001be88ldr x3, [sp+96]
0001be8cldr x4, [sp+104]
0001be90ldr x5, [sp+120]
0001be94mov x2, xzr
0001be98mov x6, xzr
0001be9cb 0x1beb4
0001bea0
0001bea0loc_1bea0:
0001bea0ldrb w7, [x3+x2]
0001bea4add x2, x2, 1
0001bea8movz x8, 403
0001beacmovk x8, 0x1000000
0001beb0madd w6, w8, w6, w7
0001beb4
0001beb4loc_1beb4:
0001beb4subs xzr, x5, x2
0001beb8b.le 0x1bec8
0001bebcsubs xzr, x4, x2
0001bec0b.hi 0x1bea0
0001bec4b 0x1c024
0001bec8
0001bec8loc_1bec8:
0001bec8str w0, [sp+44]
0001beccstr w1, [sp+40]
0001bed0subs wzr, w0, w6
0001bed4b.ne 0x1bf10
0001bed8subs xzr, x4, x5
0001bedcb.lo 0x1c018
0001bee0str w6, [sp+48]
0001bee4mov x0, x3
0001bee8ldr x1, [sp+112]
0001beecmov x2, x5
0001bef0bl runtime.memequal
0001bef4tbnz w0, 0, 0x1bf18
0001bef8ldr w0, [sp+44]
0001befcldr w1, [sp+40]
0001bf00ldr x3, [sp+96]
0001bf04ldr x4, [sp+104]
0001bf08ldr x5, [sp+120]
0001bf0cldr w6, [sp+48]
0001bf10
0001bf10loc_1bf10:
0001bf10mov x2, x5
0001bf14b 0x1bf2c
0001bf18
0001bf18loc_1bf18:
0001bf18mov x0, xzr
0001bf1cldur x29, [sp-8]
0001bf20ldr x30, [sp], 80
0001bf24ret x30
0001bf28
0001bf28loc_1bf28:
0001bf28mov x5, x7
0001bf2c
0001bf2cloc_1bf2c:
0001bf2csubs xzr, x4, x5
0001bf30b.le 0x1bff0
0001bf34ldrb w7, [x3+x5]
0001bf38sub x8, x5, x2
0001bf3cmovz x9, 403
0001bf40movk x9, 0x1000000
0001bf44madd w6, w9, w6, w7
0001bf48subs xzr, x4, x8
0001bf4cb.ls 0x1c00c
0001bf50ldrb w7, [x3+x8]
0001bf54msub w6, w7, w1, w6
0001bf58add x7, x5, 1
0001bf5csubs wzr, w0, w6
0001bf60b.ne 0x1bf28
0001bf64add x8, x8, 1
0001bf68subs xzr, x8, x7
0001bf6cb.hi 0x1c000
0001bf70add x10, x5, x2
0001bf74sub x5, x10, x5
0001bf78sub x10, xzr, x5
0001bf7cand x10, x8, x10, asr #63
0001bf80add x10, x3, x10
0001bf84subs xzr, x2, x5
0001bf88b.eq 0x1bf94
0001bf8cmov x5, xzr
0001bf90b 0x1bfdc
0001bf94
0001bf94loc_1bf94:
0001bf94str w6, [sp+52]
0001bf98str x7, [sp+56]
0001bf9cstr x8, [sp+64]
0001bfa0mov x0, x10
0001bfa4ldr x1, [sp+112]
0001bfa8mov x2, x5
0001bfacbl runtime.memequal
0001bfb0ldr w1, [sp+40]
0001bfb4ldr x2, [sp+120]
0001bfb8ldr x3, [sp+96]
0001bfbcldr x4, [sp+104]
0001bfc0ldr w6, [sp+52]
0001bfc4ldr x7, [sp+56]
0001bfc8ldr x8, [sp+64]
0001bfccmovz x9, 403
0001bfd0movk x9, 0x1000000
0001bfd4mov x5, x0
0001bfd8ldr w0, [sp+44]
0001bfdc
0001bfdcloc_1bfdc:
0001bfdctbz w5, 0, 0x1bf28
0001bfe0mov x0, x8
0001bfe4ldur x29, [sp-8]
0001bfe8ldr x30, [sp], 80
0001bfecret x30
0001bff0
0001bff0loc_1bff0:
0001bff0movn x0, 0
0001bff4ldur x29, [sp-8]
0001bff8ldr x30, [sp], 80
0001bffcret x30
0001c000
0001c000loc_1c000:
0001c000mov x0, x8
0001c004mov x1, x7
0001c008bl runtime.panicSliceB
0001c00c
0001c00cloc_1c00c:
0001c00cmov x0, x8
0001c010mov x1, x4
0001c014bl runtime.panicIndex
0001c018
0001c018loc_1c018:
0001c018mov x1, x5
0001c01cmov x2, x4
0001c020bl runtime.panicSliceAlen
0001c024
0001c024loc_1c024:
0001c024mov x0, x2
0001c028mov x1, x4
0001c02cbl runtime.panicIndex
0001c030hint
0001c034
0001c034loc_1c034:
0001c034stp x0, x1, [sp+8]
0001c038stp x2, x3, [sp+24]
0001c03cstr x4, [sp+40]
0001c040mov x3, x30
0001c044bl runtime.morestack_noctxt.abi0
0001c048ldp x0, x1, [sp+8]
0001c04cldp x2, x3, [sp+24]
0001c050ldr x4, [sp+40]
0001c054b 0x1be50
0001c058udf 0
0001c05cudf 0
0001be50

0001c060
0001c060internal/bytealg.HashStr[go.shape.string]: ; void internal/bytealg.HashStr[go.shape.string](uint64_t * dict, struct go_shape_string sep)
0001c060str x1, [sp+16]
0001c064mov x0, xzr
0001c068mov x3, xzr
0001c06cb 0x1c084
0001c070
0001c070loc_1c070:
0001c070ldrb w4, [x1+x0]
0001c074add x0, x0, 1
0001c078movz x5, 403
0001c07cmovk x5, 0x1000000
0001c080madd w3, w5, w3, w4
0001c084
0001c084loc_1c084:
0001c084subs xzr, x2, x0
0001c088b.gt 0x1c070
0001c08cmovz x0, 403
0001c090movk x0, 0x1000000
0001c094orr x1, xzr, 1
0001c098b 0x1c0b4
0001c09c
0001c09cloc_1c09c:
0001c09cand x4, x2, 1
0001c0a0madd w5, w1, w0, wzr
0001c0a4sbfm x2, x2, 1, 63
0001c0a8madd w0, w0, w0, wzr
0001c0acsubs xzr, x4, 0
0001c0b0csel x1, x5, x1, ne
0001c0b4
0001c0b4loc_1c0b4:
0001c0b4subs xzr, x2, 0
0001c0b8b.gt 0x1c09c
0001c0bcmov x0, x3
0001c0c0ret x30
0001c0c4udf 0
0001c0c8udf 0
0001c0ccudf 0
0001c060

0001c0d0
0001c0d0internal/runtime/exithook.Run: ; void internal/runtime/exithook.Run(int code)
0001c0d0ldr x16, [x28+16]
0001c0d4subs xzr, sp, x16
0001c0d8b.ls 0x1c288
0001c0dcstr x30, [sp-112]!
0001c0e0stur x29, [sp-8]
0001c0e4sub x29, sp, 8
0001c0e8str xzr, [sp+80]
0001c0ecstr xzr, [sp+88]
0001c0f0str xzr, [sp+96]
0001c0f4str x0, [sp+120]
0001c0f8strb wzr, [sp+39]
0001c0fcb 0x1c110
0001c100
0001c100loc_1c100:
0001c100adrp x27, 0xa04000
0001c104ldr x26, [x27+3392]
0001c108ldr x0, [x26]
0001c10cblr x0
0001c110
0001c110loc_1c110:
0001c110adrp x0, 0xa2f000
0001c114add x0, x0, 1700
0001c118mov x1, xzr
0001c11corr x2, xzr, 1
0001c120bl internal/runtime/atomic.(*Int32).CompareAndSwap
0001c124tbnz w0, 0, 0x1c174
0001c128adrp x27, 0xa04000
0001c12cldr x26, [x27+3400]
0001c130ldr x0, [x26]
0001c134blr x0
0001c138str x0, [sp+40]
0001c13cadrp x0, 0xa2f000
0001c140add x0, x0, 2224
0001c144bl internal/runtime/atomic.(*Uint64).Load
0001c148ldr x1, [sp+40]
0001c14csubs xzr, x0, x1
0001c150b.ne 0x1c100
0001c154adrp x27, 0xa04000
0001c158ldr x26, [x27+3408]
0001c15cldr x2, [x26]
0001c160adrp x0, 0x69b000
0001c164add x0, x0, 3304
0001c168movz x1, 22
0001c16cblr x2
0001c170b 0x1c100
0001c174
0001c174loc_1c174:
0001c174adrp x0, 0
0001c178add x0, x0, 768
0001c17cstr x0, [sp+64]
0001c180adrp x0, 0xa2f000
0001c184add x0, x0, 1700
0001c188str x0, [sp+72]
0001c18cadd x0, sp, 64
0001c190str x0, [sp+80]
0001c194orr x0, xzr, 1
0001c198strb w0, [sp+39]
0001c19cadrp x27, 0xa04000
0001c1a0ldr x26, [x27+3400]
0001c1a4ldr x0, [x26]
0001c1a8blr x0
0001c1acmov x1, x0
0001c1b0adrp x0, 0xa2f000
0001c1b4add x0, x0, 2224
0001c1b8bl internal/runtime/atomic.(*Uint64).Store
0001c1bcadrp x0, 0
0001c1c0add x0, x0, 672
0001c1c4str x0, [sp+48]
0001c1c8adrp x0, 0xa2f000
0001c1ccadd x0, x0, 2224
0001c1d0str x0, [sp+56]
0001c1d4add x0, sp, 48
0001c1d8str x0, [sp+88]
0001c1dcadrp x0, 0x6bc000
0001c1e0add x0, x0, 3656
0001c1e4str x0, [sp+96]
0001c1e8orr x0, xzr, 7
0001c1ecstrb w0, [sp+39]
0001c1f0ldr x0, [sp+120]
0001c1f4
0001c1f4loc_1c1f4:
0001c1f4adrp x27, 0xa06000
0001c1f8ldr x1, [x27+3464]
0001c1fccbz x1, 0x1c23c
0001c200adrp x27, 0xa06000
0001c204ldr x2, [x27+3456]
0001c208sub x1, x1, 1
0001c20cadd x3, x2, x1, lsl #4
0001c210ubfm x4, x1, 60, 59
0001c214ldr x26, [x2+x4]
0001c218ldrb w2, [x3+8]
0001c21cadrp x27, 0xa06000
0001c220str x1, [x27+3464]
0001c224cbz x0, 0x1c22c
0001c228tbz w2, 0, 0x1c1f4
0001c22c
0001c22cloc_1c22c:
0001c22cldr x0, [x26]
0001c230blr x0
0001c234ldr x0, [sp+120]
0001c238b 0x1c1f4
0001c23c
0001c23cloc_1c23c:
0001c23corr x0, xzr, 3
0001c240strb w0, [sp+39]
0001c244bl internal/runtime/exithook.Run.func1
0001c248orr x0, xzr, 1
0001c24cstrb w0, [sp+39]
0001c250ldr x26, [sp+88]
0001c254ldr x0, [x26]
0001c258blr x0
0001c25cstrb wzr, [sp+39]
0001c260ldr x26, [sp+80]
0001c264ldr x0, [x26]
0001c268blr x0
0001c26cldur x29, [sp-8]
0001c270ldr x30, [sp], 112
0001c274ret x30
0001c278bl runtime.deferreturn
0001c27cldur x29, [sp-8]
0001c280ldr x30, [sp], 112
0001c284ret x30
0001c288
0001c288loc_1c288:
0001c288str x0, [sp+8]
0001c28cmov x3, x30
0001c290bl runtime.morestack_noctxt.abi0
0001c294ldr x0, [sp+8]
0001c298b 0x1c0d0
0001c29cudf 0
0001c0d0

0001c2a0
0001c2a0internal/runtime/exithook.Run.deferwrap2: ; void internal/runtime/exithook.Run.deferwrap2(void)
0001c2a0ldr x16, [x28+16]
0001c2a4subs xzr, sp, x16
0001c2a8b.ls 0x1c2d8
0001c2acstr x30, [sp-32]!
0001c2b0stur x29, [sp-8]
0001c2b4sub x29, sp, 8
0001c2b8ldr x16, [x28+32]
0001c2bccbnz x16, 0x1c2e4
0001c2c0
0001c2c0loc_1c2c0:
0001c2c0ldr x0, [x26+8]
0001c2c4mov x1, xzr
0001c2c8bl internal/runtime/atomic.(*Uint64).Store
0001c2ccldur x29, [sp-8]
0001c2d0ldr x30, [sp], 32
0001c2d4ret x30
0001c2d8
0001c2d8loc_1c2d8:
0001c2d8mov x3, x30
0001c2dcbl runtime.morestack.abi0
0001c2e0b 0x1c2a0
0001c2e4
0001c2e4loc_1c2e4:
0001c2e4ldr x17, [x16]
0001c2e8add x20, sp, 40
0001c2ecsubs xzr, x20, x17
0001c2f0b.ne 0x1c2c0
0001c2f4add x20, sp, 8
0001c2f8str x20, [x16]
0001c2fcb 0x1c2c0
0001c2a0

0001c300
0001c300internal/runtime/exithook.Run.deferwrap1: ; void internal/runtime/exithook.Run.deferwrap1(void)
0001c300ldr x16, [x28+16]
0001c304subs xzr, sp, x16
0001c308b.ls 0x1c338
0001c30cstr x30, [sp-32]!
0001c310stur x29, [sp-8]
0001c314sub x29, sp, 8
0001c318ldr x16, [x28+32]
0001c31ccbnz x16, 0x1c344
0001c320
0001c320loc_1c320:
0001c320ldr x0, [x26+8]
0001c324mov x1, xzr
0001c328bl internal/runtime/atomic.(*Int32).Store
0001c32cldur x29, [sp-8]
0001c330ldr x30, [sp], 32
0001c334ret x30
0001c338
0001c338loc_1c338:
0001c338mov x3, x30
0001c33cbl runtime.morestack.abi0
0001c340b 0x1c300
0001c344
0001c344loc_1c344:
0001c344ldr x17, [x16]
0001c348add x20, sp, 40
0001c34csubs xzr, x20, x17
0001c350b.ne 0x1c320
0001c354add x20, sp, 8
0001c358str x20, [x16]
0001c35cb 0x1c320
0001c300

0001c360
0001c360internal/runtime/exithook.Run.func1: ; void internal/runtime/exithook.Run.func1(void)
0001c360ldr x16, [x28+16]
0001c364subs xzr, sp, x16
0001c368b.ls 0x1c3b0
0001c36cstr x30, [sp-32]!
0001c370stur x29, [sp-8]
0001c374sub x29, sp, 8
0001c378add x1, sp, 32
0001c37cadd x0, x1, 8
0001c380bl runtime.gorecover
0001c384cbz x0, 0x1c3a4
0001c388adrp x27, 0xa04000
0001c38cldr x26, [x27+3408]
0001c390ldr x2, [x26]
0001c394adrp x0, 0x69c000
0001c398add x0, x0, 1973
0001c39cmovz x1, 23
0001c3a0blr x2
0001c3a4
0001c3a4loc_1c3a4:
0001c3a4ldur x29, [sp-8]
0001c3a8ldr x30, [sp], 32
0001c3acret x30
0001c3b0
0001c3b0loc_1c3b0:
0001c3b0mov x3, x30
0001c3b4bl runtime.morestack_noctxt.abi0
0001c3b8b 0x1c360
0001c3bcudf 0
0001c360

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