Similarity

001bfa80
001bfa80Stdlib.Map.partition:
001bfa80lea r10, [rsp-376]
001bfa88cmp r10, [r14+40]
001bfa8cjb 0x1bfbcd
001bfa92
001bfa92loc_1bfa92:
001bfa92sub rsp, 56
001bfa96test bl, 1
001bfa99je 0x1bfaa8
001bfa9blea rax, [rip+0x1886ae]
001bfaa2add rsp, 56
001bfaa6ret
001bfaa7
001bfaa7 90 .
001bfaa8
001bfaa8loc_1bfaa8:
001bfaa8mov [rsp], rbx
001bfaacmov [rsp+8], rax
001bfab1mov rdi, [rbx+16]
001bfab5mov [rsp+48], rdi
001bfabamov rdi, [rbx+8]
001bfabemov [rsp+40], rdi
001bfac3mov rbx, [rbx]
001bfac6call Stdlib.Map.partition
001bfacbmov rbx, [rax+8]
001bfacfmov [rsp+24], rbx
001bfad4mov rax, [rax]
001bfad7mov [rsp+32], rax
001bfadcmov rax, [rsp+40]
001bfae1mov rbx, [rsp+48]
001bfae6mov rdi, [rsp+8]
001bfaebcall caml_apply2
001bfaf0mov [rsp+16], rax
001bfaf5mov rax, [rsp]
001bfaf9mov rbx, [rax+24]
001bfafdmov rax, [rsp+8]
001bfb02call Stdlib.Map.partition
001bfb07mov rsi, [rax+8]
001bfb0bmov rax, [rax]
001bfb0emov [rsp+8], rax
001bfb13mov rax, [rsp+16]
001bfb18cmp rax, 1
001bfb1cje 0x1bfb70
001bfb1emov rax, [rsp+24]
001bfb23mov rbx, rsi
001bfb26call Stdlib.Map.concat
001bfb2bmov [rsp], rax
001bfb2fmov rax, [rsp+32]
001bfb34mov rbx, [rsp+40]
001bfb39mov rdi, [rsp+48]
001bfb3emov rsi, [rsp+8]
001bfb43call Stdlib.Map.join
001bfb48sub r15, 24
001bfb4ccmp r15, [r14]
001bfb4fjb 0x1bfbc6
001bfb51
001bfb51loc_1bfb51:
001bfb51lea rbx, [r15+8]
001bfb55mov [rbx-8], 2048
001bfb5dmov [rbx], rax
001bfb60mov rax, [rsp]
001bfb64mov [rbx+8], rax
001bfb68mov rax, rbx
001bfb6badd rsp, 56
001bfb6fret
001bfb70
001bfb70loc_1bfb70:
001bfb70mov rax, [rsp+24]
001bfb75mov rbx, [rsp+40]
001bfb7amov rdi, [rsp+48]
001bfb7fcall Stdlib.Map.join
001bfb84mov [rsp], rax
001bfb88mov rax, [rsp+32]
001bfb8dmov rbx, [rsp+8]
001bfb92call Stdlib.Map.concat
001bfb97sub r15, 24
001bfb9bcmp r15, [r14]
001bfb9ejb 0x1bfbbf
001bfba0
001bfba0loc_1bfba0:
001bfba0lea rbx, [r15+8]
001bfba4mov [rbx-8], 2048
001bfbacmov [rbx], rax
001bfbafmov rax, [rsp]
001bfbb3mov [rbx+8], rax
001bfbb7mov rax, rbx
001bfbbaadd rsp, 56
001bfbberet
001bfbbf
001bfbbfloc_1bfbbf:
001bfbbfcall caml_call_gc
001bfbc4jmp 0x1bfba0
001bfbc6
001bfbc6loc_1bfbc6:
001bfbc6call caml_call_gc
001bfbcbjmp 0x1bfb51
001bfbcd
001bfbcdloc_1bfbcd:
001bfbcdpush 40
001bfbcfcall caml_call_realloc_stack
001bfbd4pop r10
001bfbd6jmp 0x1bfa92
001bfa80

001bfbdb
001bfbdb // align 0x10

001bfbe0
001bfbe0Stdlib.Map.cons_enum:
001bfbe0test al, 1
001bfbe2je 0x1bfbe8
001bfbe4mov rax, rbx
001bfbe7ret
001bfbe8
001bfbe8loc_1bfbe8:
001bfbe8sub r15, 40
001bfbeccmp r15, [r14]
001bfbefjb 0x1bfc20
001bfbf1
001bfbf1loc_1bfbf1:
001bfbf1lea rdi, [r15+8]
001bfbf5mov [rdi-8], 4096
001bfbfdmov rsi, [rax+8]
001bfc01mov [rdi], rsi
001bfc04mov rsi, [rax+16]
001bfc08mov [rdi+8], rsi
001bfc0cmov rsi, [rax+24]
001bfc10mov [rdi+16], rsi
001bfc14mov [rdi+24], rbx
001bfc18mov rax, [rax]
001bfc1bmov rbx, rdi
001bfc1ejmp 0x1bfbe0
001bfc20
001bfc20loc_1bfc20:
001bfc20call caml_call_gc
001bfc25jmp 0x1bfbf1
001bfbe0

001bfc27
001bfc27 // align 0x10

001bfc30
001bfc30Stdlib.Map.compare:
001bfc30lea r10, [rsp-344]
001bfc38cmp r10, [r14+40]
001bfc3cjb 0x1bfcd8
001bfc42
001bfc42loc_1bfc42:
001bfc42sub rsp, 24
001bfc46mov [rsp], rbx
001bfc4asub r15, 56
001bfc4ecmp r15, [r14]
001bfc51jb 0x1bfcce
001bfc53
001bfc53loc_1bfc53:
001bfc53lea rbx, [r15+8]
001bfc57mov [rsp+16], rbx
001bfc5cmov [rbx-8], 6391
001bfc64lea rdx, [rip-0xc8c4b]
001bfc6bmov [rbx], rdx
001bfc6emov rdx, 0x200000000000007
001bfc78mov [rbx+8], rdx
001bfc7clea rdx, [rip+109]
001bfc83mov [rbx+16], rdx
001bfc87mov rdx, [rsi+24]
001bfc8bmov [rbx+24], rdx
001bfc8fmov [rbx+32], rax
001bfc93mov rax, [rsi+32]
001bfc97mov [rbx+40], rax
001bfc9bmov ebx, 1
001bfca0mov rax, rdi
001bfca3call Stdlib.Map.cons_enum
001bfca8mov [rsp+8], rax
001bfcadmov ebx, 1
001bfcb2mov rax, [rsp]
001bfcb6call Stdlib.Map.cons_enum
001bfcbbmov rbx, [rsp+8]
001bfcc0mov rdi, [rsp+16]
001bfcc5add rsp, 24
001bfcc9jmp 0x1bfcf0
001bfcce
001bfcceloc_1bfcce:
001bfccecall caml_call_gc
001bfcd3jmp 0x1bfc53
001bfcd8
001bfcd8loc_1bfcd8:
001bfcd8push 36
001bfcdacall caml_call_realloc_stack
001bfcdfpop r10
001bfce1jmp 0x1bfc42
001bfc30

001bfce6
001bfce6 // align 0x10

001bfcf0
001bfcf0Stdlib.Map.compare_aux:
001bfcf0lea r10, [rsp-344]
001bfcf8cmp r10, [r14+40]
001bfcfcjb 0x1bfdd7
001bfd02
001bfd02loc_1bfd02:
001bfd02sub rsp, 24
001bfd06
001bfd06loc_1bfd06:
001bfd06cmp r15, [r14]
001bfd09jbe 0x1bfdcd
001bfd0f
001bfd0floc_1bfd0f:
001bfd0ftest al, 1
001bfd11je 0x1bfd30
001bfd13test bl, 1
001bfd16je 0x1bfd24
001bfd18mov eax, 1
001bfd1dadd rsp, 24
001bfd21ret
001bfd22
001bfd22 66 90 f.
001bfd24
001bfd24loc_1bfd24:
001bfd24mov rax, -1
001bfd2badd rsp, 24
001bfd2fret
001bfd30
001bfd30loc_1bfd30:
001bfd30test bl, 1
001bfd33je 0x1bfd40
001bfd35mov eax, 3
001bfd3aadd rsp, 24
001bfd3eret
001bfd3f
001bfd3f 90 .
001bfd40
001bfd40loc_1bfd40:
001bfd40mov [rsp+16], rdi
001bfd45mov [rsp], rbx
001bfd49mov [rsp+8], rax
001bfd4emov rdi, [rdi+40]
001bfd52mov rdi, [rdi]
001bfd55mov rbx, [rbx]
001bfd58mov rax, [rax]
001bfd5bcall caml_apply2
001bfd60cmp rax, 1
001bfd64je 0x1bfd6c
001bfd66add rsp, 24
001bfd6aret
001bfd6b
001bfd6b 90 .
001bfd6c
001bfd6cloc_1bfd6c:
001bfd6cmov rax, [rsp+16]
001bfd71mov rdi, [rax+32]
001bfd75mov rax, [rsp]
001bfd79mov rbx, [rax+8]
001bfd7dmov rax, [rsp+8]
001bfd82mov rax, [rax+8]
001bfd86call caml_apply2
001bfd8bcmp rax, 1
001bfd8fje 0x1bfd98
001bfd91add rsp, 24
001bfd95ret
001bfd96
001bfd96 66 90 f.
001bfd98
001bfd98loc_1bfd98:
001bfd98mov rax, [rsp]
001bfd9cmov rbx, [rax+24]
001bfda0mov rax, [rax+16]
001bfda4call Stdlib.Map.cons_enum
001bfda9mov [rsp], rax
001bfdadmov rax, [rsp+8]
001bfdb2mov rbx, [rax+24]
001bfdb6mov rax, [rax+16]
001bfdbacall Stdlib.Map.cons_enum
001bfdbfmov rbx, [rsp]
001bfdc3mov rdi, [rsp+16]
001bfdc8jmp 0x1bfd06
001bfdcd
001bfdcdloc_1bfdcd:
001bfdcdcall caml_call_gc
001bfdd2jmp 0x1bfd0f
001bfdd7
001bfdd7loc_1bfdd7:
001bfdd7push 36
001bfdd9call caml_call_realloc_stack
001bfddepop r10
001bfde0jmp 0x1bfd02
001bfcf0

001bfde5
001bfde5 // align 0x10

001bfdf0
001bfdf0Stdlib.Map.equal:
001bfdf0lea r10, [rsp-344]
001bfdf8cmp r10, [r14+40]
001bfdfcjb 0x1bfe98
001bfe02
001bfe02loc_1bfe02:
001bfe02sub rsp, 24
001bfe06mov [rsp], rbx
001bfe0asub r15, 56
001bfe0ecmp r15, [r14]
001bfe11jb 0x1bfe8e
001bfe13
001bfe13loc_1bfe13:
001bfe13lea rbx, [r15+8]
001bfe17mov [rsp+16], rbx
001bfe1cmov [rbx-8], 6391
001bfe24lea rdx, [rip-0xc8e0b]
001bfe2bmov [rbx], rdx
001bfe2emov rdx, 0x200000000000007
001bfe38mov [rbx+8], rdx
001bfe3clea rdx, [rip+109]
001bfe43mov [rbx+16], rdx
001bfe47mov rdx, [rsi+24]
001bfe4bmov [rbx+24], rdx
001bfe4fmov [rbx+32], rax
001bfe53mov rax, [rsi+32]
001bfe57mov [rbx+40], rax
001bfe5bmov ebx, 1
001bfe60mov rax, rdi
001bfe63call Stdlib.Map.cons_enum
001bfe68mov [rsp+8], rax
001bfe6dmov ebx, 1
001bfe72mov rax, [rsp]
001bfe76call Stdlib.Map.cons_enum
001bfe7bmov rbx, [rsp+8]
001bfe80mov rdi, [rsp+16]
001bfe85add rsp, 24
001bfe89jmp 0x1bfeb0
001bfe8e
001bfe8eloc_1bfe8e:
001bfe8ecall caml_call_gc
001bfe93jmp 0x1bfe13
001bfe98
001bfe98loc_1bfe98:
001bfe98push 36
001bfe9acall caml_call_realloc_stack
001bfe9fpop r10
001bfea1jmp 0x1bfe02
001bfdf0

