File hevea_f46f610a6b0078f4aa208dda361f21de574cc56ad64b32889301afc466d33979.elf
Function:
    001bf430
    001bf430Stdlib.Map.merge:
    001bf430lea r10, [rsp-376]
    001bf438cmp r10, [r14+40]
    001bf43cjb 0x1bf690
    001bf442
    001bf442loc_1bf442:
    001bf442sub rsp, 56
    001bf446test bl, 1
    001bf449je 0x1bf470
    001bf44btest dil, 1
    001bf44fje 0x1bf45c
    001bf451mov eax, 1
    001bf456add rsp, 56
    001bf45aret
    001bf45b
    001bf45b 90 .
    001bf45c
    001bf45cloc_1bf45c:
    001bf45cmov [rsp+48], rsi
    001bf461mov [rsp], rdi
    001bf465mov [rsp+40], rax
    001bf46ajmp 0x1bf570
    001bf46f
    001bf46f 90 .
    001bf470
    001bf470loc_1bf470:
    001bf470mov [rsp+48], rsi
    001bf475mov [rsp+40], rax
    001bf47amov rax, [rbx+8]
    001bf47etest dil, 1
    001bf482je 0x1bf48c
    001bf484mov edx, 1
    001bf489jmp 0x1bf490
    001bf48b
    001bf48b 90 .
    001bf48c
    001bf48cloc_1bf48c:
    001bf48cmov rdx, [rdi+32]
    001bf490
    001bf490loc_1bf490:
    001bf490mov rcx, [rbx+32]
    001bf494cmp rcx, rdx
    001bf497jl 0x1bf56c
    001bf49dmov [rsp+24], rax
    001bf4a2mov [rsp+8], rbx
    001bf4a7mov rsi, [rsi+40]
    001bf4abmov rbx, rdi
    001bf4aemov rdi, rsi
    001bf4b1call Stdlib.Map.split
    001bf4b6mov [rsp], rax
    001bf4bamov rdi, [rax+16]
    001bf4bemov rax, [rsp+8]
    001bf4c3mov rbx, [rax+24]
    001bf4c7mov rax, [rsp+40]
    001bf4ccmov rsi, [rsp+48]
    001bf4d1call Stdlib.Map.merge
    001bf4d6mov [rsp+32], rax
    001bf4dbsub r15, 16
    001bf4dfcmp r15, [r14]
    001bf4e2jb 0x1bf686
    001bf4e8
    001bf4e8loc_1bf4e8:
    001bf4e8lea rbx, [r15+8]
    001bf4ecmov [rbx-8], 1024
    001bf4f4mov rax, [rsp+8]
    001bf4f9mov rax, [rax+16]
    001bf4fdmov [rbx], rax
    001bf500mov rax, [rsp]
    001bf504mov rdi, [rax+8]
    001bf508mov rax, [rsp+24]
    001bf50dmov rsi, [rsp+40]
    001bf512call caml_apply3
    001bf517mov [rsp+16], rax
    001bf51cmov rax, [rsp]
    001bf520mov rdi, [rax]
    001bf523mov rax, [rsp+8]
    001bf528mov rbx, [rax]
    001bf52bmov rax, [rsp+40]
    001bf530mov rsi, [rsp+48]
    001bf535call Stdlib.Map.merge
    001bf53amov rbx, [rsp+16]
    001bf53ftest bl, 1
    001bf542je 0x1bf554
    001bf544mov rbx, [rsp+32]
    001bf549add rsp, 56
    001bf54djmp 0x1bf1e0
    001bf552
    001bf552 66 90 f.
    001bf554
    001bf554loc_1bf554:
    001bf554mov rdi, [rbx]
    001bf557mov rbx, [rsp+24]
    001bf55cmov rsi, [rsp+32]
    001bf561add rsp, 56
    001bf565jmp 0x1bf100
    001bf56a
    001bf56a 66 90 f.
    001bf56c
    001bf56cloc_1bf56c:
    001bf56cmov [rsp], rdi
    001bf570
    001bf570loc_1bf570:
    001bf570test dil, 1
    001bf574je 0x1bf5ac
    001bf576sub r15, 24
    001bf57acmp r15, [r14]
    001bf57djb 0x1bf67c
    001bf583
    001bf583loc_1bf583:
    001bf583lea rax, [r15+8]
    001bf587mov [rax-8], 2048
    001bf58flea rbx, [rip+0xb6c72]
    001bf596mov [rax], rbx
    001bf599lea rbx, [rip+0x188bc8]
    001bf5a0mov [rax+8], rbx
    001bf5a4call caml_raise_exn
    001bf5a9nop [rax]
    001bf5ac
    001bf5acloc_1bf5ac:
    001bf5acmov rax, [rdi+8]
    001bf5b0mov [rsp+24], rax
    001bf5b5mov rdi, [rsi+40]
    001bf5b9call Stdlib.Map.split
    001bf5bemov [rsp+8], rax
    001bf5c3mov rbx, [rsp]
    001bf5c7mov rdi, [rbx+24]
    001bf5cbmov rbx, [rax+16]
    001bf5cfmov rax, [rsp+40]
    001bf5d4mov rsi, [rsp+48]
    001bf5d9call Stdlib.Map.merge
    001bf5demov [rsp+32], rax
    001bf5e3sub r15, 16
    001bf5e7cmp r15, [r14]
    001bf5eajb 0x1bf672
    001bf5f0
    001bf5f0loc_1bf5f0:
    001bf5f0lea rdi, [r15+8]
    001bf5f4mov [rdi-8], 1024
    001bf5fcmov rax, [rsp]
    001bf600mov rax, [rax+16]
    001bf604mov [rdi], rax
    001bf607mov rax, [rsp+8]
    001bf60cmov rbx, [rax+8]
    001bf610mov rax, [rsp+24]
    001bf615mov rsi, [rsp+40]
    001bf61acall caml_apply3
    001bf61fmov [rsp+16], rax
    001bf624mov rax, [rsp]
    001bf628mov rdi, [rax]
    001bf62bmov rax, [rsp+8]
    001bf630mov rbx, [rax]
    001bf633mov rax, [rsp+40]
    001bf638mov rsi, [rsp+48]
    001bf63dcall Stdlib.Map.merge
    001bf642mov rbx, [rsp+16]
    001bf647test bl, 1
    001bf64aje 0x1bf65c
    001bf64cmov rbx, [rsp+32]
    001bf651add rsp, 56
    001bf655jmp 0x1bf1e0
    001bf65a
    001bf65a 66 90 f.
    001bf65c
    001bf65cloc_1bf65c:
    001bf65cmov rdi, [rbx]
    001bf65fmov rbx, [rsp+24]
    001bf664mov rsi, [rsp+32]
    001bf669add rsp, 56
    001bf66djmp 0x1bf100
    001bf672
    001bf672loc_1bf672:
    001bf672call caml_call_gc
    001bf677jmp 0x1bf5f0
    001bf67c
    001bf67cloc_1bf67c:
    001bf67ccall caml_call_gc
    001bf681jmp 0x1bf583
    001bf686
    001bf686loc_1bf686:
    001bf686call caml_call_gc
    001bf68bjmp 0x1bf4e8
    001bf690
    001bf690loc_1bf690:
    001bf690push 40
    001bf692call caml_call_realloc_stack
    001bf697pop r10
    001bf699jmp 0x1bf442
    001bf430
    001bf69e
    001bf69e // align 0x10
    001bf6a0
    001bf6a0Stdlib.Map.union:
    001bf6a0lea r10, [rsp-384]
    001bf6a8cmp r10, [r14+40]
    001bf6acjb 0x1bf8bd
    001bf6b2
    001bf6b2loc_1bf6b2:
    001bf6b2sub rsp, 64
    001bf6b6test bl, 1
    001bf6b9je 0x1bf6c4
    001bf6bbmov rax, rdi
    001bf6bejmp 0x1bf8b8
    001bf6c3
    001bf6c3 90 .
    001bf6c4
    001bf6c4loc_1bf6c4:
    001bf6c4test dil, 1
    001bf6c8je 0x1bf6d4
    001bf6camov rax, rbx
    001bf6cdjmp 0x1bf8b8
    001bf6d2
    001bf6d2 66 90 f.
    001bf6d4
    001bf6d4loc_1bf6d4:
    001bf6d4mov [rsp+48], rsi
    001bf6d9mov [rsp+56], rax
    001bf6demov rdx, [rdi+16]
    001bf6e2mov rax, [rdi+8]
    001bf6e6mov rcx, [rbx+16]
    001bf6eamov r8, [rbx+8]
    001bf6eemov r9, [rdi+32]
    001bf6f2mov r12, [rbx+32]
    001bf6f6cmp r12, r9
    001bf6f9jl 0x1bf7e0
    001bf6ffmov [rsp+32], r8
    001bf704mov [rsp+40], rcx
    001bf709mov [rsp+8], rbx
    001bf70emov rsi, [rsi+40]
    001bf712mov rax, r8
    001bf715mov rbx, rdi
    001bf718mov rdi, rsi
    001bf71bcall Stdlib.Map.split
    001bf720mov [rsp], rax
    001bf724mov rbx, [rax+8]
    001bf728mov [rsp+16], rbx
    001bf72dmov rdi, [rax]
    001bf730mov rax, [rsp+8]
    001bf735mov rbx, [rax]
    001bf738mov rax, [rsp+56]
    001bf73dmov rsi, [rsp+48]
    001bf742call Stdlib.Map.union
    001bf747mov [rsp+24], rax
    001bf74cmov rax, [rsp]
    001bf750mov rdi, [rax+16]
    001bf754mov rax, [rsp+8]
    001bf759mov rbx, [rax+24]
    001bf75dmov rax, [rsp+56]
    001bf762mov rsi, [rsp+48]
    001bf767call Stdlib.Map.union
    001bf76cmov rsi, rax
    001bf76fmov rax, [rsp+16]
    001bf774test al, 1
    001bf776je 0x1bf790
    001bf778mov rax, [rsp+24]
    001bf77dmov rbx, [rsp+32]
    001bf782mov rdi, [rsp+40]
    001bf787add rsp, 64
    001bf78bjmp 0x1bf100
    001bf790
    001bf790loc_1bf790:
    001bf790mov [rsp], rsi
    001bf794mov rdi, [rax]
    001bf797mov rax, [rsp+32]
    001bf79cmov rbx, [rsp+40]
    001bf7a1mov rsi, [rsp+56]
    001bf7a6call caml_apply3
    001bf7abtest al, 1
    001bf7adje 0x1bf7c4
    001bf7afmov rax, [rsp+24]
    001bf7b4mov rbx, [rsp]
    001bf7b8add rsp, 64
    001bf7bcjmp 0x1bf1e0
    001bf7c1
    001bf7c1 0f 1f 00 ...
    001bf7c4
    001bf7c4loc_1bf7c4:
    001bf7c4mov rdi, [rax]
    001bf7c7mov rax, [rsp+24]
    001bf7ccmov rbx, [rsp+32]
    001bf7d1mov rsi, [rsp]
    001bf7d5add rsp, 64
    001bf7d9jmp 0x1bf100
    001bf7de
    001bf7de 66 90 f.
    001bf7e0
    001bf7e0loc_1bf7e0:
    001bf7e0mov [rsp+32], rax
    001bf7e5mov [rsp+40], rdx
    001bf7eamov [rsp], rdi
    001bf7eemov rdi, [rsi+40]
    001bf7f2call Stdlib.Map.split
    001bf7f7mov [rsp+8], rax
    001bf7fcmov rbx, [rax+8]
    001bf800mov [rsp+16], rbx
    001bf805mov rbx, [rsp]
    001bf809mov rdi, [rbx]
    001bf80cmov rbx, [rax]
    001bf80fmov rax, [rsp+56]
    001bf814mov rsi, [rsp+48]
    001bf819call Stdlib.Map.union
    001bf81emov [rsp+24], rax
    001bf823mov rax, [rsp]
    001bf827mov rdi, [rax+24]
    001bf82bmov rax, [rsp+8]
    001bf830mov rbx, [rax+16]
    001bf834mov rax, [rsp+56]
    001bf839mov rsi, [rsp+48]
    001bf83ecall Stdlib.Map.union
    001bf843mov rsi, rax
    001bf846mov rax, [rsp+16]
    001bf84btest al, 1
    001bf84dje 0x1bf868
    001bf84fmov rax, [rsp+24]
    001bf854mov rbx, [rsp+32]
    001bf859mov rdi, [rsp+40]
    001bf85eadd rsp, 64
    001bf862jmp 0x1bf100
    001bf867
    001bf867 90 .
    001bf868
    001bf868loc_1bf868:
    001bf868mov [rsp], rsi
    001bf86cmov rbx, [rax]
    001bf86fmov rax, [rsp+32]
    001bf874mov rdi, [rsp+40]
    001bf879mov rsi, [rsp+56]
    001bf87ecall caml_apply3
    001bf883test al, 1
    001bf885je 0x1bf89c
    001bf887mov rax, [rsp+24]
    001bf88cmov rbx, [rsp]
    001bf890add rsp, 64
    001bf894jmp 0x1bf1e0
    001bf899
    001bf899 0f 1f 00 ...
    001bf89c
    001bf89cloc_1bf89c:
    001bf89cmov rdi, [rax]
    001bf89fmov rax, [rsp+24]
    001bf8a4mov rbx, [rsp+32]
    001bf8a9mov rsi, [rsp]
    001bf8adadd rsp, 64
    001bf8b1jmp 0x1bf100
    001bf8b6
    001bf8b6 66 90 f.
    001bf8b8
    001bf8b8loc_1bf8b8:
    001bf8b8add rsp, 64
    001bf8bcret
    001bf8bd
    001bf8bdloc_1bf8bd:
    001bf8bdpush 41
    001bf8bfcall caml_call_realloc_stack
    001bf8c4pop r10
    001bf8c6jmp 0x1bf6b2
    001bf6a0
    001bf8cb
    001bf8cb // align 0x10
    001bf8d0
    001bf8d0Stdlib.Map.filter:
    001bf8d0lea r10, [rsp-384]
    001bf8d8cmp r10, [r14+40]
    001bf8dcjb 0x1bf9ad
    001bf8e2
    001bf8e2loc_1bf8e2:
    001bf8e2sub rsp, 64
    001bf8e6test bl, 1
    001bf8e9je 0x1bf8f8
    001bf8ebmov eax, 1
    001bf8f0add rsp, 64
    001bf8f4ret
    001bf8f5
    001bf8f5 0f 1f 00 ...
    001bf8f8
    001bf8f8loc_1bf8f8:
    001bf8f8mov [rsp+56], rbx
    001bf8fdmov [rsp], rax
    001bf901mov rdi, [rbx+24]
    001bf905mov [rsp+48], rdi
    001bf90amov rdi, [rbx+16]
    001bf90emov [rsp+24], rdi
    001bf913mov rdi, [rbx+8]
    001bf917mov [rsp+16], rdi
    001bf91cmov rbx, [rbx]
    001bf91fmov [rsp+40], rbx
    001bf924call Stdlib.Map.filter
    001bf929mov [rsp+32], rax
    001bf92emov rax, [rsp+16]
    001bf933mov rbx, [rsp+24]
    001bf938mov rdi, [rsp]
    001bf93ccall caml_apply2
    001bf941mov [rsp+8], rax
    001bf946mov rax, [rsp]
    001bf94amov rbx, [rsp+48]
    001bf94fcall Stdlib.Map.filter
    001bf954mov rsi, rax
    001bf957mov rax, [rsp+8]
    001bf95ccmp rax, 1
    001bf960je 0x1bf99c
    001bf962mov rax, [rsp+32]
    001bf967mov rbx, [rsp+40]
    001bf96ccmp rbx, rax
    001bf96fjne 0x1bf988
    001bf971mov rbx, [rsp+48]
    001bf976cmp rbx, rsi
    001bf979jne 0x1bf988
    001bf97bmov rax, [rsp+56]
    001bf980add rsp, 64
    001bf984ret
    001bf985
    001bf985 0f 1f 00 ...
    001bf988
    001bf988loc_1bf988:
    001bf988mov rbx, [rsp+16]
    001bf98dmov rdi, [rsp+24]
    001bf992add rsp, 64
    001bf996jmp 0x1bf100
    001bf99b
    001bf99b 90 .
    001bf99c
    001bf99cloc_1bf99c:
    001bf99cmov rax, [rsp+32]
    001bf9a1mov rbx, rsi
    001bf9a4add rsp, 64
    001bf9a8jmp 0x1bf1e0
    001bf9ad
    001bf9adloc_1bf9ad:
    001bf9adpush 41
    001bf9afcall caml_call_realloc_stack
    001bf9b4pop r10
    001bf9b6jmp 0x1bf8e2
    001bf8d0
    001bf9bb
    001bf9bb // align 0x10
    001bf9c0
    001bf9c0Stdlib.Map.filter_map:
    001bf9c0lea r10, [rsp-360]
    001bf9c8cmp r10, [r14+40]
    001bf9ccjb 0x1bfa6a
    001bf9d2
    001bf9d2loc_1bf9d2:
    001bf9d2sub rsp, 40
    001bf9d6test bl, 1
    001bf9d9je 0x1bf9e8
    001bf9dbmov eax, 1
    001bf9e0add rsp, 40
    001bf9e4ret
    001bf9e5
    001bf9e5 0f 1f 00 ...
    001bf9e8
    001bf9e8loc_1bf9e8:
    001bf9e8mov [rsp], rbx
    001bf9ecmov [rsp+8], rax
    001bf9f1mov rdi, [rbx+8]
    001bf9f5mov [rsp+24], rdi
    001bf9famov rbx, [rbx]
    001bf9fdcall Stdlib.Map.filter_map
    001bfa02mov [rsp+32], rax
    001bfa07mov rax, [rsp]
    001bfa0bmov rbx, [rax+16]
    001bfa0fmov rax, [rsp+24]
    001bfa14mov rdi, [rsp+8]
    001bfa19call caml_apply2
    001bfa1emov [rsp+16], rax
    001bfa23mov rax, [rsp]
    001bfa27mov rbx, [rax+24]
    001bfa2bmov rax, [rsp+8]
    001bfa30call Stdlib.Map.filter_map
    001bfa35mov rsi, rax
    001bfa38mov rax, [rsp+16]
    001bfa3dtest al, 1
    001bfa3fje 0x1bfa54
    001bfa41mov rax, [rsp+32]
    001bfa46mov rbx, rsi
    001bfa49add rsp, 40
    001bfa4djmp 0x1bf1e0
    001bfa52
    001bfa52 66 90 f.
    001bfa54
    001bfa54loc_1bfa54:
    001bfa54mov rdi, [rax]
    001bfa57mov rax, [rsp+32]
    001bfa5cmov rbx, [rsp+24]
    001bfa61add rsp, 40
    001bfa65jmp 0x1bf100
    001bfa6a
    001bfa6aloc_1bfa6a:
    001bfa6apush 38
    001bfa6ccall caml_call_realloc_stack
    001bfa71pop r10
    001bfa73jmp 0x1bf9d2
    001bf9c0
    001bfa78
    001bfa78 // align 0x10
    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