Similarity

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

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

001c1037
001c1037 // align 0x10

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

001c1067
001c1067 // align 0x10

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

001c1084
001c1084 // align 0x10

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

001c111d
001c111d // align 0x10

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

001c11bb
001c11bb // align 0x10

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

001c123c
001c123c // align 0x10

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

001c130c
001c130c // align 0x10

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

001c1324
001c1324 // align 0x10

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

001c1385
001c1385 // align 0x10

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

001c1409
001c1409 // align 0x10

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

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

001c151b
001c151b // align 0x10

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

001c15c4
001c15c4 // align 0x10

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

001c1797
001c1797 // align 0x10

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

001c181e
001c181e // align 0x10

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

001c1a1f
001c1a1f // align 0x10

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

001c1a48
001c1a48 // align 0x10

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

001c1ac9
001c1ac9 // align 0x10

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

001c1b74
001c1b74 // align 0x10

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

001c1b93
001c1b93 // align 0x10

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

001c1bb3
001c1bb3 // align 0x10

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

001c1c39
001c1c39 // align 0x10

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

001c1cfa
001c1cfa // align 0x10

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

001c1d13
001c1d13 // align 0x10

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

001c1d33
001c1d33 // align 0x10

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

001c1d4f
001c1d4f // align 0x10

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

001c1d9f
001c1d9f // align 0x10

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

001c1de3
001c1de3 // align 0x10

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

001c1ea5
001c1ea5 // align 0x10

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

001c1f76
001c1f76 // align 0x10

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

001c2046
001c2046 // align 0x10

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

001c211b
001c211b // align 0x10

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

001c21e6
001c21e6 // align 0x10

001c21f0
001c21f0Stdlib.Buffer.add_int16_be:
001c21f0lea r10, [rsp-344]
001c21f8cmp r10, [r14+40]
001c21fcjb 0x1c22c0
001c2202
001c2202loc_1c2202:
001c2202sub rsp, 24
001c2206mov rdi, rax
001c2209mov rax, rbx
001c220csar rax, 1
001c220fxchg al, ah
001c2211movzx rax, ax
001c2215lea rax, [rax+rax+1]
001c221amov rbx, [rdi+8]
001c221emov rsi, [rdi]
001c2221mov rdx, rbx
001c2224add rdx, 4
001c2228mov [rsp], rdx
001c222cmov rcx, [rsi+8]
001c2230cmp rdx, rcx
001c2233jle 0x1c229c
001c2235mov [rsp+8], rax
001c223amov [rsp+16], rdi
001c223fmov ebx, 5
001c2244mov rax, rdi
001c2247call Stdlib.Buffer.resize
001c224cmov rbx, [rsp+8]
001c2251sar rbx, 1
001c2254mov rdi, [rsp+16]
001c2259mov rax, [rdi+8]
001c225dsar rax, 1
001c2260mov rsi, [rdi]
001c2263mov rsi, [rsi]
001c2266mov rdx, [rsi-8]
001c226ashr rdx, 10
001c226elea rdx, [8*rdx-1]
001c2276movzx rcx, [rsi+rdx]
001c227bsub rdx, rcx
001c227edec rdx
001c2281mov rcx, rdx
001c2284sar rcx, 63
001c2288xor rcx, -1
001c228cand rcx, rdx
001c228fcmp rcx, rax
001c2292jbe 0x1c22bb
001c2294mov [rsi+rax], bx
001c2298jmp 0x1c22a9
001c229a
001c229a 66 90 f.
001c229c
001c229cloc_1c229c:
001c229csar rax, 1
001c229fsar rbx, 1
001c22a2mov rsi, [rsi]
001c22a5mov [rsi+rbx], ax
001c22a9
001c22a9loc_1c22a9:
001c22a9mov rax, [rsp]
001c22admov [rdi+8], rax
001c22b1mov eax, 1
001c22b6add rsp, 24
001c22baret
001c22bb
001c22bbloc_1c22bb:
001c22bbcall caml_ml_array_bound_error
001c22c0
001c22c0loc_1c22c0:
001c22c0push 36
001c22c2call caml_call_realloc_stack
001c22c7pop r10
001c22c9jmp 0x1c2202
001c21f0

001c22ce
001c22ce // align 0x10