001bfea6
001bfea6 // align 0x10

001bfeb0
001bfeb0Stdlib.Map.equal_aux:
001bfeb0lea r10, [rsp-344]
001bfeb8cmp r10, [r14+40]
001bfebcjb 0x1bff88
001bfec2
001bfec2loc_1bfec2:
001bfec2sub rsp, 24
001bfec6
001bfec6loc_1bfec6:
001bfec6cmp r15, [r14]
001bfec9jbe 0x1bff7e
001bfecf
001bfecfloc_1bfecf:
001bfecftest al, 1
001bfed1je 0x1bfee4
001bfed3and rbx, 1
001bfed7lea rax, [rbx+rbx+1]
001bfedcadd rsp, 24
001bfee0ret
001bfee1
001bfee1 0f 1f 00 ...
001bfee4
001bfee4loc_1bfee4:
001bfee4test bl, 1
001bfee7je 0x1bfef4
001bfee9mov eax, 1
001bfeeeadd rsp, 24
001bfef2ret
001bfef3
001bfef3 90 .
001bfef4
001bfef4loc_1bfef4:
001bfef4mov [rsp+16], rdi
001bfef9mov [rsp], rbx
001bfefdmov [rsp+8], rax
001bff02mov rdi, [rdi+40]
001bff06mov rdi, [rdi]
001bff09mov rbx, [rbx]
001bff0cmov rax, [rax]
001bff0fcall caml_apply2
001bff14cmp rax, 1
001bff18jne 0x1bff74
001bff1amov rax, [rsp+16]
001bff1fmov rdi, [rax+32]
001bff23mov rax, [rsp]
001bff27mov rbx, [rax+8]
001bff2bmov rax, [rsp+8]
001bff30mov rax, [rax+8]
001bff34call caml_apply2
001bff39cmp rax, 1
001bff3dje 0x1bff74
001bff3fmov rax, [rsp]
001bff43mov rbx, [rax+24]
001bff47mov rax, [rax+16]
001bff4bcall Stdlib.Map.cons_enum
001bff50mov [rsp], rax
001bff54mov rax, [rsp+8]
001bff59mov rbx, [rax+24]
001bff5dmov rax, [rax+16]
001bff61call Stdlib.Map.cons_enum
001bff66mov rbx, [rsp]
001bff6amov rdi, [rsp+16]
001bff6fjmp 0x1bfec6
001bff74
001bff74loc_1bff74:
001bff74mov eax, 1
001bff79add rsp, 24
001bff7dret
001bff7e
001bff7eloc_1bff7e:
001bff7ecall caml_call_gc
001bff83jmp 0x1bfecf
001bff88
001bff88loc_1bff88:
001bff88push 36
001bff8acall caml_call_realloc_stack
001bff8fpop r10
001bff91jmp 0x1bfec2
001bfeb0

001bff96
001bff96 // align 0x10

001bffa0
001bffa0Stdlib.Map.cardinal:
001bffa0lea r10, [rsp-336]
001bffa8cmp r10, [r14+40]
001bffacjb 0x1bffee
001bffae
001bffaeloc_1bffae:
001bffaesub rsp, 16
001bffb2test al, 1
001bffb4je 0x1bffc0
001bffb6mov eax, 1
001bffbbadd rsp, 16
001bffbfret
001bffc0
001bffc0loc_1bffc0:
001bffc0mov [rsp], rax
001bffc4mov rax, [rax+24]
001bffc8call Stdlib.Map.cardinal
001bffcdmov [rsp+8], rax
001bffd2mov rax, [rsp]
001bffd6mov rax, [rax]
001bffd9call Stdlib.Map.cardinal
001bffdemov rbx, [rsp+8]
001bffe3add rax, rbx
001bffe6inc rax
001bffe9add rsp, 16
001bffedret
001bffee
001bffeeloc_1bffee:
001bffeepush 35
001bfff0call caml_call_realloc_stack
001bfff5pop r10
001bfff7jmp 0x1bffae
001bffa0

001bfff9
001bfff9 // align 0x10

001c0000
001c0000Stdlib.Map.bindings_aux:
001c0000lea r10, [rsp-328]
001c0008cmp r10, [r14+40]
001c000cjb 0x1c0077
001c000e
001c000eloc_1c000e:
001c000esub rsp, 8
001c0012
001c0012loc_1c0012:
001c0012test bl, 1
001c0015je 0x1c001c
001c0017add rsp, 8
001c001bret
001c001c
001c001cloc_1c001c:
001c001cmov [rsp], rbx
001c0020mov rbx, [rbx+24]
001c0024call Stdlib.Map.bindings_aux
001c0029sub r15, 48
001c002dcmp r15, [r14]
001c0030jb 0x1c0070
001c0032
001c0032loc_1c0032:
001c0032lea rbx, [r15+8]
001c0036add rbx, 24
001c003amov [rbx-8], 2048
001c0042mov rsi, [rsp]
001c0046mov rdi, [rsi+8]
001c004amov [rbx], rdi
001c004dmov rdi, [rsi+16]
001c0051mov [rbx+8], rdi
001c0055lea rdi, [rbx-24]
001c0059mov [rdi-8], 2048
001c0061mov [rdi], rbx
001c0064mov [rdi+8], rax
001c0068mov rbx, [rsi]
001c006bmov rax, rdi
001c006ejmp 0x1c0012
001c0070
001c0070loc_1c0070:
001c0070call caml_call_gc
001c0075jmp 0x1c0032
001c0077
001c0077loc_1c0077:
001c0077push 34
001c0079call caml_call_realloc_stack
001c007epop r10
001c0080jmp 0x1c000e
001c0000

001c0082
001c0082 // align 0x10

001c0090
001c0090Stdlib.Map.bindings:
001c0090mov rbx, rax
001c0093mov eax, 1
001c0098jmp 0x1c0000
001c0090

001c009d
001c009d // align 0x10

001c00a0
001c00a0Stdlib.Map.fun:
001c00a0mov rdx, rax
001c00a3mov rcx, [rbx+8]
001c00a7mov rax, [rbx]
001c00aamov rsi, [rdi+24]
001c00aemov rbx, rcx
001c00b1mov rdi, rdx
001c00b4jmp 0x1bdbe0
001c00a0

001c00b9
001c00b9 // align 0x10

001c00c0
001c00c0Stdlib.Map.of_list:
001c00c0mov rdi, rax
001c00c3sub r15, 40
001c00c7cmp r15, [r14]
001c00cajb 0x1c010d
001c00cc
001c00ccloc_1c00cc:
001c00cclea rax, [r15+8]
001c00d0mov [rax-8], 4343
001c00d8lea rsi, [rip-0xc90bf]
001c00dfmov [rax], rsi
001c00e2mov rsi, 0x200000000000007
001c00ecmov [rax+8], rsi
001c00f0lea rsi, [rip-87]
001c00f7mov [rax+16], rsi
001c00fbmov rbx, [rbx+24]
001c00ffmov [rax+24], rbx
001c0103mov ebx, 1
001c0108jmp 0x1a0430
001c010d
001c010dloc_1c010d:
001c010dcall caml_call_gc
001c0112jmp 0x1c00cc
001c00c0

001c0114
001c0114 // align 0x10

001c0120
001c0120Stdlib.Map.add_seq:
001c0120mov rsi, rax
001c0123sub r15, 40
001c0127cmp r15, [r14]
001c012ajb 0x1c016b
001c012c
001c012cloc_1c012c:
001c012clea rax, [r15+8]
001c0130mov [rax-8], 4343
001c0138lea rdx, [rip-0xc911f]
001c013fmov [rax], rdx
001c0142mov rdx, 0x200000000000007
001c014cmov [rax+8], rdx
001c0150lea rdx, [rip+41]
001c0157mov [rax+16], rdx
001c015bmov rdi, [rdi+24]
001c015fmov [rax+24], rdi
001c0163mov rdi, rsi
001c0166jmp 0x19a7c0
001c016b
001c016bloc_1c016b:
001c016bcall caml_call_gc
001c0170jmp 0x1c012c
001c0120

001c0172
001c0172 // align 0x10

001c0180
001c0180Stdlib.Map.fun:
001c0180mov rdx, rax
001c0183mov rcx, [rbx+8]
001c0187mov rax, [rbx]
001c018amov rsi, [rdi+24]
001c018emov rbx, rcx
001c0191mov rdi, rdx
001c0194jmp 0x1bdbe0
001c0180

001c0199
001c0199 // align 0x10

001c01a0
001c01a0Stdlib.Map.of_seq:
001c01a0mov rdi, [rbx+24]
001c01a4mov ebx, 1
001c01a9jmp 0x1c0120
001c01a0

001c01ae
001c01ae // align 0x10

001c01b0
001c01b0Stdlib.Map.seq_of_enum_:
001c01b0lea r10, [rsp-336]
001c01b8cmp r10, [r14+40]
001c01bcjb 0x1c0265
001c01c2
001c01c2loc_1c01c2:
001c01c2sub rsp, 16
001c01c6test al, 1
001c01c8je 0x1c01d4
001c01camov eax, 1
001c01cfadd rsp, 16
001c01d3ret
001c01d4
001c01d4loc_1c01d4:
001c01d4mov [rsp], rdi
001c01d8mov [rsp+8], rax
001c01ddmov rbx, [rax+24]
001c01e1mov rax, [rax+16]
001c01e5call Stdlib.Map.cons_enum
001c01eamov rbx, [rsp]
001c01eesub r15, 88
001c01f2cmp r15, [r14]
001c01f5jb 0x1c025e
001c01f7
001c01f7loc_1c01f7:
001c01f7lea rdi, [r15+8]
001c01fbadd rdi, 48
001c01ffmov [rdi-8], 4343
001c0207lea rsi, [rip+114]
001c020emov [rdi], rsi
001c0211mov rsi, 0x100000000000005
001c021bmov [rdi+8], rsi
001c021fmov [rdi+16], rax
001c0223mov [rdi+24], rbx
001c0227lea rbx, [rdi-24]
001c022bmov [rbx-8], 2048
001c0233mov rsi, [rsp+8]
001c0238mov rax, [rsi]
001c023bmov [rbx], rax
001c023emov rax, [rsi+8]
001c0242mov [rbx+8], rax
001c0246lea rax, [rbx-24]
001c024amov [rax-8], 2048
001c0252mov [rax], rbx
001c0255mov [rax+8], rdi
001c0259add rsp, 16
001c025dret
001c025e
001c025eloc_1c025e:
001c025ecall caml_call_gc
001c0263jmp 0x1c01f7
001c0265
001c0265loc_1c0265:
001c0265push 35
001c0267call caml_call_realloc_stack
001c026cpop r10
001c026ejmp 0x1c01c2
001c01b0

001c0273
001c0273 // align 0x10

001c0280
001c0280Stdlib.Map.fun:
001c0280mov rsi, rax
001c0283mov rax, [rbx+16]
001c0287mov rdi, [rbx+24]
001c028bmov rbx, rsi
001c028ejmp 0x1c01b0
001c0280

001c0293
001c0293 // align 0x10

