Similarity

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

001c1b74
001c1b74 // align 0x10

001c1b80
001c1b80Stdlib.Buffer.fun:
001c1b80mov rsi, rax
001c1b83mov rax, [rbx+16]
001c1b87mov rdi, [rbx+24]
001c1b8bmov rbx, rsi
001c1b8ejmp 0x1c1ad0
001c1b80

001c1b93
001c1b93 // align 0x10

001c1ba0
001c1ba0Stdlib.Buffer.fun:
001c1ba0mov rsi, rax
001c1ba3mov rax, [rbx+16]
001c1ba7mov rdi, [rbx+24]
001c1babmov rbx, rsi
001c1baejmp 0x1c1ad0
001c1ba0

001c1bb3
001c1bb3 // align 0x10

001c1bc0
001c1bc0Stdlib.Buffer.to_seqi:
001c1bc0sub r15, 80
001c1bc4cmp r15, [r14]
001c1bc7jb 0x1c1c32
001c1bc9
001c1bc9loc_1c1bc9:
001c1bc9lea rbx, [r15+8]
001c1bcdadd rbx, 40
001c1bd1mov [rbx-8], 4343
001c1bd9lea rdi, [rip-0xcabc0]
001c1be0mov [rbx], rdi
001c1be3mov rdi, 0x200000000000007
001c1bedmov [rbx+8], rdi
001c1bf1lea rdi, [rip+72]
001c1bf8mov [rbx+16], rdi
001c1bfcmov [rbx+24], rax
001c1c00mov edi, 1
001c1c05lea rax, [rbx-40]
001c1c09mov [rax-8], 4343
001c1c11lea rsi, [rip+264]
001c1c18mov [rax], rsi
001c1c1bmov rsi, 0x100000000000005
001c1c25mov [rax+8], rsi
001c1c29mov [rax+16], rdi
001c1c2dmov [rax+24], rbx
001c1c31ret
001c1c32
001c1c32loc_1c1c32:
001c1c32call caml_call_gc
001c1c37jmp 0x1c1bc9
001c1bc0

001c1c39
001c1c39 // align 0x10

001c1c40
001c1c40Stdlib.Buffer.aux:
001c1c40mov rbx, [rdi+24]
001c1c44mov rsi, [rbx+8]
001c1c48cmp rax, rsi
001c1c4bjl 0x1c1c54
001c1c4dmov eax, 1
001c1c52ret
001c1c53
001c1c53 90 .
001c1c54
001c1c54loc_1c1c54:
001c1c54mov rsi, rax
001c1c57sar rsi, 1
001c1c5amov rbx, [rbx]
001c1c5dmov rbx, [rbx]
001c1c60mov rdx, [rbx-8]
001c1c64shr rdx, 10
001c1c68lea rdx, [8*rdx-1]
001c1c70movzx rcx, [rbx+rdx]
001c1c75sub rdx, rcx
001c1c78cmp rdx, rsi
001c1c7bjbe 0x1c1cf5
001c1c7dmovzx rbx, [rbx+rsi]
001c1c82lea rbx, [rbx+rbx+1]
001c1c87mov rsi, rax
001c1c8aadd rsi, 2
001c1c8esub r15, 88
001c1c92cmp r15, [r14]
001c1c95jb 0x1c1cee
001c1c97
001c1c97loc_1c1c97:
001c1c97lea rdx, [r15+8]
001c1c9badd rdx, 48
001c1c9fmov [rdx-8], 4343
001c1ca7lea rcx, [rip+82]
001c1caemov [rdx], rcx
001c1cb1mov rcx, 0x100000000000005
001c1cbbmov [rdx+8], rcx
001c1cbfmov [rdx+16], rsi
001c1cc3mov [rdx+24], rdi
001c1cc7lea rdi, [rdx-24]
001c1ccbmov [rdi-8], 2048
001c1cd3mov [rdi], rax
001c1cd6mov [rdi+8], rbx
001c1cdalea rax, [rdi-24]
001c1cdemov [rax-8], 2048
001c1ce6mov [rax], rdi
001c1ce9mov [rax+8], rdx
001c1cedret
001c1cee
001c1ceeloc_1c1cee:
001c1ceecall caml_call_gc
001c1cf3jmp 0x1c1c97
001c1cf5
001c1cf5loc_1c1cf5:
001c1cf5call caml_ml_array_bound_error
001c1c40

