Similarity

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

0017f14f
0017f14f // align 0x10

0017f150
0017f150camlLexstate.scan_this_1185:
0017f150lea r10, [rsp-344]
0017f158cmp r10, [r14+40]
0017f15cjb 0x17f22e
0017f162
0017f162loc_17f162:
0017f162sub rsp, 24
0017f166mov [rsp], rax
0017f16amov [rsp+8], rbx
0017f16fmov eax, 1
0017f174call camlLexstate.start_lexstate_907
0017f179lea rax, [rip+0x1aaef0]
0017f180mov rax, [rax+80]
0017f184mov rax, [rax]
0017f187cmp rax, 3
0017f18bjle 0x17f1ca
0017f18dmov rax, [rsp+8]
0017f192mov [rsp+16], rax
0017f197lea rbx, [rip+0x198a82]
0017f19elea rax, [rip+0x1ae473]
0017f1a5mov rax, [rax+312]
0017f1accall Stdlib.Printf.fprintf
0017f1b1mov rbx, rax
0017f1b4mov rdi, [rbx]
0017f1b7mov rax, [rsp+16]
0017f1bccall rdi
0017f1belea rax, [rip+0x198abb]
0017f1c5call camlStdlib.prerr_endline_390
0017f1ca
0017f1caloc_17f1ca:
0017f1camov rax, [rsp+8]
0017f1cfcall camlMyLexing.from_string_309
0017f1d4mov rbx, [rsp]
0017f1d8mov rdi, [rbx]
0017f1dbcall rdi
0017f1ddmov [rsp], rax
0017f1e1lea rax, [rip+0x1aae88]
0017f1e8mov rax, [rax+80]
0017f1ecmov rax, [rax]
0017f1efcmp rax, 3
0017f1f3jle 0x17f21b
0017f1f5lea rbx, [rip+0x1989d4]
0017f1fclea rax, [rip+0x1ae415]
0017f203mov rax, [rax+312]
0017f20acall Stdlib.Printf.fprintf
0017f20flea rax, [rip+0x198a6a]
0017f216call camlStdlib.prerr_endline_390
0017f21b
0017f21bloc_17f21b:
0017f21bmov eax, 1
0017f220call camlLexstate.restore_lexstate_882
0017f225mov rax, [rsp]
0017f229add rsp, 24
0017f22dret
0017f22e
0017f22eloc_17f22e:
0017f22epush 36
0017f230call caml_call_realloc_stack
0017f235pop r10
0017f237jmp 0x17f162
0017f150

0017f23c
0017f23c // align 0x10

0017f240
0017f240camlLexstate.scan_this_list_1186:
0017f240lea r10, [rsp-352]
0017f248cmp r10, [r14+40]
0017f24cjb 0x17f332
0017f252
0017f252loc_17f252:
0017f252sub rsp, 32
0017f256mov [rsp], rax
0017f25amov [rsp+8], rbx
0017f25fmov eax, 1
0017f264call camlLexstate.start_lexstate_907
0017f269lea rax, [rip+0x1aae00]
0017f270mov rax, [rax+80]
0017f274mov rax, [rax]
0017f277cmp rax, 3
0017f27bjle 0x17f2ce
0017f27dmov rax, [rsp+8]
0017f282mov [rsp+24], rax
0017f287lea rax, [rip+0x197712]
0017f28emov rax, [rax]
0017f291mov [rsp+16], rax
0017f296lea rbx, [rip+0x19889b]
0017f29dlea rax, [rip+0x1ae374]
0017f2a4mov rax, [rax+312]
0017f2abcall Stdlib.Printf.fprintf
0017f2b0mov rdi, rax
0017f2b3mov rax, [rsp+16]
0017f2b8mov rbx, [rsp+24]
0017f2bdcall caml_apply2
0017f2c2lea rax, [rip+0x1989b7]
0017f2c9call camlStdlib.prerr_endline_390
0017f2ce
0017f2celoc_17f2ce:
0017f2cemov rax, [rsp+8]
0017f2d3call camlMyLexing.from_list_562
0017f2d8mov rbx, [rsp]
0017f2dcmov rdi, [rbx]
0017f2dfcall rdi
0017f2e1mov [rsp], rax
0017f2e5lea rax, [rip+0x1aad84]
0017f2ecmov rax, [rax+80]
0017f2f0mov rax, [rax]
0017f2f3cmp rax, 3
0017f2f7jle 0x17f31f
0017f2f9lea rbx, [rip+0x1987e8]
0017f300lea rax, [rip+0x1ae311]
0017f307mov rax, [rax+312]
0017f30ecall Stdlib.Printf.fprintf
0017f313lea rax, [rip+0x198966]
0017f31acall camlStdlib.prerr_endline_390
0017f31f
0017f31floc_17f31f:
0017f31fmov eax, 1
0017f324call camlLexstate.restore_lexstate_882
0017f329mov rax, [rsp]
0017f32dadd rsp, 32
0017f331ret
0017f332
0017f332loc_17f332:
0017f332push 37
0017f334call caml_call_realloc_stack
0017f339pop r10
0017f33bjmp 0x17f252
0017f240