001c02a0
001c02a0Stdlib.Map.to_seq:
001c02a0lea r10, [rsp-328]
001c02a8cmp r10, [r14+40]
001c02acjb 0x1c030c
001c02ae
001c02aeloc_1c02ae:
001c02aesub rsp, 8
001c02b2mov [rsp], rbx
001c02b6mov ebx, 1
001c02bbcall Stdlib.Map.cons_enum
001c02c0mov rbx, [rsp]
001c02c4mov rbx, [rbx+24]
001c02c8sub r15, 40
001c02cccmp r15, [r14]
001c02cfjb 0x1c0305
001c02d1
001c02d1loc_1c02d1:
001c02d1lea rdi, [r15+8]
001c02d5mov [rdi-8], 4343
001c02ddlea rsi, [rip+60]
001c02e4mov [rdi], rsi
001c02e7mov rsi, 0x100000000000005
001c02f1mov [rdi+8], rsi
001c02f5mov [rdi+16], rax
001c02f9mov [rdi+24], rbx
001c02fdmov rax, rdi
001c0300add rsp, 8
001c0304ret
001c0305
001c0305loc_1c0305:
001c0305call caml_call_gc
001c030ajmp 0x1c02d1
001c030c
001c030cloc_1c030c:
001c030cpush 34
001c030ecall caml_call_realloc_stack
001c0313pop r10
001c0315jmp 0x1c02ae
001c02a0

001c0317
001c0317 // align 0x10

001c0320
001c0320Stdlib.Map.fun:
001c0320mov rsi, rax
001c0323mov rax, [rbx+16]
001c0327mov rdi, [rbx+24]
001c032bmov rbx, rsi
001c032ejmp 0x1c01b0
001c0320

001c0333
001c0333 // align 0x10

001c0340
001c0340Stdlib.Map.snoc_enum:
001c0340test al, 1
001c0342je 0x1c0348
001c0344mov rax, rbx
001c0347ret
001c0348
001c0348loc_1c0348:
001c0348sub r15, 40
001c034ccmp r15, [r14]
001c034fjb 0x1c0380
001c0351
001c0351loc_1c0351:
001c0351lea rdi, [r15+8]
001c0355mov [rdi-8], 4096
001c035dmov rsi, [rax+8]
001c0361mov [rdi], rsi
001c0364mov rsi, [rax+16]
001c0368mov [rdi+8], rsi
001c036cmov rsi, [rax]
001c036fmov [rdi+16], rsi
001c0373mov [rdi+24], rbx
001c0377mov rax, [rax+24]
001c037bmov rbx, rdi
001c037ejmp 0x1c0340
001c0380
001c0380loc_1c0380:
001c0380call caml_call_gc
001c0385jmp 0x1c0351
001c0340

001c0387
001c0387 // align 0x10

001c0390
001c0390Stdlib.Map.rev_seq_of_enum_:
001c0390lea r10, [rsp-336]
001c0398cmp r10, [r14+40]
001c039cjb 0x1c0445
001c03a2
001c03a2loc_1c03a2:
001c03a2sub rsp, 16
001c03a6test al, 1
001c03a8je 0x1c03b4
001c03aamov eax, 1
001c03afadd rsp, 16
001c03b3ret
001c03b4
001c03b4loc_1c03b4:
001c03b4mov [rsp], rdi
001c03b8mov [rsp+8], rax
001c03bdmov rbx, [rax+24]
001c03c1mov rax, [rax+16]
001c03c5call Stdlib.Map.snoc_enum
001c03camov rbx, [rsp]
001c03cesub r15, 88
001c03d2cmp r15, [r14]
001c03d5jb 0x1c043e
001c03d7
001c03d7loc_1c03d7:
001c03d7lea rdi, [r15+8]
001c03dbadd rdi, 48
001c03dfmov [rdi-8], 4343
001c03e7lea rsi, [rip+114]
001c03eemov [rdi], rsi
001c03f1mov rsi, 0x100000000000005
001c03fbmov [rdi+8], rsi
001c03ffmov [rdi+16], rax
001c0403mov [rdi+24], rbx
001c0407lea rbx, [rdi-24]
001c040bmov [rbx-8], 2048
001c0413mov rsi, [rsp+8]
001c0418mov rax, [rsi]
001c041bmov [rbx], rax
001c041emov rax, [rsi+8]
001c0422mov [rbx+8], rax
001c0426lea rax, [rbx-24]
001c042amov [rax-8], 2048
001c0432mov [rax], rbx
001c0435mov [rax+8], rdi
001c0439add rsp, 16
001c043dret
001c043e
001c043eloc_1c043e:
001c043ecall caml_call_gc
001c0443jmp 0x1c03d7
001c0445
001c0445loc_1c0445:
001c0445push 35
001c0447call caml_call_realloc_stack
001c044cpop r10
001c044ejmp 0x1c03a2
001c0390

001c0453
001c0453 // align 0x10

001c0460
001c0460Stdlib.Map.fun:
001c0460mov rsi, rax
001c0463mov rax, [rbx+16]
001c0467mov rdi, [rbx+24]
001c046bmov rbx, rsi
001c046ejmp 0x1c0390
001c0460

001c0473
001c0473 // align 0x10

001c0480
001c0480Stdlib.Map.to_rev_seq:
001c0480lea r10, [rsp-328]
001c0488cmp r10, [r14+40]
001c048cjb 0x1c04ec
001c048e
001c048eloc_1c048e:
001c048esub rsp, 8
001c0492mov [rsp], rbx
001c0496mov ebx, 1
001c049bcall Stdlib.Map.snoc_enum
001c04a0mov rbx, [rsp]
001c04a4mov rbx, [rbx+24]
001c04a8sub r15, 40
001c04accmp r15, [r14]
001c04afjb 0x1c04e5
001c04b1
001c04b1loc_1c04b1:
001c04b1lea rdi, [r15+8]
001c04b5mov [rdi-8], 4343
001c04bdlea rsi, [rip+60]
001c04c4mov [rdi], rsi
001c04c7mov rsi, 0x100000000000005
001c04d1mov [rdi+8], rsi
001c04d5mov [rdi+16], rax
001c04d9mov [rdi+24], rbx
001c04ddmov rax, rdi
001c04e0add rsp, 8
001c04e4ret
001c04e5
001c04e5loc_1c04e5:
001c04e5call caml_call_gc
001c04eajmp 0x1c04b1
001c04ec
001c04ecloc_1c04ec:
001c04ecpush 34
001c04eecall caml_call_realloc_stack
001c04f3pop r10
001c04f5jmp 0x1c048e
001c0480

001c04f7
001c04f7 // align 0x10

001c0500
001c0500Stdlib.Map.fun:
001c0500mov rsi, rax
001c0503mov rax, [rbx+16]
001c0507mov rdi, [rbx+24]
001c050bmov rbx, rsi
001c050ejmp 0x1c0390
001c0500

001c0513
001c0513 // align 0x10

001c0520
001c0520Stdlib.Map.to_seq_from:
001c0520lea r10, [rsp-328]
001c0528cmp r10, [r14+40]
001c052cjb 0x1c05de
001c0532
001c0532loc_1c0532:
001c0532sub rsp, 8
001c0536mov [rsp], rdi
001c053asub r15, 40
001c053ecmp r15, [r14]
001c0541jb 0x1c05d4
001c0547
001c0547loc_1c0547:
001c0547lea rsi, [r15+8]
001c054bmov [rsi-8], 4343
001c0553lea rdx, [rip-0xc962a]
001c055amov [rsi], rdx
001c055dmov rdx, 0x300000000000007
001c0567mov [rsi+8], rdx
001c056blea rdx, [rip+126]
001c0572mov [rsi+16], rdx
001c0576mov rdi, [rdi+32]
001c057amov [rsi+24], rdi
001c057emov edi, 1
001c0583call Stdlib.Map.aux
001c0588mov rbx, [rsp]
001c058cmov rbx, [rbx+24]
001c0590sub r15, 40
001c0594cmp r15, [r14]
001c0597jb 0x1c05cd
001c0599
001c0599loc_1c0599:
001c0599lea rdi, [r15+8]
001c059dmov [rdi-8], 4343
001c05a5lea rsi, [rip+404]
001c05acmov [rdi], rsi
001c05afmov rsi, 0x100000000000005
001c05b9mov [rdi+8], rsi
001c05bdmov [rdi+16], rax
001c05c1mov [rdi+24], rbx
001c05c5mov rax, rdi
001c05c8add rsp, 8
001c05ccret
001c05cd
001c05cdloc_1c05cd:
001c05cdcall caml_call_gc
001c05d2jmp 0x1c0599
001c05d4
001c05d4loc_1c05d4:
001c05d4call caml_call_gc
001c05d9jmp 0x1c0547
001c05de
001c05deloc_1c05de:
001c05depush 34
001c05e0call caml_call_realloc_stack
001c05e5pop r10
001c05e7jmp 0x1c0532
001c0520

001c05ec
001c05ec // align 0x10

001c05f0
001c05f0Stdlib.Map.aux:
001c05f0lea r10, [rsp-376]
001c05f8cmp r10, [r14+40]
001c05fcjb 0x1c072b
001c0602
001c0602loc_1c0602:
001c0602sub rsp, 56
001c0606
001c0606loc_1c0606:
001c0606mov rdx, rax
001c0609mov rax, rdi
001c060ccmp r15, [r14]
001c060fjbe 0x1c0721
001c0615
001c0615loc_1c0615:
001c0615test bl, 1
001c0618je 0x1c0620
001c061aadd rsp, 56
001c061eret
001c061f
001c061f 90 .
001c0620
001c0620loc_1c0620:
001c0620mov [rsp+48], rsi
001c0625mov [rsp+40], rax
001c062amov [rsp+16], rbx
001c062fmov [rsp+24], rdx
001c0634mov rax, [rbx+24]
001c0638mov [rsp+32], rax
001c063dmov rax, [rbx+16]
001c0641mov [rsp+8], rax
001c0646mov rax, [rbx+8]
001c064amov [rsp], rax
001c064emov rbx, [rsi+24]
001c0652mov rdi, [rbx]
001c0655mov rbx, rdx
001c0658call caml_apply2
001c065dcmp rax, 1
001c0661je 0x1c06d4
001c0663cmp rax, 1
001c0667jge 0x1c0680
001c0669mov rax, [rsp+24]
001c066emov rbx, [rsp+32]
001c0673mov rdi, [rsp+40]
001c0678mov rsi, [rsp+48]
001c067djmp 0x1c0606
001c067f
001c067f 90 .
001c0680
001c0680loc_1c0680:
001c0680sub r15, 40
001c0684cmp r15, [r14]
001c0687jb 0x1c0717
001c068d
001c068dloc_1c068d:
001c068dlea rdi, [r15+8]
001c0691mov [rdi-8], 4096
001c0699mov rax, [rsp]
001c069dmov [rdi], rax
001c06a0mov rax, [rsp+8]
001c06a5mov [rdi+8], rax
001c06a9mov rax, [rsp+32]
001c06aemov [rdi+16], rax
001c06b2mov rax, [rsp+40]
001c06b7mov [rdi+24], rax
001c06bbmov rax, [rsp+16]
001c06c0mov rbx, [rax]
001c06c3mov rax, [rsp+24]
001c06c8mov rsi, [rsp+48]
001c06cdjmp 0x1c0606
001c06d2
001c06d2 66 90 f.
001c06d4
001c06d4loc_1c06d4:
001c06d4sub r15, 40
001c06d8cmp r15, [r14]
001c06dbjb 0x1c0710
001c06dd
001c06ddloc_1c06dd:
001c06ddlea rax, [r15+8]
001c06e1mov [rax-8], 4096
001c06e9mov rbx, [rsp]
001c06edmov [rax], rbx
001c06f0mov rbx, [rsp+8]
001c06f5mov [rax+8], rbx
001c06f9mov rbx, [rsp+32]
001c06femov [rax+16], rbx
001c0702mov rbx, [rsp+40]
001c0707mov [rax+24], rbx
001c070badd rsp, 56
001c070fret
001c0710
001c0710loc_1c0710:
001c0710call caml_call_gc
001c0715jmp 0x1c06dd
001c0717
001c0717loc_1c0717:
001c0717call caml_call_gc
001c071cjmp 0x1c068d
001c0721
001c0721loc_1c0721:
001c0721call caml_call_gc
001c0726jmp 0x1c0615
001c072b
001c072bloc_1c072b:
001c072bpush 40
001c072dcall caml_call_realloc_stack
001c0732pop r10
001c0734jmp 0x1c0602
001c05f0