001c22d0
001c22d0Stdlib.Buffer.add_int32_le:
001c22d0lea r10, [rsp-344]
001c22d8cmp r10, [r14+40]
001c22dcjb 0x1c2388
001c22e2
001c22e2loc_1c22e2:
001c22e2sub rsp, 24
001c22e6mov rdi, [rax+8]
001c22eamov rsi, [rax]
001c22edmov rdx, rdi
001c22f0add rdx, 8
001c22f4mov [rsp], rdx
001c22f8mov rcx, [rsi+8]
001c22fccmp rdx, rcx
001c22ffjle 0x1c2364
001c2301mov [rsp+8], rbx
001c2306mov [rsp+16], rax
001c230bmov ebx, 9
001c2310call Stdlib.Buffer.resize
001c2315mov rax, [rsp+8]
001c231amovsxd rdi, [rax+8]
001c231emov rax, [rsp+16]
001c2323mov rbx, [rax+8]
001c2327sar rbx, 1
001c232amov rsi, [rax]
001c232dmov rsi, [rsi]
001c2330mov rdx, [rsi-8]
001c2334shr rdx, 10
001c2338lea rdx, [8*rdx-1]
001c2340movzx rcx, [rsi+rdx]
001c2345sub rdx, rcx
001c2348add rdx, -3
001c234cmov rcx, rdx
001c234fsar rcx, 63
001c2353xor rcx, -1
001c2357and rcx, rdx
001c235acmp rcx, rbx
001c235djbe 0x1c2383
001c235fmov [rsi+rbx], edi
001c2362jmp 0x1c2371
001c2364
001c2364loc_1c2364:
001c2364movsxd rbx, [rbx+8]
001c2368sar rdi, 1
001c236bmov rsi, [rsi]
001c236emov [rsi+rdi], ebx
001c2371
001c2371loc_1c2371:
001c2371mov rbx, [rsp]
001c2375mov [rax+8], rbx
001c2379mov eax, 1
001c237eadd rsp, 24
001c2382ret
001c2383
001c2383loc_1c2383:
001c2383call caml_ml_array_bound_error
001c2388
001c2388loc_1c2388:
001c2388push 36
001c238acall caml_call_realloc_stack
001c238fpop r10
001c2391jmp 0x1c22e2
001c22d0

001c2396
001c2396 // align 0x10

001c23a0
001c23a0Stdlib.Buffer.add_int32_be:
001c23a0lea r10, [rsp-344]
001c23a8cmp r10, [r14+40]
001c23acjb 0x1c245f
001c23b2
001c23b2loc_1c23b2:
001c23b2sub rsp, 24
001c23b6movsxd rbx, [rbx+8]
001c23babswap ebx
001c23bcmovsxd rbx, ebx
001c23bfmov rdi, [rax+8]
001c23c3mov rsi, [rax]
001c23c6mov rdx, rdi
001c23c9add rdx, 8
001c23cdmov [rsp], rdx
001c23d1mov rcx, [rsi+8]
001c23d5cmp rdx, rcx
001c23d8jle 0x1c243c
001c23damov [rsp+8], rbx
001c23dfmov [rsp+16], rax
001c23e4mov ebx, 9
001c23e9call Stdlib.Buffer.resize
001c23eemov rax, [rsp+8]
001c23f3movsxd rdi, eax
001c23f6mov rax, [rsp+16]
001c23fbmov rbx, [rax+8]
001c23ffsar rbx, 1
001c2402mov rsi, [rax]
001c2405mov rsi, [rsi]
001c2408mov rdx, [rsi-8]
001c240cshr rdx, 10
001c2410lea rdx, [8*rdx-1]
001c2418movzx rcx, [rsi+rdx]
001c241dsub rdx, rcx
001c2420add rdx, -3
001c2424mov rcx, rdx
001c2427sar rcx, 63
001c242bxor rcx, -1
001c242fand rcx, rdx
001c2432cmp rcx, rbx
001c2435jbe 0x1c245a
001c2437mov [rsi+rbx], edi
001c243ajmp 0x1c2448
001c243c
001c243cloc_1c243c:
001c243cmovsxd rbx, ebx
001c243fsar rdi, 1
001c2442mov rsi, [rsi]
001c2445mov [rsi+rdi], ebx
001c2448
001c2448loc_1c2448:
001c2448mov rbx, [rsp]
001c244cmov [rax+8], rbx
001c2450mov eax, 1
001c2455add rsp, 24
001c2459ret
001c245a
001c245aloc_1c245a:
001c245acall caml_ml_array_bound_error
001c245f
001c245floc_1c245f:
001c245fpush 36
001c2461call caml_call_realloc_stack
001c2466pop r10
001c2468jmp 0x1c23b2
001c23a0

001c246d
001c246d // align 0x10