001c1cfa
001c1cfa // align 0x10

001c1d00
001c1d00Stdlib.Buffer.fun:
001c1d00mov rsi, rax
001c1d03mov rax, [rbx+16]
001c1d07mov rdi, [rbx+24]
001c1d0bmov rbx, rsi
001c1d0ejmp 0x1c1c40
001c1d00

001c1d13
001c1d13 // align 0x10

001c1d20
001c1d20Stdlib.Buffer.fun:
001c1d20mov rsi, rax
001c1d23mov rax, [rbx+16]
001c1d27mov rdi, [rbx+24]
001c1d2bmov rbx, rsi
001c1d2ejmp 0x1c1c40
001c1d20

001c1d33
001c1d33 // align 0x10

001c1d40
001c1d40Stdlib.Buffer.fun:
001c1d40mov rdi, rax
001c1d43mov rax, [rbx+16]
001c1d47mov rbx, rdi
001c1d4ajmp 0x1c0b10
001c1d40

001c1d4f
001c1d4f // align 0x10

001c1d50
001c1d50Stdlib.Buffer.add_seq:
001c1d50lea rdi, [rip+0x188c49]
001c1d57mov rdi, [rdi+88]
001c1d5bsub r15, 40
001c1d5fcmp r15, [r14]
001c1d62jb 0x1c1d98
001c1d64
001c1d64loc_1c1d64:
001c1d64lea rsi, [r15+8]
001c1d68mov [rsi-8], 4343
001c1d70lea rdx, [rip-55]
001c1d77mov [rsi], rdx
001c1d7amov rdx, 0x100000000000005
001c1d84mov [rsi+8], rdx
001c1d88mov [rsi+16], rax
001c1d8cmov [rsi+24], rdi
001c1d90mov rax, rsi
001c1d93jmp 0x19a840
001c1d98
001c1d98loc_1c1d98:
001c1d98call caml_call_gc
001c1d9djmp 0x1c1d64
001c1d50

001c1d9f
001c1d9f // align 0x10

001c1da0
001c1da0Stdlib.Buffer.of_seq:
001c1da0lea r10, [rsp-336]
001c1da8cmp r10, [r14+40]
001c1dacjb 0x1c1dd8
001c1dae
001c1daeloc_1c1dae:
001c1daesub rsp, 16
001c1db2mov [rsp], rax
001c1db6mov eax, 65
001c1dbbcall Stdlib.Buffer.create
001c1dc0mov [rsp+8], rax
001c1dc5mov rbx, [rsp]
001c1dc9call Stdlib.Buffer.add_seq
001c1dcemov rax, [rsp+8]
001c1dd3add rsp, 16
001c1dd7ret
001c1dd8
001c1dd8loc_1c1dd8:
001c1dd8push 35
001c1ddacall caml_call_realloc_stack
001c1ddfpop r10
001c1de1jmp 0x1c1dae
001c1da0

001c1de3
001c1de3 // align 0x10