0017f340
0017f340camlLexstate.scan_this_arg_1187:
0017f340lea r10, [rsp-344]
0017f348cmp r10, [r14+40]
0017f34cjb 0x17f44a
0017f352
0017f352loc_17f352:
0017f352sub rsp, 24
0017f356mov [rsp+8], rax
0017f35bmov [rsp], rbx
0017f35fmov rax, [rbx]
0017f362mov [rsp+16], rax
0017f367mov eax, 1
0017f36ccall camlLexstate.start_lexstate_907
0017f371mov rax, [rsp]
0017f375mov rsi, [rax+8]
0017f379lea rax, [rip+0x197620]
0017f380mov rdi, [rax+728]
0017f387mov rbx, rsp
0017f38amov rsp, [r14+64]
0017f38ecall caml_modify
0017f393mov rsp, rbx
0017f396lea rax, [rip+0x1aacd3]
0017f39dmov rax, [rax+80]
0017f3a1mov rax, [rax]
0017f3a4cmp rax, 3
0017f3a8jle 0x17f3e5
0017f3aamov rax, [rsp+16]
0017f3afmov [rsp], rax
0017f3b3lea rbx, [rip+0x1986be]
0017f3balea rax, [rip+0x1ae257]
0017f3c1mov rax, [rax+312]
0017f3c8call Stdlib.Printf.fprintf
0017f3cdmov rbx, rax
0017f3d0mov rdi, [rbx]
0017f3d3mov rax, [rsp]
0017f3d7call rdi
0017f3d9lea rax, [rip+0x1988a0]
0017f3e0call camlStdlib.prerr_endline_390
0017f3e5
0017f3e5loc_17f3e5:
0017f3e5mov rax, [rsp+16]
0017f3eacall camlMyLexing.from_string_309
0017f3efmov rbx, [rsp+8]
0017f3f4mov rdi, [rbx]
0017f3f7call rdi
0017f3f9mov [rsp], rax
0017f3fdlea rax, [rip+0x1aac6c]
0017f404mov rax, [rax+80]
0017f408mov rax, [rax]
0017f40bcmp rax, 3
0017f40fjle 0x17f437
0017f411lea rbx, [rip+0x1985f8]
0017f418lea rax, [rip+0x1ae1f9]
0017f41fmov rax, [rax+312]
0017f426call Stdlib.Printf.fprintf
0017f42blea rax, [rip+0x19884e]
0017f432call camlStdlib.prerr_endline_390
0017f437
0017f437loc_17f437:
0017f437mov eax, 1
0017f43ccall camlLexstate.restore_lexstate_882
0017f441mov rax, [rsp]
0017f445add rsp, 24
0017f449ret
0017f44a
0017f44aloc_17f44a:
0017f44apush 36
0017f44ccall caml_call_realloc_stack
0017f451pop r10
0017f453jmp 0x17f352
0017f340