001c0739
001c0739 // align 0x10

001c0740
001c0740Stdlib.Map.fun:
001c0740mov rsi, rax
001c0743mov rax, [rbx+16]
001c0747mov rdi, [rbx+24]
001c074bmov rbx, rsi
001c074ejmp 0x1c01b0
001c0740

001c0753
001c0753 // align 0x10

001c0760
001c0760Stdlib.Map.entry:
001c0760lea rsi, [rip+0x187999]
001c0767lea rdi, [rip+0x1879c2]
001c076emov rbx, rsp
001c0771mov rsp, [r14+64]
001c0775call caml_initialize
001c077amov rsp, rbx
001c077dmov eax, 1
001c0782ret
001c0760

001c0783
001c0783 // align 0x10

001c0790
001c0790Stdlib.Buffer.create:
001c0790sub rsp, 8
001c0794cmp rax, 3
001c0798jge 0x1c079f
001c079amov eax, 3
001c079f
001c079floc_1c079f:
001c079fmov rbx, 0x3ffffffffffffef
001c07a9cmp rax, rbx
001c07acjle 0x1c07c0
001c07aemov rax, 0x3ffffffffffffef
001c07b8mov [rsp], rax
001c07bcjmp 0x1c07c4
001c07be
001c07be 66 90 f.
001c07c0
001c07c0loc_1c07c0:
001c07c0mov [rsp], rax
001c07c4
001c07c4loc_1c07c4:
001c07c4mov rdi, rax
001c07c7lea rax, [rip+0x60862]
001c07cecall caml_c_call
001c07d3sub r15, 56
001c07d7cmp r15, [r14]
001c07dajb 0x1c081a
001c07dc
001c07dcloc_1c07dc:
001c07dclea rbx, [r15+8]
001c07e0add rbx, 32
001c07e4mov [rbx-8], 2048
001c07ecmov [rbx], rax
001c07efmov rdi, [rsp]
001c07f3mov [rbx+8], rdi
001c07f7lea rdi, [rbx-32]
001c07fbmov [rdi-8], 3072
001c0803mov [rdi], rbx
001c0806mov [rdi+8], 1
001c080emov [rdi+16], rax
001c0812mov rax, rdi
001c0815add rsp, 8
001c0819ret
001c081a
001c081aloc_1c081a:
001c081acall caml_call_gc
001c081fjmp 0x1c07dc
001c0790

001c0821
001c0821 // align 0x10

001c0830
001c0830Stdlib.Buffer.contents:
001c0830mov rdi, [rax+8]
001c0834mov rax, [rax]
001c0837mov rax, [rax]
001c083amov ebx, 1
001c083fjmp 0x1a63e0
001c0830

001c0844
001c0844 // align 0x10

001c0850
001c0850Stdlib.Buffer.to_bytes:
001c0850mov rdi, [rax+8]
001c0854mov ebx, 1
001c0859mov rax, [rax]
001c085cmov rax, [rax]
001c085fjmp 0x1a63e0
001c0850

001c0864
001c0864 // align 0x10

001c0870
001c0870Stdlib.Buffer.sub:
001c0870cmp rbx, 1
001c0874jl 0x1c0898
001c0876cmp rdi, 1
001c087ajl 0x1c0898
001c087cmov rsi, [rax+8]
001c0880sub rsi, rdi
001c0883inc rsi
001c0886cmp rbx, rsi
001c0889jg 0x1c0898
001c088bmov rax, [rax]
001c088emov rax, [rax]
001c0891jmp 0x1a63e0
001c0896
001c0896 66 90 f.
001c0898
001c0898loc_1c0898:
001c0898lea rax, [rip+0x18a3a9]
001c089fjmp 0x195ab0
001c0870

001c08a4
001c08a4 // align 0x10

001c08b0
001c08b0Stdlib.Buffer.blit:
001c08b0cmp rdx, 1
001c08b4jl 0x1c0904
001c08b6cmp rbx, 1
001c08bajl 0x1c0904
001c08bcmov rcx, [rax+8]
001c08c0sub rcx, rdx
001c08c3inc rcx
001c08c6cmp rbx, rcx
001c08c9jg 0x1c0904
001c08cbcmp rsi, 1
001c08cfjl 0x1c0904
001c08d1mov rcx, [rdi-8]
001c08d5shr rcx, 10
001c08d9lea rcx, [8*rcx-1]
001c08e1movzx r8, [rdi+rcx]
001c08e6sub rcx, r8
001c08e9shl rcx, 1
001c08ecsub rcx, rdx
001c08efadd rcx, 2
001c08f3cmp rsi, rcx
001c08f6jg 0x1c0904
001c08f8mov rax, [rax]
001c08fbmov rax, [rax]
001c08fejmp 0x1a6660
001c0903
001c0903 90 .
001c0904
001c0904loc_1c0904:
001c0904lea rax, [rip+0x18a30d]
001c090bjmp 0x195ab0
001c08b0

001c0910
001c0910Stdlib.Buffer.nth:
001c0910mov rdi, [rax+8]
001c0914mov rax, [rax]
001c0917cmp rbx, 1
001c091bjl 0x1c093c
001c091dcmp rbx, rdi
001c0920jge 0x1c093c
001c0922mov rsi, [rax+8]
001c0926cmp rdi, rsi
001c0929jg 0x1c093c
001c092bsar rbx, 1
001c092emov rax, [rax]
001c0931movzx rax, [rax+rbx]
001c0936lea rax, [rax+rax+1]
001c093bret
001c093c
001c093cloc_1c093c:
001c093clea rax, [rip+0x18a2bd]
001c0943jmp 0x195ab0
001c0910

001c0948
001c0948 // align 0x10

001c0950
001c0950Stdlib.Buffer.length:
001c0950mov rax, [rax+8]
001c0954ret
001c0950

001c0955
001c0955 // align 0x10

001c0960
001c0960Stdlib.Buffer.clear:
001c0960mov [rax+8], 1
001c0968mov eax, 1
001c096dret
001c0960

001c096e
001c096e // align 0x10

001c0970
001c0970Stdlib.Buffer.reset:
001c0970mov [rax+8], 1
001c0978sub r15, 24
001c097ccmp r15, [r14]
001c097fjb 0x1c09cd
001c0981
001c0981loc_1c0981:
001c0981lea rsi, [r15+8]
001c0985mov [rsi-8], 2048
001c098dmov rbx, [rax+16]
001c0991mov [rsi], rbx
001c0994mov rdi, [rbx-8]
001c0998shr rdi, 10
001c099clea rdi, [8*rdi-1]
001c09a4movzx rbx, [rbx+rdi]
001c09a9sub rdi, rbx
001c09aclea rbx, [rdi+rdi+1]
001c09b1mov [rsi+8], rbx
001c09b5mov rdi, rax
001c09b8mov rbx, rsp
001c09bbmov rsp, [r14+64]
001c09bfcall caml_modify
001c09c4mov rsp, rbx
001c09c7mov eax, 1
001c09ccret
001c09cd
001c09cdloc_1c09cd:
001c09cdcall caml_call_gc
001c09d2jmp 0x1c0981
001c0970

001c09d4
001c09d4 // align 0x10

001c09e0
001c09e0Stdlib.Buffer.resize:
001c09e0lea r10, [rsp-344]
001c09e8cmp r10, [r14+40]
001c09ecjb 0x1c0af7
001c09f2
001c09f2loc_1c09f2:
001c09f2sub rsp, 24
001c09f6mov [rsp+16], rax
001c09fbmov rdi, [rax+8]
001c09ffmov rax, [rax]
001c0a02mov rax, [rax+8]
001c0a06
001c0a06loc_1c0a06:
001c0a06lea rsi, [rdi+rbx-1]
001c0a0bcmp rsi, rax
001c0a0ejle 0x1c0a1f
001c0a10lea rax, [rax+rax-1]
001c0a15cmp r15, [r14]
001c0a18ja 0x1c0a06
001c0a1ajmp 0x1c0aed
001c0a1f
001c0a1floc_1c0a1f:
001c0a1fmov rsi, 0x3ffffffffffffef
001c0a29cmp rax, rsi
001c0a2cjle 0x1c0a68
001c0a2emov rsi, 0x3ffffffffffffef
001c0a38lea rbx, [rdi+rbx-1]
001c0a3dcmp rbx, rsi
001c0a40jg 0x1c0a54
001c0a42mov rax, 0x3ffffffffffffef
001c0a4cmov [rsp+8], rax
001c0a51jmp 0x1c0a6d
001c0a53
001c0a53 90 .
001c0a54
001c0a54loc_1c0a54:
001c0a54mov [rsp+8], rax
001c0a59lea rax, [rip+0x18a178]
001c0a60call camlStdlib.failwith_7
001c0a65jmp 0x1c0a6d
001c0a67
001c0a67 90 .
001c0a68
001c0a68loc_1c0a68:
001c0a68mov [rsp+8], rax
001c0a6d
001c0a6dloc_1c0a6d:
001c0a6dmov rdi, [rsp+8]
001c0a72lea rax, [rip+0x605b7]
001c0a79call caml_c_call
001c0a7emov rdi, rax
001c0a81mov [rsp], rdi
001c0a85mov rax, [rsp+16]
001c0a8amov rdx, [rax+8]
001c0a8emov esi, 1
001c0a93mov ebx, 1
001c0a98mov rax, [rax]
001c0a9bmov rax, [rax]
001c0a9ecall Stdlib.Bytes.blit
001c0aa3sub r15, 24
001c0aa7cmp r15, [r14]
001c0aaajb 0x1c0ae6
001c0aac
001c0aacloc_1c0aac:
001c0aaclea rsi, [r15+8]
001c0ab0mov [rsi-8], 2048
001c0ab8mov rax, [rsp]
001c0abcmov [rsi], rax
001c0abfmov rax, [rsp+8]
001c0ac4mov [rsi+8], rax
001c0ac8mov rdi, [rsp+16]
001c0acdmov rbx, rsp
001c0ad0mov rsp, [r14+64]
001c0ad4call caml_modify
001c0ad9mov rsp, rbx
001c0adcmov eax, 1
001c0ae1add rsp, 24
001c0ae5ret
001c0ae6
001c0ae6loc_1c0ae6:
001c0ae6call caml_call_gc
001c0aebjmp 0x1c0aac
001c0aed
001c0aedloc_1c0aed:
001c0aedcall caml_call_gc
001c0af2jmp 0x1c0a06
001c0af7
001c0af7loc_1c0af7:
001c0af7push 36
001c0af9call caml_call_realloc_stack
001c0afepop r10
001c0b00jmp 0x1c09f2
001c09e0

001c0b05
001c0b05 // align 0x10