001c1df0
001c1df0Stdlib.Buffer.add_int8:
001c1df0lea r10, [rsp-344]
001c1df8cmp r10, [r14+40]
001c1dfcjb 0x1c1e97
001c1e02
001c1e02loc_1c1e02:
001c1e02sub rsp, 24
001c1e06mov rdi, [rax+8]
001c1e0amov rsi, [rax]
001c1e0dmov rdx, rdi
001c1e10add rdx, 2
001c1e14mov [rsp], rdx
001c1e18mov rcx, [rsi+8]
001c1e1ccmp rdx, rcx
001c1e1fjle 0x1c1e74
001c1e21mov [rsp+8], rbx
001c1e26mov [rsp+16], rax
001c1e2bmov ebx, 3
001c1e30call Stdlib.Buffer.resize
001c1e35mov rbx, [rsp+8]
001c1e3asar rbx, 1
001c1e3dmov rax, [rsp+16]
001c1e42mov rdi, [rax+8]
001c1e46sar rdi, 1
001c1e49mov rsi, [rax]
001c1e4cmov rsi, [rsi]
001c1e4fmov rdx, [rsi-8]
001c1e53shr rdx, 10
001c1e57lea rdx, [8*rdx-1]
001c1e5fmovzx rcx, [rsi+rdx]
001c1e64sub rdx, rcx
001c1e67cmp rdx, rdi
001c1e6ajbe 0x1c1e92
001c1e6cmov [rsi+rdi], bl
001c1e6fjmp 0x1c1e80
001c1e71
001c1e71 0f 1f 00 ...
001c1e74
001c1e74loc_1c1e74:
001c1e74sar rdi, 1
001c1e77mov rsi, [rsi]
001c1e7asar rbx, 1
001c1e7dmov [rsi+rdi], bl
001c1e80
001c1e80loc_1c1e80:
001c1e80mov rbx, [rsp]
001c1e84mov [rax+8], rbx
001c1e88mov eax, 1
001c1e8dadd rsp, 24
001c1e91ret
001c1e92
001c1e92loc_1c1e92:
001c1e92call caml_ml_array_bound_error
001c1e97
001c1e97loc_1c1e97:
001c1e97push 36
001c1e99call caml_call_realloc_stack
001c1e9epop r10
001c1ea0jmp 0x1c1e02
001c1df0

001c1ea5
001c1ea5 // align 0x10

001c1eb0
001c1eb0Stdlib.Buffer.add_int16_ne:
001c1eb0lea r10, [rsp-344]
001c1eb8cmp r10, [r14+40]
001c1ebcjb 0x1c1f68
001c1ec2
001c1ec2loc_1c1ec2:
001c1ec2sub rsp, 24
001c1ec6mov rdi, [rax+8]
001c1ecamov rsi, [rax]
001c1ecdmov rdx, rdi
001c1ed0add rdx, 4
001c1ed4mov [rsp], rdx
001c1ed8mov rcx, [rsi+8]
001c1edccmp rdx, rcx
001c1edfjle 0x1c1f44
001c1ee1mov [rsp+8], rbx
001c1ee6mov [rsp+16], rax
001c1eebmov ebx, 5
001c1ef0call Stdlib.Buffer.resize
001c1ef5mov rdi, [rsp+8]
001c1efasar rdi, 1
001c1efdmov rax, [rsp+16]
001c1f02mov rbx, [rax+8]
001c1f06sar rbx, 1
001c1f09mov rsi, [rax]
001c1f0cmov rsi, [rsi]
001c1f0fmov rdx, [rsi-8]
001c1f13shr rdx, 10
001c1f17lea rdx, [8*rdx-1]
001c1f1fmovzx rcx, [rsi+rdx]
001c1f24sub rdx, rcx
001c1f27dec rdx
001c1f2amov rcx, rdx
001c1f2dsar rcx, 63
001c1f31xor rcx, -1
001c1f35and rcx, rdx
001c1f38cmp rcx, rbx
001c1f3bjbe 0x1c1f63
001c1f3dmov [rsi+rbx], di
001c1f41jmp 0x1c1f51
001c1f43
001c1f43 90 .
001c1f44
001c1f44loc_1c1f44:
001c1f44sar rbx, 1
001c1f47sar rdi, 1
001c1f4amov rsi, [rsi]
001c1f4dmov [rsi+rdi], bx
001c1f51
001c1f51loc_1c1f51:
001c1f51mov rbx, [rsp]
001c1f55mov [rax+8], rbx
001c1f59mov eax, 1
001c1f5eadd rsp, 24
001c1f62ret
001c1f63
001c1f63loc_1c1f63:
001c1f63call caml_ml_array_bound_error
001c1f68
001c1f68loc_1c1f68:
001c1f68push 36
001c1f6acall caml_call_realloc_stack
001c1f6fpop r10
001c1f71jmp 0x1c1ec2
001c1eb0