001c2470
001c2470Stdlib.Buffer.add_int64_le:
001c2470lea r10, [rsp-344]
001c2478cmp r10, [r14+40]
001c247cjb 0x1c252d
001c2482
001c2482loc_1c2482:
001c2482sub rsp, 24
001c2486mov rdi, [rax+8]
001c248amov rsi, [rax]
001c248dmov rdx, rdi
001c2490add rdx, 16
001c2494mov [rsp], rdx
001c2498mov rcx, [rsi+8]
001c249ccmp rdx, rcx
001c249fjle 0x1c2508
001c24a1mov [rsp+8], rbx
001c24a6mov [rsp+16], rax
001c24abmov ebx, 17
001c24b0call Stdlib.Buffer.resize
001c24b5mov rax, [rsp+8]
001c24bamov rdi, [rax+8]
001c24bemov rax, [rsp+16]
001c24c3mov rbx, [rax+8]
001c24c7sar rbx, 1
001c24camov rsi, [rax]
001c24cdmov rsi, [rsi]
001c24d0mov rdx, [rsi-8]
001c24d4shr rdx, 10
001c24d8lea rdx, [8*rdx-1]
001c24e0movzx rcx, [rsi+rdx]
001c24e5sub rdx, rcx
001c24e8add rdx, -7
001c24ecmov rcx, rdx
001c24efsar rcx, 63
001c24f3xor rcx, -1
001c24f7and rcx, rdx
001c24facmp rcx, rbx
001c24fdjbe 0x1c2528
001c24ffmov [rsi+rbx], rdi
001c2503jmp 0x1c2516
001c2505
001c2505 0f 1f 00 ...
001c2508
001c2508loc_1c2508:
001c2508mov rbx, [rbx+8]
001c250csar rdi, 1
001c250fmov rsi, [rsi]
001c2512mov [rsi+rdi], rbx
001c2516
001c2516loc_1c2516:
001c2516mov rbx, [rsp]
001c251amov [rax+8], rbx
001c251emov eax, 1
001c2523add rsp, 24
001c2527ret
001c2528
001c2528loc_1c2528:
001c2528call caml_ml_array_bound_error
001c252d
001c252dloc_1c252d:
001c252dpush 36
001c252fcall caml_call_realloc_stack
001c2534pop r10
001c2536jmp 0x1c2482
001c2470

001c253b
001c253b // align 0x10

001c2540
001c2540Stdlib.Buffer.add_int64_be:
001c2540lea r10, [rsp-344]
001c2548cmp r10, [r14+40]
001c254cjb 0x1c25f9
001c2552
001c2552loc_1c2552:
001c2552sub rsp, 24
001c2556mov rbx, [rbx+8]
001c255abswap rbx
001c255dmov rdi, [rax+8]
001c2561mov rsi, [rax]
001c2564mov rdx, rdi
001c2567add rdx, 16
001c256bmov [rsp], rdx
001c256fmov rcx, [rsi+8]
001c2573cmp rdx, rcx
001c2576jle 0x1c25d8
001c2578mov [rsp+16], rbx
001c257dmov [rsp+8], rax
001c2582mov ebx, 17
001c2587call Stdlib.Buffer.resize
001c258cmov rax, [rsp+8]
001c2591mov rbx, [rax+8]
001c2595sar rbx, 1
001c2598mov rdi, [rax]
001c259bmov rdi, [rdi]
001c259emov rsi, [rdi-8]
001c25a2shr rsi, 10
001c25a6lea rsi, [8*rsi-1]
001c25aemovzx rdx, [rdi+rsi]
001c25b3sub rsi, rdx
001c25b6add rsi, -7
001c25bamov rdx, rsi
001c25bdsar rdx, 63
001c25c1xor rdx, -1
001c25c5and rdx, rsi
001c25c8cmp rdx, rbx
001c25cbjbe 0x1c25f4
001c25cdmov rsi, [rsp+16]
001c25d2mov [rdi+rbx], rsi
001c25d6jmp 0x1c25e2
001c25d8
001c25d8loc_1c25d8:
001c25d8sar rdi, 1
001c25dbmov rsi, [rsi]
001c25demov [rsi+rdi], rbx
001c25e2
001c25e2loc_1c25e2:
001c25e2mov rbx, [rsp]
001c25e6mov [rax+8], rbx
001c25eamov eax, 1
001c25efadd rsp, 24
001c25f3ret
001c25f4
001c25f4loc_1c25f4:
001c25f4call caml_ml_array_bound_error
001c25f9
001c25f9loc_1c25f9:
001c25f9push 36
001c25fbcall caml_call_realloc_stack
001c2600pop r10
001c2602jmp 0x1c2552
001c2540

001c2607
001c2607 // align 0x10