001c0b10
001c0b10Stdlib.Buffer.add_char:
001c0b10lea r10, [rsp-344]
001c0b18cmp r10, [r14+40]
001c0b1cjb 0x1c0bb3
001c0b22
001c0b22loc_1c0b22:
001c0b22sub rsp, 24
001c0b26mov rdi, [rax+8]
001c0b2amov [rsp], rdi
001c0b2emov rsi, [rax]
001c0b31mov rdx, [rsi+8]
001c0b35cmp rdi, rdx
001c0b38jl 0x1c0b8c
001c0b3amov [rsp+8], rbx
001c0b3fmov [rsp+16], rax
001c0b44mov ebx, 3
001c0b49call Stdlib.Buffer.resize
001c0b4emov rbx, [rsp+8]
001c0b53sar rbx, 1
001c0b56mov rax, [rsp+16]
001c0b5bmov rdi, [rax+8]
001c0b5fsar rdi, 1
001c0b62mov rsi, [rax]
001c0b65mov rsi, [rsi]
001c0b68mov rdx, [rsi-8]
001c0b6cshr rdx, 10
001c0b70lea rdx, [8*rdx-1]
001c0b78movzx rcx, [rsi+rdx]
001c0b7dsub rdx, rcx
001c0b80cmp rdx, rdi
001c0b83jbe 0x1c0bae
001c0b85mov [rsi+rdi], bl
001c0b88jmp 0x1c0b98
001c0b8a
001c0b8a 66 90 f.
001c0b8c
001c0b8cloc_1c0b8c:
001c0b8csar rdi, 1
001c0b8fmov rsi, [rsi]
001c0b92sar rbx, 1
001c0b95mov [rsi+rdi], bl
001c0b98
001c0b98loc_1c0b98:
001c0b98mov rbx, [rsp]
001c0b9cadd rbx, 2
001c0ba0mov [rax+8], rbx
001c0ba4mov eax, 1
001c0ba9add rsp, 24
001c0badret
001c0bae
001c0baeloc_1c0bae:
001c0baecall caml_ml_array_bound_error
001c0bb3
001c0bb3loc_1c0bb3:
001c0bb3push 36
001c0bb5call caml_call_realloc_stack
001c0bbapop r10
001c0bbcjmp 0x1c0b22
001c0b10

001c0bc1
001c0bc1 // align 0x10

001c0bd0
001c0bd0Stdlib.Buffer.add_utf_8_uchar:
001c0bd0lea r10, [rsp-344]
001c0bd8cmp r10, [r14+40]
001c0bdcjb 0x1c0c73
001c0be2
001c0be2loc_1c0be2:
001c0be2sub rsp, 24
001c0be6
001c0be6loc_1c0be6:
001c0be6mov [rsp+8], rax
001c0bebmov [rsp+16], rbx
001c0bf0cmp r15, [r14]
001c0bf3jbe 0x1c0c6c
001c0bf5
001c0bf5loc_1c0bf5:
001c0bf5mov rbx, [rax+8]
001c0bf9mov [rsp], rbx
001c0bfdmov rdi, [rax]
001c0c00mov rdi, [rdi+8]
001c0c04cmp rbx, rdi
001c0c07jl 0x1c0c13
001c0c09mov ebx, 9
001c0c0ecall Stdlib.Buffer.resize
001c0c13
001c0c13loc_1c0c13:
001c0c13mov rax, [rsp+8]
001c0c18mov rax, [rax]
001c0c1bmov rax, [rax]
001c0c1emov rbx, [rsp]
001c0c22mov rdi, [rsp+16]
001c0c27call Stdlib.Bytes.set_utf_8_uchar
001c0c2ccmp rax, 1
001c0c30jne 0x1c0c50
001c0c32mov ebx, 9
001c0c37mov rax, [rsp+8]
001c0c3ccall Stdlib.Buffer.resize
001c0c41mov rax, [rsp+8]
001c0c46mov rbx, [rsp+16]
001c0c4bjmp 0x1c0be6
001c0c4d
001c0c4d 0f 1f 00 ...
001c0c50
001c0c50loc_1c0c50:
001c0c50mov rbx, [rsp]
001c0c54lea rax, [rbx+rax-1]
001c0c59mov rbx, [rsp+8]
001c0c5emov [rbx+8], rax
001c0c62mov eax, 1
001c0c67add rsp, 24
001c0c6bret
001c0c6c
001c0c6cloc_1c0c6c:
001c0c6ccall caml_call_gc
001c0c71jmp 0x1c0bf5
001c0c73
001c0c73loc_1c0c73:
001c0c73push 36
001c0c75call caml_call_realloc_stack
001c0c7apop r10
001c0c7cjmp 0x1c0be2
001c0bd0

001c0c81
001c0c81 // align 0x10

001c0c90
001c0c90Stdlib.Buffer.add_utf_16be_uchar:
001c0c90lea r10, [rsp-344]
001c0c98cmp r10, [r14+40]
001c0c9cjb 0x1c0d33
001c0ca2
001c0ca2loc_1c0ca2:
001c0ca2sub rsp, 24
001c0ca6
001c0ca6loc_1c0ca6:
001c0ca6mov [rsp+8], rax
001c0cabmov [rsp+16], rbx
001c0cb0cmp r15, [r14]
001c0cb3jbe 0x1c0d2c
001c0cb5
001c0cb5loc_1c0cb5:
001c0cb5mov rbx, [rax+8]
001c0cb9mov [rsp], rbx
001c0cbdmov rdi, [rax]
001c0cc0mov rdi, [rdi+8]
001c0cc4cmp rbx, rdi
001c0cc7jl 0x1c0cd3
001c0cc9mov ebx, 9
001c0ccecall Stdlib.Buffer.resize
001c0cd3
001c0cd3loc_1c0cd3:
001c0cd3mov rax, [rsp+8]
001c0cd8mov rax, [rax]
001c0cdbmov rax, [rax]
001c0cdemov rbx, [rsp]
001c0ce2mov rdi, [rsp+16]
001c0ce7call Stdlib.Bytes.set_utf_16be_uchar
001c0ceccmp rax, 1
001c0cf0jne 0x1c0d10
001c0cf2mov ebx, 9
001c0cf7mov rax, [rsp+8]
001c0cfccall Stdlib.Buffer.resize
001c0d01mov rax, [rsp+8]
001c0d06mov rbx, [rsp+16]
001c0d0bjmp 0x1c0ca6
001c0d0d
001c0d0d 0f 1f 00 ...
001c0d10
001c0d10loc_1c0d10:
001c0d10mov rbx, [rsp]
001c0d14lea rax, [rbx+rax-1]
001c0d19mov rbx, [rsp+8]
001c0d1emov [rbx+8], rax
001c0d22mov eax, 1
001c0d27add rsp, 24
001c0d2bret
001c0d2c
001c0d2cloc_1c0d2c:
001c0d2ccall caml_call_gc
001c0d31jmp 0x1c0cb5
001c0d33
001c0d33loc_1c0d33:
001c0d33push 36
001c0d35call caml_call_realloc_stack
001c0d3apop r10
001c0d3cjmp 0x1c0ca2
001c0c90

001c0d41
001c0d41 // align 0x10

001c0d50
001c0d50Stdlib.Buffer.add_utf_16le_uchar:
001c0d50lea r10, [rsp-344]
001c0d58cmp r10, [r14+40]
001c0d5cjb 0x1c0df3
001c0d62
001c0d62loc_1c0d62:
001c0d62sub rsp, 24
001c0d66
001c0d66loc_1c0d66:
001c0d66mov [rsp+8], rax
001c0d6bmov [rsp+16], rbx
001c0d70cmp r15, [r14]
001c0d73jbe 0x1c0dec
001c0d75
001c0d75loc_1c0d75:
001c0d75mov rbx, [rax+8]
001c0d79mov [rsp], rbx
001c0d7dmov rdi, [rax]
001c0d80mov rdi, [rdi+8]
001c0d84cmp rbx, rdi
001c0d87jl 0x1c0d93
001c0d89mov ebx, 9
001c0d8ecall Stdlib.Buffer.resize
001c0d93
001c0d93loc_1c0d93:
001c0d93mov rax, [rsp+8]
001c0d98mov rax, [rax]
001c0d9bmov rax, [rax]
001c0d9emov rbx, [rsp]
001c0da2mov rdi, [rsp+16]
001c0da7call Stdlib.Bytes.set_utf_16le_uchar
001c0daccmp rax, 1
001c0db0jne 0x1c0dd0
001c0db2mov ebx, 9
001c0db7mov rax, [rsp+8]
001c0dbccall Stdlib.Buffer.resize
001c0dc1mov rax, [rsp+8]
001c0dc6mov rbx, [rsp+16]
001c0dcbjmp 0x1c0d66
001c0dcd
001c0dcd 0f 1f 00 ...
001c0dd0
001c0dd0loc_1c0dd0:
001c0dd0mov rbx, [rsp]
001c0dd4lea rax, [rbx+rax-1]
001c0dd9mov rbx, [rsp+8]
001c0ddemov [rbx+8], rax
001c0de2mov eax, 1
001c0de7add rsp, 24
001c0debret
001c0dec
001c0decloc_1c0dec:
001c0deccall caml_call_gc
001c0df1jmp 0x1c0d75
001c0df3
001c0df3loc_1c0df3:
001c0df3push 36
001c0df5call caml_call_realloc_stack
001c0dfapop r10
001c0dfcjmp 0x1c0d62
001c0d50

001c0e01
001c0e01 // align 0x10

001c0e10
001c0e10Stdlib.Buffer.add_substring:
001c0e10lea r10, [rsp-360]
001c0e18cmp r10, [r14+40]
001c0e1cjb 0x1c0f02
001c0e22
001c0e22loc_1c0e22:
001c0e22sub rsp, 40
001c0e26mov [rsp+8], rax
001c0e2bmov [rsp+16], rbx
001c0e30mov [rsp+24], rdi
001c0e35mov [rsp+32], rsi
001c0e3acmp rdi, 1
001c0e3ejl 0x1c0e6d
001c0e40cmp rsi, 1
001c0e44jl 0x1c0e6d
001c0e46mov rax, [rbx-8]
001c0e4ashr rax, 10
001c0e4elea rax, [8*rax-1]
001c0e56movzx rbx, [rbx+rax]
001c0e5bsub rax, rbx
001c0e5eshl rax, 1
001c0e61sub rax, rsi
001c0e64add rax, 2
001c0e68cmp rdi, rax
001c0e6bjle 0x1c0e79
001c0e6d
001c0e6dloc_1c0e6d:
001c0e6dlea rax, [rip+0x189d44]
001c0e74call camlStdlib.invalid_arg_10
001c0e79
001c0e79loc_1c0e79:
001c0e79mov rax, [rsp+8]
001c0e7emov rcx, [rax+8]
001c0e82mov rdi, [rax]
001c0e85mov rbx, [rsp+32]
001c0e8alea rsi, [rcx+rbx-1]
001c0e8fmov [rsp], rsi
001c0e93mov rdx, [rdi+8]
001c0e97cmp rsi, rdx
001c0e9ajle 0x1c0ecc
001c0e9cmov [rsp+32], rbx
001c0ea1call Stdlib.Buffer.resize
001c0ea6mov rax, [rsp+8]
001c0eabmov rsi, [rax+8]
001c0eafmov rax, [rax]
001c0eb2mov rdi, [rax]
001c0eb5mov rax, [rsp+16]
001c0ebamov rbx, [rsp+24]
001c0ebfmov rdx, [rsp+32]
001c0ec4call Stdlib.Bytes.blit_string
001c0ec9jmp 0x1c0eeb
001c0ecb
001c0ecb 90 .
001c0ecc
001c0eccloc_1c0ecc:
001c0eccmov rdx, [rdi]
001c0ecfmov rdi, [rsp+16]
001c0ed4mov rsi, [rsp+24]
001c0ed9mov r8, rbx
001c0edcmov rbx, rsp
001c0edfmov rsp, [r14+64]
001c0ee3call caml_blit_string
001c0ee8mov rsp, rbx
001c0eeb
001c0eebloc_1c0eeb:
001c0eebmov rax, [rsp]
001c0eefmov rbx, [rsp+8]
001c0ef4mov [rbx+8], rax
001c0ef8mov eax, 1
001c0efdadd rsp, 40
001c0f01ret
001c0f02
001c0f02loc_1c0f02:
001c0f02push 38
001c0f04call caml_call_realloc_stack
001c0f09pop r10
001c0f0bjmp 0x1c0e22
001c0e10