001c1f76
001c1f76 // align 0x10

001c1f80
001c1f80Stdlib.Buffer.add_int32_ne:
001c1f80lea r10, [rsp-344]
001c1f88cmp r10, [r14+40]
001c1f8cjb 0x1c2038
001c1f92
001c1f92loc_1c1f92:
001c1f92sub rsp, 24
001c1f96mov rdi, [rax+8]
001c1f9amov rsi, [rax]
001c1f9dmov rdx, rdi
001c1fa0add rdx, 8
001c1fa4mov [rsp], rdx
001c1fa8mov rcx, [rsi+8]
001c1faccmp rdx, rcx
001c1fafjle 0x1c2014
001c1fb1mov [rsp+8], rbx
001c1fb6mov [rsp+16], rax
001c1fbbmov ebx, 9
001c1fc0call Stdlib.Buffer.resize
001c1fc5mov rax, [rsp+8]
001c1fcamovsxd rdi, [rax+8]
001c1fcemov rax, [rsp+16]
001c1fd3mov rbx, [rax+8]
001c1fd7sar rbx, 1
001c1fdamov rsi, [rax]
001c1fddmov rsi, [rsi]
001c1fe0mov rdx, [rsi-8]
001c1fe4shr rdx, 10
001c1fe8lea rdx, [8*rdx-1]
001c1ff0movzx rcx, [rsi+rdx]
001c1ff5sub rdx, rcx
001c1ff8add rdx, -3
001c1ffcmov rcx, rdx
001c1fffsar rcx, 63
001c2003xor rcx, -1
001c2007and rcx, rdx
001c200acmp rcx, rbx
001c200djbe 0x1c2033
001c200fmov [rsi+rbx], edi
001c2012jmp 0x1c2021
001c2014
001c2014loc_1c2014:
001c2014movsxd rbx, [rbx+8]
001c2018sar rdi, 1
001c201bmov rsi, [rsi]
001c201emov [rsi+rdi], ebx
001c2021
001c2021loc_1c2021:
001c2021mov rbx, [rsp]
001c2025mov [rax+8], rbx
001c2029mov eax, 1
001c202eadd rsp, 24
001c2032ret
001c2033
001c2033loc_1c2033:
001c2033call caml_ml_array_bound_error
001c2038
001c2038loc_1c2038:
001c2038push 36
001c203acall caml_call_realloc_stack
001c203fpop r10
001c2041jmp 0x1c1f92
001c1f80

001c2046
001c2046 // align 0x10