0017f458
0017f458 // align 0x10

0017f460
0017f460camlLexstate.scan_this_arg_list_1188:
0017f460lea r10, [rsp-352]
0017f468cmp r10, [r14+40]
0017f46cjb 0x17f566
0017f472
0017f472loc_17f472:
0017f472sub rsp, 32
0017f476mov [rsp+8], rax
0017f47bmov [rsp], rbx
0017f47fmov rax, [rbx]
0017f482mov [rsp+16], rax
0017f487mov eax, 1
0017f48ccall camlLexstate.start_lexstate_907
0017f491mov rax, [rsp]
0017f495mov rsi, [rax+8]
0017f499lea rax, [rip+0x197500]
0017f4a0mov rdi, [rax+728]
0017f4a7mov rbx, rsp
0017f4aamov rsp, [r14+64]
0017f4aecall caml_modify
0017f4b3mov rsp, rbx
0017f4b6lea rax, [rip+0x1aabb3]
0017f4bdmov rax, [rax+80]
0017f4c1mov rax, [rax]
0017f4c4cmp rax, 3
0017f4c8jle 0x17f50d
0017f4camov rax, [rsp+16]
0017f4cfmov [rsp+24], rax
0017f4d4lea rax, [rip+0x1974c5]
0017f4dbmov rax, [rax]
0017f4demov [rsp], rax
0017f4e2lea rbx, [rip+0x198467]
0017f4e9lea rax, [rip+0x1ae128]
0017f4f0mov rax, [rax+312]
0017f4f7call Stdlib.Printf.fprintf
0017f4fcmov rdi, rax
0017f4ffmov rax, [rsp]
0017f503mov rbx, [rsp+24]
0017f508call caml_apply2
0017f50d
0017f50dloc_17f50d:
0017f50dmov rax, [rsp+16]
0017f512call camlMyLexing.from_list_562
0017f517mov rbx, [rsp+8]
0017f51cmov rdi, [rbx]
0017f51fcall rdi
0017f521mov [rsp], rax
0017f525lea rax, [rip+0x1aab44]
0017f52cmov rax, [rax+80]
0017f530mov rax, [rax]
0017f533cmp rax, 3
0017f537jle 0x17f553
0017f539lea rbx, [rip+0x198388]
0017f540lea rax, [rip+0x1ae0d1]
0017f547mov rax, [rax+312]
0017f54ecall Stdlib.Printf.fprintf
0017f553
0017f553loc_17f553:
0017f553mov eax, 1
0017f558call camlLexstate.restore_lexstate_882
0017f55dmov rax, [rsp]
0017f561add rsp, 32
0017f565ret
0017f566
0017f566loc_17f566:
0017f566push 37
0017f568call caml_call_realloc_stack
0017f56dpop r10
0017f56fjmp 0x17f472
0017f460

0017f574
0017f574 // align 0x10