001c2610
001c2610Stdlib.Buffer.entry:
001c2610lea rsi, [rip+0x187e79]
001c2617lea rdi, [rip+0x188382]
001c261emov rbx, rsp
001c2621mov rsp, [r14+64]
001c2625call caml_initialize
001c262amov rsp, rbx
001c262dlea rsi, [rip+0x187e74]
001c2634lea rdi, [rip+0x188365]
001c263badd rdi, 8
001c263fmov rbx, rsp
001c2642mov rsp, [r14+64]
001c2646call caml_initialize
001c264bmov rsp, rbx
001c264elea rsi, [rip+0x187e6b]
001c2655lea rdi, [rip+0x188344]
001c265cadd rdi, 16
001c2660mov rbx, rsp
001c2663mov rsp, [r14+64]
001c2667call caml_initialize
001c266cmov rsp, rbx
001c266flea rsi, [rip+0x187e62]
001c2676lea rdi, [rip+0x188323]
001c267dadd rdi, 24
001c2681mov rbx, rsp
001c2684mov rsp, [r14+64]
001c2688call caml_initialize
001c268dmov rsp, rbx
001c2690lea rsi, [rip+0x187e61]
001c2697lea rdi, [rip+0x188302]
001c269eadd rdi, 32
001c26a2mov rbx, rsp
001c26a5mov rsp, [r14+64]
001c26a9call caml_initialize
001c26aemov rsp, rbx
001c26b1lea rsi, [rip+0x187e60]
001c26b8lea rdi, [rip+0x1882e1]
001c26bfadd rdi, 40
001c26c3mov rbx, rsp
001c26c6mov rsp, [r14+64]
001c26cacall caml_initialize
001c26cfmov rsp, rbx
001c26d2lea rsi, [rip+0x187e5f]
001c26d9lea rdi, [rip+0x1882c0]
001c26e0add rdi, 48
001c26e4mov rbx, rsp
001c26e7mov rsp, [r14+64]
001c26ebcall caml_initialize
001c26f0mov rsp, rbx
001c26f3lea rsi, [rip+0x187e56]
001c26falea rdi, [rip+0x18829f]
001c2701add rdi, 56
001c2705mov rbx, rsp
001c2708mov rsp, [r14+64]
001c270ccall caml_initialize
001c2711mov rsp, rbx
001c2714lea rsi, [rip+0x187e4d]
001c271blea rdi, [rip+0x18827e]
001c2722add rdi, 64
001c2726mov rbx, rsp
001c2729mov rsp, [r14+64]
001c272dcall caml_initialize
001c2732mov rsp, rbx
001c2735lea rsi, [rip+0x187e44]
001c273clea rdi, [rip+0x18825d]
001c2743add rdi, 320
001c274amov rbx, rsp
001c274dmov rsp, [r14+64]
001c2751call caml_initialize
001c2756mov rsp, rbx
001c2759lea rsi, [rip+0x187e40]
001c2760lea rdi, [rip+0x188239]
001c2767add rdi, 88
001c276bmov rbx, rsp
001c276emov rsp, [r14+64]
001c2772call caml_initialize
001c2777mov rsp, rbx
001c277amov esi, 9
001c277flea rdi, [rip+0x18821a]
001c2786add rdi, 328
001c278dmov rbx, rsp
001c2790mov rsp, [r14+64]
001c2794call caml_initialize
001c2799mov rsp, rbx
001c279cmov esi, 9
001c27a1lea rdi, [rip+0x1881f8]
001c27a8add rdi, 336
001c27afmov rbx, rsp
001c27b2mov rsp, [r14+64]
001c27b6call caml_initialize
001c27bbmov rsp, rbx
001c27belea rsi, [rip+0x187dfb]
001c27c5lea rdi, [rip+0x1881d4]
001c27ccadd rdi, 96
001c27d0mov rbx, rsp
001c27d3mov rsp, [r14+64]
001c27d7call caml_initialize
001c27dcmov rsp, rbx
001c27dflea rsi, [rip+0x187dfa]
001c27e6lea rdi, [rip+0x1881b3]
001c27edadd rdi, 112
001c27f1mov rbx, rsp
001c27f4mov rsp, [r14+64]
001c27f8call caml_initialize
001c27fdmov rsp, rbx
001c2800lea rsi, [rip+0x187df9]
001c2807lea rdi, [rip+0x188192]
001c280eadd rdi, 104
001c2812mov rbx, rsp
001c2815mov rsp, [r14+64]
001c2819call caml_initialize
001c281emov rsp, rbx
001c2821lea rsi, [rip+0x187df8]
001c2828lea rdi, [rip+0x188171]
001c282fadd rdi, 136
001c2836mov rbx, rsp
001c2839mov rsp, [r14+64]
001c283dcall caml_initialize
001c2842mov rsp, rbx
001c2845lea rsi, [rip+0x187df4]
001c284clea rdi, [rip+0x18814d]
001c2853add rdi, 144
001c285amov rbx, rsp
001c285dmov rsp, [r14+64]
001c2861call caml_initialize
001c2866mov rsp, rbx
001c2869lea rsi, [rip+0x187df0]
001c2870lea rdi, [rip+0x188129]
001c2877add rdi, 120
001c287bmov rbx, rsp
001c287emov rsp, [r14+64]
001c2882call caml_initialize
001c2887mov rsp, rbx
001c288alea rsi, [rip+0x187def]
001c2891lea rdi, [rip+0x188108]
001c2898add rdi, 128
001c289fmov rbx, rsp
001c28a2mov rsp, [r14+64]
001c28a6call caml_initialize
001c28abmov rsp, rbx
001c28aelea rsi, [rip+0x187deb]
001c28b5lea rdi, [rip+0x1880e4]
001c28bcadd rdi, 160
001c28c3mov rbx, rsp
001c28c6mov rsp, [r14+64]
001c28cacall caml_initialize
001c28cfmov rsp, rbx
001c28d2lea rsi, [rip+0x187de7]
001c28d9lea rdi, [rip+0x1880c0]
001c28e0add rdi, 344
001c28e7mov rbx, rsp
001c28eamov rsp, [r14+64]
001c28eecall caml_initialize
001c28f3mov rsp, rbx
001c28f6lea rsi, [rip+0x187de3]
001c28fdlea rdi, [rip+0x18809c]
001c2904add rdi, 352
001c290bmov rbx, rsp
001c290emov rsp, [r14+64]
001c2912call caml_initialize
001c2917mov rsp, rbx
001c291alea rsi, [rip+0x187ddf]
001c2921lea rdi, [rip+0x188078]
001c2928add rdi, 168
001c292fmov rbx, rsp
001c2932mov rsp, [r14+64]
001c2936call caml_initialize
001c293bmov rsp, rbx
001c293elea rsi, [rip+0x187ddb]
001c2945lea rdi, [rip+0x188054]
001c294cadd rdi, 72
001c2950mov rbx, rsp
001c2953mov rsp, [r14+64]
001c2957call caml_initialize
001c295cmov rsp, rbx
001c295flea rsi, [rip+0x187dda]
001c2966lea rdi, [rip+0x188033]
001c296dadd rdi, 360
001c2974mov rbx, rsp
001c2977mov rsp, [r14+64]
001c297bcall caml_initialize
001c2980mov rsp, rbx
001c2983lea rsi, [rip+0x187dce]
001c298alea rdi, [rip+0x18800f]
001c2991add rdi, 368
001c2998mov rbx, rsp
001c299bmov rsp, [r14+64]
001c299fcall caml_initialize
001c29a4mov rsp, rbx
001c29a7lea rsi, [rip+0x187dca]
001c29aelea rdi, [rip+0x187feb]
001c29b5add rdi, 376
001c29bcmov rbx, rsp
001c29bfmov rsp, [r14+64]
001c29c3call caml_initialize
001c29c8mov rsp, rbx
001c29cblea rsi, [rip+0x187dc6]
001c29d2lea rdi, [rip+0x187fc7]
001c29d9add rdi, 384
001c29e0mov rbx, rsp
001c29e3mov rsp, [r14+64]
001c29e7call caml_initialize
001c29ecmov rsp, rbx
001c29eflea rsi, [rip+0x187dc2]
001c29f6lea rdi, [rip+0x187fa3]
001c29fdadd rdi, 152
001c2a04mov rbx, rsp
001c2a07mov rsp, [r14+64]
001c2a0bcall caml_initialize
001c2a10mov rsp, rbx
001c2a13lea rsi, [rip+0x187dbe]
001c2a1alea rdi, [rip+0x187f7f]
001c2a21add rdi, 80
001c2a25mov rbx, rsp
001c2a28mov rsp, [r14+64]
001c2a2ccall caml_initialize
001c2a31mov rsp, rbx
001c2a34lea rsi, [rip+0x187dbd]
001c2a3blea rdi, [rip+0x187f5e]
001c2a42add rdi, 176
001c2a49mov rbx, rsp
001c2a4cmov rsp, [r14+64]
001c2a50call caml_initialize
001c2a55mov rsp, rbx
001c2a58lea rsi, [rip+0x187db1]
001c2a5flea rdi, [rip+0x187f3a]
001c2a66add rdi, 184
001c2a6dmov rbx, rsp
001c2a70mov rsp, [r14+64]
001c2a74call caml_initialize
001c2a79mov rsp, rbx
001c2a7clea rsi, [rip+0x187da5]
001c2a83lea rdi, [rip+0x187f16]
001c2a8aadd rdi, 192
001c2a91mov rbx, rsp
001c2a94mov rsp, [r14+64]
001c2a98call caml_initialize
001c2a9dmov rsp, rbx
001c2aa0lea rsi, [rip+0x187da1]
001c2aa7lea rdi, [rip+0x187ef2]
001c2aaeadd rdi, 200
001c2ab5mov rbx, rsp
001c2ab8mov rsp, [r14+64]
001c2abccall caml_initialize
001c2ac1mov rsp, rbx
001c2ac4lea rsi, [rip+0x187d95]
001c2acblea rdi, [rip+0x187ece]
001c2ad2add rdi, 216
001c2ad9mov rbx, rsp
001c2adcmov rsp, [r14+64]
001c2ae0call caml_initialize
001c2ae5mov rsp, rbx
001c2ae8lea rsi, [rip+0x187d91]
001c2aeflea rdi, [rip+0x187eaa]
001c2af6add rdi, 248
001c2afdmov rbx, rsp
001c2b00mov rsp, [r14+64]
001c2b04call caml_initialize
001c2b09mov rsp, rbx
001c2b0clea rsi, [rip+0x187d8d]
001c2b13lea rdi, [rip+0x187e86]
001c2b1aadd rdi, 272
001c2b21mov rbx, rsp
001c2b24mov rsp, [r14+64]
001c2b28call caml_initialize
001c2b2dmov rsp, rbx
001c2b30lea rsi, [rip+0x187d89]
001c2b37lea rdi, [rip+0x187e62]
001c2b3eadd rdi, 296
001c2b45mov rbx, rsp
001c2b48mov rsp, [r14+64]
001c2b4ccall caml_initialize
001c2b51mov rsp, rbx
001c2b54lea rsi, [rip+0x187d85]
001c2b5blea rdi, [rip+0x187e3e]
001c2b62add rdi, 264
001c2b69mov rbx, rsp
001c2b6cmov rsp, [r14+64]
001c2b70call caml_initialize
001c2b75mov rsp, rbx
001c2b78lea rsi, [rip+0x187d81]
001c2b7flea rdi, [rip+0x187e1a]
001c2b86add rdi, 256
001c2b8dmov rbx, rsp
001c2b90mov rsp, [r14+64]
001c2b94call caml_initialize
001c2b99mov rsp, rbx
001c2b9clea rsi, [rip+0x187d7d]
001c2ba3lea rdi, [rip+0x187df6]
001c2baaadd rdi, 288
001c2bb1mov rbx, rsp
001c2bb4mov rsp, [r14+64]
001c2bb8call caml_initialize
001c2bbdmov rsp, rbx
001c2bc0lea rsi, [rip+0x187d79]
001c2bc7lea rdi, [rip+0x187dd2]
001c2bceadd rdi, 280
001c2bd5mov rbx, rsp
001c2bd8mov rsp, [r14+64]
001c2bdccall caml_initialize
001c2be1mov rsp, rbx
001c2be4lea rsi, [rip+0x187d75]
001c2beblea rdi, [rip+0x187dae]
001c2bf2add rdi, 312
001c2bf9mov rbx, rsp
001c2bfcmov rsp, [r14+64]
001c2c00call caml_initialize
001c2c05mov rsp, rbx
001c2c08lea rsi, [rip+0x187d71]
001c2c0flea rdi, [rip+0x187d8a]
001c2c16add rdi, 304
001c2c1dmov rbx, rsp
001c2c20mov rsp, [r14+64]
001c2c24call caml_initialize
001c2c29mov rsp, rbx
001c2c2clea rdi, [rip+0x187d6d]
001c2c33mov rsi, [rdi+216]
001c2c3aadd rdi, 208
001c2c41mov rbx, rsp
001c2c44mov rsp, [r14+64]
001c2c48call caml_initialize
001c2c4dmov rsp, rbx
001c2c50lea rdi, [rip+0x187d49]
001c2c57mov rsi, [rdi+248]
001c2c5eadd rdi, 224
001c2c65mov rbx, rsp
001c2c68mov rsp, [r14+64]
001c2c6ccall caml_initialize
001c2c71mov rsp, rbx
001c2c74lea rdi, [rip+0x187d25]
001c2c7bmov rsi, [rdi+264]
001c2c82add rdi, 240
001c2c89mov rbx, rsp
001c2c8cmov rsp, [r14+64]
001c2c90call caml_initialize
001c2c95mov rsp, rbx
001c2c98lea rdi, [rip+0x187d01]
001c2c9fmov rsi, [rdi+256]
001c2ca6add rdi, 232
001c2cadmov rbx, rsp
001c2cb0mov rsp, [r14+64]
001c2cb4call caml_initialize
001c2cb9mov rsp, rbx
001c2cbcmov eax, 1
001c2cc1ret
001c2610

