Similarity

0017cec0
0017cec0camlLexstate.scan_arg_855:
0017cec0lea r10, [rsp-360]
0017cec8cmp r10, [r14+40]
0017ceccjb 0x17d073
0017ced2
0017ced2loc_17ced2:
0017ced2sub rsp, 40
0017ced6cmp r15, [r14]
0017ced9jbe 0x17d064
0017cedf
0017cedfloc_17cedf:
0017cedflea rdi, [rip+0x199aba]
0017cee6mov rsi, [rdi+728]
0017ceedmov rsi, [rsi]
0017cef0test sil, 1
0017cef4je 0x17cf08
0017cef6mov rax, [rdi+112]
0017cefamov rsp, [r14+48]
0017cefepop [r14+48]
0017cf02pop r11
0017cf04jmp r11
0017cf07nop
0017cf08
0017cf08loc_17cf08:
0017cf08mov rdi, [rsi]
0017cf0bmov rsi, [rdi-8]
0017cf0fshr rsi, 9
0017cf13or rsi, 1
0017cf17cmp rbx, rsi
0017cf1ajl 0x17cfc8
0017cf20lea rax, [rip+0x1ad149]
0017cf27mov rax, [rax+80]
0017cf2bmov rax, [rax]
0017cf2ecmp rax, 3
0017cf32jle 0x17cf87
0017cf34mov rax, rbx
0017cf37add rax, 2
0017cf3bcall camlStdlib.string_of_int_175
0017cf40lea rbx, [rip+0x19a341]
0017cf47call camlStdlib.$5e_139
0017cf4cmov rbx, rax
0017cf4flea rax, [rip+0x19a34a]
0017cf56call camlStdlib.$5e_139
0017cf5bmov rbx, rax
0017cf5elea rax, [rip+0x1b06b3]
0017cf65mov rax, [rax+312]
0017cf6ccall camlStdlib.output_string_253
0017cf71lea rax, [rip+0x199a28]
0017cf78mov rax, [rax+728]
0017cf7fmov rax, [rax]
0017cf82call camlLexstate.pretty_subst_612
0017cf87
0017cf87loc_17cf87:
0017cf87sub r15, 24
0017cf8bcmp r15, [r14]
0017cf8ejb 0x17d05a
0017cf94
0017cf94loc_17cf94:
0017cf94lea rax, [r15+8]
0017cf98mov [rax-8], 2048
0017cfa0lea rbx, [rip+0x1999f9]
0017cfa7mov rbx, [rbx+104]
0017cfabmov [rax], rbx
0017cfaelea rbx, [rip+0x19a2ab]
0017cfb5mov [rax+8], rbx
0017cfb9mov rsp, [r14+48]
0017cfbdpop [r14+48]
0017cfc1pop r11
0017cfc3jmp r11
0017cfc6nop
0017cfc8
0017cfc8loc_17cfc8:
0017cfc8mov [rsp], rax
0017cfccmov rax, [rdi-8]
0017cfd0shr rax, 9
0017cfd4cmp rax, rbx
0017cfd7jbe 0x17d06e
0017cfddmov rax, [rdi+4*rbx-4]
0017cfe2mov [rsp+8], rax
0017cfe7lea rdi, [rip+0x1ad082]
0017cfeemov rdi, [rdi+80]
0017cff2mov rdi, [rdi]
0017cff5cmp rdi, 3
0017cff9jle 0x17d048
0017cffbmov rax, [rax]
0017cffemov [rsp+32], rax
0017d003lea rax, [rip+0x199996]
0017d00amov rax, [rax]
0017d00dmov [rsp+24], rax
0017d012mov [rsp+16], rbx
0017d017lea rbx, [rip+0x19a16a]
0017d01elea rax, [rip+0x1b05f3]
0017d025mov rax, [rax+312]
0017d02ccall Stdlib.Printf.fprintf
0017d031mov rsi, rax
0017d034mov rax, [rsp+16]
0017d039mov rbx, [rsp+24]
0017d03emov rdi, [rsp+32]
0017d043call caml_apply3
0017d048
0017d048loc_17d048:
0017d048mov rbx, [rsp]
0017d04cmov rdi, [rbx]
0017d04fmov rax, [rsp+8]
0017d054add rsp, 40
0017d058jmp rdi
0017d05a
0017d05aloc_17d05a:
0017d05acall caml_call_gc
0017d05fjmp 0x17cf94
0017d064
0017d064loc_17d064:
0017d064call caml_call_gc
0017d069jmp 0x17cedf
0017d06e
0017d06eloc_17d06e:
0017d06ecall caml_ml_array_bound_error
0017d073
0017d073loc_17d073:
0017d073push 38
0017d075call caml_call_realloc_stack
0017d07apop r10
0017d07cjmp 0x17ced2
0017cec0

0017d081
0017d081 // align 0x10

0017d090
0017d090camlLexstate.scan_body_856:
0017d090lea r10, [rsp-328]
0017d098cmp r10, [r14+40]
0017d09cjb 0x17d133
0017d0a2
0017d0a2loc_17d0a2:
0017d0a2sub rsp, 8
0017d0a6mov r12, rax
0017d0a9mov r13, rbx
0017d0acmov rsi, rdi
0017d0afcmp r15, [r14]
0017d0b2jbe 0x17d12c
0017d0b4
0017d0b4loc_17d0b4:
0017d0b4movzx rax, [r13-8]
0017d0b9test rax, rax
0017d0bcjne 0x17d11c
0017d0belea rax, [rip+0x1998db]
0017d0c5mov rdi, [rax+728]
0017d0ccmov rax, [rdi]
0017d0cfmov [rsp], rax
0017d0d3mov rbx, rsp
0017d0d6mov rsp, [r14+64]
0017d0dacall caml_modify
0017d0dfmov rsp, rbx
0017d0e2mov rdi, [r12]
0017d0e6mov rax, r13
0017d0e9mov rbx, r12
0017d0eccall rdi
0017d0eemov r12, rax
0017d0f1lea rax, [rip+0x1998a8]
0017d0f8mov rdi, [rax+728]
0017d0ffmov rsi, [rsp]
0017d103mov rbx, rsp
0017d106mov rsp, [r14+64]
0017d10acall caml_modify
0017d10fmov rsp, rbx
0017d112mov rax, r12
0017d115add rsp, 8
0017d119ret
0017d11anop
0017d11c
0017d11cloc_17d11c:
0017d11cmov rdi, [r12]
0017d120mov rax, r13
0017d123mov rbx, r12
0017d126add rsp, 8
0017d12ajmp rdi
0017d12c
0017d12cloc_17d12c:
0017d12ccall caml_call_gc
0017d131jmp 0x17d0b4
0017d133
0017d133loc_17d133:
0017d133push 34
0017d135call caml_call_realloc_stack
0017d13apop r10
0017d13cjmp 0x17d0a2
0017d090

0017d141
0017d141 // align 0x10

0017d150
0017d150camlLexstate.record_lexbuf_869:
0017d150mov r12, rax
0017d153lea rax, [rip+0x199846]
0017d15amov rdi, [rax+736]
0017d161sub r15, 24
0017d165cmp r15, [r14]
0017d168jb 0x17d1d8
0017d16a
0017d16aloc_17d16a:
0017d16alea rsi, [r15+8]
0017d16emov [rsi-8], 2048
0017d176mov [rsi], rbx
0017d179mov rax, [rdi]
0017d17cmov [rsi+8], rax
0017d180mov rbx, rsp
0017d183mov rsp, [r14+64]
0017d187call caml_modify
0017d18cmov rsp, rbx
0017d18flea rax, [rip+0x19980a]
0017d196mov rdi, [rax+344]
0017d19dsub r15, 24
0017d1a1cmp r15, [r14]
0017d1a4jb 0x17d1d1
0017d1a6
0017d1a6loc_17d1a6:
0017d1a6lea rsi, [r15+8]
0017d1aamov [rsi-8], 2048
0017d1b2mov [rsi], r12
0017d1b5mov rax, [rdi]
0017d1b8mov [rsi+8], rax
0017d1bcmov rbx, rsp
0017d1bfmov rsp, [r14+64]
0017d1c3call caml_modify
0017d1c8mov rsp, rbx
0017d1cbmov eax, 1
0017d1d0ret
0017d1d1
0017d1d1loc_17d1d1:
0017d1d1call caml_call_gc
0017d1d6jmp 0x17d1a6
0017d1d8
0017d1d8loc_17d1d8:
0017d1d8call caml_call_gc
0017d1ddjmp 0x17d16a
0017d150

0017d1df
0017d1df // align 0x10

0017d1e0
0017d1e0camlLexstate.previous_lexbuf_870:
0017d1e0lea r10, [rsp-328]
0017d1e8cmp r10, [r14+40]
0017d1ecjb 0x17d245
0017d1ee
0017d1eeloc_17d1ee:
0017d1eesub rsp, 8
0017d1f2lea rax, [rip+0x1997a7]
0017d1f9mov rax, [rax+344]
0017d200call camlMyStack.pop_292
0017d205mov [rsp], rax
0017d209lea rax, [rip+0x199790]
0017d210mov rax, [rax+736]
0017d217call camlMyStack.pop_292
0017d21clea rbx, [rip+0x19977d]
0017d223mov rdi, [rbx+728]
0017d22amov rsi, rax
0017d22dmov rbx, rsp
0017d230mov rsp, [r14+64]
0017d234call caml_modify
0017d239mov rsp, rbx
0017d23cmov rax, [rsp]
0017d240add rsp, 8
0017d244ret
0017d245
0017d245loc_17d245:
0017d245push 34
0017d247call caml_call_realloc_stack
0017d24cpop r10
0017d24ejmp 0x17d1ee
0017d1e0

0017d250
0017d250camlLexstate.top_lexstate_878:
0017d250lea rax, [rip+0x199749]
0017d257mov rax, [rax+776]
0017d25emov rax, [rax]
0017d261and rax, 1
0017d265lea rax, [rax+rax+1]
0017d26aret
0017d250

0017d26b
0017d26b // align 0x10

0017d270
0017d270camlLexstate.save_lexstate_881:
0017d270lea rax, [rip+0x199729]
0017d277mov rdi, [rax+736]
0017d27emov r12, [rdi]
0017d281mov rax, [rax+728]
0017d288mov rax, [rax]
0017d28bsub r15, 24
0017d28fcmp r15, [r14]
0017d292jb 0x17d358
0017d298
0017d298loc_17d298:
0017d298lea rsi, [r15+8]
0017d29cmov [rsi-8], 2048
0017d2a4mov [rsi], rax
0017d2a7mov rax, [rdi]
0017d2aamov [rsi+8], rax
0017d2aemov rbx, rsp
0017d2b1mov rsp, [r14+64]
0017d2b5call caml_modify
0017d2bamov rsp, rbx
0017d2bdsub r15, 48
0017d2c1cmp r15, [r14]
0017d2c4jb 0x17d34e
0017d2ca
0017d2caloc_17d2ca:
0017d2calea rax, [r15+8]
0017d2ceadd rax, 24
0017d2d2mov [rax-8], 2048
0017d2dalea rbx, [rip+0x1996bf]
0017d2e1mov rdi, [rbx+344]
0017d2e8mov rdi, [rdi]
0017d2ebmov [rax], rdi
0017d2eemov rdi, [rbx+736]
0017d2f5mov rdi, [rdi]
0017d2f8mov [rax+8], rdi
0017d2fcmov rdi, [rbx+776]
0017d303lea rsi, [rax-24]
0017d307mov [rsi-8], 2048
0017d30fmov [rsi], rax
0017d312mov rax, [rdi]
0017d315mov [rsi+8], rax
0017d319mov rbx, rsp
0017d31cmov rsp, [r14+64]
0017d320call caml_modify
0017d325mov rsp, rbx
0017d328lea rax, [rip+0x199671]
0017d32fmov rdi, [rax+736]
0017d336mov rsi, r12
0017d339mov rbx, rsp
0017d33cmov rsp, [r14+64]
0017d340call caml_modify
0017d345mov rsp, rbx
0017d348mov eax, 1
0017d34dret
0017d34e
0017d34eloc_17d34e:
0017d34ecall caml_call_gc
0017d353jmp 0x17d2ca
0017d358
0017d358loc_17d358:
0017d358call caml_call_gc
0017d35djmp 0x17d298
0017d270