001c0f10
001c0f10Stdlib.Buffer.add_subbytes:
001c0f10lea r10, [rsp-360]
001c0f18cmp r10, [r14+40]
001c0f1cjb 0x1c1002
001c0f22
001c0f22loc_1c0f22:
001c0f22sub rsp, 40
001c0f26mov [rsp+8], rax
001c0f2bmov [rsp+16], rbx
001c0f30mov [rsp+24], rdi
001c0f35mov [rsp+32], rsi
001c0f3acmp rdi, 1
001c0f3ejl 0x1c0f6d
001c0f40cmp rsi, 1
001c0f44jl 0x1c0f6d
001c0f46mov rax, [rbx-8]
001c0f4ashr rax, 10
001c0f4elea rax, [8*rax-1]
001c0f56movzx rbx, [rbx+rax]
001c0f5bsub rax, rbx
001c0f5eshl rax, 1
001c0f61sub rax, rsi
001c0f64add rax, 2
001c0f68cmp rdi, rax
001c0f6bjle 0x1c0f79
001c0f6d
001c0f6dloc_1c0f6d:
001c0f6dlea rax, [rip+0x189c24]
001c0f74call camlStdlib.invalid_arg_10
001c0f79
001c0f79loc_1c0f79:
001c0f79mov rax, [rsp+8]
001c0f7emov rcx, [rax+8]
001c0f82mov rdi, [rax]
001c0f85mov rbx, [rsp+32]
001c0f8alea rsi, [rcx+rbx-1]
001c0f8fmov [rsp], rsi
001c0f93mov rdx, [rdi+8]
001c0f97cmp rsi, rdx
001c0f9ajle 0x1c0fcc
001c0f9cmov [rsp+32], rbx
001c0fa1call Stdlib.Buffer.resize
001c0fa6mov rax, [rsp+8]
001c0fabmov rsi, [rax+8]
001c0fafmov rax, [rax]
001c0fb2mov rdi, [rax]
001c0fb5mov rax, [rsp+16]
001c0fbamov rbx, [rsp+24]
001c0fbfmov rdx, [rsp+32]
001c0fc4call Stdlib.Bytes.blit
001c0fc9jmp 0x1c0feb
001c0fcb
001c0fcb 90 .
001c0fcc
001c0fccloc_1c0fcc:
001c0fccmov rdx, [rdi]
001c0fcfmov rdi, [rsp+16]
001c0fd4mov rsi, [rsp+24]
001c0fd9mov r8, rbx
001c0fdcmov rbx, rsp
001c0fdfmov rsp, [r14+64]
001c0fe3call caml_blit_bytes
001c0fe8mov rsp, rbx
001c0feb
001c0febloc_1c0feb:
001c0febmov rax, [rsp]
001c0fefmov rbx, [rsp+8]
001c0ff4mov [rbx+8], rax
001c0ff8mov eax, 1
001c0ffdadd rsp, 40
001c1001ret
001c1002
001c1002loc_1c1002:
001c1002push 38
001c1004call caml_call_realloc_stack
001c1009pop r10
001c100bjmp 0x1c0f22
001c0f10

001c1010
001c1010Stdlib.Buffer.add_string:
001c1010mov rdi, [rbx-8]
001c1014shr rdi, 10
001c1018lea rdi, [8*rdi-1]
001c1020movzx rsi, [rbx+rdi]
001c1025sub rdi, rsi
001c1028lea rsi, [rdi+rdi+1]
001c102dmov edi, 1
001c1032jmp 0x1c0e10
001c1010

001c1037
001c1037 // align 0x10

001c1040
001c1040Stdlib.Buffer.add_bytes:
001c1040mov rdi, [rbx-8]
001c1044shr rdi, 10
001c1048lea rdi, [8*rdi-1]
001c1050movzx rsi, [rbx+rdi]
001c1055sub rdi, rsi
001c1058lea rsi, [rdi+rdi+1]
001c105dmov edi, 1
001c1062jmp 0x1c0f10
001c1040

001c1067
001c1067 // align 0x10

001c1070
001c1070Stdlib.Buffer.add_buffer:
001c1070mov rsi, [rbx+8]
001c1074mov edi, 1
001c1079mov rbx, [rbx]
001c107cmov rbx, [rbx]
001c107fjmp 0x1c0f10
001c1070

001c1084
001c1084 // align 0x10

001c1090
001c1090Stdlib.Buffer.really_input_up_to:
001c1090lea r10, [rsp-352]
001c1098cmp r10, [r14+40]
001c109cjb 0x1c1112
001c109e
001c109eloc_1c109e:
001c109esub rsp, 32
001c10a2cmp r15, [r14]
001c10a5jbe 0x1c110b
001c10a7
001c10a7loc_1c10a7:
001c10a7cmp rsi, 1
001c10abjne 0x1c10b8
001c10admov eax, 1
001c10b2add rsp, 32
001c10b6ret
001c10b7
001c10b7 90 .
001c10b8
001c10b8loc_1c10b8:
001c10b8mov [rsp+8], rsi
001c10bdmov [rsp], rdi
001c10c1mov [rsp+24], rbx
001c10c6mov [rsp+16], rax
001c10cbcall camlStdlib.input_302
001c10d0mov rdi, rax
001c10d3cmp rdi, 1
001c10d7jne 0x1c10e4
001c10d9mov eax, 1
001c10deadd rsp, 32
001c10e2ret
001c10e3
001c10e3 90 .
001c10e4
001c10e4loc_1c10e4:
001c10e4mov rax, [rsp]
001c10e8lea rsi, [rax+rdi-1]
001c10edmov rdx, [rsp+8]
001c10f2sub rdx, rdi
001c10f5inc rdx
001c10f8mov rax, [rsp+16]
001c10fdmov rbx, [rsp+24]
001c1102add rsp, 32
001c1106jmp 0x1c1120
001c110b
001c110bloc_1c110b:
001c110bcall caml_call_gc
001c1110jmp 0x1c10a7
001c1112
001c1112loc_1c1112:
001c1112push 37
001c1114call caml_call_realloc_stack
001c1119pop r10
001c111bjmp 0x1c109e
001c1090

001c111d
001c111d // align 0x10

001c1120
001c1120Stdlib.Buffer.loop:
001c1120lea r10, [rsp-360]
001c1128cmp r10, [r14+40]
001c112cjb 0x1c11ad
001c112e
001c112eloc_1c112e:
001c112esub rsp, 40
001c1132
001c1132loc_1c1132:
001c1132cmp r15, [r14]
001c1135jbe 0x1c11a6
001c1137
001c1137loc_1c1137:
001c1137cmp rdx, 1
001c113bjne 0x1c1148
001c113dmov rax, rdi
001c1140add rsp, 40
001c1144ret
001c1145
001c1145 0f 1f 00 ...
001c1148
001c1148loc_1c1148:
001c1148mov [rsp+8], rdx
001c114dmov [rsp], rsi
001c1151mov [rsp+32], rdi
001c1156mov [rsp+24], rbx
001c115bmov [rsp+16], rax
001c1160mov rdi, rsi
001c1163mov rsi, rdx
001c1166call camlStdlib.input_302
001c116bcmp rax, 1
001c116fjne 0x1c117c
001c1171mov rax, [rsp+32]
001c1176add rsp, 40
001c117aret
001c117b
001c117b 90 .
001c117c
001c117cloc_1c117c:
001c117cmov rbx, [rsp+32]
001c1181lea rdi, [rbx+rax-1]
001c1186mov rbx, [rsp]
001c118alea rsi, [rbx+rax-1]
001c118fmov rdx, [rsp+8]
001c1194sub rdx, rax
001c1197inc rdx
001c119amov rax, [rsp+16]
001c119fmov rbx, [rsp+24]
001c11a4jmp 0x1c1132
001c11a6
001c11a6loc_1c11a6:
001c11a6call caml_call_gc
001c11abjmp 0x1c1137
001c11ad
001c11adloc_1c11ad:
001c11adpush 38
001c11afcall caml_call_realloc_stack
001c11b4pop r10
001c11b6jmp 0x1c112e
001c1120

001c11bb
001c11bb // align 0x10

001c11c0
001c11c0Stdlib.Buffer.unsafe_add_channel_up_to:
001c11c0lea r10, [rsp-344]
001c11c8cmp r10, [r14+40]
001c11ccjb 0x1c1231
001c11ce
001c11celoc_1c11ce:
001c11cesub rsp, 24
001c11d2mov [rsp+16], rax
001c11d7mov [rsp], rbx
001c11dbmov rbx, rdi
001c11demov [rsp+8], rbx
001c11e3mov rdi, [rax]
001c11e6mov rdi, [rdi+8]
001c11eamov rsi, [rax+8]
001c11eelea rsi, [rsi+rbx-1]
001c11f3cmp rsi, rdi
001c11f6jle 0x1c11fd
001c11f8call Stdlib.Buffer.resize
001c11fd
001c11fdloc_1c11fd:
001c11fdmov rax, [rsp+16]
001c1202mov rdi, [rax+8]
001c1206mov rax, [rax]
001c1209mov rbx, [rax]
001c120cmov rax, [rsp]
001c1210mov rsi, [rsp+8]
001c1215call Stdlib.Buffer.really_input_up_to
001c121amov rdi, [rsp+16]
001c121fmov rbx, [rdi+8]
001c1223lea rbx, [rbx+rax-1]
001c1228mov [rdi+8], rbx
001c122cadd rsp, 24
001c1230ret
001c1231
001c1231loc_1c1231:
001c1231push 36
001c1233call caml_call_realloc_stack
001c1238pop r10
001c123ajmp 0x1c11ce
001c11c0

001c123c
001c123c // align 0x10

001c1240
001c1240Stdlib.Buffer.add_channel:
001c1240lea r10, [rsp-344]
001c1248cmp r10, [r14+40]
001c124cjb 0x1c12fe
001c1252
001c1252loc_1c1252:
001c1252sub rsp, 24
001c1256mov [rsp+8], rax
001c125bmov [rsp], rbx
001c125fmov [rsp+16], rdi
001c1264cmp rdi, 1
001c1268jl 0x1c1279
001c126amov rax, 0x3ffffffffffffef
001c1274cmp rdi, rax
001c1277jle 0x1c1285
001c1279
001c1279loc_1c1279:
001c1279lea rax, [rip+0x1898f8]
001c1280call camlStdlib.invalid_arg_10
001c1285
001c1285loc_1c1285:
001c1285mov rax, [rsp+8]
001c128amov rbx, [rax]
001c128dmov rdi, [rbx+8]
001c1291mov rsi, [rax+8]
001c1295mov rbx, [rsp+16]
001c129alea rsi, [rsi+rbx-1]
001c129fcmp rsi, rdi
001c12a2jle 0x1c12a9
001c12a4call Stdlib.Buffer.resize
001c12a9
001c12a9loc_1c12a9:
001c12a9mov rax, [rsp+8]
001c12aemov rdi, [rax+8]
001c12b2mov rax, [rax]
001c12b5mov rbx, [rax]
001c12b8mov rax, [rsp]
001c12bcmov rsi, [rsp+16]
001c12c1call Stdlib.Buffer.really_input_up_to
001c12c6mov rdi, [rsp+8]
001c12cbmov rbx, [rdi+8]
001c12cflea rbx, [rbx+rax-1]
001c12d4mov [rdi+8], rbx
001c12d8mov rbx, [rsp+16]
001c12ddcmp rax, rbx
001c12e0jge 0x1c12f4
001c12e2lea rax, [rip+0x16c32f]
001c12e9mov rax, [rax+88]
001c12edcall caml_raise_exn
001c12f2nop
001c12f4
001c12f4loc_1c12f4:
001c12f4mov eax, 1
001c12f9add rsp, 24
001c12fdret
001c12fe
001c12feloc_1c12fe:
001c12fepush 36
001c1300call caml_call_realloc_stack
001c1305pop r10
001c1307jmp 0x1c1252
001c1240

001c130c
001c130c // align 0x10