0017f580
0017f580camlLexstate.scan_this_may_cont_1215:
0017f580lea r10, [rsp-368]
0017f588cmp r10, [r14+40]
0017f58cjb 0x17f6e0
0017f592
0017f592loc_17f592:
0017f592sub rsp, 48
0017f596mov [rsp+24], rax
0017f59bmov [rsp+40], rbx
0017f5a0mov [rsp], rdi
0017f5a4mov [rsp+8], rsi
0017f5a9mov rax, [rsi]
0017f5acmov [rsp+16], rax
0017f5b1lea rbx, [rip+0x1aaab8]
0017f5b8mov rbx, [rbx+80]
0017f5bcmov rbx, [rbx]
0017f5bfcmp rbx, 3
0017f5c3jle 0x17f63d
0017f5c5mov [rsp+32], rax
0017f5calea rbx, [rip+0x19827f]
0017f5d1lea rax, [rip+0x1ae040]
0017f5d8mov rax, [rax+312]
0017f5dfcall Stdlib.Printf.fprintf
0017f5e4mov rbx, rax
0017f5e7mov rdi, [rbx]
0017f5eamov rax, [rsp+32]
0017f5efcall rdi
0017f5f1lea rax, [rip+0x198688]
0017f5f8call camlStdlib.prerr_endline_390
0017f5fdlea rax, [rip+0x1aaa6c]
0017f604mov rax, [rax+80]
0017f608mov rax, [rax]
0017f60bcmp rax, 3
0017f60fjle 0x17f63d
0017f611lea rax, [rip+0x198218]
0017f618call camlStdlib.prerr_endline_390
0017f61dmov rax, [rsp+40]
0017f622call camlLexstate.pretty_lexbuf_726
0017f627lea rax, [rip+0x197372]
0017f62emov rax, [rax+728]
0017f635mov rax, [rax]
0017f638call camlLexstate.pretty_subst_612
0017f63d
0017f63dloc_17f63d:
0017f63dmov eax, 1
0017f642call camlLexstate.save_lexstate_881
0017f647mov rax, [rsp+40]
0017f64cmov rbx, [rsp]
0017f650call camlLexstate.record_lexbuf_869
0017f655mov rax, [rsp+8]
0017f65amov rsi, [rax+8]
0017f65elea rax, [rip+0x19733b]
0017f665mov rdi, [rax+728]
0017f66cmov rbx, rsp
0017f66fmov rsp, [r14+64]
0017f673call caml_modify
0017f678mov rsp, rbx
0017f67bmov rax, [rsp+16]
0017f680call camlMyLexing.from_string_309
0017f685mov rbx, [rsp+24]
0017f68amov rdi, [rbx]
0017f68dcall rdi
0017f68fmov [rsp], rax
0017f693mov eax, 1
0017f698call camlLexstate.restore_lexstate_882
0017f69dlea rax, [rip+0x1aa9cc]
0017f6a4mov rax, [rax+80]
0017f6a8mov rax, [rax]
0017f6abcmp rax, 3
0017f6afjle 0x17f6d7
0017f6b1lea rbx, [rip+0x198110]
0017f6b8lea rax, [rip+0x1adf59]
0017f6bfmov rax, [rax+312]
0017f6c6call Stdlib.Printf.fprintf
0017f6cblea rax, [rip+0x1985ae]
0017f6d2call camlStdlib.prerr_endline_390
0017f6d7
0017f6d7loc_17f6d7:
0017f6d7mov rax, [rsp]
0017f6dbadd rsp, 48
0017f6dfret
0017f6e0
0017f6e0loc_17f6e0:
0017f6e0push 39
0017f6e2call caml_call_realloc_stack
0017f6e7pop r10
0017f6e9jmp 0x17f592
0017f580

0017f6ee
0017f6ee // align 0x10