0017d362
0017d362 // align 0x10

0017d370
0017d370camlLexstate.restore_lexstate_882:
0017d370lea r10, [rsp-320]
0017d378cmp r10, [r14+40]
0017d37cjb 0x17d414
0017d382
0017d382loc_17d382:
0017d382lea rax, [rip+0x199617]
0017d389mov rax, [rax+776]
0017d390call camlMyStack.pop_292
0017d395mov r12, rax
0017d398mov rsi, [r12]
0017d39clea rax, [rip+0x1995fd]
0017d3a3mov rdi, [rax+344]
0017d3aamov rbx, rsp
0017d3admov rsp, [r14+64]
0017d3b1call caml_modify
0017d3b6mov rsp, rbx
0017d3b9mov rsi, [r12+8]
0017d3belea rax, [rip+0x1995db]
0017d3c5mov rdi, [rax+736]
0017d3ccmov rbx, rsp
0017d3cfmov rsp, [r14+64]
0017d3d3call caml_modify
0017d3d8mov rsp, rbx
0017d3dblea rax, [rip+0x1995be]
0017d3e2mov rax, [rax+736]
0017d3e9call camlMyStack.pop_292
0017d3eelea rbx, [rip+0x1995ab]
0017d3f5mov rdi, [rbx+728]
0017d3fcmov rsi, rax
0017d3ffmov rbx, rsp
0017d402mov rsp, [r14+64]
0017d406call caml_modify
0017d40bmov rsp, rbx
0017d40emov eax, 1
0017d413ret
0017d414
0017d414loc_17d414:
0017d414push 33
0017d416call caml_call_realloc_stack
0017d41bpop r10
0017d41djmp 0x17d382
0017d370

0017d422
0017d422 // align 0x10

0017d430
0017d430camlLexstate.save_flags_890:
0017d430lea rax, [rip+0x199569]
0017d437mov rbx, [rax+136]
0017d43emov rbx, [rbx]
0017d441mov rdi, [rax+448]
0017d448sub r15, 24
0017d44ccmp r15, [r14]
0017d44fjb 0x17d4c9
0017d451
0017d451loc_17d451:
0017d451lea rsi, [r15+8]
0017d455mov [rsi-8], 2048
0017d45dmov [rsi], rbx
0017d460mov rax, [rdi]
0017d463mov [rsi+8], rax
0017d467mov rbx, rsp
0017d46amov rsp, [r14+64]
0017d46ecall caml_modify
0017d473mov rsp, rbx
0017d476lea rax, [rip+0x199523]
0017d47dmov rbx, [rax+144]
0017d484mov rbx, [rbx]
0017d487mov rdi, [rax+440]
0017d48esub r15, 24
0017d492cmp r15, [r14]
0017d495jb 0x17d4c2
0017d497
0017d497loc_17d497:
0017d497lea rsi, [r15+8]
0017d49bmov [rsi-8], 2048
0017d4a3mov [rsi], rbx
0017d4a6mov rax, [rdi]
0017d4a9mov [rsi+8], rax
0017d4admov rbx, rsp
0017d4b0mov rsp, [r14+64]
0017d4b4call caml_modify
0017d4b9mov rsp, rbx
0017d4bcmov eax, 1
0017d4c1ret
0017d4c2
0017d4c2loc_17d4c2:
0017d4c2call caml_call_gc
0017d4c7jmp 0x17d497
0017d4c9
0017d4c9loc_17d4c9:
0017d4c9call caml_call_gc
0017d4cejmp 0x17d451
0017d430

0017d4d0
0017d4d0camlLexstate.restore_flags_891:
0017d4d0lea r10, [rsp-320]
0017d4d8cmp r10, [r14+40]
0017d4dcjb 0x17d525
0017d4de
0017d4deloc_17d4de:
0017d4delea rax, [rip+0x1994bb]
0017d4e5mov rax, [rax+440]
0017d4eccall camlMyStack.pop_292
0017d4f1lea rbx, [rip+0x1994a8]
0017d4f8mov rdi, [rbx+144]
0017d4ffmov [rdi], rax
0017d502mov rax, [rbx+448]
0017d509call camlMyStack.pop_292
0017d50elea rbx, [rip+0x19948b]
0017d515mov rbx, [rbx+136]
0017d51cmov [rbx], rax
0017d51fmov eax, 1
0017d524ret
0017d525
0017d525loc_17d525:
0017d525push 33
0017d527call caml_call_realloc_stack
0017d52cpop r10
0017d52ejmp 0x17d4de
0017d4d0

0017d530
0017d530camlLexstate.check_lexstate_897:
0017d530lea r10, [rsp-328]
0017d538cmp r10, [r14+40]
0017d53cjb 0x17d5c7
0017d542
0017d542loc_17d542:
0017d542sub rsp, 8
0017d546mov eax, 1
0017d54bcall camlLexstate.save_lexstate_881
0017d550mov eax, 1
0017d555call camlLexstate.save_flags_890
0017d55asub r15, 32
0017d55ecmp r15, [r14]
0017d561jb 0x17d5c0
0017d563
0017d563loc_17d563:
0017d563lea rax, [r15+8]
0017d567mov [rsp], rax
0017d56bmov [rax-8], 3072
0017d573lea rbx, [rip+0x199426]
0017d57amov rdi, [rbx+776]
0017d581mov rdi, [rdi]
0017d584mov [rax], rdi
0017d587mov rdi, [rbx+448]
0017d58emov rdi, [rdi]
0017d591mov [rax+8], rdi
0017d595mov rbx, [rbx+440]
0017d59cmov rbx, [rbx]
0017d59fmov [rax+16], rbx
0017d5a3mov eax, 1
0017d5a8call camlLexstate.restore_lexstate_882
0017d5admov eax, 1
0017d5b2call camlLexstate.restore_flags_891
0017d5b7mov rax, [rsp]
0017d5bbadd rsp, 8
0017d5bfret
0017d5c0
0017d5c0loc_17d5c0:
0017d5c0call caml_call_gc
0017d5c5jmp 0x17d563
0017d5c7
0017d5c7loc_17d5c7:
0017d5c7push 34
0017d5c9call caml_call_realloc_stack
0017d5cepop r10
0017d5d0jmp 0x17d542
0017d530

0017d5d5
0017d5d5 // align 0x10

0017d5e0
0017d5e0camlLexstate.hot_lexstate_898:
0017d5e0lea r10, [rsp-320]
0017d5e8cmp r10, [r14+40]
0017d5ecjb 0x17d668
0017d5ee
0017d5eeloc_17d5ee:
0017d5eemov r12, rbx
0017d5f1mov r13, rdi
0017d5f4lea rbx, [rip+0x1993a5]
0017d5fbmov rdi, [rbx+776]
0017d602mov rsi, rax
0017d605mov rbx, rsp
0017d608mov rsp, [r14+64]
0017d60ccall caml_modify
0017d611mov rsp, rbx
0017d614lea rax, [rip+0x199385]
0017d61bmov rdi, [rax+448]
0017d622mov rsi, r12
0017d625mov rbx, rsp
0017d628mov rsp, [r14+64]
0017d62ccall caml_modify
0017d631mov rsp, rbx
0017d634lea rax, [rip+0x199365]
0017d63bmov rdi, [rax+440]
0017d642mov rsi, r13
0017d645mov rbx, rsp
0017d648mov rsp, [r14+64]
0017d64ccall caml_modify
0017d651mov rsp, rbx
0017d654mov eax, 1
0017d659call camlLexstate.restore_lexstate_882
0017d65emov eax, 1
0017d663jmp 0x17d4d0
0017d668
0017d668loc_17d668:
0017d668push 33
0017d66acall caml_call_realloc_stack
0017d66fpop r10
0017d671jmp 0x17d5ee
0017d5e0

0017d676
0017d676 // align 0x10

0017d680
0017d680camlLexstate.start_lexstate_907:
0017d680lea r10, [rsp-320]
0017d688cmp r10, [r14+40]
0017d68cjb 0x17d6e2
0017d68e
0017d68eloc_17d68e:
0017d68emov eax, 1
0017d693call camlLexstate.save_lexstate_881
0017d698lea rax, [rip+0x199301]
0017d69fmov rdi, [rax+344]
0017d6a6mov esi, 1
0017d6abmov rbx, rsp
0017d6aemov rsp, [r14+64]
0017d6b2call caml_modify
0017d6b7mov rsp, rbx
0017d6balea rax, [rip+0x1992df]
0017d6c1mov rdi, [rax+736]
0017d6c8mov esi, 1
0017d6cdmov rbx, rsp
0017d6d0mov rsp, [r14+64]
0017d6d4call caml_modify
0017d6d9mov rsp, rbx
0017d6dcmov eax, 1
0017d6e1ret
0017d6e2
0017d6e2loc_17d6e2:
0017d6e2push 33
0017d6e4call caml_call_realloc_stack
0017d6e9pop r10
0017d6ebjmp 0x17d68e
0017d680

0017d6ed
0017d6ed // align 0x10

0017d6f0
0017d6f0camlLexstate.start_lexstate_subst_910:
0017d6f0lea r10, [rsp-328]
0017d6f8cmp r10, [r14+40]
0017d6fcjb 0x17d73b
0017d6fe
0017d6feloc_17d6fe:
0017d6fesub rsp, 8
0017d702mov [rsp], rax
0017d706mov eax, 1
0017d70bcall camlLexstate.start_lexstate_907
0017d710lea rax, [rip+0x199289]
0017d717mov rdi, [rax+728]
0017d71emov rsi, [rsp]
0017d722mov rbx, rsp
0017d725mov rsp, [r14+64]
0017d729call caml_modify
0017d72emov rsp, rbx
0017d731mov eax, 1
0017d736add rsp, 8
0017d73aret
0017d73b
0017d73bloc_17d73b:
0017d73bpush 34
0017d73dcall caml_call_realloc_stack
0017d742pop r10
0017d744jmp 0x17d6fe
0017d6f0

0017d746
0017d746 // align 0x10

0017d750
0017d750camlLexstate.start_normal_914:
0017d750lea r10, [rsp-328]
0017d758cmp r10, [r14+40]
0017d75cjb 0x17d7c1
0017d75e
0017d75eloc_17d75e:
0017d75esub rsp, 8
0017d762mov [rsp], rax
0017d766mov eax, 1
0017d76bcall camlLexstate.start_lexstate_907
0017d770mov eax, 1
0017d775call camlLexstate.save_flags_890
0017d77alea rax, [rip+0x19921f]
0017d781mov rbx, [rax+136]
0017d788mov [rbx], 1
0017d78fmov rbx, [rax+144]
0017d796mov [rbx], 1
0017d79dmov rdi, [rax+728]
0017d7a4mov rsi, [rsp]
0017d7a8mov rbx, rsp
0017d7abmov rsp, [r14+64]
0017d7afcall caml_modify
0017d7b4mov rsp, rbx
0017d7b7mov eax, 1
0017d7bcadd rsp, 8
0017d7c0ret
0017d7c1
0017d7c1loc_17d7c1:
0017d7c1push 34
0017d7c3call caml_call_realloc_stack
0017d7c8pop r10
0017d7cajmp 0x17d75e
0017d750

0017d7cc
0017d7cc // align 0x10