001c2050
001c2050Stdlib.Buffer.add_int64_ne:
001c2050lea r10, [rsp-344]
001c2058cmp r10, [r14+40]
001c205cjb 0x1c210d
001c2062
001c2062loc_1c2062:
001c2062sub rsp, 24
001c2066mov rdi, [rax+8]
001c206amov rsi, [rax]
001c206dmov rdx, rdi
001c2070add rdx, 16
001c2074mov [rsp], rdx
001c2078mov rcx, [rsi+8]
001c207ccmp rdx, rcx
001c207fjle 0x1c20e8
001c2081mov [rsp+8], rbx
001c2086mov [rsp+16], rax
001c208bmov ebx, 17
001c2090call Stdlib.Buffer.resize
001c2095mov rax, [rsp+8]
001c209amov rdi, [rax+8]
001c209emov rax, [rsp+16]
001c20a3mov rbx, [rax+8]
001c20a7sar rbx, 1
001c20aamov rsi, [rax]
001c20admov rsi, [rsi]
001c20b0mov rdx, [rsi-8]
001c20b4shr rdx, 10
001c20b8lea rdx, [8*rdx-1]
001c20c0movzx rcx, [rsi+rdx]
001c20c5sub rdx, rcx
001c20c8add rdx, -7
001c20ccmov rcx, rdx
001c20cfsar rcx, 63
001c20d3xor rcx, -1
001c20d7and rcx, rdx
001c20dacmp rcx, rbx
001c20ddjbe 0x1c2108
001c20dfmov [rsi+rbx], rdi
001c20e3jmp 0x1c20f6
001c20e5
001c20e5 0f 1f 00 ...
001c20e8
001c20e8loc_1c20e8:
001c20e8mov rbx, [rbx+8]
001c20ecsar rdi, 1
001c20efmov rsi, [rsi]
001c20f2mov [rsi+rdi], rbx
001c20f6
001c20f6loc_1c20f6:
001c20f6mov rbx, [rsp]
001c20famov [rax+8], rbx
001c20femov eax, 1
001c2103add rsp, 24
001c2107ret
001c2108
001c2108loc_1c2108:
001c2108call caml_ml_array_bound_error
001c210d
001c210dloc_1c210d:
001c210dpush 36
001c210fcall caml_call_realloc_stack
001c2114pop r10
001c2116jmp 0x1c2062
001c2050

001c211b
001c211b // align 0x10

001c2120
001c2120Stdlib.Buffer.add_int16_le:
001c2120lea r10, [rsp-344]
001c2128cmp r10, [r14+40]
001c212cjb 0x1c21d8
001c2132
001c2132loc_1c2132:
001c2132sub rsp, 24
001c2136mov rdi, [rax+8]
001c213amov rsi, [rax]
001c213dmov rdx, rdi
001c2140add rdx, 4
001c2144mov [rsp], rdx
001c2148mov rcx, [rsi+8]
001c214ccmp rdx, rcx
001c214fjle 0x1c21b4
001c2151mov [rsp+8], rbx
001c2156mov [rsp+16], rax
001c215bmov ebx, 5
001c2160call Stdlib.Buffer.resize
001c2165mov rdi, [rsp+8]
001c216asar rdi, 1
001c216dmov rax, [rsp+16]
001c2172mov rbx, [rax+8]
001c2176sar rbx, 1
001c2179mov rsi, [rax]
001c217cmov rsi, [rsi]
001c217fmov rdx, [rsi-8]
001c2183shr rdx, 10
001c2187lea rdx, [8*rdx-1]
001c218fmovzx rcx, [rsi+rdx]
001c2194sub rdx, rcx
001c2197dec rdx
001c219amov rcx, rdx
001c219dsar rcx, 63
001c21a1xor rcx, -1
001c21a5and rcx, rdx
001c21a8cmp rcx, rbx
001c21abjbe 0x1c21d3
001c21admov [rsi+rbx], di
001c21b1jmp 0x1c21c1
001c21b3
001c21b3 90 .
001c21b4
001c21b4loc_1c21b4:
001c21b4sar rbx, 1
001c21b7sar rdi, 1
001c21bamov rsi, [rsi]
001c21bdmov [rsi+rdi], bx
001c21c1
001c21c1loc_1c21c1:
001c21c1mov rbx, [rsp]
001c21c5mov [rax+8], rbx
001c21c9mov eax, 1
001c21ceadd rsp, 24
001c21d2ret
001c21d3
001c21d3loc_1c21d3:
001c21d3call caml_ml_array_bound_error
001c21d8
001c21d8loc_1c21d8:
001c21d8push 36
001c21dacall caml_call_realloc_stack
001c21dfpop r10
001c21e1jmp 0x1c2132
001c2120