0017f6f0
0017f6f0camlLexstate.scan_this_list_may_cont_1225:
0017f6f0lea r10, [rsp-376]
0017f6f8cmp r10, [r14+40]
0017f6fcjb 0x17f85c
0017f702
0017f702loc_17f702:
0017f702sub rsp, 56
0017f706mov [rsp+24], rax
0017f70bmov [rsp+48], rbx
0017f710mov [rsp], rdi
0017f714mov [rsp+8], rsi
0017f719mov rax, [rsi]
0017f71cmov [rsp+16], rax
0017f721lea rbx, [rip+0x1aa948]
0017f728mov rbx, [rbx+80]
0017f72cmov rbx, [rbx]
0017f72fcmp rbx, 3
0017f733jle 0x17f7b9
0017f739mov [rsp+40], rax
0017f73elea rax, [rip+0x19725b]
0017f745mov rax, [rax]
0017f748mov [rsp+32], rax
0017f74dlea rbx, [rip+0x197fec]
0017f754lea rax, [rip+0x1adebd]
0017f75bmov rax, [rax+312]
0017f762call Stdlib.Printf.fprintf
0017f767mov rdi, rax
0017f76amov rax, [rsp+32]
0017f76fmov rbx, [rsp+40]
0017f774call caml_apply2
0017f779lea rax, [rip+0x1aa8f0]
0017f780mov rax, [rax+80]
0017f784mov rax, [rax]
0017f787cmp rax, 3
0017f78bjle 0x17f7b9
0017f78dlea rax, [rip+0x19809c]
0017f794call camlStdlib.prerr_endline_390
0017f799mov rax, [rsp+48]
0017f79ecall camlLexstate.pretty_lexbuf_726
0017f7a3lea rax, [rip+0x1971f6]
0017f7aamov rax, [rax+728]
0017f7b1mov rax, [rax]
0017f7b4call camlLexstate.pretty_subst_612
0017f7b9
0017f7b9loc_17f7b9:
0017f7b9mov eax, 1
0017f7becall camlLexstate.save_lexstate_881
0017f7c3mov rax, [rsp+48]
0017f7c8mov rbx, [rsp]
0017f7cccall camlLexstate.record_lexbuf_869
0017f7d1mov rax, [rsp+8]
0017f7d6mov rsi, [rax+8]
0017f7dalea rax, [rip+0x1971bf]
0017f7e1mov rdi, [rax+728]
0017f7e8mov rbx, rsp
0017f7ebmov rsp, [r14+64]
0017f7efcall caml_modify
0017f7f4mov rsp, rbx
0017f7f7mov rax, [rsp+16]
0017f7fccall camlMyLexing.from_list_562
0017f801mov rbx, [rsp+24]
0017f806mov rdi, [rbx]
0017f809call rdi
0017f80bmov [rsp], rax
0017f80fmov eax, 1
0017f814call camlLexstate.restore_lexstate_882
0017f819lea rax, [rip+0x1aa850]
0017f820mov rax, [rax+80]
0017f824mov rax, [rax]
0017f827cmp rax, 3
0017f82bjle 0x17f853
0017f82dlea rbx, [rip+0x197eb4]
0017f834lea rax, [rip+0x1adddd]
0017f83bmov rax, [rax+312]
0017f842call Stdlib.Printf.fprintf
0017f847lea rax, [rip+0x198432]
0017f84ecall camlStdlib.prerr_endline_390
0017f853
0017f853loc_17f853:
0017f853mov rax, [rsp]
0017f857add rsp, 56
0017f85bret
0017f85c
0017f85cloc_17f85c:
0017f85cpush 40
0017f85ecall caml_call_realloc_stack
0017f863pop r10
0017f865jmp 0x17f702
0017f6f0

0017f86a
0017f86a // align 0x10