0017d7d0
0017d7d0camlLexstate.end_normal_915:
0017d7d0lea r10, [rsp-320]
0017d7d8cmp r10, [r14+40]
0017d7dcjb 0x17d7f2
0017d7de
0017d7deloc_17d7de:
0017d7demov eax, 1
0017d7e3call camlLexstate.restore_flags_891
0017d7e8mov eax, 1
0017d7edjmp 0x17d370
0017d7f2
0017d7f2loc_17d7f2:
0017d7f2push 33
0017d7f4call caml_call_realloc_stack
0017d7f9pop r10
0017d7fbjmp 0x17d7de
0017d7d0

0017d7fd
0017d7fd // align 0x10

0017d800
0017d800camlLexstate.full_peek_char_920:
0017d800cmp r15, [r14]
0017d803jbe 0x17d80a
0017d805
0017d805loc_17d805:
0017d805jmp 0x17d820
0017d80a
0017d80aloc_17d80a:
0017d80acall caml_call_gc
0017d80fjmp 0x17d805
0017d800

0017d811
0017d811 // align 0x10

0017d820
0017d820camlLexstate.full_peek_923:
0017d820lea r10, [rsp-336]
0017d828cmp r10, [r14+40]
0017d82cjb 0x17d8b4
0017d832
0017d832loc_17d832:
0017d832cmp r15, [r14]
0017d835jbe 0x17d8ad
0017d837
0017d837loc_17d837:
0017d837lea r11, [rip+26]
0017d83epush r11
0017d840push [r14+48]
0017d844mov [r14+48], rsp
0017d848call camlSave.peek_next_char_355
0017d84dpop [r14+48]
0017d851add rsp, 8
0017d855jmp 0x17d8ac
0017d857nop
0017d858lea rbx, [rip+0x1afdb9]
0017d85fmov rbx, [rbx+56]
0017d863cmp rax, rbx
0017d866jne 0x17d89c
0017d868lea rax, [rip+0x199131]
0017d86fmov rax, [rax+344]
0017d876mov rax, [rax]
0017d879test al, 1
0017d87bje 0x17d890
0017d87dmov rax, rbx
0017d880mov rsp, [r14+48]
0017d884pop [r14+48]
0017d888pop r11
0017d88ajmp r11
0017d88dnop [rax]
0017d890
0017d890loc_17d890:
0017d890mov eax, 1
0017d895call camlLexstate.previous_lexbuf_870
0017d89ajmp 0x17d832
0017d89c
0017d89cloc_17d89c:
0017d89cmov rsp, [r14+48]
0017d8a0pop [r14+48]
0017d8a4pop r11
0017d8a6jmp r11
0017d8a9nop [rax]
0017d8ac
0017d8acloc_17d8ac:
0017d8acret
0017d8ad
0017d8adloc_17d8ad:
0017d8adcall caml_call_gc
0017d8b2jmp 0x17d837
0017d8b4
0017d8b4loc_17d8b4:
0017d8b4push 35
0017d8b6call caml_call_realloc_stack
0017d8bbpop r10
0017d8bdjmp 0x17d832
0017d820

0017d8c2
0017d8c2 // align 0x10

0017d8d0
0017d8d0camlLexstate.full_save_arg_964:
0017d8d0lea r10, [rsp-368]
0017d8d8cmp r10, [r14+40]
0017d8dcjb 0x17da7c
0017d8e2
0017d8e2loc_17d8e2:
0017d8e2sub rsp, 32
0017d8e6mov [rsp+24], rdi
0017d8ebmov [rsp+8], rdx
0017d8f0sub r15, 48
0017d8f4cmp r15, [r14]
0017d8f7jb 0x17da72
0017d8fd
0017d8fdloc_17d8fd:
0017d8fdlea rdi, [r15+8]
0017d901mov [rsp+16], rdi
0017d906mov [rdi-8], 5367
0017d90elea rdx, [rip+379]
0017d915mov [rdi], rdx
0017d918mov rdx, 0x100000000000005
0017d922mov [rdi+8], rdx
0017d926mov [rdi+16], rax
0017d92amov [rdi+24], rbx
0017d92emov [rdi+32], rsi
0017d932mov eax, 1
0017d937call camlLocation.get_pos_414
0017d93cmov [rsp], rax
0017d940lea r11, [rip+149]
0017d947push r11
0017d949push [r14+48]
0017d94dmov [r14+48], rsp
0017d951lea rax, [rip+0x19d7f8]
0017d958mov rax, [rax+56]
0017d95cmov [rax], 1
0017d963mov eax, 1
0017d968call camlLexstate.save_lexstate_881
0017d96dmov rax, [rsp+24]
0017d972mov rbx, [rsp+32]
0017d977call camlLexstate.save_rec_971
0017d97cmov [rsp+24], rax
0017d981mov eax, 1
0017d986call camlLexstate.restore_lexstate_882
0017d98blea rax, [rip+0x1ac6de]
0017d992mov rax, [rax+80]
0017d996mov rax, [rax]
0017d999cmp rax, 5
0017d99djle 0x17d9ce
0017d99fmov rbx, [rsp+40]
0017d9a4mov rdi, [rbx]
0017d9a7mov rax, [rsp+24]
0017d9accall rdi
0017d9aelea rbx, [rip+0x199aa3]
0017d9b5call camlStdlib.$5e_139
0017d9bamov rbx, rax
0017d9bdlea rax, [rip+0x199764]
0017d9c4call camlStdlib.$5e_139
0017d9c9call camlStdlib.prerr_endline_390
0017d9ce
0017d9celoc_17d9ce:
0017d9cepop [r14+48]
0017d9d2add rsp, 8
0017d9d6jmp 0x17da68
0017d9dbnop
0017d9dcmov [rsp+8], rax
0017d9e1lea rbx, [rip+0x19d768]
0017d9e8mov rbx, [rbx+24]
0017d9ecmov rax, [rax]
0017d9efcmp rax, rbx
0017d9f2je 0x17da20
0017d9f4lea rbx, [rip+0x198fa5]
0017d9fbmov rbx, [rbx+104]
0017d9ffcmp rax, rbx
0017da02je 0x17da20
0017da04mov eax, 1
0017da09call camlLexstate.restore_lexstate_882
0017da0emov rax, [rsp+8]
0017da13mov rsp, [r14+48]
0017da17pop [r14+48]
0017da1bpop r11
0017da1djmp r11
0017da20
0017da20loc_17da20:
0017da20mov eax, 1
0017da25call camlLexstate.restore_lexstate_882
0017da2alea rax, [rip+0x19d71f]
0017da31mov rax, [rax+56]
0017da35mov [rax], 1
0017da3cmov eax, 1
0017da41mov rbx, [rsp]
0017da45call camlLocation.do_print_pos_423
0017da4alea rax, [rip+0x1996af]
0017da51call camlStdlib.prerr_endline_390
0017da56mov rax, [rsp+8]
0017da5bmov rsp, [r14+48]
0017da5fpop [r14+48]
0017da63pop r11
0017da65jmp r11
0017da68
0017da68loc_17da68:
0017da68mov rax, [rsp+8]
0017da6dadd rsp, 32
0017da71ret
0017da72
0017da72loc_17da72:
0017da72call caml_call_gc
0017da77jmp 0x17d8fd
0017da7c
0017da7cloc_17da7c:
0017da7cpush 39
0017da7ecall caml_call_realloc_stack
0017da83pop r10
0017da85jmp 0x17d8e2
0017d8d0

0017da8a
0017da8a // align 0x10

0017da90
0017da90camlLexstate.save_rec_971:
0017da90lea r10, [rsp-352]
0017da98cmp r10, [r14+40]
0017da9cjb 0x17dbb7
0017daa2
0017daa2loc_17daa2:
0017daa2sub rsp, 16
0017daa6
0017daa6loc_17daa6:
0017daa6mov [rsp+8], rbx
0017daabcmp r15, [r14]
0017daaejbe 0x17dbad
0017dab4
0017dab4loc_17dab4:
0017dab4lea r11, [rip+65]
0017dabbpush r11
0017dabdpush [r14+48]
0017dac1mov [r14+48], rsp
0017dac5mov rbx, [rbx+32]
0017dac9mov rdi, [rbx]
0017dacccall rdi
0017dacemov rbx, [rsp+24]
0017dad3mov rdi, [rbx+24]
0017dad7lea rbx, [rip+0x198ec2]
0017dademov rbx, [rbx+728]
0017dae5mov rbx, [rbx]
0017dae8call caml_apply2
0017daedpop [r14+48]
0017daf1add rsp, 8
0017daf5jmp 0x17dba8
0017dafanop
0017dafclea rbx, [rip+0x19d64d]
0017db03mov rbx, [rbx+72]
0017db07cmp rax, rbx
0017db0ajne 0x17db98
0017db10lea rax, [rip+0x198e89]
0017db17mov rax, [rax+344]
0017db1emov rax, [rax]
0017db21test al, 1
0017db23je 0x17db3c
0017db25mov rax, [rsp+8]
0017db2amov rbx, [rax+16]
0017db2emov eax, 1
0017db33mov rdi, [rbx]
0017db36add rsp, 16
0017db3ajmp rdi
0017db3c
0017db3cloc_17db3c:
0017db3cmov eax, 1
0017db41call camlLexstate.previous_lexbuf_870
0017db46mov [rsp], rax
0017db4alea rax, [rip+0x1ac51f]
0017db51mov rax, [rax+80]
0017db55mov rax, [rax]
0017db58cmp rax, 3
0017db5cjle 0x17db89
0017db5elea rax, [rip+0x1995db]
0017db65call camlStdlib.prerr_endline_390
0017db6amov rax, [rsp]
0017db6ecall camlLexstate.pretty_lexbuf_726
0017db73lea rax, [rip+0x198e26]
0017db7amov rax, [rax+728]
0017db81mov rax, [rax]
0017db84call camlLexstate.pretty_subst_612
0017db89
0017db89loc_17db89:
0017db89mov rax, [rsp]
0017db8dmov rbx, [rsp+8]
0017db92jmp 0x17daa6
0017db97nop
0017db98
0017db98loc_17db98:
0017db98mov rsp, [r14+48]
0017db9cpop [r14+48]
0017dba0pop r11
0017dba2jmp r11
0017dba5nop [rax]
0017dba8
0017dba8loc_17dba8:
0017dba8add rsp, 16
0017dbacret
0017dbad
0017dbadloc_17dbad:
0017dbadcall caml_call_gc
0017dbb2jmp 0x17dab4
0017dbb7
0017dbb7loc_17dbb7:
0017dbb7push 37
0017dbb9call caml_call_realloc_stack
0017dbbepop r10
0017dbc0jmp 0x17daa2
0017da90

0017dbc5
0017dbc5 // align 0x10