001c2cc2
001c2cc2 // align 0x10

001c2cd0
001c2cd0Stdlib.Mutex.fun:
001c2cd0mov rdi, rax
001c2cd3lea rax, [rip+0x5ef86]
001c2cdacall caml_c_call
001c2cdfret
001c2cd0

001c2ce0
001c2ce0Stdlib.Mutex.fun:
001c2ce0mov rdi, rax
001c2ce3lea rax, [rip+0x5efc6]
001c2ceacall caml_c_call
001c2cefret
001c2ce0

001c2cf0
001c2cf0Stdlib.Mutex.fun:
001c2cf0mov rdi, rax
001c2cf3lea rax, [rip+0x5ee86]
001c2cfacall caml_c_call
001c2cffret
001c2cf0

001c2d00
001c2d00Stdlib.Mutex.fun:
001c2d00mov rdi, rax
001c2d03lea rax, [rip+0x5ed86]
001c2d0acall caml_c_call
001c2d0fret
001c2d00

001c2d10
001c2d10Stdlib.Mutex.protect:
001c2d10lea r10, [rsp-352]
001c2d18cmp r10, [r14+40]
001c2d1cjb 0x1c2daa
001c2d22
001c2d22loc_1c2d22:
001c2d22sub rsp, 16
001c2d26mov [rsp+8], rax
001c2d2bmov [rsp], rbx
001c2d2fmov rdi, rax
001c2d32lea rax, [rip+0x5ee47]
001c2d39call caml_c_call
001c2d3elea r11, [rip+43]
001c2d45push r11
001c2d47push [r14+48]
001c2d4bmov [r14+48], rsp
001c2d4fmov eax, 1
001c2d54mov rbx, [rsp+16]
001c2d59mov rdi, [rbx]
001c2d5ccall rdi
001c2d5emov [rsp+16], rax
001c2d63pop [r14+48]
001c2d67add rsp, 8
001c2d6bjmp 0x1c2d90
001c2d6d
001c2d6d 0f 1f 00 ...
001c2d70mov [rsp], rax
001c2d74mov rdi, [rsp+8]
001c2d79lea rax, [rip+0x5eee0]
001c2d80call caml_c_call
001c2d85mov rax, [rsp]
001c2d89call caml_reraise_exn
001c2d8enop
001c2d90
001c2d90loc_1c2d90:
001c2d90mov rdi, [rsp+8]
001c2d95lea rax, [rip+0x5eec4]
001c2d9ccall caml_c_call
001c2da1mov rax, [rsp]
001c2da5add rsp, 16
001c2da9ret
001c2daa
001c2daaloc_1c2daa:
001c2daapush 37
001c2daccall caml_call_realloc_stack
001c2db1pop r10
001c2db3jmp 0x1c2d22
001c2d10