001c1310
001c1310Stdlib.Buffer.output_buffer:
001c1310mov rsi, [rbx+8]
001c1314mov edi, 1
001c1319mov rbx, [rbx]
001c131cmov rbx, [rbx]
001c131fjmp 0x196410
001c1310

001c1324
001c1324 // align 0x10

001c1330
001c1330Stdlib.Buffer.closing:
001c1330cmp rax, 81
001c1334je 0x1c1378
001c1336cmp rax, 247
001c133cje 0x1c1370
001c133esub r15, 24
001c1342cmp r15, [r14]
001c1345jb 0x1c137e
001c1347
001c1347loc_1c1347:
001c1347lea rax, [r15+8]
001c134bmov [rax-8], 2048
001c1353lea rbx, [rip+0xb4eae]
001c135amov [rax], rbx
001c135dlea rbx, [rip+0x1897dc]
001c1364mov [rax+8], rbx
001c1368call caml_raise_exn
001c136dnop [rax]
001c1370
001c1370loc_1c1370:
001c1370mov eax, 251
001c1375ret
001c1376
001c1376 66 90 f.
001c1378
001c1378loc_1c1378:
001c1378mov eax, 83
001c137dret
001c137e
001c137eloc_1c137e:
001c137ecall caml_call_gc
001c1383jmp 0x1c1347
001c1330

001c1385
001c1385 // align 0x10

001c1390
001c1390Stdlib.Buffer.advance_to_closing:
001c1390mov rcx, rsi
001c1393sub r15, 56
001c1397cmp r15, [r14]
001c139ajb 0x1c1402
001c139c
001c139cloc_1c139c:
001c139clea rsi, [r15+8]
001c13a0mov [rsi-8], 6391
001c13a8lea r8, [rip-0xca47f]
001c13afmov [rsi], r8
001c13b2mov r8, 0x300000000000007
001c13bcmov [rsi+8], r8
001c13c0lea r8, [rip+73]
001c13c7mov [rsi+16], r8
001c13cbmov [rsi+24], rax
001c13cfmov [rsi+32], rbx
001c13d3mov [rsi+40], rcx
001c13d7mov rax, [rcx-8]
001c13dbshr rax, 10
001c13dflea rax, [8*rax-1]
001c13e7movzx rbx, [rcx+rax]
001c13ecsub rax, rbx
001c13eflea rcx, [rax+rax+1]
001c13f4mov rax, rdi
001c13f7mov rbx, rdx
001c13famov rdi, rcx
001c13fdjmp 0x1c1410
001c1402
001c1402loc_1c1402:
001c1402call caml_call_gc
001c1407jmp 0x1c139c
001c1390

001c1409
001c1409 // align 0x10

001c1410
001c1410Stdlib.Buffer.advance:
001c1410cmp r15, [r14]
001c1413jbe 0x1c14a1
001c1419
001c1419loc_1c1419:
001c1419cmp rbx, rdi
001c141cjl 0x1c1430
001c141elea rax, [rip+0x16c1f3]
001c1425mov rax, [rax+56]
001c1429call caml_raise_exn
001c142enop
001c1430
001c1430loc_1c1430:
001c1430mov rdx, [rsi+24]
001c1434mov rcx, rbx
001c1437sar rcx, 1
001c143amov r8, [rsi+40]
001c143emov r9, [r8-8]
001c1442shr r9, 10
001c1446lea r9, [8*r9-1]
001c144emovzx r12, [r8+r9]
001c1453sub r9, r12
001c1456cmp r9, rcx
001c1459jbe 0x1c14ab
001c145bmovzx rcx, [r8+rcx]
001c1460lea rcx, [rcx+rcx+1]
001c1465cmp rcx, rdx
001c1468jne 0x1c1474
001c146aadd rbx, 2
001c146eadd rax, 2
001c1472jmp 0x1c1410
001c1474
001c1474loc_1c1474:
001c1474mov rdx, [rsi+32]
001c1478cmp rcx, rdx
001c147bjne 0x1c1498
001c147dcmp rax, 1
001c1481jne 0x1c1488
001c1483mov rax, rbx
001c1486ret
001c1487
001c1487 90 .
001c1488
001c1488loc_1c1488:
001c1488add rbx, 2
001c148cadd rax, -2
001c1490jmp 0x1c1410
001c1495
001c1495 0f 1f 00 ...
001c1498
001c1498loc_1c1498:
001c1498add rbx, 2
001c149cjmp 0x1c1410
001c14a1
001c14a1loc_1c14a1:
001c14a1call caml_call_gc
001c14a6jmp 0x1c1419
001c14ab
001c14abloc_1c14ab:
001c14abcall caml_ml_array_bound_error
001c1410

001c14b0
001c14b0Stdlib.Buffer.advance_to_non_alpha:
001c14b0mov rsi, rax
001c14b3mov rax, rbx
001c14b6sub r15, 40
001c14bacmp r15, [r14]
001c14bdjb 0x1c1514
001c14bf
001c14bfloc_1c14bf:
001c14bflea rdi, [r15+8]
001c14c3mov [rdi-8], 4343
001c14cblea rbx, [rip-0xca4b2]
001c14d2mov [rdi], rbx
001c14d5mov rbx, 0x200000000000007
001c14dfmov [rdi+8], rbx
001c14e3lea rbx, [rip+54]
001c14eamov [rdi+16], rbx
001c14eemov [rdi+24], rsi
001c14f2mov rbx, [rsi-8]
001c14f6shr rbx, 10
001c14falea rbx, [8*rbx-1]
001c1502movzx rsi, [rsi+rbx]
001c1507sub rbx, rsi
001c150alea rbx, [rbx+rbx+1]
001c150fjmp 0x1c1520
001c1514
001c1514loc_1c1514:
001c1514call caml_call_gc
001c1519jmp 0x1c14bf
001c14b0

001c151b
001c151b // align 0x10

001c1520
001c1520Stdlib.Buffer.advance:
001c1520cmp r15, [r14]
001c1523jbe 0x1c15b5
001c1529
001c1529loc_1c1529:
001c1529cmp rax, rbx
001c152cjl 0x1c1534
001c152emov rax, rbx
001c1531ret
001c1532
001c1532 66 90 f.
001c1534
001c1534loc_1c1534:
001c1534mov rsi, rax
001c1537sar rsi, 1
001c153amov rdx, [rdi+24]
001c153emov rcx, [rdx-8]
001c1542shr rcx, 10
001c1546lea rcx, [8*rcx-1]
001c154emovzx r8, [rdx+rcx]
001c1553sub rcx, r8
001c1556cmp rcx, rsi
001c1559jbe 0x1c15bf
001c155bmovzx rsi, [rdx+rsi]
001c1560lea rsi, [rsi+rsi+1]
001c1565cmp rsi, 183
001c156cjl 0x1c1590
001c156ecmp rsi, 195
001c1575jl 0x1c1584
001c1577cmp rsi, 247
001c157ejl 0x1c15ac
001c1580jmp 0x1c15aa
001c1582
001c1582 66 90 f.
001c1584
001c1584loc_1c1584:
001c1584cmp rsi, 191
001c158bje 0x1c15ac
001c158djmp 0x1c15aa
001c158f
001c158f 90 .
001c1590
001c1590loc_1c1590:
001c1590cmp rsi, 117
001c1594jl 0x1c15a4
001c1596cmp rsi, 131
001c159djge 0x1c15ac
001c159fjmp 0x1c15aa
001c15a1
001c15a1 0f 1f 00 ...
001c15a4
001c15a4loc_1c15a4:
001c15a4cmp rsi, 97
001c15a8jge 0x1c15ac
001c15aa
001c15aaloc_1c15aa:
001c15aaret
001c15ab
001c15ab 90 .
001c15ac
001c15acloc_1c15ac:
001c15acadd rax, 2
001c15b0jmp 0x1c1520
001c15b5
001c15b5loc_1c15b5:
001c15b5call caml_call_gc
001c15bajmp 0x1c1529
001c15bf
001c15bfloc_1c15bf:
001c15bfcall caml_ml_array_bound_error
001c1520

001c15c4
001c15c4 // align 0x10

001c15d0
001c15d0Stdlib.Buffer.find_ident:
001c15d0lea r10, [rsp-352]
001c15d8cmp r10, [r14+40]
001c15dcjb 0x1c1789
001c15e2
001c15e2loc_1c15e2:
001c15e2sub rsp, 32
001c15e6mov rsi, rax
001c15e9mov rdx, rbx
001c15eccmp rdx, rdi
001c15efjl 0x1c1604
001c15f1lea rax, [rip+0x16c020]
001c15f8mov rax, [rax+56]
001c15fccall caml_raise_exn
001c1601nop [rax]
001c1604
001c1604loc_1c1604:
001c1604mov [rsp+16], rdx
001c1609mov [rsp+24], rsi
001c160emov rax, rdx
001c1611sar rax, 1
001c1614mov rbx, [rsi-8]
001c1618shr rbx, 10
001c161clea rbx, [8*rbx-1]
001c1624movzx rdi, [rsi+rbx]
001c1629sub rbx, rdi
001c162ccmp rbx, rax
001c162fjbe 0x1c1784
001c1635movzx rax, [rsi+rax]
001c163alea rax, [rax+rax+1]
001c163fcmp rax, 81
001c1643je 0x1c16b8
001c1645cmp rax, 247
001c164bje 0x1c16b8
001c164dmov rax, rsi
001c1650mov rbx, rdx
001c1653call Stdlib.Buffer.advance_to_non_alpha
001c1658mov rdi, rax
001c165bmov rbx, [rsp+16]
001c1660cmp rdi, rbx
001c1663jne 0x1c1678
001c1665lea rax, [rip+0x16bfac]
001c166cmov rax, [rax+56]
001c1670call caml_raise_exn
001c1675nop [rax]
001c1678
001c1678loc_1c1678:
001c1678mov [rsp], rdi
001c167csub rdi, rbx
001c167finc rdi
001c1682mov rax, [rsp+24]
001c1687call Stdlib.Bytes.sub
001c168csub r15, 24
001c1690cmp r15, [r14]
001c1693jb 0x1c177a
001c1699
001c1699loc_1c1699:
001c1699lea rbx, [r15+8]
001c169dmov [rbx-8], 2048
001c16a5mov [rbx], rax
001c16a8mov rax, [rsp]
001c16acmov [rbx+8], rax
001c16b0mov rax, rbx
001c16b3add rsp, 32
001c16b7ret
001c16b8
001c16b8loc_1c16b8:
001c16b8add rdx, 2
001c16bcmov [rsp], rdx
001c16c0cmp rax, 81
001c16c4je 0x1c170c
001c16c6cmp rax, 247
001c16ccje 0x1c1704
001c16cesub r15, 24
001c16d2cmp r15, [r14]
001c16d5jb 0x1c1770
001c16db
001c16dbloc_1c16db:
001c16dblea rax, [r15+8]
001c16dfmov [rax-8], 2048
001c16e7lea rbx, [rip+0xb4b1a]
001c16eemov [rax], rbx
001c16f1lea rbx, [rip+0x189448]
001c16f8mov [rax+8], rbx
001c16fccall caml_raise_exn
001c1701nop [rax]
001c1704
001c1704loc_1c1704:
001c1704mov ebx, 251
001c1709jmp 0x1c1711
001c170b
001c170b 90 .
001c170c
001c170cloc_1c170c:
001c170cmov ebx, 83
001c1711
001c1711loc_1c1711:
001c1711mov edi, 1
001c1716call Stdlib.Buffer.advance_to_closing
001c171bmov rdi, rax
001c171emov [rsp+8], rdi
001c1723mov rax, [rsp+16]
001c1728sub rdi, rax
001c172bdec rdi
001c172emov rax, [rsp+24]
001c1733mov rbx, [rsp]
001c1737call Stdlib.Bytes.sub
001c173csub r15, 24
001c1740cmp r15, [r14]
001c1743jb 0x1c1769
001c1745
001c1745loc_1c1745:
001c1745lea rbx, [r15+8]
001c1749mov [rbx-8], 2048
001c1751mov [rbx], rax
001c1754mov rax, [rsp+8]
001c1759add rax, 2
001c175dmov [rbx+8], rax
001c1761mov rax, rbx
001c1764add rsp, 32
001c1768ret
001c1769
001c1769loc_1c1769:
001c1769call caml_call_gc
001c176ejmp 0x1c1745
001c1770
001c1770loc_1c1770:
001c1770call caml_call_gc
001c1775jmp 0x1c16db
001c177a
001c177aloc_1c177a:
001c177acall caml_call_gc
001c177fjmp 0x1c1699
001c1784
001c1784loc_1c1784:
001c1784call caml_ml_array_bound_error
001c1789
001c1789loc_1c1789:
001c1789push 37
001c178bcall caml_call_realloc_stack
001c1790pop r10
001c1792jmp 0x1c15e2
001c15d0