0017dbd0
0017dbd0camlLexstate.full_save_arg_limits_992:
0017dbd0lea r10, [rsp-368]
0017dbd8cmp r10, [r14+40]
0017dbdcjb 0x17dd88
0017dbe2
0017dbe2loc_17dbe2:
0017dbe2sub rsp, 32
0017dbe6mov [rsp+24], rbx
0017dbebmov [rsp+8], rsi
0017dbf0sub r15, 48
0017dbf4cmp r15, [r14]
0017dbf7jb 0x17dd7e
0017dbfd
0017dbfdloc_17dbfd:
0017dbfdlea rbx, [r15+8]
0017dc01mov [rsp+16], rbx
0017dc06mov [rbx-8], 5367
0017dc0elea rsi, [rip-0x86bf5]
0017dc15mov [rbx], rsi
0017dc18mov rsi, 0x200000000000007
0017dc22mov [rbx+8], rsi
0017dc26lea rsi, [rip+371]
0017dc2dmov [rbx+16], rsi
0017dc31mov [rbx+24], rax
0017dc35mov [rbx+32], rdi
0017dc39mov eax, 1
0017dc3ecall camlLocation.get_pos_414
0017dc43mov [rsp], rax
0017dc47lea r11, [rip+154]
0017dc4epush r11
0017dc50push [r14+48]
0017dc54mov [r14+48], rsp
0017dc58lea rax, [rip+0x19d4f1]
0017dc5fmov rax, [rax+56]
0017dc63mov [rax], 1
0017dc6amov eax, 1
0017dc6fcall camlLexstate.save_lexstate_881
0017dc74mov eax, 1
0017dc79mov rbx, [rsp+24]
0017dc7emov rdi, [rsp+32]
0017dc83call camlLexstate.save_rec_998
0017dc88mov [rsp+24], rax
0017dc8dmov eax, 1
0017dc92call camlLexstate.restore_lexstate_882
0017dc97lea rax, [rip+0x1ac3d2]
0017dc9emov rax, [rax+80]
0017dca2mov rax, [rax]
0017dca5cmp rax, 5
0017dca9jle 0x17dcda
0017dcabmov rbx, [rsp+40]
0017dcb0mov rdi, [rbx]
0017dcb3mov rax, [rsp+24]
0017dcb8call rdi
0017dcbalea rbx, [rip+0x199797]
0017dcc1call camlStdlib.$5e_139
0017dcc6mov rbx, rax
0017dcc9lea rax, [rip+0x199458]
0017dcd0call camlStdlib.$5e_139
0017dcd5call camlStdlib.prerr_endline_390
0017dcda
0017dcdaloc_17dcda:
0017dcdapop [r14+48]
0017dcdeadd rsp, 8
0017dce2jmp 0x17dd74
0017dce7nop
0017dce8mov [rsp+8], rax
0017dcedlea rbx, [rip+0x19d45c]
0017dcf4mov rbx, [rbx+24]
0017dcf8mov rax, [rax]
0017dcfbcmp rax, rbx
0017dcfeje 0x17dd2c
0017dd00lea rbx, [rip+0x198c99]
0017dd07mov rbx, [rbx+104]
0017dd0bcmp rax, rbx
0017dd0eje 0x17dd2c
0017dd10mov eax, 1
0017dd15call camlLexstate.restore_lexstate_882
0017dd1amov rax, [rsp+8]
0017dd1fmov rsp, [r14+48]
0017dd23pop [r14+48]
0017dd27pop r11
0017dd29jmp r11
0017dd2c
0017dd2cloc_17dd2c:
0017dd2cmov eax, 1
0017dd31call camlLexstate.restore_lexstate_882
0017dd36lea rax, [rip+0x19d413]
0017dd3dmov rax, [rax+56]
0017dd41mov [rax], 1
0017dd48mov eax, 1
0017dd4dmov rbx, [rsp]
0017dd51call camlLocation.do_print_pos_423
0017dd56lea rax, [rip+0x1993a3]
0017dd5dcall camlStdlib.prerr_endline_390
0017dd62mov rax, [rsp+8]
0017dd67mov rsp, [r14+48]
0017dd6bpop [r14+48]
0017dd6fpop r11
0017dd71jmp r11
0017dd74
0017dd74loc_17dd74:
0017dd74mov rax, [rsp+8]
0017dd79add rsp, 32
0017dd7dret
0017dd7e
0017dd7eloc_17dd7e:
0017dd7ecall caml_call_gc
0017dd83jmp 0x17dbfd
0017dd88
0017dd88loc_17dd88:
0017dd88push 39
0017dd8acall caml_call_realloc_stack
0017dd8fpop r10
0017dd91jmp 0x17dbe2
0017dbd0

0017dd96
0017dd96 // align 0x10

0017dda0
0017dda0camlLexstate.save_rec_998:
0017dda0lea r10, [rsp-360]
0017dda8cmp r10, [r14+40]
0017ddacjb 0x17dec7
0017ddb2
0017ddb2loc_17ddb2:
0017ddb2sub rsp, 24
0017ddb6
0017ddb6loc_17ddb6:
0017ddb6mov [rsp+16], rdi
0017ddbbcmp r15, [r14]
0017ddbejbe 0x17debd
0017ddc4
0017ddc4loc_17ddc4:
0017ddc4lea r11, [rip+33]
0017ddcbpush r11
0017ddcdpush [r14+48]
0017ddd1mov [r14+48], rsp
0017ddd5mov rdi, [rdi+32]
0017ddd9call caml_apply2
0017dddepop [r14+48]
0017dde2add rsp, 8
0017dde6jmp 0x17deb8
0017ddebnop
0017ddeclea rbx, [rip+0x19d35d]
0017ddf3mov rbx, [rbx+80]
0017ddf7mov rdi, [rax]
0017ddfacmp rdi, rbx
0017ddfdjne 0x17dea8
0017de03mov rax, [rax+8]
0017de07lea rbx, [rip+0x198b92]
0017de0emov rbx, [rbx+344]
0017de15mov rbx, [rbx]
0017de18test bl, 1
0017de1bje 0x17de40
0017de1dtest al, 1
0017de1fje 0x17de38
0017de21mov rax, [rsp+16]
0017de26mov rbx, [rax+24]
0017de2amov eax, 1
0017de2fmov rdi, [rbx]
0017de32add rsp, 24
0017de36jmp rdi
0017de38
0017de38loc_17de38:
0017de38add rsp, 24
0017de3cret
0017de3dnop [rax]
0017de40
0017de40loc_17de40:
0017de40mov [rsp], rax
0017de44mov eax, 1
0017de49call camlLexstate.previous_lexbuf_870
0017de4emov [rsp+8], rax
0017de53lea rax, [rip+0x1ac216]
0017de5amov rax, [rax+80]
0017de5emov rax, [rax]
0017de61cmp rax, 3
0017de65jle 0x17de93
0017de67lea rax, [rip+0x19925a]
0017de6ecall camlStdlib.prerr_endline_390
0017de73mov rax, [rsp+8]
0017de78call camlLexstate.pretty_lexbuf_726
0017de7dlea rax, [rip+0x198b1c]
0017de84mov rax, [rax+728]
0017de8bmov rax, [rax]
0017de8ecall camlLexstate.pretty_subst_612
0017de93
0017de93loc_17de93:
0017de93mov rax, [rsp]
0017de97mov rbx, [rsp+8]
0017de9cmov rdi, [rsp+16]
0017dea1jmp 0x17ddb6
0017dea6nop
0017dea8
0017dea8loc_17dea8:
0017dea8mov rsp, [r14+48]
0017deacpop [r14+48]
0017deb0pop r11
0017deb2jmp r11
0017deb5nop [rax]
0017deb8
0017deb8loc_17deb8:
0017deb8add rsp, 24
0017debcret
0017debd
0017debdloc_17debd:
0017debdcall caml_call_gc
0017dec2jmp 0x17ddc4
0017dec7
0017dec7loc_17dec7:
0017dec7push 38
0017dec9call caml_call_realloc_stack
0017decepop r10
0017ded0jmp 0x17ddb2
0017dda0

0017ded5
0017ded5 // align 0x10

0017dee0
0017dee0camlLexstate.parg_1010:
0017dee0mov rax, [rax]
0017dee3ret
0017dee0

0017dee4
0017dee4 // align 0x10

0017def0
0017def0camlLexstate.pargs_1011:
0017def0mov rbx, [rax]
0017def3lea rax, [rip+0x1991be]
0017defajmp 0x1ab480
0017def0

0017deff
0017deff // align 0x10

0017df00
0017df00camlLexstate.parg_list_1012:
0017df00mov rbx, [rax]
0017df03lea rax, [rip+0x198a96]
0017df0amov rax, [rax+8]
0017df0emov rax, [rax+16]
0017df12jmp 0x1ab480
0017df00

0017df17
0017df17 // align 0x10

0017df20
0017df20camlLexstate.pok_1013:
0017df20lea r10, [rsp-320]
0017df28cmp r10, [r14+40]
0017df2cjb 0x17df6a
0017df2e
0017df2eloc_17df2e:
0017df2emov rax, [rax]
0017df31movzx rbx, [rax-8]
0017df36test rbx, rbx
0017df39je 0x17df4c
0017df3bmov rbx, [rax]
0017df3elea rax, [rip+0x199d3b]
0017df45jmp 0x1ab480
0017df4a
0017df4a 66 90 f.
0017df4c
0017df4cloc_17df4c:
0017df4clea rbx, [rip+0x19911d]
0017df53mov rax, [rax]
0017df56call camlStdlib.$5e_139
0017df5bmov rbx, rax
0017df5elea rax, [rip+0x199133]
0017df65jmp 0x195ba0
0017df6a
0017df6aloc_17df6a:
0017df6apush 33
0017df6ccall caml_call_realloc_stack
0017df71pop r10
0017df73jmp 0x17df2e
0017df20

0017df75
0017df75 // align 0x10

0017df80
0017df80camlLexstate.eof_arg_1027:
0017df80lea r10, [rsp-320]
0017df88cmp r10, [r14+40]
0017df8cjb 0x17dfda
0017df8e
0017df8eloc_17df8e:
0017df8emov eax, 1
0017df93call camlSaveUtils.empty_buffs_314
0017df98sub r15, 24
0017df9ccmp r15, [r14]
0017df9fjb 0x17dfd3
0017dfa1
0017dfa1loc_17dfa1:
0017dfa1lea rax, [r15+8]
0017dfa5mov [rax-8], 2048
0017dfadlea rbx, [rip+0x1989ec]
0017dfb4mov rbx, [rbx+104]
0017dfb8mov [rax], rbx
0017dfbblea rbx, [rip+0x199086]
0017dfc2mov [rax+8], rbx
0017dfc6mov rsp, [r14+48]
0017dfcapop [r14+48]
0017dfcepop r11
0017dfd0jmp r11
0017dfd3
0017dfd3loc_17dfd3:
0017dfd3call caml_call_gc
0017dfd8jmp 0x17dfa1
0017dfda
0017dfdaloc_17dfda:
0017dfdapush 33
0017dfdccall caml_call_realloc_stack
0017dfe1pop r10
0017dfe3jmp 0x17df8e
0017df80

0017dfe5
0017dfe5 // align 0x10

0017dff0
0017dff0camlLexstate.save_arg_1030:
0017dff0mov rdx, rax
0017dff3lea rax, [rip+0x19d156]
0017dffamov rsi, [rax+128]
0017e001lea rax, [rip+0x198998]
0017e008mov rdi, [rax+816]
0017e00fmov rbx, [rax+72]
0017e013mov rax, [rax+848]
0017e01ajmp 0x17d8d0
0017dff0

0017e01f
0017e01f // align 0x10

0017e020
0017e020camlLexstate.save_body_1031:
0017e020mov rdx, rax
0017e023lea rax, [rip+0x19d126]
0017e02amov rsi, [rax+136]
0017e031lea rax, [rip+0x198968]
0017e038mov rdi, [rax+832]
0017e03fmov rbx, [rax+72]
0017e043mov rax, [rax+848]
0017e04ajmp 0x17d8d0
0017e020

0017e04f
0017e04f // align 0x10

0017e050
0017e050camlLexstate.save_arg_with_delim_1032:
0017e050mov rdx, rbx
0017e053lea rbx, [rip+0x19d0f6]
0017e05amov rbx, [rbx+288]
0017e061sub r15, 40
0017e065cmp r15, [r14]
0017e068jb 0x17e0b4
0017e06a
0017e06aloc_17e06a:
0017e06alea rsi, [r15+8]
0017e06emov [rsi-8], 4343
0017e076lea rdi, [rip+67]
0017e07dmov [rsi], rdi
0017e080mov rdi, 0x100000000000005
0017e08amov [rsi+8], rdi
0017e08emov [rsi+16], rax
0017e092mov [rsi+24], rbx
0017e096lea rax, [rip+0x198903]
0017e09dmov rdi, [rax+816]
0017e0a4mov rbx, [rax+72]
0017e0a8mov rax, [rax+848]
0017e0afjmp 0x17d8d0
0017e0b4
0017e0b4loc_17e0b4:
0017e0b4call caml_call_gc
0017e0b9jmp 0x17e06a
0017e050