001c2db8
001c2db8 // align 0x10

001c2dc0
001c2dc0Stdlib.Mutex.entry:
001c2dc0lea rsi, [rip+0x188fe1]
001c2dc7lea rdi, [rip+0x18905a]
001c2dceadd rdi, 24
001c2dd2mov rbx, rsp
001c2dd5mov rsp, [r14+64]
001c2dd9call caml_initialize
001c2ddemov rsp, rbx
001c2de1lea rsi, [rip+0x188fd8]
001c2de8lea rdi, [rip+0x189039]
001c2defadd rdi, 16
001c2df3mov rbx, rsp
001c2df6mov rsp, [r14+64]
001c2dfacall caml_initialize
001c2dffmov rsp, rbx
001c2e02lea rsi, [rip+0x188fcf]
001c2e09lea rdi, [rip+0x189018]
001c2e10add rdi, 8
001c2e14mov rbx, rsp
001c2e17mov rsp, [r14+64]
001c2e1bcall caml_initialize
001c2e20mov rsp, rbx
001c2e23lea rsi, [rip+0x188fc6]
001c2e2alea rdi, [rip+0x188ff7]
001c2e31mov rbx, rsp
001c2e34mov rsp, [r14+64]
001c2e38call caml_initialize
001c2e3dmov rsp, rbx
001c2e40lea rsi, [rip+0x188fc1]
001c2e47lea rdi, [rip+0x188fda]
001c2e4eadd rdi, 32
001c2e52mov rbx, rsp
001c2e55mov rsp, [r14+64]
001c2e59call caml_initialize
001c2e5emov rsp, rbx
001c2e61mov eax, 1
001c2e66ret
001c2dc0