001c1797
001c1797 // align 0x10

001c17a0
001c17a0Stdlib.Buffer.add_substitute:
001c17a0mov rsi, [rdi-8]
001c17a4shr rsi, 10
001c17a8lea rsi, [8*rsi-1]
001c17b0movzx rdx, [rdi+rsi]
001c17b5sub rsi, rdx
001c17b8lea rsi, [rsi+rsi+1]
001c17bdsub r15, 64
001c17c1cmp r15, [r14]
001c17c4jb 0x1c1817
001c17c6
001c17c6loc_1c17c6:
001c17c6lea rdx, [r15+8]
001c17camov [rdx-8], 7415
001c17d2lea rcx, [rip-0xca7b9]
001c17d9mov [rdx], rcx
001c17dcmov rcx, 0x200000000000007
001c17e6mov [rdx+8], rcx
001c17ealea rcx, [rip+47]
001c17f1mov [rdx+16], rcx
001c17f5mov [rdx+24], rax
001c17f9mov [rdx+32], rbx
001c17fdmov [rdx+40], rdi
001c1801mov [rdx+48], rsi
001c1805mov ebx, 1
001c180amov eax, 65
001c180fmov rdi, rdx
001c1812jmp 0x1c1820
001c1817
001c1817loc_1c1817:
001c1817call caml_call_gc
001c181cjmp 0x1c17c6
001c17a0

001c181e
001c181e // align 0x10

001c1820
001c1820Stdlib.Buffer.subst:
001c1820lea r10, [rsp-360]
001c1828cmp r10, [r14+40]
001c182cjb 0x1c1a11
001c1832
001c1832loc_1c1832:
001c1832sub rsp, 24
001c1836
001c1836loc_1c1836:
001c1836mov rsi, rax
001c1839cmp r15, [r14]
001c183cjbe 0x1c1a02
001c1842
001c1842loc_1c1842:
001c1842mov rdx, [rdi+48]
001c1846cmp rbx, rdx
001c1849jge 0x1c19dc
001c184fmov [rsp+16], rdi
001c1854mov rcx, rbx
001c1857sar rcx, 1
001c185amov rax, [rdi+40]
001c185emov r8, [rax-8]
001c1862shr r8, 10
001c1866lea r8, [8*r8-1]
001c186emovzx r9, [rax+r8]
001c1873sub r8, r9
001c1876cmp r8, rcx
001c1879jbe 0x1c1a0c
001c187fmovzx rcx, [rax+rcx]
001c1884lea rcx, [rcx+rcx+1]
001c1889cmp rcx, 73
001c188dje 0x1c18e0
001c188fmov [rsp+8], rcx
001c1894mov [rsp], rbx
001c1898cmp rsi, 185
001c189fjne 0x1c18ad
001c18a1mov rax, [rdi+24]
001c18a5mov rbx, rsi
001c18a8call Stdlib.Buffer.add_char
001c18ad
001c18adloc_1c18ad:
001c18admov rbx, [rsp+8]
001c18b2cmp rbx, 185
001c18b9je 0x1c18c9
001c18bbmov rax, [rsp+16]
001c18c0mov rax, [rax+24]
001c18c4call Stdlib.Buffer.add_char
001c18c9
001c18c9loc_1c18c9:
001c18c9mov rbx, [rsp]
001c18cdadd rbx, 2
001c18d1mov rax, [rsp+8]
001c18d6mov rdi, [rsp+16]
001c18dbjmp 0x1c1836
001c18e0
001c18e0loc_1c18e0:
001c18e0cmp rsi, 185
001c18e7jne 0x1c1910
001c18e9mov [rsp], rbx
001c18edmov rax, [rdi+24]
001c18f1mov rbx, rcx
001c18f4call Stdlib.Buffer.add_char
001c18f9mov rbx, [rsp]
001c18fdadd rbx, 2
001c1901mov eax, 65
001c1906mov rdi, [rsp+16]
001c190bjmp 0x1c1836
001c1910
001c1910loc_1c1910:
001c1910add rbx, 2
001c1914mov [rsp], rbx
001c1918lea r11, [rip+33]
001c191fpush r11
001c1921push [r14+48]
001c1925mov [r14+48], rsp
001c1929mov rdi, rdx
001c192ccall Stdlib.Buffer.find_ident
001c1931mov [rsp+16], rax
001c1936pop [r14+48]
001c193aadd rsp, 8
001c193ejmp 0x1c1980
001c1940lea rbx, [rip+0x16bcd1]
001c1947mov rbx, [rbx+56]
001c194bcmp rax, rbx
001c194ejne 0x1c1978
001c1950mov ebx, 73
001c1955mov rax, [rsp+16]
001c195amov rax, [rax+24]
001c195ecall Stdlib.Buffer.add_char
001c1963mov eax, 65
001c1968mov rbx, [rsp]
001c196cmov rdi, [rsp+16]
001c1971jmp 0x1c1836
001c1976
001c1976 66 90 f.
001c1978
001c1978loc_1c1978:
001c1978call caml_reraise_exn
001c197dnop [rax]
001c1980
001c1980loc_1c1980:
001c1980mov rbx, [rsp+16]
001c1985mov rbx, [rbx+32]
001c1989mov rax, [rax]
001c198cmov rdi, [rbx]
001c198fcall rdi
001c1991mov rbx, rax
001c1994mov rax, [rsp+16]
001c1999mov rax, [rax+24]
001c199dmov rdi, [rbx-8]
001c19a1shr rdi, 10
001c19a5lea rdi, [8*rdi-1]
001c19admovzx rsi, [rbx+rdi]
001c19b2sub rdi, rsi
001c19b5lea rsi, [rdi+rdi+1]
001c19bamov edi, 1
001c19bfcall Stdlib.Buffer.add_substring
001c19c4mov rax, [rsp]
001c19c8mov rbx, [rax+8]
001c19ccmov eax, 65
001c19d1mov rdi, [rsp+16]
001c19d6jmp 0x1c1836
001c19db
001c19db 90 .
001c19dc
001c19dcloc_1c19dc:
001c19dccmp rsi, 185
001c19e3jne 0x1c19f8
001c19e5mov rax, [rdi+24]
001c19e9mov rbx, rsi
001c19ecadd rsp, 24
001c19f0jmp 0x1c0b10
001c19f5
001c19f5 0f 1f 00 ...
001c19f8
001c19f8loc_1c19f8:
001c19f8mov eax, 1
001c19fdadd rsp, 24
001c1a01ret
001c1a02
001c1a02loc_1c1a02:
001c1a02call caml_call_gc
001c1a07jmp 0x1c1842
001c1a0c
001c1a0cloc_1c1a0c:
001c1a0ccall caml_ml_array_bound_error
001c1a11
001c1a11loc_1c1a11:
001c1a11push 38
001c1a13call caml_call_realloc_stack
001c1a18pop r10
001c1a1ajmp 0x1c1832
001c1820

001c1a1f
001c1a1f // align 0x10

001c1a20
001c1a20Stdlib.Buffer.truncate:
001c1a20cmp rbx, 1
001c1a24jl 0x1c1a3c
001c1a26mov rdi, [rax+8]
001c1a2acmp rbx, rdi
001c1a2djg 0x1c1a3c
001c1a2fmov [rax+8], rbx
001c1a33mov eax, 1
001c1a38ret
001c1a39
001c1a39 0f 1f 00 ...
001c1a3c
001c1a3cloc_1c1a3c:
001c1a3clea rax, [rip+0x1891ed]
001c1a43jmp 0x195ab0
001c1a20

001c1a48
001c1a48 // align 0x10

001c1a50
001c1a50Stdlib.Buffer.to_seq:
001c1a50sub r15, 80
001c1a54cmp r15, [r14]
001c1a57jb 0x1c1ac2
001c1a59
001c1a59loc_1c1a59:
001c1a59lea rbx, [r15+8]
001c1a5dadd rbx, 40
001c1a61mov [rbx-8], 4343
001c1a69lea rdi, [rip-0xcaa50]
001c1a70mov [rbx], rdi
001c1a73mov rdi, 0x200000000000007
001c1a7dmov [rbx+8], rdi
001c1a81lea rdi, [rip+72]
001c1a88mov [rbx+16], rdi
001c1a8cmov [rbx+24], rax
001c1a90mov edi, 1
001c1a95lea rax, [rbx-40]
001c1a99mov [rax-8], 4343
001c1aa1lea rsi, [rip+248]
001c1aa8mov [rax], rsi
001c1aabmov rsi, 0x100000000000005
001c1ab5mov [rax+8], rsi
001c1ab9mov [rax+16], rdi
001c1abdmov [rax+24], rbx
001c1ac1ret
001c1ac2
001c1ac2loc_1c1ac2:
001c1ac2call caml_call_gc
001c1ac7jmp 0x1c1a59
001c1a50

001c1ac9
001c1ac9 // align 0x10

001c1ad0
001c1ad0Stdlib.Buffer.aux:
001c1ad0mov rbx, [rdi+24]
001c1ad4mov rsi, [rbx+8]
001c1ad8cmp rax, rsi
001c1adbjl 0x1c1ae4
001c1addmov eax, 1
001c1ae2ret
001c1ae3
001c1ae3 90 .
001c1ae4
001c1ae4loc_1c1ae4:
001c1ae4mov rsi, rax
001c1ae7sar rsi, 1
001c1aeamov rbx, [rbx]
001c1aedmov rbx, [rbx]
001c1af0mov rdx, [rbx-8]
001c1af4shr rdx, 10
001c1af8lea rdx, [8*rdx-1]
001c1b00movzx rcx, [rbx+rdx]
001c1b05sub rdx, rcx
001c1b08cmp rdx, rsi
001c1b0bjbe 0x1c1b6f
001c1b0dmovzx rbx, [rbx+rsi]
001c1b12lea rbx, [rbx+rbx+1]
001c1b17add rax, 2
001c1b1bsub r15, 64
001c1b1fcmp r15, [r14]
001c1b22jb 0x1c1b68
001c1b24
001c1b24loc_1c1b24:
001c1b24lea rsi, [r15+8]
001c1b28add rsi, 24
001c1b2cmov [rsi-8], 4343
001c1b34lea rdx, [rip+69]
001c1b3bmov [rsi], rdx
001c1b3emov rdx, 0x100000000000005
001c1b48mov [rsi+8], rdx
001c1b4cmov [rsi+16], rax
001c1b50mov [rsi+24], rdi
001c1b54lea rax, [rsi-24]
001c1b58mov [rax-8], 2048
001c1b60mov [rax], rbx
001c1b63mov [rax+8], rsi
001c1b67ret
001c1b68
001c1b68loc_1c1b68:
001c1b68call caml_call_gc
001c1b6djmp 0x1c1b24
001c1b6f
001c1b6floc_1c1b6f:
001c1b6fcall caml_ml_array_bound_error
001c1ad0