0017e0bb
0017e0bb // align 0x10

0017e0c0
0017e0c0camlLexstate.fun_1630:
0017e0c0mov rdi, rax
0017e0c3mov rax, [rbx+16]
0017e0c7mov rbx, rdi
0017e0cajmp 0x184ad0
0017e0c0

0017e0cf
0017e0cf // align 0x10

0017e0d0
0017e0d0camlLexstate.save_filename_1033:
0017e0d0mov rdx, rax
0017e0d3lea rax, [rip+0x19d076]
0017e0damov rsi, [rax+208]
0017e0e1lea rax, [rip+0x1988b8]
0017e0e8mov rdi, [rax+816]
0017e0efmov rbx, [rax+72]
0017e0f3mov rax, [rax+848]
0017e0fajmp 0x17d8d0
0017e0d0

0017e0ff
0017e0ff // align 0x10

0017e100
0017e100camlLexstate.save_verbatim_1034:
0017e100mov rdx, rax
0017e103lea rax, [rip+0x19d046]
0017e10amov rsi, [rax+144]
0017e111lea rax, [rip+0x198888]
0017e118mov rdi, [rax+816]
0017e11fmov rbx, [rax+72]
0017e123mov rax, [rax+848]
0017e12ajmp 0x17d8d0
0017e100

0017e12f
0017e12f // align 0x10

0017e130
0017e130camlLexstate.save_xy_arg_1035:
0017e130mov rdx, rax
0017e133lea rax, [rip+0x19d016]
0017e13amov rsi, [rax+304]
0017e141lea rax, [rip+0x198858]
0017e148mov rdi, [rax+816]
0017e14fmov rbx, [rax+72]
0017e153mov rax, [rax+848]
0017e15ajmp 0x17d8d0
0017e130

0017e15f
0017e15f // align 0x10

0017e160
0017e160camlLexstate.save_cite_arg_1036:
0017e160mov rdx, rax
0017e163lea rax, [rip+0x19cfe6]
0017e16amov rsi, [rax+168]
0017e171lea rax, [rip+0x198828]
0017e178mov rdi, [rax+824]
0017e17fmov rbx, [rax+72]
0017e183mov rax, [rax+848]
0017e18ajmp 0x17d8d0
0017e160

0017e18f
0017e18f // align 0x10

0017e190
0017e190camlLexstate.plimits_1056:
0017e190test al, 1
0017e192je 0x17e19c
0017e194lea rax, [rip+0x198e95]
0017e19bret
0017e19c
0017e19cloc_17e19c:
0017e19cmov rax, [rax]
0017e19for rax, 1
0017e1a3lea rbx, [rip+0x197e0e]
0017e1aamov rax, [rbx+4*rax-4]
0017e1afret
0017e190

0017e1b0
0017e1b0camlLexstate.eof_over_1060:
0017e1b0lea rax, [rip+0x1987e9]
0017e1b7mov rax, [rax+864]
0017e1bemov rsp, [r14+48]
0017e1c2pop [r14+48]
0017e1c6pop r11
0017e1c8jmp r11
0017e1b0

0017e1cb
0017e1cb // align 0x10

0017e1d0
0017e1d0camlLexstate.save_limits_1063:
0017e1d0sub r15, 32
0017e1d4cmp r15, [r14]
0017e1d7jb 0x17e20b
0017e1d9
0017e1d9loc_17e1d9:
0017e1d9lea rbx, [r15+8]
0017e1ddmov [rbx-8], 3319
0017e1e5lea rdi, [rip+52]
0017e1ecmov [rbx], rdi
0017e1efmov rdi, 0x100000000000005
0017e1f9mov [rbx+8], rdi
0017e1fdmov [rbx+16], rax
0017e201mov eax, 1
0017e206jmp 0x17e220
0017e20b
0017e20bloc_17e20b:
0017e20bcall caml_call_gc
0017e210jmp 0x17e1d9
0017e1d0

0017e212
0017e212 // align 0x10

0017e220
0017e220camlLexstate.do_rec_1066:
0017e220lea r10, [rsp-352]
0017e228cmp r10, [r14+40]
0017e22cjb 0x17e2d1
0017e232
0017e232loc_17e232:
0017e232sub rsp, 16
0017e236mov [rsp+8], rax
0017e23bmov [rsp], rbx
0017e23flea r11, [rip+86]
0017e246push r11
0017e248push [r14+48]
0017e24cmov [r14+48], rsp
0017e250mov rsi, [rbx+16]
0017e254lea rax, [rip+0x19cef5]
0017e25bmov rdi, [rax+224]
0017e262lea rax, [rip+0x198737]
0017e269mov rbx, [rax+856]
0017e270mov rax, [rax+872]
0017e277call camlLexstate.full_save_arg_limits_992
0017e27ctest al, 1
0017e27eje 0x17e288
0017e280mov rax, [rsp+24]
0017e285jmp 0x17e292
0017e287nop
0017e288
0017e288loc_17e288:
0017e288mov rbx, [rsp+16]
0017e28dcall camlLexstate.do_rec_1066
0017e292
0017e292loc_17e292:
0017e292pop [r14+48]
0017e296add rsp, 8
0017e29ajmp 0x17e2cc
0017e29clea rbx, [rip+0x1986fd]
0017e2a3mov rbx, [rbx+864]
0017e2aacmp rax, rbx
0017e2adjne 0x17e2bc
0017e2afmov rax, [rsp+8]
0017e2b4add rsp, 16
0017e2b8ret
0017e2b9nop [rax]
0017e2bc
0017e2bcloc_17e2bc:
0017e2bcmov rsp, [r14+48]
0017e2c0pop [r14+48]
0017e2c4pop r11
0017e2c6jmp r11
0017e2c9nop [rax]
0017e2cc
0017e2ccloc_17e2cc:
0017e2ccadd rsp, 16
0017e2d0ret
0017e2d1
0017e2d1loc_17e2d1:
0017e2d1push 37
0017e2d3call caml_call_realloc_stack
0017e2d8pop r10
0017e2dajmp 0x17e232
0017e220

0017e2df
0017e2df // align 0x10

0017e2e0
0017e2e0camlLexstate.mkoptionarg_1069:
0017e2e0test al, 1
0017e2e2je 0x17e2ec
0017e2e4mov eax, 1
0017e2e9ret
0017e2ea
0017e2ea 66 90 f.
0017e2ec
0017e2ecloc_17e2ec:
0017e2ecmov rax, [rax]
0017e2efsub r15, 40
0017e2f3cmp r15, [r14]
0017e2f6jb 0x17e31f
0017e2f8
0017e2f8loc_17e2f8:
0017e2f8lea rdi, [r15+8]
0017e2fcadd rdi, 16
0017e300mov [rdi-8], 2048
0017e308mov [rdi], rax
0017e30bmov [rdi+8], rbx
0017e30flea rax, [rdi-16]
0017e313mov [rax-8], 1024
0017e31bmov [rax], rdi
0017e31eret
0017e31f
0017e31floc_17e31f:
0017e31fcall caml_call_gc
0017e324jmp 0x17e2f8
0017e2e0

0017e326
0017e326 // align 0x10

0017e330
0017e330camlLexstate.poptionarg_1070:
0017e330test al, 1
0017e332je 0x17e33c
0017e334lea rax, [rip+0x198c8d]
0017e33bret
0017e33c
0017e33cloc_17e33c:
0017e33cmov rax, [rax]
0017e33fmov rax, [rax]
0017e342ret
0017e330

0017e343
0017e343 // align 0x10

0017e350
0017e350camlLexstate.save_sup_1078:
0017e350lea r10, [rsp-336]
0017e358cmp r10, [r14+40]
0017e35cjb 0x17e3d9
0017e35e
0017e35eloc_17e35e:
0017e35emov rdx, rax
0017e361lea r11, [rip+68]
0017e368push r11
0017e36apush [r14+48]
0017e36emov [r14+48], rsp
0017e372lea rax, [rip+0x19cdd7]
0017e379mov rsi, [rax+232]
0017e380lea rax, [rip+0x198619]
0017e387mov rdi, [rax+896]
0017e38emov rbx, [rax+888]
0017e395mov rax, [rax+872]
0017e39ccall camlLexstate.full_save_arg_964
0017e3a1pop [r14+48]
0017e3a5add rsp, 8
0017e3a9jmp 0x17e3d8
0017e3abnop
0017e3aclea rbx, [rip+0x1985ed]
0017e3b3mov rbx, [rbx+864]
0017e3bacmp rax, rbx
0017e3bdjne 0x17e3c8
0017e3bfmov eax, 1
0017e3c4ret
0017e3c5nop [rax]
0017e3c8
0017e3c8loc_17e3c8:
0017e3c8mov rsp, [r14+48]
0017e3ccpop [r14+48]
0017e3d0pop r11
0017e3d2jmp r11
0017e3d5nop [rax]
0017e3d8
0017e3d8loc_17e3d8:
0017e3d8ret
0017e3d9
0017e3d9loc_17e3d9:
0017e3d9push 35
0017e3dbcall caml_call_realloc_stack
0017e3e0pop r10
0017e3e2jmp 0x17e35e
0017e350

0017e3e7
0017e3e7 // align 0x10

0017e3f0
0017e3f0camlLexstate.save_sub_1079:
0017e3f0lea r10, [rsp-336]
0017e3f8cmp r10, [r14+40]
0017e3fcjb 0x17e479
0017e3fe
0017e3feloc_17e3fe:
0017e3femov rdx, rax
0017e401lea r11, [rip+68]
0017e408push r11
0017e40apush [r14+48]
0017e40emov [r14+48], rsp
0017e412lea rax, [rip+0x19cd37]
0017e419mov rsi, [rax+240]
0017e420lea rax, [rip+0x198579]
0017e427mov rdi, [rax+896]
0017e42emov rbx, [rax+888]
0017e435mov rax, [rax+872]
0017e43ccall camlLexstate.full_save_arg_964
0017e441pop [r14+48]
0017e445add rsp, 8
0017e449jmp 0x17e478
0017e44bnop
0017e44clea rbx, [rip+0x19854d]
0017e453mov rbx, [rbx+864]
0017e45acmp rax, rbx
0017e45djne 0x17e468
0017e45fmov eax, 1
0017e464ret
0017e465nop [rax]
0017e468
0017e468loc_17e468:
0017e468mov rsp, [r14+48]
0017e46cpop [r14+48]
0017e470pop r11
0017e472jmp r11
0017e475nop [rax]
0017e478
0017e478loc_17e478:
0017e478ret
0017e479
0017e479loc_17e479:
0017e479push 35
0017e47bcall caml_call_realloc_stack
0017e480pop r10
0017e482jmp 0x17e3fe
0017e3f0

0017e487
0017e487 // align 0x10

0017e490
0017e490camlLexstate.unoption_1084:
0017e490test al, 1
0017e492je 0x17e49c
0017e494lea rax, [rip+0x198b15]
0017e49bret
0017e49c
0017e49cloc_17e49c:
0017e49cmov rax, [rax]
0017e49fret
0017e490