001c2e67
001c2e67 // align 0x10

001c2e70
001c2e70Stdlib.Condition.fun:
001c2e70mov rdi, rax
001c2e73lea rax, [rip+0x5f056]
001c2e7acall caml_c_call
001c2e7fret
001c2e70

001c2e80
001c2e80Stdlib.Condition.fun:
001c2e80mov rdi, rax
001c2e83lea rax, [rip+0x5eff6]
001c2e8acall caml_c_call
001c2e8fret
001c2e80

001c2e90
001c2e90Stdlib.Condition.fun:
001c2e90mov rdi, rax
001c2e93mov rsi, rbx
001c2e96lea rax, [rip+0x5eef3]
001c2e9dcall caml_c_call
001c2ea2ret
001c2e90

001c2ea3
001c2ea3 // align 0x10

001c2eb0
001c2eb0Stdlib.Condition.fun:
001c2eb0mov rdi, rax
001c2eb3lea rax, [rip+0x5ee56]
001c2ebacall caml_c_call
001c2ebfret
001c2eb0

001c2ec0
001c2ec0Stdlib.Condition.entry:
001c2ec0lea rsi, [rip+0x1890d9]
001c2ec7lea rdi, [rip+0x18913a]
001c2eceadd rdi, 24
001c2ed2mov rbx, rsp
001c2ed5mov rsp, [r14+64]
001c2ed9call caml_initialize
001c2edemov rsp, rbx
001c2ee1lea rsi, [rip+0x1890d0]
001c2ee8lea rdi, [rip+0x189119]
001c2eefadd rdi, 16
001c2ef3mov rbx, rsp
001c2ef6mov rsp, [r14+64]
001c2efacall caml_initialize
001c2effmov rsp, rbx
001c2f02lea rsi, [rip+0x1890c7]
001c2f09lea rdi, [rip+0x1890f8]
001c2f10add rdi, 8
001c2f14mov rbx, rsp
001c2f17mov rsp, [r14+64]
001c2f1bcall caml_initialize
001c2f20mov rsp, rbx
001c2f23lea rsi, [rip+0x1890c6]
001c2f2alea rdi, [rip+0x1890d7]
001c2f31mov rbx, rsp
001c2f34mov rsp, [r14+64]
001c2f38call caml_initialize
001c2f3dmov rsp, rbx
001c2f40mov eax, 1
001c2f45ret
001c2ec0