0017f870
0017f870camlLexstate.real_input_file_1235:
0017f870lea r10, [rsp-392]
0017f878cmp r10, [r14+40]
0017f87cjb 0x17fa86
0017f882
0017f882loc_17f882:
0017f882sub rsp, 56
0017f886mov [rsp], rax
0017f88amov [rsp+32], rbx
0017f88fmov rbx, rdi
0017f892mov [rsp+48], rbx
0017f897mov [rsp+8], rsi
0017f89clea rax, [rip+0x1aa7cd]
0017f8a3mov rax, [rax+80]
0017f8a7mov rax, [rax]
0017f8aacmp rax, 1
0017f8aejle 0x17f8c1
0017f8b0lea rax, [rip+0x197e19]
0017f8b7call camlStdlib.$5e_139
0017f8bccall camlStdlib.prerr_endline_390
0017f8c1
0017f8c1loc_17f8c1:
0017f8c1mov eax, 1
0017f8c6mov rbx, [rsp+8]
0017f8cbcall Stdlib.Lexing.from_channel
0017f8d0mov rbx, rax
0017f8d3mov [rsp+40], rbx
0017f8d8mov rax, [rsp+48]
0017f8ddcall camlLocation.set_382
0017f8e2lea rax, [rip+0x1aa787]
0017f8e9mov rax, [rax+80]
0017f8edmov rbx, [rax]
0017f8f0mov [rsp+16], rbx
0017f8f5mov rbx, [rsp]
0017f8f9mov [rax], rbx
0017f8fcmov rax, [rax]
0017f8ffcmp rax, 3
0017f903jle 0x17f91b
0017f905lea rax, [rip+0x197dac]
0017f90cmov rbx, [rsp+48]
0017f911call camlStdlib.$5e_139
0017f916call camlStdlib.prerr_endline_390
0017f91b
0017f91bloc_17f91b:
0017f91bmov eax, 1
0017f920call camlLexstate.start_lexstate_907
0017f925lea rax, [rip+0x197074]
0017f92cmov rbx, [rax+776]
0017f933mov rbx, [rbx]
0017f936mov [rsp+24], rbx
0017f93bmov esi, 1
0017f940mov rdi, [rax+728]
0017f947mov rbx, rsp
0017f94amov rsp, [r14+64]
0017f94ecall caml_modify
0017f953mov rsp, rbx
0017f956lea r11, [rip+39]
0017f95dpush r11
0017f95fpush [r14+48]
0017f963mov [r14+48], rsp
0017f967mov rbx, [rsp+48]
0017f96cmov rdi, [rbx]
0017f96fmov rax, [rsp+56]
0017f974call rdi
0017f976pop [r14+48]
0017f97aadd rsp, 8
0017f97ejmp 0x17fa20
0017f983nop
0017f984lea rbx, [rip+0x1aa6e5]
0017f98bmov rbx, [rbx+48]
0017f98fcmp rax, rbx
0017f992jne 0x17f9b8
0017f994lea rax, [rip+0x197005]
0017f99bmov rdi, [rax+776]
0017f9a2mov rsi, [rsp+24]
0017f9a7mov rbx, rsp
0017f9aamov rsp, [r14+64]
0017f9aecall caml_modify
0017f9b3mov rsp, rbx
0017f9b6jmp 0x17fa20
0017f9b8
0017f9b8loc_17f9b8:
0017f9b8mov [rsp], rax
0017f9bclea rax, [rip+0x196fdd]
0017f9c3mov rdi, [rax+776]
0017f9camov rsi, [rsp+24]
0017f9cfmov rbx, rsp
0017f9d2mov rsp, [r14+64]
0017f9d6call caml_modify
0017f9dbmov rsp, rbx
0017f9demov eax, 1
0017f9e3call camlLexstate.restore_lexstate_882
0017f9e8mov rdi, [rsp+8]
0017f9edlea rax, [rip+0x9005c]
0017f9f4call caml_c_call
0017f9f9lea rax, [rip+0x1aa670]
0017fa00mov rax, [rax+80]
0017fa04mov rbx, [rsp+16]
0017fa09mov [rax], rbx
0017fa0cmov rax, [rsp]
0017fa10mov rsp, [r14+48]
0017fa14pop [r14+48]
0017fa18pop r11
0017fa1ajmp r11
0017fa1dnop [rax]
0017fa20
0017fa20loc_17fa20:
0017fa20mov eax, 1
0017fa25call camlLexstate.restore_lexstate_882
0017fa2alea rax, [rip+0x1aa63f]
0017fa31mov rax, [rax+80]
0017fa35mov rax, [rax]
0017fa38cmp rax, 3
0017fa3cjle 0x17fa54
0017fa3elea rax, [rip+0x197c43]
0017fa45mov rbx, [rsp+48]
0017fa4acall camlStdlib.$5e_139
0017fa4fcall camlStdlib.prerr_endline_390
0017fa54
0017fa54loc_17fa54:
0017fa54mov rdi, [rsp+8]
0017fa59lea rax, [rip+0x8fff0]
0017fa60call caml_c_call
0017fa65lea rax, [rip+0x1aa604]
0017fa6cmov rax, [rax+80]
0017fa70mov rbx, [rsp+16]
0017fa75mov [rax], rbx
0017fa78mov eax, 1
0017fa7dadd rsp, 56
0017fa81jmp 0x193210
0017fa86
0017fa86loc_17fa86:
0017fa86push 42
0017fa88call caml_call_realloc_stack
0017fa8dpop r10
0017fa8fjmp 0x17f882
0017f870