0017e4a0
0017e4a0camlLexstate.save_sup_sub_1088:
0017e4a0lea r10, [rsp-344]
0017e4a8cmp r10, [r14+40]
0017e4acjb 0x17e5a4
0017e4b2
0017e4b2loc_17e4b2:
0017e4b2sub rsp, 24
0017e4b6mov [rsp+8], rax
0017e4bbcall camlLexstate.save_limits_1063
0017e4c0mov [rsp+16], rax
0017e4c5mov rax, [rsp+8]
0017e4cacall camlLexstate.save_sup_1078
0017e4cftest al, 1
0017e4d1je 0x17e540
0017e4d3mov rax, [rsp+8]
0017e4d8call camlLexstate.save_sub_1079
0017e4ddmov [rsp], rax
0017e4e1mov rax, [rsp+8]
0017e4e6call camlLexstate.save_sup_1078
0017e4ebmov rbx, [rsp]
0017e4eftest bl, 1
0017e4f2je 0x17e500
0017e4f4lea rbx, [rip+0x198ab5]
0017e4fbjmp 0x17e503
0017e4fd
0017e4fd 0f 1f 00 ...
0017e500
0017e500loc_17e500:
0017e500mov rbx, [rbx]
0017e503
0017e503loc_17e503:
0017e503test al, 1
0017e505je 0x17e510
0017e507lea rax, [rip+0x198aa2]
0017e50ejmp 0x17e513
0017e510
0017e510loc_17e510:
0017e510mov rax, [rax]
0017e513
0017e513loc_17e513:
0017e513sub r15, 32
0017e517cmp r15, [r14]
0017e51ajb 0x17e59a
0017e51c
0017e51cloc_17e51c:
0017e51clea rdi, [r15+8]
0017e520mov [rdi-8], 3072
0017e528mov rsi, [rsp+16]
0017e52dmov [rdi], rsi
0017e530mov [rdi+8], rax
0017e534mov [rdi+16], rbx
0017e538mov rax, rdi
0017e53badd rsp, 24
0017e53fret
0017e540
0017e540loc_17e540:
0017e540mov [rsp], rax
0017e544mov rax, [rsp+8]
0017e549call camlLexstate.save_sub_1079
0017e54etest al, 1
0017e550je 0x17e55c
0017e552lea rax, [rip+0x198a57]
0017e559jmp 0x17e55f
0017e55b
0017e55b 90 .
0017e55c
0017e55cloc_17e55c:
0017e55cmov rax, [rax]
0017e55f
0017e55floc_17e55f:
0017e55fsub r15, 32
0017e563cmp r15, [r14]
0017e566jb 0x17e593
0017e568
0017e568loc_17e568:
0017e568lea rbx, [r15+8]
0017e56cmov [rbx-8], 3072
0017e574mov rdi, [rsp+16]
0017e579mov [rbx], rdi
0017e57cmov rdi, [rsp]
0017e580mov rdi, [rdi]
0017e583mov [rbx+8], rdi
0017e587mov [rbx+16], rax
0017e58bmov rax, rbx
0017e58eadd rsp, 24
0017e592ret
0017e593
0017e593loc_17e593:
0017e593call caml_call_gc
0017e598jmp 0x17e568
0017e59a
0017e59aloc_17e59a:
0017e59acall caml_call_gc
0017e59fjmp 0x17e51c
0017e5a4
0017e5a4loc_17e5a4:
0017e5a4push 36
0017e5a6call caml_call_realloc_stack
0017e5abpop r10
0017e5adjmp 0x17e4b2
0017e4a0

0017e5b2
0017e5b2 // align 0x10

0017e5c0
0017e5c0camlLexstate.protect_save_string_1096:
0017e5c0mov rsi, rax
0017e5c3mov rdx, rbx
0017e5c6lea rdi, [rip+0x197a0b]
0017e5cdlea rbx, [rip+0x197a1c]
0017e5d4lea rax, [rip+0x1983c5]
0017e5dbmov rax, [rax+848]
0017e5e2jmp 0x17d8d0
0017e5c0

0017e5e7
0017e5e7 // align 0x10

0017e5f0
0017e5f0camlLexstate.fun_1651:
0017e5f0ret
0017e5f0

0017e5f1
0017e5f1 // align 0x10

0017e600
0017e600camlLexstate.fun_1653:
0017e600ret
0017e600

0017e601
0017e601 // align 0x10

0017e610
0017e610camlLexstate.eof_opt_1103:
0017e610sub r15, 40
0017e614cmp r15, [r14]
0017e617jb 0x17e644
0017e619
0017e619loc_17e619:
0017e619lea rbx, [r15+8]
0017e61dadd rbx, 24
0017e621mov [rbx-8], 1024
0017e629mov [rbx], rax
0017e62clea rax, [rbx-24]
0017e630mov [rax-8], 2048
0017e638mov [rax], rbx
0017e63bmov [rax+8], 1
0017e643ret
0017e644
0017e644loc_17e644:
0017e644call caml_call_gc
0017e649jmp 0x17e619
0017e610

0017e64b
0017e64b // align 0x10

0017e650
0017e650camlLexstate.save_arg_opt_1107:
0017e650lea r10, [rsp-328]
0017e658cmp r10, [r14+40]
0017e65cjb 0x17e762
0017e662
0017e662loc_17e662:
0017e662sub rsp, 8
0017e666mov [rsp], rax
0017e66amov rdx, rbx
0017e66dsub r15, 72
0017e671cmp r15, [r14]
0017e674jb 0x17e758
0017e67a
0017e67aloc_17e67a:
0017e67alea rsi, [r15+8]
0017e67eadd rsi, 40
0017e682mov [rsi-8], 3319
0017e68alea rbx, [rip+239]
0017e691mov [rsi], rbx
0017e694mov rbx, 0x100000000000005
0017e69emov [rsi+8], rbx
0017e6a2mov [rsi+16], rax
0017e6a6lea rbx, [rip+0x1982f3]
0017e6admov rdi, [rbx+904]
0017e6b4lea rcx, [rsi-40]
0017e6b8mov [rcx-8], 4343
0017e6c0lea r8, [rip+169]
0017e6c7mov [rcx], r8
0017e6camov r8, 0x100000000000005
0017e6d4mov [rcx+8], r8
0017e6d8mov [rcx+16], rax
0017e6dcmov [rcx+24], rdi
0017e6e0mov rdi, [rbx+840]
0017e6e7mov rbx, [rbx+72]
0017e6ebmov rax, rcx
0017e6eecall camlLexstate.full_save_arg_964
0017e6f3mov rbx, [rax]
0017e6f6movzx rbx, [rbx-8]
0017e6fbtest rbx, rbx
0017e6feje 0x17e708
0017e700add rsp, 8
0017e704ret
0017e705
0017e705 0f 1f 00 ...
0017e708
0017e708loc_17e708:
0017e708lea rax, [rip+0x198291]
0017e70fmov rax, [rax+728]
0017e716mov rbx, [rax]
0017e719sub r15, 40
0017e71dcmp r15, [r14]
0017e720jb 0x17e751
0017e722
0017e722loc_17e722:
0017e722lea rdi, [r15+8]
0017e726add rdi, 24
0017e72amov [rdi-8], 1024
0017e732mov rax, [rsp]
0017e736mov [rdi], rax
0017e739lea rax, [rdi-24]
0017e73dmov [rax-8], 2048
0017e745mov [rax], rdi
0017e748mov [rax+8], rbx
0017e74cadd rsp, 8
0017e750ret
0017e751
0017e751loc_17e751:
0017e751call caml_call_gc
0017e756jmp 0x17e722
0017e758
0017e758loc_17e758:
0017e758call caml_call_gc
0017e75djmp 0x17e67a
0017e762
0017e762loc_17e762:
0017e762push 34
0017e764call caml_call_realloc_stack
0017e769pop r10
0017e76bjmp 0x17e662
0017e650

0017e770
0017e770camlLexstate.fun_1660:
0017e770mov rdi, rax
0017e773mov rax, [rbx+16]
0017e777mov rbx, rdi
0017e77ajmp 0x17e610
0017e770

0017e77f
0017e77f // align 0x10

0017e780
0017e780camlLexstate.fun_1663:
0017e780lea r10, [rsp-344]
0017e788cmp r10, [r14+40]
0017e78cjb 0x17e846
0017e792
0017e792loc_17e792:
0017e792sub rsp, 8
0017e796mov [rsp], rbx
0017e79alea r11, [rip+71]
0017e7a1push r11
0017e7a3push [r14+48]
0017e7a7mov [r14+48], rsp
0017e7ablea rbx, [rip+0x19c99e]
0017e7b2mov rdi, [rbx+120]
0017e7b6add rdi, 24
0017e7bamov ebx, 1
0017e7bfcall Saver..ocaml_lex_opt_rec
0017e7c4sub r15, 16
0017e7c8cmp r15, [r14]
0017e7cbjb 0x17e83f
0017e7cd
0017e7cdloc_17e7cd:
0017e7cdlea rbx, [r15+8]
0017e7d1mov [rbx-8], 1025
0017e7d9mov [rbx], rax
0017e7dcpop [r14+48]
0017e7e0add rsp, 8
0017e7e4jmp 0x17e830
0017e7e6nop
0017e7e8lea rbx, [rip+0x19c961]
0017e7efmov rbx, [rbx+88]
0017e7f3cmp rax, rbx
0017e7f6jne 0x17e820
0017e7f8sub r15, 16
0017e7fccmp r15, [r14]
0017e7ffjb 0x17e838
0017e801
0017e801loc_17e801:
0017e801lea rax, [r15+8]
0017e805mov [rax-8], 1024
0017e80dmov rbx, [rsp]
0017e811mov rbx, [rbx+16]
0017e815mov [rax], rbx
0017e818add rsp, 8
0017e81cret
0017e81dnop [rax]
0017e820
0017e820loc_17e820:
0017e820mov rsp, [r14+48]
0017e824pop [r14+48]
0017e828pop r11
0017e82ajmp r11
0017e82dnop [rax]
0017e830
0017e830loc_17e830:
0017e830mov rax, rbx
0017e833add rsp, 8
0017e837ret
0017e838
0017e838loc_17e838:
0017e838call caml_call_gc
0017e83djmp 0x17e801
0017e83f
0017e83floc_17e83f:
0017e83fcall caml_call_gc
0017e844jmp 0x17e7cd
0017e846
0017e846loc_17e846:
0017e846push 36
0017e848call caml_call_realloc_stack
0017e84dpop r10
0017e84fjmp 0x17e792
0017e780

0017e854
0017e854 // align 0x10

0017e860
0017e860camlLexstate.from_ok_1113:
0017e860mov rbx, [rax]
0017e863movzx rdi, [rbx-8]
0017e868test rdi, rdi
0017e86bje 0x17e8a8
0017e86dlea rdi, [rip+0x19812c]
0017e874mov rdi, [rdi+184]
0017e87bmov [rdi], 3
0017e882mov rdi, [rax+8]
0017e886mov rbx, [rbx]
0017e889sub r15, 24
0017e88dcmp r15, [r14]
0017e890jb 0x17e903
0017e892
0017e892loc_17e892:
0017e892lea rax, [r15+8]
0017e896mov [rax-8], 2048
0017e89emov [rax], rbx
0017e8a1mov [rax+8], rdi
0017e8a5ret
0017e8a6
0017e8a6 66 90 f.
0017e8a8
0017e8a8loc_17e8a8:
0017e8a8lea rdi, [rip+0x1980f1]
0017e8afmov rdi, [rdi+184]
0017e8b6mov [rdi], 1
0017e8bdmov rdi, [rax+8]
0017e8c1sub r15, 48
0017e8c5cmp r15, [r14]
0017e8c8jb 0x17e8fc
0017e8ca
0017e8caloc_17e8ca:
0017e8calea rsi, [r15+8]
0017e8ceadd rsi, 24
0017e8d2mov [rsi-8], 2048
0017e8damov rax, [rbx]
0017e8ddmov [rsi], rax
0017e8e0mov [rsi+8], 1
0017e8e8lea rax, [rsi-24]
0017e8ecmov [rax-8], 2048
0017e8f4mov [rax], rsi
0017e8f7mov [rax+8], rdi
0017e8fbret
0017e8fc
0017e8fcloc_17e8fc:
0017e8fccall caml_call_gc
0017e901jmp 0x17e8ca
0017e903
0017e903loc_17e903:
0017e903call caml_call_gc
0017e908jmp 0x17e892
0017e860