001c2f46
001c2f46 // align 0x10

001c2f50
001c2f50Stdlib.Domain.fun:
001c2f50mov rdi, rax
001c2f53mov rbx, rsp
001c2f56mov rsp, [r14+64]
001c2f5acall caml_ml_domain_index
001c2f5fmov rsp, rbx
001c2f62ret
001c2f50

001c2f63
001c2f63 // align 0x10

001c2f70
001c2f70Stdlib.Domain.cpu_relax:
001c2f70mov edi, 1
001c2f75lea rax, [rip+0x401b4]
001c2f7ccall caml_c_call
001c2f81ret
001c2f70

001c2f82
001c2f82 // align 0x10

001c2f90
001c2f90Stdlib.Domain.some:
001c2f90ret
001c2f90

001c2f91
001c2f91 // align 0x10

001c2fa0
001c2fa0Stdlib.Domain.is_some:
001c2fa0mov rbx, [rbx+16]
001c2fa4cmp rax, rbx
001c2fa7setne al
001c2faamovzx rax, al
001c2faelea rax, [rax+rax+1]
001c2fb3ret
001c2fa0

001c2fb4
001c2fb4 // align 0x10

001c2fc0
001c2fc0Stdlib.Domain.unsafe_get:
001c2fc0ret
001c2fc0

001c2fc1
001c2fc1 // align 0x10

001c2fd0
001c2fd0Stdlib.Domain.create_dls:
001c2fd0lea rax, [rip+0x189371]
001c2fd7mov rax, [rax+136]
001c2fdemov rsi, [rax]
001c2fe1mov edi, 17
001c2fe6lea rax, [rip+0x36cb3]
001c2fedcall caml_c_call
001c2ff2mov rdi, rax
001c2ff5mov rbx, rsp
001c2ff8mov rsp, [r14+64]
001c2ffccall caml_domain_dls_set
001c3001mov rsp, rbx
001c3004ret
001c2fd0