0017e90a
0017e90a // align 0x10

0017e910
0017e910camlLexstate.pretty_ok_1118:
0017e910lea r10, [rsp-320]
0017e918cmp r10, [r14+40]
0017e91cjb 0x17e972
0017e91e
0017e91eloc_17e91e:
0017e91emovzx rbx, [rax-8]
0017e923test rbx, rbx
0017e926je 0x17e954
0017e928mov rbx, [rax]
0017e92blea rax, [rip+0x19934e]
0017e932call Stdlib.String.concat
0017e937lea rbx, [rip+0x198642]
0017e93ecall camlStdlib.$5e_139
0017e943mov rbx, rax
0017e946lea rax, [rip+0x198633]
0017e94djmp 0x195ba0
0017e952
0017e952 66 90 f.
0017e954
0017e954loc_17e954:
0017e954lea rbx, [rip+0x198645]
0017e95bmov rax, [rax]
0017e95ecall camlStdlib.$5e_139
0017e963mov rbx, rax
0017e966lea rax, [rip+0x198633]
0017e96djmp 0x195ba0
0017e972
0017e972loc_17e972:
0017e972push 33
0017e974call caml_call_realloc_stack
0017e979pop r10
0017e97bjmp 0x17e91e
0017e910

0017e97d
0017e97d // align 0x10

0017e980
0017e980camlLexstate.norm_arg_1123:
0017e980mov rbx, [rax-8]
0017e984shr rbx, 10
0017e988lea rbx, [8*rbx-1]
0017e990movzx rdi, [rax+rbx]
0017e995sub rbx, rdi
0017e998lea rdi, [rbx+rbx+1]
0017e99dcmp rdi, 5
0017e9a1jne 0x17e9e0
0017e9a3cmp rbx, 0
0017e9a7jbe 0x17e9e6
0017e9a9movzx rdi, [rax]
0017e9adlea rdi, [rdi+rdi+1]
0017e9b2cmp rdi, 71
0017e9b6jne 0x17e9e0
0017e9b8cmp rbx, 1
0017e9bcjbe 0x17e9e6
0017e9bemovzx rax, [rax+1]
0017e9c3lea rax, [rax+rax+1]
0017e9c8cmp rax, 97
0017e9ccjl 0x17e9e0
0017e9cecmp rax, 115
0017e9d2setle al
0017e9d5movzx rax, al
0017e9d9lea rax, [rax+rax+1]
0017e9deret
0017e9df
0017e9df 90 .
0017e9e0
0017e9e0loc_17e9e0:
0017e9e0mov eax, 1
0017e9e5ret
0017e9e6
0017e9e6loc_17e9e6:
0017e9e6call caml_ml_array_bound_error
0017e980

0017e9eb
0017e9eb // align 0x10

0017e9f0
0017e9f0camlLexstate.list_arg_1126:
0017e9f0sub r15, 48
0017e9f4cmp r15, [r14]
0017e9f7jb 0x17ea32
0017e9f9
0017e9f9loc_17e9f9:
0017e9f9lea rbx, [r15+8]
0017e9fdadd rbx, 24
0017ea01mov [rbx-8], 2048
0017ea09mov rdi, [rax]
0017ea0cmov [rbx], rdi
0017ea0fmov [rbx+8], 1
0017ea17lea rdi, [rbx-24]
0017ea1bmov [rdi-8], 2048
0017ea23mov [rdi], rbx
0017ea26mov rax, [rax+8]
0017ea2amov [rdi+8], rax
0017ea2emov rax, rdi
0017ea31ret
0017ea32
0017ea32loc_17ea32:
0017ea32call caml_call_gc
0017ea37jmp 0x17e9f9
0017e9f0

0017ea39
0017ea39 // align 0x10

0017ea40
0017ea40camlLexstate.parse_args_norm_1129:
0017ea40lea r10, [rsp-360]
0017ea48cmp r10, [r14+40]
0017ea4cjb 0x17ec27
0017ea52
0017ea52loc_17ea52:
0017ea52sub rsp, 40
0017ea56
0017ea56loc_17ea56:
0017ea56cmp r15, [r14]
0017ea59jbe 0x17ec1d
0017ea5f
0017ea5floc_17ea5f:
0017ea5ftest al, 1
0017ea61je 0x17ea70
0017ea63mov eax, 1
0017ea68add rsp, 40
0017ea6cret
0017ea6d
0017ea6d 0f 1f 00 ...
0017ea70
0017ea70loc_17ea70:
0017ea70mov [rsp+32], rbx
0017ea75mov [rsp], rax
0017ea79mov rbx, [rax]
0017ea7cmov [rsp+8], rbx
0017ea81mov rax, [rax+8]
0017ea85mov [rsp+24], rax
0017ea8atest al, 1
0017ea8cjne 0x17eb88
0017ea92mov rax, [rax]
0017ea95mov [rsp+16], rax
0017ea9amov rax, rbx
0017ea9dcall camlLexstate.norm_arg_1123
0017eaa2cmp rax, 1
0017eaa6je 0x17eb04
0017eaa8mov rax, [rsp+16]
0017eaadcall camlLexstate.norm_arg_1123
0017eab2cmp rax, 1
0017eab6je 0x17eb04
0017eab8mov rax, [rsp+32]
0017eabdcall camlLexstate.save_body_1031
0017eac2mov [rsp], rax
0017eac6mov rax, [rsp+24]
0017eacbmov rbx, [rsp+32]
0017ead0call camlLexstate.parse_args_norm_1129
0017ead5sub r15, 24
0017ead9cmp r15, [r14]
0017eadcjb 0x17ec13
0017eae2
0017eae2loc_17eae2:
0017eae2lea rbx, [r15+8]
0017eae6mov [rbx-8], 2048
0017eaeemov rdi, [rsp]
0017eaf2mov [rbx], rdi
0017eaf5mov [rbx+8], rax
0017eaf9mov rax, rbx
0017eafcadd rsp, 40
0017eb00ret
0017eb01
0017eb01 0f 1f 00 ...
0017eb04
0017eb04loc_17eb04:
0017eb04mov rax, [rsp+8]
0017eb09call camlLexstate.norm_arg_1123
0017eb0ecmp rax, 1
0017eb12je 0x17eb88
0017eb14mov rax, [rsp+16]
0017eb19call camlLexstate.norm_arg_1123
0017eb1ecmp rax, 1
0017eb22jne 0x17eb88
0017eb24mov rax, [rsp+16]
0017eb29mov rbx, [rsp+32]
0017eb2ecall camlLexstate.save_arg_with_delim_1032
0017eb33mov [rsp], rax
0017eb37mov rax, [rsp+24]
0017eb3cmov rax, [rax+8]
0017eb40mov rbx, [rsp+32]
0017eb45call camlLexstate.parse_args_norm_1129
0017eb4amov [rsp+8], rax
0017eb4fmov rax, [rsp]
0017eb53call camlLexstate.list_arg_1126
0017eb58sub r15, 24
0017eb5ccmp r15, [r14]
0017eb5fjb 0x17ec09
0017eb65
0017eb65loc_17eb65:
0017eb65lea rbx, [r15+8]
0017eb69mov [rbx-8], 2048
0017eb71mov [rbx], rax
0017eb74mov rax, [rsp+8]
0017eb79mov [rbx+8], rax
0017eb7dmov rax, rbx
0017eb80add rsp, 40
0017eb84ret
0017eb85
0017eb85 0f 1f 00 ...
0017eb88
0017eb88loc_17eb88:
0017eb88mov rax, [rsp+8]
0017eb8dcall camlLexstate.norm_arg_1123
0017eb92cmp rax, 1
0017eb96je 0x17ebe4
0017eb98mov rax, [rsp+32]
0017eb9dcall camlLexstate.save_body_1031
0017eba2mov [rsp+8], rax
0017eba7mov rax, [rsp]
0017ebabmov rax, [rax+8]
0017ebafmov rbx, [rsp+32]
0017ebb4call camlLexstate.parse_args_norm_1129
0017ebb9sub r15, 24
0017ebbdcmp r15, [r14]
0017ebc0jb 0x17ec02
0017ebc2
0017ebc2loc_17ebc2:
0017ebc2lea rbx, [r15+8]
0017ebc6mov [rbx-8], 2048
0017ebcemov rdi, [rsp+8]
0017ebd3mov [rbx], rdi
0017ebd6mov [rbx+8], rax
0017ebdamov rax, rbx
0017ebddadd rsp, 40
0017ebe1ret
0017ebe2
0017ebe2 66 90 f.
0017ebe4
0017ebe4loc_17ebe4:
0017ebe4mov rax, [rsp+8]
0017ebe9mov rbx, [rsp+32]
0017ebeecall camlSave.skip_delim_1009
0017ebf3mov rax, [rsp+24]
0017ebf8mov rbx, [rsp+32]
0017ebfdjmp 0x17ea56
0017ec02
0017ec02loc_17ec02:
0017ec02call caml_call_gc
0017ec07jmp 0x17ebc2
0017ec09
0017ec09loc_17ec09:
0017ec09call caml_call_gc
0017ec0ejmp 0x17eb65
0017ec13
0017ec13loc_17ec13:
0017ec13call caml_call_gc
0017ec18jmp 0x17eae2
0017ec1d
0017ec1dloc_17ec1d:
0017ec1dcall caml_call_gc
0017ec22jmp 0x17ea5f
0017ec27
0017ec27loc_17ec27:
0017ec27push 38
0017ec29call caml_call_realloc_stack
0017ec2epop r10
0017ec30jmp 0x17ea52
0017ea40

0017ec35
0017ec35 // align 0x10

0017ec40
0017ec40camlLexstate.skip_csname_1146:
0017ec40lea r10, [rsp-320]
0017ec48cmp r10, [r14+40]
0017ec4cjb 0x17ec81
0017ec4e
0017ec4eloc_17ec4e:
0017ec4emov rdi, rax
0017ec51lea rbx, [rip+0x1973d0]
0017ec58lea rax, [rip+0x1973b1]
0017ec5flea rsi, [rip+0x19c4ea]
0017ec66mov rdx, [rsi+152]
0017ec6dadd rdx, 32
0017ec71mov esi, 49
0017ec76call Save..ocaml_lex_csname_rec
0017ec7bmov eax, 1
0017ec80ret
0017ec81
0017ec81loc_17ec81:
0017ec81push 33
0017ec83call caml_call_realloc_stack
0017ec88pop r10
0017ec8ajmp 0x17ec4e
0017ec40

0017ec8c
0017ec8c // align 0x10

0017ec90
0017ec90camlLexstate.fun_1681:
0017ec90ret
0017ec90

0017ec91
0017ec91 // align 0x10

0017eca0
0017eca0camlLexstate.fun_1683:
0017eca0ret
0017eca0

0017eca1
0017eca1 // align 0x10

0017ecb0
0017ecb0camlLexstate.skip_opt_1151:
0017ecb0lea r10, [rsp-320]
0017ecb8cmp r10, [r14+40]
0017ecbcjb 0x17ecd3
0017ecbe
0017ecbeloc_17ecbe:
0017ecbemov rbx, rax
0017ecc1lea rax, [rip+0x198fb8]
0017ecc8call camlLexstate.save_arg_opt_1107
0017eccdmov eax, 1
0017ecd2ret
0017ecd3
0017ecd3loc_17ecd3:
0017ecd3push 33
0017ecd5call caml_call_realloc_stack
0017ecdapop r10
0017ecdcjmp 0x17ecbe
0017ecb0

0017ecde
0017ecde // align 0x10

0017ece0
0017ece0camlLexstate.save_opt_1152:
0017ece0lea r10, [rsp-320]
0017ece8cmp r10, [r14+40]
0017ececjb 0x17ecf8
0017ecee
0017eceeloc_17ecee:
0017eceecall camlLexstate.save_arg_opt_1107
0017ecf3jmp 0x17e860
0017ecf8
0017ecf8loc_17ecf8:
0017ecf8push 33
0017ecfacall caml_call_realloc_stack
0017ecffpop r10
0017ed01jmp 0x17ecee
0017ece0

0017ed03
0017ed03 // align 0x10

0017ed10
0017ed10camlLexstate.save_opts_1158:
0017ed10lea r10, [rsp-344]
0017ed18cmp r10, [r14+40]
0017ed1cjb 0x17ed88
0017ed1e
0017ed1eloc_17ed1e:
0017ed1esub rsp, 24
0017ed22test al, 1
0017ed24je 0x17ed30
0017ed26mov eax, 1
0017ed2badd rsp, 24
0017ed2fret
0017ed30
0017ed30loc_17ed30:
0017ed30mov [rsp+8], rbx
0017ed35mov [rsp], rax
0017ed39mov rax, [rax]
0017ed3ccall camlLexstate.save_arg_opt_1107
0017ed41mov [rsp+16], rax
0017ed46mov rax, [rsp]
0017ed4amov rax, [rax+8]
0017ed4emov rbx, [rsp+8]
0017ed53call camlLexstate.save_opts_1158
0017ed58sub r15, 24
0017ed5ccmp r15, [r14]
0017ed5fjb 0x17ed81
0017ed61
0017ed61loc_17ed61:
0017ed61lea rbx, [r15+8]
0017ed65mov [rbx-8], 2048
0017ed6dmov rdi, [rsp+16]
0017ed72mov [rbx], rdi
0017ed75mov [rbx+8], rax
0017ed79mov rax, rbx
0017ed7cadd rsp, 24
0017ed80ret
0017ed81
0017ed81loc_17ed81:
0017ed81call caml_call_gc
0017ed86jmp 0x17ed61
0017ed88
0017ed88loc_17ed88:
0017ed88push 36
0017ed8acall caml_call_realloc_stack
0017ed8fpop r10
0017ed91jmp 0x17ed1e
0017ed10

0017ed93
0017ed93 // align 0x10

0017eda0
0017eda0camlLexstate.parse_args_1165:
0017eda0lea r10, [rsp-352]
0017eda8cmp r10, [r14+40]
0017edacjb 0x17ee79
0017edb2
0017edb2loc_17edb2:
0017edb2sub rsp, 32
0017edb6mov [rsp+24], rbx
0017edbbmov rdi, [rax+8]
0017edbfmov [rsp+8], rdi
0017edc4lea rdi, [rip+0x19c385]
0017edcbmov rdi, [rdi+56]
0017edcfmov [rdi], 1
0017edd6mov rax, [rax]
0017edd9call camlLexstate.save_opts_1158
0017eddemov [rsp], rax
0017ede2mov rbx, [rsp+8]
0017ede7test bl, 1
0017edeajne 0x17ee3b
0017edecmov rax, [rbx+8]
0017edf0test al, 1
0017edf2jne 0x17ee3b
0017edf4mov [rsp+16], rax
0017edf9mov rax, [rbx]
0017edfccall camlLexstate.norm_arg_1123
0017ee01cmp rax, 1
0017ee05je 0x17ee3b
0017ee07mov rax, [rsp+16]
0017ee0cmov rax, [rax]
0017ee0fcall camlLexstate.norm_arg_1123
0017ee14cmp rax, 1
0017ee18jne 0x17ee3b
0017ee1alea rax, [rip+0x19c32f]
0017ee21mov rdi, [rax+384]
0017ee28add rdi, 24
0017ee2cmov ebx, 23
0017ee31mov rax, [rsp+24]
0017ee36call Save..ocaml_lex_skip_blanks_rec
0017ee3b
0017ee3bloc_17ee3b:
0017ee3bmov rax, [rsp+8]
0017ee40mov rbx, [rsp+24]
0017ee45call camlLexstate.parse_args_norm_1129
0017ee4asub r15, 24
0017ee4ecmp r15, [r14]
0017ee51jb 0x17ee72
0017ee53
0017ee53loc_17ee53:
0017ee53lea rbx, [r15+8]
0017ee57mov [rbx-8], 2048
0017ee5fmov rdi, [rsp]
0017ee63mov [rbx], rdi
0017ee66mov [rbx+8], rax
0017ee6amov rax, rbx
0017ee6dadd rsp, 32
0017ee71ret
0017ee72
0017ee72loc_17ee72:
0017ee72call caml_call_gc
0017ee77jmp 0x17ee53
0017ee79
0017ee79loc_17ee79:
0017ee79push 37
0017ee7bcall caml_call_realloc_stack
0017ee80pop r10
0017ee82jmp 0x17edb2
0017eda0

0017ee87
0017ee87 // align 0x10

0017ee90
0017ee90camlLexstate.make_stack_1175:
0017ee90lea r10, [rsp-392]
0017ee98cmp r10, [r14+40]
0017ee9cjb 0x17f141
0017eea2
0017eea2loc_17eea2:
0017eea2sub rsp, 56
0017eea6mov [rsp+8], rax
0017eeabmov rax, rbx
0017eeaemov [rsp+16], rax
0017eeb3mov rbx, rdi
0017eeb6lea r11, [rip+455]
0017eebdpush r11
0017eebfpush [r14+48]
0017eec3mov [r14+48], rsp
0017eec7call camlLexstate.parse_args_1165
0017eeccmov [rsp+16], rax
0017eed1mov rbx, [rax]
0017eed4lea rax, [rip+0x197ac5]
0017eedbmov rax, [rax+520]
0017eee2call Stdlib.List.map
0017eee7mov rbx, [rsp+16]
0017eeecmov rbx, [rbx+8]
0017eef0call camlStdlib.$40_196
0017eef5call Stdlib.Array.of_list
0017eefamov [rsp+48], rax
0017eefflea rax, [rip+0x1ab16a]
0017ef06mov rax, [rax+80]
0017ef0amov rax, [rax]
0017ef0dcmp rax, 3
0017ef11jle 0x17f054
0017ef17mov rax, [rsp+24]
0017ef1cmov [rsp+16], rax
0017ef21lea rbx, [rip+0x197fb0]
0017ef28lea rax, [rip+0x1ae6e9]
0017ef2fmov rax, [rax+312]
0017ef36call Stdlib.Printf.fprintf
0017ef3bmov rbx, rax
0017ef3emov rdi, [rbx]
0017ef41mov rax, [rsp+16]
0017ef46call rdi
0017ef48lea rax, [rip+0x197a51]
0017ef4fmov rbx, [rax+32]
0017ef53mov rdi, [rbx]
0017ef56mov rax, [rsp+32]
0017ef5bcall rdi
0017ef5dlea rax, [rip+0x198d1c]
0017ef64call camlStdlib.prerr_endline_390
0017ef69mov eax, 1
0017ef6emov rbx, [rsp+48]
0017ef73mov rbx, [rbx-8]
0017ef77shr rbx, 9
0017ef7bor rbx, 1
0017ef7fadd rbx, -2
0017ef83cmp rax, rbx
0017ef86jg 0x17f054
0017ef8cmov [rsp+64], rbx
0017ef91mov [rsp+56], rax
0017ef96
0017ef96loc_17ef96:
0017ef96mov rdi, [rsp+48]
0017ef9bmov rbx, [rdi-8]
0017ef9fshr rbx, 9
0017efa3cmp rbx, rax
0017efa6jbe 0x17f13c
0017efacmov rbx, [rdi+4*rax-4]
0017efb1mov rbx, [rbx]
0017efb4mov [rsp+40], rbx
0017efb9lea rbx, [rip+0x1979e0]
0017efc0mov rbx, [rbx]
0017efc3mov [rsp+32], rbx
0017efc8add rax, 2
0017efccmov [rsp+16], rax
0017efd1lea rbx, [rip+0x197e40]
0017efd8lea rax, [rip+0x1ae639]
0017efdfmov rax, [rax+312]
0017efe6call Stdlib.Printf.fprintf
0017efebmov rsi, rax
0017efeemov rax, [rsp+16]
0017eff3mov rbx, [rsp+32]
0017eff8mov rdi, [rsp+40]
0017effdcall caml_apply3
0017f002mov rbx, [rsp+48]
0017f007mov rax, [rbx-8]
0017f00bshr rax, 9
0017f00fmov rdi, [rsp+56]
0017f014cmp rax, rdi
0017f017jbe 0x17f13c
0017f01dmov rax, [rbx+4*rdi-4]
0017f022mov rax, [rax+8]
0017f026call camlLexstate.pretty_subst_612
0017f02bmov rax, [rsp+56]
0017f030mov rbx, rax
0017f033add rax, 2
0017f037mov [rsp+56], rax
0017f03cmov rdi, [rsp+64]
0017f041cmp rbx, rdi
0017f044je 0x17f054
0017f046cmp r15, [r14]
0017f049ja 0x17ef96
0017f04fjmp 0x17f132
0017f054
0017f054loc_17f054:
0017f054sub r15, 16
0017f058cmp r15, [r14]
0017f05bjb 0x17f128
0017f061
0017f061loc_17f061:
0017f061lea rax, [r15+8]
0017f065mov [rax-8], 1024
0017f06dmov rbx, [rsp+48]
0017f072mov [rax], rbx
0017f075pop [r14+48]
0017f079add rsp, 8
0017f07djmp 0x17f11c
0017f082nop
0017f084lea rbx, [rip+0x19c0c5]
0017f08bmov rbx, [rbx+32]
0017f08fmov rdi, [rax]
0017f092cmp rdi, rbx
0017f095jne 0x17f10c
0017f097lea rbx, [rip+0x197d22]
0017f09emov rax, [rax+8]
0017f0a2call camlStdlib.$5e_139
0017f0a7mov rbx, rax
0017f0aalea rax, [rip+0x197d1f]
0017f0b1call camlStdlib.$5e_139
0017f0b6mov rbx, rax
0017f0b9mov rax, [rsp+8]
0017f0becall camlStdlib.$5e_139
0017f0c3mov rbx, rax
0017f0c6lea rax, [rip+0x197d3b]
0017f0cdcall camlStdlib.$5e_139
0017f0d2sub r15, 24
0017f0d6cmp r15, [r14]
0017f0d9jb 0x17f121
0017f0db
0017f0dbloc_17f0db:
0017f0dblea rbx, [r15+8]
0017f0dfmov [rbx-8], 2048
0017f0e7lea rdi, [rip+0x1978b2]
0017f0eemov rdi, [rdi+104]
0017f0f2mov [rbx], rdi
0017f0f5mov [rbx+8], rax
0017f0f9mov rax, rbx
0017f0fcmov rsp, [r14+48]
0017f100pop [r14+48]
0017f104pop r11
0017f106jmp r11
0017f109nop [rax]
0017f10c
0017f10cloc_17f10c:
0017f10cmov rsp, [r14+48]
0017f110pop [r14+48]
0017f114pop r11
0017f116jmp r11
0017f119nop [rax]
0017f11c
0017f11cloc_17f11c:
0017f11cadd rsp, 56
0017f120ret
0017f121
0017f121loc_17f121:
0017f121call caml_call_gc
0017f126jmp 0x17f0db
0017f128
0017f128loc_17f128:
0017f128call caml_call_gc
0017f12djmp 0x17f061
0017f132
0017f132loc_17f132:
0017f132call caml_call_gc
0017f137jmp 0x17ef96
0017f13c
0017f13cloc_17f13c:
0017f13ccall caml_ml_array_bound_error
0017f141
0017f141loc_17f141:
0017f141push 42
0017f143call caml_call_realloc_stack
0017f148pop r10
0017f14ajmp 0x17eea2
0017ee90