Similarity

14003bdc0
14003bdc0std::__cxx11::moneypunct<wchar_t, false>::do_positive_sign() const:
14003bdc0push rsi
14003bdc1push rbx
14003bdc2sub rsp, 40
14003bdc6mov rax, [rdx+16]
14003bdcamov rsi, [rax+56]
14003bdcelea rax, [rcx+16]
14003bdd2mov rbx, rcx
14003bdd5mov [rcx], rax
14003bdd8test rsi, rsi
14003bddbje 0x14003bdfe
14003bdddmov rcx, rsi
14003bde0call wcslen
14003bde5mov rdx, rsi
14003bde8mov rcx, rbx
14003bdeblea r8, [rsi+2*rax]
14003bdefcall _ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_M_constructIPKwEEvT_S8_St20forward_iterator_tag.isra.0
14003bdf4mov rax, rbx
14003bdf7add rsp, 40
14003bdfbpop rbx
14003bdfcpop rsi
14003bdfdret
14003bdfe
14003bdfeloc_14003bdfe:
14003bdfelea rcx, [rip+0x1555db]
14003be05call std::__throw_logic_error(char const*)
14003be0anop
14003bdc0

14003be0b
14003be0b // align 0x10

14003be10
14003be10std::__cxx11::moneypunct<wchar_t, false>::do_thousands_sep() const:
14003be10mov rax, [rcx+16]
14003be14movzx eax, [rax+36]
14003be18ret
14003be10

14003be19
14003be19 // align 0x10

14003be20
14003be20std::__cxx11::moneypunct<wchar_t, false>::grouping() const:
14003be20push rdi
14003be21push rsi
14003be22push rbx
14003be23sub rsp, 64
14003be27mov rdi, [rip+0x15b862]
14003be2emov rax, [rdi]
14003be31mov [rsp+56], rax
14003be36mov rax, [rdx]
14003be39mov rbx, rcx
14003be3clea rcx, [rip-1091]
14003be43mov rax, [rax+32]
14003be47cmp rax, rcx
14003be4ajne 0x14003bf08
14003be50mov rax, [rdx+16]
14003be54lea rsi, [rbx+16]
14003be58mov rdi, [rax+16]
14003be5cmov [rbx], rsi
14003be5ftest rdi, rdi
14003be62je 0x14003bf0f
14003be68mov rcx, rdi
14003be6bcall strlen
14003be70mov [rsp+48], rax
14003be75mov r9, rax
14003be78cmp rax, 15
14003be7cja 0x14003bec0
14003be7ecmp rax, 1
14003be82jne 0x14003beb0
14003be84movzx edx, [rdi]
14003be87mov [rbx+16], dl
14003be8a
14003be8aloc_14003be8a:
14003be8amov [rbx+8], rax
14003be8emov [rsi+rax], 0
14003be92
14003be92loc_14003be92:
14003be92mov rsi, [rip+0x15b7f7]
14003be99mov rax, [rsp+56]
14003be9esub rax, [rsi]
14003bea1jne 0x14003bf20
14003bea3mov rax, rbx
14003bea6add rsp, 64
14003beaapop rbx
14003beabpop rsi
14003beacpop rdi
14003beadret
14003beae
14003beae 66 90 f.
14003beb0
14003beb0loc_14003beb0:
14003beb0test rax, rax
14003beb3je 0x14003be8a
14003beb5jmp 0x14003bee9
14003beb7
14003beb7 66 0f 1f 84 00 00 00 00 00 f........
14003bec0
14003bec0loc_14003bec0:
14003bec0lea rdx, [rsp+48]
14003bec5xor r8l, r8l
14003bec8mov rcx, rbx
14003becbmov [rsp+40], rax
14003bed0call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_create(unsigned long long&, unsigned long long)
14003bed5mov r9, [rsp+40]
14003bedamov [rbx], rax
14003beddmov rsi, rax
14003bee0mov rax, [rsp+48]
14003bee5mov [rbx+16], rax
14003bee9
14003bee9loc_14003bee9:
14003bee9mov rcx, rsi
14003beecmov r8, r9
14003beefmov rdx, rdi
14003bef2call memcpy
14003bef7mov rax, [rsp+48]
14003befcmov rsi, [rbx]
14003beffjmp 0x14003be8a
14003bf01
14003bf01 0f 1f 80 00 00 00 00 .......
14003bf08
14003bf08loc_14003bf08:
14003bf08mov rcx, rbx
14003bf0bcall rax
14003bf0djmp 0x14003be92
14003bf0f
14003bf0floc_14003bf0f:
14003bf0fmov rcx, [rip+0x15b77a]
14003bf16mov rax, [rsp+56]
14003bf1bsub rax, [rcx]
14003bf1eje 0x14003bf25
14003bf20
14003bf20loc_14003bf20:
14003bf20call __stack_chk_fail
14003bf25
14003bf25loc_14003bf25:
14003bf25lea rcx, [rip+0x1554b4]
14003bf2ccall std::__throw_logic_error(char const*)
14003bf31nop
14003be20

14003bf32
14003bf32 // align 0x10

14003bf40
14003bf40std::__cxx11::moneypunct<wchar_t, true>::neg_format() const:
14003bf40lea rdx, [rip+601]
14003bf47mov rax, [rcx]
14003bf4amov rax, [rax+80]
14003bf4ecmp rax, rdx
14003bf51jne 0x14003bf60
14003bf53mov rax, [rcx+16]
14003bf57mov eax, [rax+96]
14003bf5aret
14003bf5bnop [rax+rax]
14003bf60
14003bf60loc_14003bf60:
14003bf60jmp rax
14003bf40

14003bf63
14003bf63 // align 0x10

14003bf70
14003bf70std::__cxx11::moneypunct<wchar_t, true>::pos_format() const:
14003bf70lea rdx, [rip+569]
14003bf77mov rax, [rcx]
14003bf7amov rax, [rax+72]
14003bf7ecmp rax, rdx
14003bf81jne 0x14003bf90
14003bf83mov rax, [rcx+16]
14003bf87mov eax, [rax+92]
14003bf8aret
14003bf8bnop [rax+rax]
14003bf90
14003bf90loc_14003bf90:
14003bf90jmp rax
14003bf70

14003bf93
14003bf93 // align 0x10

14003bfa0
14003bfa0std::__cxx11::moneypunct<wchar_t, true>::curr_symbol() const:
14003bfa0push rsi
14003bfa1push rbx
14003bfa2sub rsp, 56
14003bfa6mov rsi, [rip+0x15b6e3]
14003bfadmov rax, [rsi]
14003bfb0mov [rsp+40], rax
14003bfb5mov rax, [rdx]
14003bfb8mov rbx, rcx
14003bfbblea rcx, [rip+910]
14003bfc2mov rax, [rax+40]
14003bfc6cmp rax, rcx
14003bfc9jne 0x14003c018
14003bfcbmov rax, [rdx+16]
14003bfcfmov rsi, [rax+40]
14003bfd3lea rax, [rbx+16]
14003bfd7mov [rbx], rax
14003bfdatest rsi, rsi
14003bfddje 0x14003c01f
14003bfdfmov rcx, rsi
14003bfe2call wcslen
14003bfe7mov rdx, rsi
14003bfeamov rcx, rbx
14003bfedlea r8, [rsi+2*rax]
14003bff1call _ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_M_constructIPKwEEvT_S8_St20forward_iterator_tag.isra.0
14003bff6
14003bff6loc_14003bff6:
14003bff6mov rcx, [rip+0x15b693]
14003bffdmov rax, [rsp+40]
14003c002sub rax, [rcx]
14003c005jne 0x14003c030
14003c007mov rax, rbx
14003c00aadd rsp, 56
14003c00epop rbx
14003c00fpop rsi
14003c010ret
14003c011
14003c011 0f 1f 80 00 00 00 00 .......
14003c018
14003c018loc_14003c018:
14003c018mov rcx, rbx
14003c01bcall rax
14003c01djmp 0x14003bff6
14003c01f
14003c01floc_14003c01f:
14003c01fmov rbx, [rip+0x15b66a]
14003c026mov rax, [rsp+40]
14003c02bsub rax, [rbx]
14003c02eje 0x14003c035
14003c030
14003c030loc_14003c030:
14003c030call __stack_chk_fail
14003c035
14003c035loc_14003c035:
14003c035lea rcx, [rip+0x1553a4]
14003c03ccall std::__throw_logic_error(char const*)
14003c041nop
14003bfa0

14003c042
14003c042 // align 0x10

14003c050
14003c050std::__cxx11::moneypunct<wchar_t, true>::do_grouping() const:
14003c050push rdi
14003c051push rsi
14003c052push rbx
14003c053sub rsp, 64
14003c057mov rbx, rcx
14003c05amov rcx, [rip+0x15b62f]
14003c061lea rsi, [rbx+16]
14003c065mov rax, [rcx]
14003c068mov [rsp+56], rax
14003c06dmov rax, [rdx+16]
14003c071mov rdi, [rax+16]
14003c075mov [rbx], rsi
14003c078test rdi, rdi
14003c07bje 0x14003c121
14003c081mov rcx, rdi
14003c084call strlen
14003c089mov [rsp+48], rax
14003c08emov r9, rax
14003c091cmp rax, 15
14003c095ja 0x14003c0e0
14003c097cmp rax, 1
14003c09bjne 0x14003c0d0
14003c09dmovzx edx, [rdi]
14003c0a0mov [rbx+16], dl
14003c0a3
14003c0a3loc_14003c0a3:
14003c0a3mov [rbx+8], rax
14003c0a7mov rdi, [rip+0x15b5e2]
14003c0aemov [rsi+rax], 0
14003c0b2mov rax, [rsp+56]
14003c0b7sub rax, [rdi]
14003c0bajne 0x14003c12b
14003c0bcmov rax, rbx
14003c0bfadd rsp, 64
14003c0c3pop rbx
14003c0c4pop rsi
14003c0c5pop rdi
14003c0c6ret
14003c0c7
14003c0c7 66 0f 1f 84 00 00 00 00 00 f........
14003c0d0
14003c0d0loc_14003c0d0:
14003c0d0test rax, rax
14003c0d3je 0x14003c0a3
14003c0d5jmp 0x14003c109
14003c0d7
14003c0d7 66 0f 1f 84 00 00 00 00 00 f........
14003c0e0
14003c0e0loc_14003c0e0:
14003c0e0lea rdx, [rsp+48]
14003c0e5xor r8l, r8l
14003c0e8mov rcx, rbx
14003c0ebmov [rsp+40], rax
14003c0f0call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_create(unsigned long long&, unsigned long long)
14003c0f5mov r9, [rsp+40]
14003c0famov [rbx], rax
14003c0fdmov rsi, rax
14003c100mov rax, [rsp+48]
14003c105mov [rbx+16], rax
14003c109
14003c109loc_14003c109:
14003c109mov rcx, rsi
14003c10cmov r8, r9
14003c10fmov rdx, rdi
14003c112call memcpy
14003c117mov rax, [rsp+48]
14003c11cmov rsi, [rbx]
14003c11fjmp 0x14003c0a3
14003c121
14003c121loc_14003c121:
14003c121mov rax, [rsp+56]
14003c126sub rax, [rcx]
14003c129je 0x14003c130
14003c12b
14003c12bloc_14003c12b:
14003c12bcall __stack_chk_fail
14003c130
14003c130loc_14003c130:
14003c130lea rcx, [rip+0x1552a9]
14003c137call std::__throw_logic_error(char const*)
14003c13cnop
14003c050

14003c13d
14003c13d // align 0x10

14003c140
14003c140std::__cxx11::moneypunct<wchar_t, true>::frac_digits() const:
14003c140lea rdx, [rip+601]
14003c147mov rax, [rcx]
14003c14amov rax, [rax+64]
14003c14ecmp rax, rdx
14003c151jne 0x14003c160
14003c153mov rax, [rcx+16]
14003c157mov eax, [rax+88]
14003c15aret
14003c15bnop [rax+rax]
14003c160
14003c160loc_14003c160:
14003c160jmp rax
14003c140

14003c163
14003c163 // align 0x10

14003c170
14003c170std::__cxx11::moneypunct<wchar_t, true>::decimal_point() const:
14003c170lea rdx, [rip+569]
14003c177mov rax, [rcx]
14003c17amov rax, [rax+16]
14003c17ecmp rax, rdx
14003c181jne 0x14003c190
14003c183mov rax, [rcx+16]
14003c187movzx eax, [rax+34]
14003c18bret
14003c18cnop [rax]
14003c190
14003c190loc_14003c190:
14003c190jmp rax
14003c170

14003c193
14003c193 // align 0x10

14003c1a0
14003c1a0std::__cxx11::moneypunct<wchar_t, true>::do_neg_format() const:
14003c1a0mov rax, [rcx+16]
14003c1a4mov eax, [rax+96]
14003c1a7ret
14003c1a0

14003c1a8
14003c1a8 // align 0x10

14003c1b0
14003c1b0std::__cxx11::moneypunct<wchar_t, true>::do_pos_format() const:
14003c1b0mov rax, [rcx+16]
14003c1b4mov eax, [rax+92]
14003c1b7ret
14003c1b0

14003c1b8
14003c1b8 // align 0x10

14003c1c0
14003c1c0std::__cxx11::moneypunct<wchar_t, true>::negative_sign() const:
14003c1c0push rsi
14003c1c1push rbx
14003c1c2sub rsp, 56
14003c1c6mov rsi, [rip+0x15b4c3]
14003c1cdmov rax, [rsi]
14003c1d0mov [rsp+40], rax
14003c1d5mov rax, [rdx]
14003c1d8mov rbx, rcx
14003c1dblea rcx, [rip+478]
14003c1e2mov rax, [rax+56]
14003c1e6cmp rax, rcx
14003c1e9jne 0x14003c238
14003c1ebmov rax, [rdx+16]
14003c1efmov rsi, [rax+72]
14003c1f3lea rax, [rbx+16]
14003c1f7mov [rbx], rax
14003c1fatest rsi, rsi
14003c1fdje 0x14003c23f
14003c1ffmov rcx, rsi
14003c202call wcslen
14003c207mov rdx, rsi
14003c20amov rcx, rbx
14003c20dlea r8, [rsi+2*rax]
14003c211call _ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_M_constructIPKwEEvT_S8_St20forward_iterator_tag.isra.0
14003c216
14003c216loc_14003c216:
14003c216mov rcx, [rip+0x15b473]
14003c21dmov rax, [rsp+40]
14003c222sub rax, [rcx]
14003c225jne 0x14003c250
14003c227mov rax, rbx
14003c22aadd rsp, 56
14003c22epop rbx
14003c22fpop rsi
14003c230ret
14003c231
14003c231 0f 1f 80 00 00 00 00 .......
14003c238
14003c238loc_14003c238:
14003c238mov rcx, rbx
14003c23bcall rax
14003c23djmp 0x14003c216
14003c23f
14003c23floc_14003c23f:
14003c23fmov rbx, [rip+0x15b44a]
14003c246mov rax, [rsp+40]
14003c24bsub rax, [rbx]
14003c24eje 0x14003c255
14003c250
14003c250loc_14003c250:
14003c250call __stack_chk_fail
14003c255
14003c255loc_14003c255:
14003c255lea rcx, [rip+0x155184]
14003c25ccall std::__throw_logic_error(char const*)
14003c261nop
14003c1c0

14003c262
14003c262 // align 0x10

14003c270
14003c270std::__cxx11::moneypunct<wchar_t, true>::positive_sign() const:
14003c270push rsi
14003c271push rbx
14003c272sub rsp, 56
14003c276mov rsi, [rip+0x15b413]
14003c27dmov rax, [rsi]
14003c280mov [rsp+40], rax
14003c285mov rax, [rdx]
14003c288mov rbx, rcx
14003c28blea rcx, [rip+382]
14003c292mov rax, [rax+48]
14003c296cmp rax, rcx
14003c299jne 0x14003c2e8
14003c29bmov rax, [rdx+16]
14003c29fmov rsi, [rax+56]
14003c2a3lea rax, [rbx+16]
14003c2a7mov [rbx], rax
14003c2aatest rsi, rsi
14003c2adje 0x14003c2ef
14003c2afmov rcx, rsi
14003c2b2call wcslen
14003c2b7mov rdx, rsi
14003c2bamov rcx, rbx
14003c2bdlea r8, [rsi+2*rax]
14003c2c1call _ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_M_constructIPKwEEvT_S8_St20forward_iterator_tag.isra.0
14003c2c6
14003c2c6loc_14003c2c6:
14003c2c6mov rcx, [rip+0x15b3c3]
14003c2cdmov rax, [rsp+40]
14003c2d2sub rax, [rcx]
14003c2d5jne 0x14003c300
14003c2d7mov rax, rbx
14003c2daadd rsp, 56
14003c2depop rbx
14003c2dfpop rsi
14003c2e0ret
14003c2e1
14003c2e1 0f 1f 80 00 00 00 00 .......
14003c2e8
14003c2e8loc_14003c2e8:
14003c2e8mov rcx, rbx
14003c2ebcall rax
14003c2edjmp 0x14003c2c6
14003c2ef
14003c2efloc_14003c2ef:
14003c2efmov rbx, [rip+0x15b39a]
14003c2f6mov rax, [rsp+40]
14003c2fbsub rax, [rbx]
14003c2feje 0x14003c305
14003c300
14003c300loc_14003c300:
14003c300call __stack_chk_fail
14003c305
14003c305loc_14003c305:
14003c305lea rcx, [rip+0x1550d4]
14003c30ccall std::__throw_logic_error(char const*)
14003c311nop
14003c270

14003c312
14003c312 // align 0x10

14003c320
14003c320std::__cxx11::moneypunct<wchar_t, true>::thousands_sep() const:
14003c320lea rdx, [rip+313]
14003c327mov rax, [rcx]
14003c32amov rax, [rax+24]
14003c32ecmp rax, rdx
14003c331jne 0x14003c340
14003c333mov rax, [rcx+16]
14003c337movzx eax, [rax+36]
14003c33bret
14003c33cnop [rax]
14003c340
14003c340loc_14003c340:
14003c340jmp rax
14003c320

14003c343
14003c343 // align 0x10

14003c350
14003c350std::__cxx11::moneypunct<wchar_t, true>::do_curr_symbol() const:
14003c350push rsi
14003c351push rbx
14003c352sub rsp, 40
14003c356mov rax, [rdx+16]
14003c35amov rsi, [rax+40]
14003c35elea rax, [rcx+16]
14003c362mov rbx, rcx
14003c365mov [rcx], rax
14003c368test rsi, rsi
14003c36bje 0x14003c38e
14003c36dmov rcx, rsi
14003c370call wcslen
14003c375mov rdx, rsi
14003c378mov rcx, rbx
14003c37blea r8, [rsi+2*rax]
14003c37fcall _ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_M_constructIPKwEEvT_S8_St20forward_iterator_tag.isra.0
14003c384mov rax, rbx
14003c387add rsp, 40
14003c38bpop rbx
14003c38cpop rsi
14003c38dret
14003c38e
14003c38eloc_14003c38e:
14003c38elea rcx, [rip+0x15504b]
14003c395call std::__throw_logic_error(char const*)
14003c39anop
14003c350

14003c39b
14003c39b // align 0x10

14003c3a0
14003c3a0std::__cxx11::moneypunct<wchar_t, true>::do_frac_digits() const:
14003c3a0mov rax, [rcx+16]
14003c3a4mov eax, [rax+88]
14003c3a7ret
14003c3a0

14003c3a8
14003c3a8 // align 0x10

14003c3b0
14003c3b0std::__cxx11::moneypunct<wchar_t, true>::do_decimal_point() const:
14003c3b0mov rax, [rcx+16]
14003c3b4movzx eax, [rax+34]
14003c3b8ret
14003c3b0

14003c3b9
14003c3b9 // align 0x10

14003c3c0
14003c3c0std::__cxx11::moneypunct<wchar_t, true>::do_negative_sign() const:
14003c3c0push rsi
14003c3c1push rbx
14003c3c2sub rsp, 40
14003c3c6mov rax, [rdx+16]
14003c3camov rsi, [rax+72]
14003c3celea rax, [rcx+16]
14003c3d2mov rbx, rcx
14003c3d5mov [rcx], rax
14003c3d8test rsi, rsi
14003c3dbje 0x14003c3fe
14003c3ddmov rcx, rsi
14003c3e0call wcslen
14003c3e5mov rdx, rsi
14003c3e8mov rcx, rbx
14003c3eblea r8, [rsi+2*rax]
14003c3efcall _ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_M_constructIPKwEEvT_S8_St20forward_iterator_tag.isra.0
14003c3f4mov rax, rbx
14003c3f7add rsp, 40
14003c3fbpop rbx
14003c3fcpop rsi
14003c3fdret
14003c3fe
14003c3feloc_14003c3fe:
14003c3felea rcx, [rip+0x154fdb]
14003c405call std::__throw_logic_error(char const*)
14003c40anop
14003c3c0

14003c40b
14003c40b // align 0x10

14003c410
14003c410std::__cxx11::moneypunct<wchar_t, true>::do_positive_sign() const:
14003c410push rsi
14003c411push rbx
14003c412sub rsp, 40
14003c416mov rax, [rdx+16]
14003c41amov rsi, [rax+56]
14003c41elea rax, [rcx+16]
14003c422mov rbx, rcx
14003c425mov [rcx], rax
14003c428test rsi, rsi
14003c42bje 0x14003c44e
14003c42dmov rcx, rsi
14003c430call wcslen
14003c435mov rdx, rsi
14003c438mov rcx, rbx
14003c43blea r8, [rsi+2*rax]
14003c43fcall _ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEE12_M_constructIPKwEEvT_S8_St20forward_iterator_tag.isra.0
14003c444mov rax, rbx
14003c447add rsp, 40
14003c44bpop rbx
14003c44cpop rsi
14003c44dret
14003c44e
14003c44eloc_14003c44e:
14003c44elea rcx, [rip+0x154f8b]
14003c455call std::__throw_logic_error(char const*)
14003c45anop
14003c410

14003c45b
14003c45b // align 0x10

14003c460
14003c460std::__cxx11::moneypunct<wchar_t, true>::do_thousands_sep() const:
14003c460mov rax, [rcx+16]
14003c464movzx eax, [rax+36]
14003c468ret
14003c460

14003c469
14003c469 // align 0x10

14003c470
14003c470std::__cxx11::moneypunct<wchar_t, true>::grouping() const:
14003c470push rdi
14003c471push rsi
14003c472push rbx
14003c473sub rsp, 64
14003c477mov rdi, [rip+0x15b212]
14003c47emov rax, [rdi]
14003c481mov [rsp+56], rax
14003c486mov rax, [rdx]
14003c489mov rbx, rcx
14003c48clea rcx, [rip-1091]
14003c493mov rax, [rax+32]
14003c497cmp rax, rcx
14003c49ajne 0x14003c558
14003c4a0mov rax, [rdx+16]
14003c4a4lea rsi, [rbx+16]
14003c4a8mov rdi, [rax+16]
14003c4acmov [rbx], rsi
14003c4aftest rdi, rdi
14003c4b2je 0x14003c55f
14003c4b8mov rcx, rdi
14003c4bbcall strlen
14003c4c0mov [rsp+48], rax
14003c4c5mov r9, rax
14003c4c8cmp rax, 15
14003c4ccja 0x14003c510
14003c4cecmp rax, 1
14003c4d2jne 0x14003c500
14003c4d4movzx edx, [rdi]
14003c4d7mov [rbx+16], dl
14003c4da
14003c4daloc_14003c4da:
14003c4damov [rbx+8], rax
14003c4demov [rsi+rax], 0
14003c4e2
14003c4e2loc_14003c4e2:
14003c4e2mov rsi, [rip+0x15b1a7]
14003c4e9mov rax, [rsp+56]
14003c4eesub rax, [rsi]
14003c4f1jne 0x14003c570
14003c4f3mov rax, rbx
14003c4f6add rsp, 64
14003c4fapop rbx
14003c4fbpop rsi
14003c4fcpop rdi
14003c4fdret
14003c4fe
14003c4fe 66 90 f.
14003c500
14003c500loc_14003c500:
14003c500test rax, rax
14003c503je 0x14003c4da
14003c505jmp 0x14003c539
14003c507
14003c507 66 0f 1f 84 00 00 00 00 00 f........
14003c510
14003c510loc_14003c510:
14003c510lea rdx, [rsp+48]
14003c515xor r8l, r8l
14003c518mov rcx, rbx
14003c51bmov [rsp+40], rax
14003c520call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_create(unsigned long long&, unsigned long long)
14003c525mov r9, [rsp+40]
14003c52amov [rbx], rax
14003c52dmov rsi, rax
14003c530mov rax, [rsp+48]
14003c535mov [rbx+16], rax
14003c539
14003c539loc_14003c539:
14003c539mov rcx, rsi
14003c53cmov r8, r9
14003c53fmov rdx, rdi
14003c542call memcpy
14003c547mov rax, [rsp+48]
14003c54cmov rsi, [rbx]
14003c54fjmp 0x14003c4da
14003c551
14003c551 0f 1f 80 00 00 00 00 .......
14003c558
14003c558loc_14003c558:
14003c558mov rcx, rbx
14003c55bcall rax
14003c55djmp 0x14003c4e2
14003c55f
14003c55floc_14003c55f:
14003c55fmov rcx, [rip+0x15b12a]
14003c566mov rax, [rsp+56]
14003c56bsub rax, [rcx]
14003c56eje 0x14003c575
14003c570
14003c570loc_14003c570:
14003c570call __stack_chk_fail
14003c575
14003c575loc_14003c575:
14003c575lea rcx, [rip+0x154e64]
14003c57ccall std::__throw_logic_error(char const*)
14003c581nop
14003c470

14003c582
14003c582 // align 0x10

14003c590
14003c590std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_disjunct(char const*) const:
14003c590push rbp
14003c591push rbx
14003c592sub rsp, 56
14003c596lea rbp, [rsp+48]
14003c59bmov [rbp+32], rcx
14003c59fmov [rbp+40], rdx
14003c5a3mov rax, [rbp+32]
14003c5a7mov rcx, rax
14003c5aacall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_data() const
14003c5afmov rcx, rax
14003c5b2mov rdx, [rbp+40]
14003c5b6lea rax, [rbp-2]
14003c5bamov r8, rcx
14003c5bdmov rcx, rax
14003c5c0call std::less<char const*>::operator()(char const*, char const*) const
14003c5c5test al, al
14003c5c7jne 0x14003c5ff
14003c5c9mov rax, [rbp+32]
14003c5cdmov rcx, rax
14003c5d0call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_data() const
14003c5d5mov rbx, rax
14003c5d8mov rax, [rbp+32]
14003c5dcmov rcx, rax
14003c5dfcall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003c5e4lea rdx, [rbx+rax]
14003c5e8mov rcx, [rbp+40]
14003c5eclea rax, [rbp-1]
14003c5f0mov r8, rcx
14003c5f3mov rcx, rax
14003c5f6call std::less<char const*>::operator()(char const*, char const*) const
14003c5fbtest al, al
14003c5fdje 0x14003c606
14003c5ff
14003c5ffloc_14003c5ff:
14003c5ffmov eax, 1
14003c604jmp 0x14003c60b
14003c606
14003c606loc_14003c606:
14003c606mov eax, 0
14003c60b
14003c60bloc_14003c60b:
14003c60badd rsp, 56
14003c60fpop rbx
14003c610pop rbp
14003c611ret
14003c590

14003c612
14003c612 // align 0x10

14003c620
14003c620std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_is_local() const:
14003c620push rbp
14003c621push rbx
14003c622sub rsp, 40
14003c626lea rbp, [rsp+32]
14003c62bmov [rbp+32], rcx
14003c62fmov rax, [rbp+32]
14003c633mov rcx, rax
14003c636call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_data() const
14003c63bmov rbx, rax
14003c63emov rax, [rbp+32]
14003c642mov rcx, rax
14003c645call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_local_data() const
14003c64acmp rbx, rax
14003c64dsete al
14003c650test al, al
14003c652je 0x14003c667
14003c654mov rax, [rbp+32]
14003c658mov rax, [rax+8]
14003c65ccmp rax, 15
14003c660mov eax, 1
14003c665jmp 0x14003c66c
14003c667
14003c667loc_14003c667:
14003c667mov eax, 0
14003c66c
14003c66cloc_14003c66c:
14003c66cadd rsp, 40
14003c670pop rbx
14003c671pop rbp
14003c672ret
14003c620

14003c673
14003c673 // align 0x10

14003c680
14003c680std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(char const*, unsigned long long) const:
14003c680push rbp
14003c681mov rbp, rsp
14003c684sub rsp, 32
14003c688mov [rbp+16], rcx
14003c68cmov [rbp+24], rdx
14003c690mov [rbp+32], r8
14003c694mov rax, [rbp+24]
14003c698mov rcx, rax
14003c69bcall std::char_traits<char>::length(char const*)
14003c6a0mov rcx, rax
14003c6a3mov r8, [rbp+32]
14003c6a7mov rdx, [rbp+24]
14003c6abmov rax, [rbp+16]
14003c6afmov r9, rcx
14003c6b2mov rcx, rax
14003c6b5call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(char const*, unsigned long long, unsigned long long) const
14003c6baadd rsp, 32
14003c6bepop rbp
14003c6bfret
14003c680

14003c6c0
14003c6c0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(char const*, unsigned long long, unsigned long long) const:
14003c6c0push rbp
14003c6c1mov rbp, rsp
14003c6c4sub rsp, 48
14003c6c8mov [rbp+16], rcx
14003c6ccmov [rbp+24], rdx
14003c6d0mov [rbp+32], r8
14003c6d4mov [rbp+40], r9
14003c6d8mov rax, [rbp+16]
14003c6dcmov rcx, rax
14003c6dfcall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003c6e4mov [rbp-8], rax
14003c6e8cmp [rbp-8], 0
14003c6edje 0x14003c75f
14003c6efcmp [rbp+40], 0
14003c6f4je 0x14003c75f
14003c6f6sub [rbp-8], 1
14003c6fbmov rax, [rbp-8]
14003c6ffcmp [rbp+32], rax
14003c703setb al
14003c706test al, al
14003c708je 0x14003c712
14003c70amov rax, [rbp+32]
14003c70emov [rbp-8], rax
14003c712
14003c712loc_14003c712:
14003c712mov rax, [rbp+16]
14003c716mov rcx, rax
14003c719call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_data() const
14003c71emov rdx, [rbp-8]
14003c722lea rcx, [rax+rdx]
14003c726mov rdx, [rbp+40]
14003c72amov rax, [rbp+24]
14003c72emov r8, rcx
14003c731mov rcx, rax
14003c734call std::char_traits<char>::find(char const*, unsigned long long, char const&)
14003c739test rax, rax
14003c73csetne al
14003c73ftest al, al
14003c741je 0x14003c749
14003c743mov rax, [rbp-8]
14003c747jmp 0x14003c766
14003c749
14003c749loc_14003c749:
14003c749mov rax, [rbp-8]
14003c74dlea rdx, [rax-1]
14003c751mov [rbp-8], rdx
14003c755test rax, rax
14003c758setne al
14003c75btest al, al
14003c75djne 0x14003c712
14003c75f
14003c75floc_14003c75f:
14003c75fmov rax, -1
14003c766
14003c766loc_14003c766:
14003c766add rsp, 48
14003c76apop rbp
14003c76bret
14003c6c0

14003c76c
14003c76c // align 0x10

14003c770
14003c770std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long long) const:
14003c770mov rax, [rdx]
14003c773mov r9, [rdx+8]
14003c777mov rdx, rax
14003c77ajmp 0x14003c6c0
14003c770

14003c77f
14003c77f // align 0x10

14003c780
14003c780std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_of(char, unsigned long long) const:
14003c780movsx edx, dl
14003c783jmp 0x14003d010
14003c780

14003c788
14003c788 // align 0x10

14003c790
14003c790std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_local_data() const:
14003c790push rbp
14003c791mov rbp, rsp
14003c794sub rsp, 32
14003c798mov [rbp+16], rcx
14003c79cmov rax, [rbp+16]
14003c7a0add rax, 16
14003c7a4mov rcx, rax
14003c7a7call std::__ptr_traits_ptr_to<char const*, char const, false>::pointer_to(char const&)
14003c7acadd rsp, 32
14003c7b0pop rbp
14003c7b1ret
14003c790

14003c7b2
14003c7b2 // align 0x10

14003c7c0
14003c7c0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(char const*, unsigned long long) const:
14003c7c0push rbx
14003c7c1sub rsp, 48
14003c7c5mov rbx, rcx
14003c7c8mov rcx, rdx
14003c7cbmov [rsp+40], r8
14003c7d0mov [rsp+32], rdx
14003c7d5call strlen
14003c7damov r8, [rsp+40]
14003c7dfmov rdx, [rsp+32]
14003c7e4mov rcx, rbx
14003c7e7mov r9, rax
14003c7eaadd rsp, 48
14003c7eepop rbx
14003c7efjmp 0x14003c800
14003c7c0

14003c7f4
14003c7f4 // align 0x10

14003c800
14003c800std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(char const*, unsigned long long, unsigned long long) const:
14003c800push r12
14003c802push rbp
14003c803push rdi
14003c804push rsi
14003c805push rbx
14003c806sub rsp, 32
14003c80amov rax, -1
14003c811mov rdi, rcx
14003c814mov rbp, rdx
14003c817mov rbx, r8
14003c81amov rsi, r9
14003c81dtest r9, r9
14003c820je 0x14003c857
14003c822mov r12, [rcx+8]
14003c826jmp 0x14003c84b
14003c828
14003c828 0f 1f 84 00 00 00 00 00 ........
14003c830
14003c830loc_14003c830:
14003c830mov rax, [rdi]
14003c833mov r8, rsi
14003c836mov rcx, rbp
14003c839movsx edx, [rax+rbx]
14003c83dcall memchr
14003c842test rax, rax
14003c845jne 0x14003c868
14003c847add rbx, 1
14003c84b
14003c84bloc_14003c84b:
14003c84bcmp rbx, r12
14003c84ejb 0x14003c830
14003c850mov rax, -1
14003c857
14003c857loc_14003c857:
14003c857add rsp, 32
14003c85bpop rbx
14003c85cpop rsi
14003c85dpop rdi
14003c85epop rbp
14003c85fpop r12
14003c861ret
14003c862
14003c862 66 0f 1f 44 00 00 f..D..
14003c868
14003c868loc_14003c868:
14003c868mov rax, rbx
14003c86badd rsp, 32
14003c86fpop rbx
14003c870pop rsi
14003c871pop rdi
14003c872pop rbp
14003c873pop r12
14003c875ret
14003c800

14003c876
14003c876 // align 0x10

14003c880
14003c880std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long long) const:
14003c880mov rax, [rdx]
14003c883mov r9, [rdx+8]
14003c887mov rdx, rax
14003c88ajmp 0x14003c800
14003c880

14003c88f
14003c88f // align 0x10

14003c890
14003c890std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_of(char, unsigned long long) const:
14003c890movsx edx, dl
14003c893jmp 0x14003ce20
14003c890

14003c898
14003c898 // align 0x10

14003c8a0
14003c8a0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::get_allocator() const:
14003c8a0push rbp
14003c8a1mov rbp, rsp
14003c8a4sub rsp, 64
14003c8a8mov [rbp+16], rcx
14003c8acmov [rbp+24], rdx
14003c8b0mov rax, [rbp+24]
14003c8b4mov rcx, rax
14003c8b7call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_get_allocator() const
14003c8bcmov rdx, [rbp+16]
14003c8c0mov [rbp-8], rdx
14003c8c4mov [rbp-16], rax
14003c8c8mov rax, [rbp-8]
14003c8ccmov [rbp-24], rax
14003c8d0mov rax, [rbp-16]
14003c8d4mov [rbp-32], rax
14003c8d8nop
14003c8d9nop
14003c8danop
14003c8dbmov rax, [rbp+16]
14003c8dfadd rsp, 64
14003c8e3pop rbp
14003c8e4ret
14003c8a0

14003c8e5
14003c8e5 // align 0x10

14003c8f0
14003c8f0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_check_length(unsigned long long, unsigned long long, char const*) const:
14003c8f0push rbp
14003c8f1push rbx
14003c8f2sub rsp, 40
14003c8f6lea rbp, [rsp+32]
14003c8fbmov [rbp+32], rcx
14003c8ffmov [rbp+40], rdx
14003c903mov [rbp+48], r8
14003c907mov [rbp+56], r9
14003c90bmov rax, [rbp+32]
14003c90fmov rcx, rax
14003c912call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::max_size() const
14003c917mov rbx, rax
14003c91amov rax, [rbp+32]
14003c91emov rcx, rax
14003c921call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003c926mov rdx, [rbp+40]
14003c92asub rdx, rax
14003c92dlea rax, [rbx+rdx]
14003c931cmp rax, [rbp+48]
14003c935setb al
14003c938test al, al
14003c93aje 0x14003c948
14003c93cmov rax, [rbp+56]
14003c940mov rcx, rax
14003c943call std::__throw_length_error(char const*)
14003c948
14003c948loc_14003c948:
14003c948nop
14003c949add rsp, 40
14003c94dpop rbx
14003c94epop rbp
14003c94fret
14003c8f0

14003c950
14003c950std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_get_allocator() const:
14003c950push rbp
14003c951mov rbp, rsp
14003c954mov [rbp+16], rcx
14003c958mov rax, [rbp+16]
14003c95cpop rbp
14003c95dret
14003c950

14003c95e
14003c95e // align 0x10

14003c960
14003c960std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(char const*, unsigned long long) const:
14003c960push rbx
14003c961sub rsp, 48
14003c965mov rbx, rcx
14003c968mov rcx, rdx
14003c96bmov [rsp+40], r8
14003c970mov [rsp+32], rdx
14003c975call strlen
14003c97amov r8, [rsp+40]
14003c97fmov rdx, [rsp+32]
14003c984mov rcx, rbx
14003c987mov r9, rax
14003c98aadd rsp, 48
14003c98epop rbx
14003c98fjmp 0x14003c9a0
14003c960

14003c994
14003c994 // align 0x10

14003c9a0
14003c9a0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(char const*, unsigned long long, unsigned long long) const:
14003c9a0push rbp
14003c9a1push rdi
14003c9a2push rsi
14003c9a3push rbx
14003c9a4sub rsp, 40
14003c9a8mov rbx, -1
14003c9afmov rax, [rcx+8]
14003c9b3mov rdi, rdx
14003c9b6mov rsi, r9
14003c9b9test rax, rax
14003c9bcje 0x14003c9d1
14003c9besub rax, 1
14003c9c2mov rbx, r8
14003c9c5cmp rax, r8
14003c9c8cmovbe rbx, rax
14003c9cctest r9, r9
14003c9cfjne 0x14003c9e0
14003c9d1
14003c9d1loc_14003c9d1:
14003c9d1mov rax, rbx
14003c9d4add rsp, 40
14003c9d8pop rbx
14003c9d9pop rsi
14003c9dapop rdi
14003c9dbpop rbp
14003c9dcret
14003c9dd
14003c9dd 0f 1f 00 ...
14003c9e0
14003c9e0loc_14003c9e0:
14003c9e0mov rbp, [rcx]
14003c9e3jmp 0x14003c9f1
14003c9e5
14003c9e5 0f 1f 00 ...
14003c9e8
14003c9e8loc_14003c9e8:
14003c9e8test rbx, rbx
14003c9ebje 0x14003ca10
14003c9edsub rbx, 1
14003c9f1
14003c9f1loc_14003c9f1:
14003c9f1movsx edx, [rbp+rbx]
14003c9f6mov r8, rsi
14003c9f9mov rcx, rdi
14003c9fccall memchr
14003ca01test rax, rax
14003ca04jne 0x14003c9e8
14003ca06jmp 0x14003c9d1
14003ca08
14003ca08 0f 1f 84 00 00 00 00 00 ........
14003ca10
14003ca10loc_14003ca10:
14003ca10mov rbx, -1
14003ca17jmp 0x14003c9d1
14003c9a0

14003ca19
14003ca19 // align 0x10

14003ca20
14003ca20std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long long) const:
14003ca20mov rax, [rdx]
14003ca23mov r9, [rdx+8]
14003ca27mov rdx, rax
14003ca2ajmp 0x14003c9a0
14003ca20

14003ca2f
14003ca2f // align 0x10

14003ca30
14003ca30std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_last_not_of(char, unsigned long long) const:
14003ca30mov rax, -1
14003ca37mov r9, rcx
14003ca3amov rcx, [rcx+8]
14003ca3etest rcx, rcx
14003ca41je 0x14003ca6b
14003ca43sub rcx, 1
14003ca47mov rax, r8
14003ca4acmp rcx, r8
14003ca4dcmovbe rax, rcx
14003ca51mov rcx, [r9]
14003ca54jmp 0x14003ca66
14003ca56
14003ca56 66 2e 0f 1f 84 00 00 00 00 00 f.........
14003ca60
14003ca60loc_14003ca60:
14003ca60sub rax, 1
14003ca64jb 0x14003ca6b
14003ca66
14003ca66loc_14003ca66:
14003ca66cmp [rcx+rax], dl
14003ca69je 0x14003ca60
14003ca6b
14003ca6bloc_14003ca6b:
14003ca6bret
14003ca30

14003ca6c
14003ca6c // align 0x10

14003ca70
14003ca70std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(char const*, unsigned long long) const:
14003ca70push rbx
14003ca71sub rsp, 48
14003ca75mov rbx, rcx
14003ca78mov rcx, rdx
14003ca7bmov [rsp+40], r8
14003ca80mov [rsp+32], rdx
14003ca85call strlen
14003ca8amov r8, [rsp+40]
14003ca8fmov rdx, [rsp+32]
14003ca94mov rcx, rbx
14003ca97mov r9, rax
14003ca9aadd rsp, 48
14003ca9epop rbx
14003ca9fjmp 0x14003cab0
14003ca70

14003caa4
14003caa4 // align 0x10

14003cab0
14003cab0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(char const*, unsigned long long, unsigned long long) const:
14003cab0push r12
14003cab2push rbp
14003cab3push rdi
14003cab4push rsi
14003cab5push rbx
14003cab6sub rsp, 32
14003cabamov rbp, [rcx+8]
14003cabemov rdi, rdx
14003cac1mov rbx, r8
14003cac4mov rsi, r9
14003cac7cmp r8, rbp
14003cacajae 0x14003cb0e
14003cacctest r9, r9
14003cacfjne 0x14003cae0
14003cad1
14003cad1loc_14003cad1:
14003cad1mov rax, rbx
14003cad4add rsp, 32
14003cad8pop rbx
14003cad9pop rsi
14003cadapop rdi
14003cadbpop rbp
14003cadcpop r12
14003caderet
14003cadf
14003cadf 90 .
14003cae0
14003cae0loc_14003cae0:
14003cae0mov r12, [rcx]
14003cae3nop [rax+rax]
14003caeenop
14003caf0
14003caf0loc_14003caf0:
14003caf0movsx edx, [r12+rbx]
14003caf5mov r8, rsi
14003caf8mov rcx, rdi
14003cafbcall memchr
14003cb00test rax, rax
14003cb03je 0x14003cad1
14003cb05add rbx, 1
14003cb09cmp rbx, rbp
14003cb0cjne 0x14003caf0
14003cb0e
14003cb0eloc_14003cb0e:
14003cb0emov rbx, -1
14003cb15mov rax, rbx
14003cb18add rsp, 32
14003cb1cpop rbx
14003cb1dpop rsi
14003cb1epop rdi
14003cb1fpop rbp
14003cb20pop r12
14003cb22ret
14003cab0

14003cb23
14003cb23 // align 0x10

14003cb30
14003cb30std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long long) const:
14003cb30mov rax, [rdx]
14003cb33mov r9, [rdx+8]
14003cb37mov rdx, rax
14003cb3ajmp 0x14003cab0
14003cb30

14003cb3f
14003cb3f // align 0x10

14003cb40
14003cb40std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find_first_not_of(char, unsigned long long) const:
14003cb40mov r9l, edx
14003cb43mov rdx, [rcx+8]
14003cb47jmp 0x14003cb6d
14003cb49
14003cb49 66 66 2e 0f 1f 84 00 ff.....
14003cb50 00 00 00 00 66 66 2e 0f 1f 84 00 00 00 00 00 90 ....ff..........
14003cb60
14003cb60loc_14003cb60:
14003cb60mov rax, [rcx]
14003cb63cmp [rax+r8], r9b
14003cb67jne 0x14003cb80
14003cb69add r8, 1
14003cb6d
14003cb6dloc_14003cb6d:
14003cb6dcmp r8, rdx
14003cb70jb 0x14003cb60
14003cb72mov rax, -1
14003cb79ret
14003cb7a
14003cb7a 66 0f 1f 44 00 00 f..D..
14003cb80
14003cb80loc_14003cb80:
14003cb80mov rax, r8
14003cb83ret
14003cb40

14003cb84
14003cb84 // align 0x20

14003cba0
14003cba0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::at(unsigned long long) const:
14003cba0sub rsp, 40
14003cba4mov r8, [rcx+8]
14003cba8cmp rdx, r8
14003cbabjae 0x14003cbb8
14003cbadmov rax, [rcx]
14003cbb0add rax, rdx
14003cbb3add rsp, 40
14003cbb7ret
14003cbb8
14003cbb8loc_14003cbb8:
14003cbb8lea rcx, [rip+0x1551f1]
14003cbbfcall std::__throw_out_of_range_fmt(char const*, ...)
14003cbc4nop
14003cba0

14003cbc5
14003cbc5 // align 0x10

14003cbd0
14003cbd0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::end() const:
14003cbd0mov rax, [rcx]
14003cbd3add rax, [rcx+8]
14003cbd7ret
14003cbd0

14003cbd8
14003cbd8 // align 0x10

14003cbe0
14003cbe0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::back() const:
14003cbe0mov rax, [rcx+8]
14003cbe4mov rdx, [rcx]
14003cbe7lea rax, [rdx+rax-1]
14003cbecret
14003cbe0

14003cbed
14003cbed // align 0x10

14003cbf0
14003cbf0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::cend() const:
14003cbf0mov rax, [rcx]
14003cbf3add rax, [rcx+8]
14003cbf7ret
14003cbf0

14003cbf8
14003cbf8 // align 0x10

14003cc00
14003cc00std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::copy(char*, unsigned long long, unsigned long long) const:
14003cc00sub rsp, 56
14003cc04mov rax, rcx
14003cc07mov rcx, rdx
14003cc0amov rdx, r9
14003cc0dmov r9, [rax+8]
14003cc11cmp r9, rdx
14003cc14jb 0x14003cc55
14003cc16sub r9, rdx
14003cc19cmp r9, r8
14003cc1ccmovbe r8, r9
14003cc20test r8, r8
14003cc23je 0x14003cc3d
14003cc25add rdx, [rax]
14003cc28cmp r8, 1
14003cc2cje 0x14003cc48
14003cc2emov [rsp+40], r8
14003cc33call memcpy
14003cc38mov r8, [rsp+40]
14003cc3d
14003cc3dloc_14003cc3d:
14003cc3dmov rax, r8
14003cc40add rsp, 56
14003cc44ret
14003cc45
14003cc45 0f 1f 00 ...
14003cc48
14003cc48loc_14003cc48:
14003cc48movzx eax, [rdx]
14003cc4bmov [rcx], al
14003cc4dmov rax, r8
14003cc50add rsp, 56
14003cc54ret
14003cc55
14003cc55loc_14003cc55:
14003cc55mov r8, rdx
14003cc58lea rcx, [rip+0x155119]
14003cc5flea rdx, [rip+0x15522d]
14003cc66call std::__throw_out_of_range_fmt(char const*, ...)
14003cc6bnop
14003cc00

14003cc6c
14003cc6c // align 0x10

14003cc70
14003cc70std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::data() const:
14003cc70push rbp
14003cc71mov rbp, rsp
14003cc74sub rsp, 32
14003cc78mov [rbp+16], rcx
14003cc7cmov rax, [rbp+16]
14003cc80mov rcx, rax
14003cc83call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_data() const
14003cc88add rsp, 32
14003cc8cpop rbp
14003cc8dret
14003cc70

14003cc8e
14003cc8e // align 0x10

14003cc90
14003cc90std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(char const*, unsigned long long) const:
14003cc90push rbp
14003cc91mov rbp, rsp
14003cc94sub rsp, 32
14003cc98mov [rbp+16], rcx
14003cc9cmov [rbp+24], rdx
14003cca0mov [rbp+32], r8
14003cca4mov rax, [rbp+24]
14003cca8mov rcx, rax
14003ccabcall std::char_traits<char>::length(char const*)
14003ccb0mov rcx, rax
14003ccb3mov r8, [rbp+32]
14003ccb7mov rdx, [rbp+24]
14003ccbbmov rax, [rbp+16]
14003ccbfmov r9, rcx
14003ccc2mov rcx, rax
14003ccc5call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(char const*, unsigned long long, unsigned long long) const
14003cccaadd rsp, 32
14003cccepop rbp
14003cccfret
14003cc90

14003ccd0
14003ccd0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(char const*, unsigned long long, unsigned long long) const:
14003ccd0push rbp
14003ccd1mov rbp, rsp
14003ccd4sub rsp, 80
14003ccd8mov [rbp+16], rcx
14003ccdcmov [rbp+24], rdx
14003cce0mov [rbp+32], r8
14003cce4mov [rbp+40], r9
14003cce8mov rax, [rbp+16]
14003ccecmov rcx, rax
14003ccefcall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003ccf4mov [rbp-24], rax
14003ccf8cmp [rbp+40], 0
14003ccfdjne 0x14003cd21
14003ccffmov rax, [rbp+32]
14003cd03cmp [rbp-24], rax
14003cd07jb 0x14003cd15
14003cd09lea rax, [rbp+32]
14003cd0dmov rax, [rax]
14003cd10jmp 0x14003cdff
14003cd15
14003cd15loc_14003cd15:
14003cd15mov rax, -1
14003cd1cjmp 0x14003cdff
14003cd21
14003cd21loc_14003cd21:
14003cd21mov rax, [rbp+32]
14003cd25cmp rax, [rbp-24]
14003cd29jb 0x14003cd37
14003cd2bmov rax, -1
14003cd32jmp 0x14003cdff
14003cd37
14003cd37loc_14003cd37:
14003cd37mov rax, [rbp+24]
14003cd3bmovzx eax, [rax]
14003cd3emov [rbp-41], al
14003cd41mov rax, [rbp+16]
14003cd45mov rcx, rax
14003cd48call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::data() const
14003cd4dmov [rbp-32], rax
14003cd51mov rdx, [rbp+32]
14003cd55mov rax, [rbp-32]
14003cd59add rax, rdx
14003cd5cmov [rbp-8], rax
14003cd60mov rdx, [rbp-32]
14003cd64mov rax, [rbp-24]
14003cd68add rax, rdx
14003cd6bmov [rbp-40], rax
14003cd6fmov rax, [rbp+32]
14003cd73mov rdx, [rbp-24]
14003cd77sub rdx, rax
14003cd7amov [rbp-16], rdx
14003cd7ejmp 0x14003cdee
14003cd80
14003cd80loc_14003cd80:
14003cd80mov rax, [rbp-16]
14003cd84sub rax, [rbp+40]
14003cd88lea rdx, [rax+1]
14003cd8clea rcx, [rbp-41]
14003cd90mov rax, [rbp-8]
14003cd94mov r8, rcx
14003cd97mov rcx, rax
14003cd9acall std::char_traits<char>::find(char const*, unsigned long long, char const&)
14003cd9fmov [rbp-8], rax
14003cda3cmp [rbp-8], 0
14003cda8jne 0x14003cdb3
14003cdaamov rax, -1
14003cdb1jmp 0x14003cdff
14003cdb3
14003cdb3loc_14003cdb3:
14003cdb3mov rcx, [rbp+40]
14003cdb7mov rdx, [rbp+24]
14003cdbbmov rax, [rbp-8]
14003cdbfmov r8, rcx
14003cdc2mov rcx, rax
14003cdc5call std::char_traits<char>::compare(char const*, char const*, unsigned long long)
14003cdcatest eax, eax
14003cdccsete al
14003cdcftest al, al
14003cdd1je 0x14003cddd
14003cdd3mov rax, [rbp-8]
14003cdd7sub rax, [rbp-32]
14003cddbjmp 0x14003cdff
14003cddd
14003cdddloc_14003cddd:
14003cdddadd [rbp-8], 1
14003cde2mov rax, [rbp-40]
14003cde6sub rax, [rbp-8]
14003cdeamov [rbp-16], rax
14003cdee
14003cdeeloc_14003cdee:
14003cdeemov rax, [rbp-16]
14003cdf2cmp rax, [rbp+40]
14003cdf6jae 0x14003cd80
14003cdf8mov rax, -1
14003cdff
14003cdffloc_14003cdff:
14003cdffadd rsp, 80
14003ce03pop rbp
14003ce04ret
14003ccd0

14003ce05
14003ce05 // align 0x10

14003ce10
14003ce10std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long long) const:
14003ce10mov rax, [rdx]
14003ce13mov r9, [rdx+8]
14003ce17mov rdx, rax
14003ce1ajmp 0x14003ccd0
14003ce10

14003ce1f
14003ce1f // align 0x10

14003ce20
14003ce20std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::find(char, unsigned long long) const:
14003ce20push rsi
14003ce21push rbx
14003ce22sub rsp, 40
14003ce26mov rbx, -1
14003ce2dmov rax, [rcx+8]
14003ce31cmp r8, rax
14003ce34jae 0x14003ce58
14003ce36mov rsi, [rcx]
14003ce39sub rax, r8
14003ce3cmovsx edx, dl
14003ce3flea rcx, [rsi+r8]
14003ce43mov r8, rax
14003ce46call memchr
14003ce4bmov rdx, rax
14003ce4esub rdx, rsi
14003ce51test rax, rax
14003ce54cmovne rbx, rdx
14003ce58
14003ce58loc_14003ce58:
14003ce58mov rax, rbx
14003ce5badd rsp, 40
14003ce5fpop rbx
14003ce60pop rsi
14003ce61ret
14003ce20

14003ce62
14003ce62 // align 0x10

14003ce70
14003ce70std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::rend() const:
14003ce70mov rdx, [rdx]
14003ce73mov rax, rcx
14003ce76mov [rcx], rdx
14003ce79ret
14003ce70

14003ce7a
14003ce7a // align 0x10

14003ce80
14003ce80std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const:
14003ce80push rbp
14003ce81mov rbp, rsp
14003ce84sub rsp, 48
14003ce88mov [rbp+16], rcx
14003ce8cmov rax, [rbp+16]
14003ce90mov rax, [rax+8]
14003ce94mov [rbp-8], rax
14003ce98mov rax, [rbp+16]
14003ce9cmov rcx, rax
14003ce9fcall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::max_size() const
14003cea4cmp rax, [rbp-8]
14003cea8setb al
14003ceabtest al, al
14003ceadmov rax, [rbp-8]
14003ceb1add rsp, 48
14003ceb5pop rbp
14003ceb6ret
14003ce80

14003ceb7
14003ceb7 // align 0x10

14003cec0
14003cec0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::begin() const:
14003cec0mov rax, [rcx]
14003cec3ret
14003cec0

14003cec4
14003cec4 // align 0x10

14003ced0
14003ced0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::c_str() const:
14003ced0push rbp
14003ced1mov rbp, rsp
14003ced4sub rsp, 32
14003ced8mov [rbp+16], rcx
14003cedcmov rax, [rbp+16]
14003cee0mov rcx, rax
14003cee3call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_data() const
14003cee8add rsp, 32
14003ceecpop rbp
14003ceedret
14003ced0

14003ceee
14003ceee // align 0x10

14003cef0
14003cef0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::crend() const:
14003cef0mov rdx, [rdx]
14003cef3mov rax, rcx
14003cef6mov [rcx], rdx
14003cef9ret
14003cef0

14003cefa
14003cefa // align 0x10

14003cf00
14003cf00std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::empty() const:
14003cf00push rbp
14003cf01mov rbp, rsp
14003cf04mov [rbp+16], rcx
14003cf08mov rax, [rbp+16]
14003cf0cmov rax, [rax+8]
14003cf10test rax, rax
14003cf13sete al
14003cf16pop rbp
14003cf17ret
14003cf00

14003cf18
14003cf18 // align 0x10

14003cf20
14003cf20std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::front() const:
14003cf20mov rax, [rcx]
14003cf23ret
14003cf20

14003cf24
14003cf24 // align 0x10

14003cf30
14003cf30std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(char const*, unsigned long long) const:
14003cf30push rbx
14003cf31sub rsp, 48
14003cf35mov rbx, rcx
14003cf38mov rcx, rdx
14003cf3bmov [rsp+40], r8
14003cf40mov [rsp+32], rdx
14003cf45call strlen
14003cf4amov r8, [rsp+40]
14003cf4fmov rdx, [rsp+32]
14003cf54mov rcx, rbx
14003cf57mov r9, rax
14003cf5aadd rsp, 48
14003cf5epop rbx
14003cf5fjmp 0x14003cf70
14003cf30

14003cf64
14003cf64 // align 0x10

14003cf70
14003cf70std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(char const*, unsigned long long, unsigned long long) const:
14003cf70push rbp
14003cf71push rdi
14003cf72push rsi
14003cf73push rbx
14003cf74sub rsp, 40
14003cf78mov rax, -1
14003cf7fmov rdi, rdx
14003cf82mov rdx, [rcx+8]
14003cf86mov rsi, r9
14003cf89cmp rdx, r9
14003cf8cjb 0x14003cfa0
14003cf8esub rdx, r9
14003cf91mov rax, r8
14003cf94cmp rdx, r8
14003cf97cmovbe rax, rdx
14003cf9btest r9, r9
14003cf9ejne 0x14003cfb0
14003cfa0
14003cfa0loc_14003cfa0:
14003cfa0add rsp, 40
14003cfa4pop rbx
14003cfa5pop rsi
14003cfa6pop rdi
14003cfa7pop rbp
14003cfa8ret
14003cfa9
14003cfa9 0f 1f 80 00 00 00 00 .......
14003cfb0
14003cfb0loc_14003cfb0:
14003cfb0mov rbp, [rcx]
14003cfb3mov rbx, rax
14003cfb6jmp 0x14003cfc9
14003cfb8
14003cfb8 0f 1f 84 00 00 00 00 00 ........
14003cfc0
14003cfc0loc_14003cfc0:
14003cfc0test rbx, rbx
14003cfc3je 0x14003cfe8
14003cfc5sub rbx, 1
14003cfc9
14003cfc9loc_14003cfc9:
14003cfc9lea rcx, [rbp+rbx]
14003cfcemov r8, rsi
14003cfd1mov rdx, rdi
14003cfd4call memcmp
14003cfd9test eax, eax
14003cfdbjne 0x14003cfc0
14003cfddmov rax, rbx
14003cfe0jmp 0x14003cfa0
14003cfe2
14003cfe2 66 0f 1f 44 00 00 f..D..
14003cfe8
14003cfe8loc_14003cfe8:
14003cfe8mov rax, -1
14003cfefjmp 0x14003cfa0
14003cf70

14003cff1
14003cff1 // align 0x10

14003d000
14003d000std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long long) const:
14003d000mov rax, [rdx]
14003d003mov r9, [rdx+8]
14003d007mov rdx, rax
14003d00ajmp 0x14003cf70
14003d000

14003d00f
14003d00f // align 0x10

14003d010
14003d010std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::rfind(char, unsigned long long) const:
14003d010mov rax, -1
14003d017mov r9, rcx
14003d01amov rcx, [rcx+8]
14003d01etest rcx, rcx
14003d021je 0x14003d055
14003d023sub rcx, 1
14003d027cmp rcx, r8
14003d02acmova rcx, r8
14003d02elea rax, [rcx+1]
14003d032mov rcx, [r9]
14003d035nop [rax+rax]
14003d040
14003d040loc_14003d040:
14003d040sub rax, 1
14003d044cmp [rcx+rax], dl
14003d047je 0x14003d055
14003d049test rax, rax
14003d04cjne 0x14003d040
14003d04emov rax, -1
14003d055
14003d055loc_14003d055:
14003d055ret
14003d010

14003d056
14003d056 // align 0x10

14003d060
14003d060std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::cbegin() const:
14003d060mov rax, [rcx]
14003d063ret
14003d060

14003d064
14003d064 // align 0x10

14003d070
14003d070std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::length() const:
14003d070push rbp
14003d071mov rbp, rsp
14003d074sub rsp, 32
14003d078mov [rbp+16], rcx
14003d07cmov rax, [rbp+16]
14003d080mov rcx, rax
14003d083call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003d088add rsp, 32
14003d08cpop rbp
14003d08dret
14003d070

14003d08e
14003d08e // align 0x10

14003d090
14003d090std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::rbegin() const:
14003d090mov rax, rcx
14003d093mov rcx, [rdx]
14003d096add rcx, [rdx+8]
14003d09amov [rax], rcx
14003d09dret
14003d090

14003d09e
14003d09e // align 0x10

14003d0a0
14003d0a0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::substr(unsigned long long, unsigned long long) const:
14003d0a0push rbp
14003d0a1mov rbp, rsp
14003d0a4sub rsp, 32
14003d0a8mov [rbp+16], rcx
14003d0acmov [rbp+24], rdx
14003d0b0mov [rbp+32], r8
14003d0b4mov [rbp+40], r9
14003d0b8lea rcx, [rip+0xcbde1]
14003d0bfmov rdx, [rbp+32]
14003d0c3mov rax, [rbp+24]
14003d0c7mov r8, rcx
14003d0camov rcx, rax
14003d0cdcall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_check(unsigned long long, char const*) const
14003d0d2mov rcx, rax
14003d0d5mov r8, [rbp+40]
14003d0d9mov rdx, [rbp+24]
14003d0ddmov rax, [rbp+16]
14003d0e1mov r9, r8
14003d0e4mov r8, rcx
14003d0e7mov rcx, rax
14003d0eacall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long long, unsigned long long)
14003d0efmov rax, [rbp+16]
14003d0f3add rsp, 32
14003d0f7pop rbp
14003d0f8ret
14003d0a0

14003d0f9
14003d0f9 // align 0x10

14003d100
14003d100std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_data() const:
14003d100push rbp
14003d101mov rbp, rsp
14003d104mov [rbp+16], rcx
14003d108mov rax, [rbp+16]
14003d10cmov rax, [rax]
14003d10fpop rbp
14003d110ret
14003d100

14003d111
14003d111 // align 0x10

14003d120
14003d120std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(char const*) const:
14003d120push rbp
14003d121push rdi
14003d122push rsi
14003d123push rbx
14003d124sub rsp, 40
14003d128mov rbx, [rcx+8]
14003d12cmov rbp, rcx
14003d12fmov rcx, rdx
14003d132mov rdi, rdx
14003d135call strlen
14003d13amov r8, rbx
14003d13dcmp rax, rbx
14003d140mov rsi, rax
14003d143cmovbe r8, rax
14003d147test r8, r8
14003d14aje 0x14003d15c
14003d14cmov rcx, [rbp]
14003d150mov rdx, rdi
14003d153call memcmp
14003d158test eax, eax
14003d15ajne 0x14003d17c
14003d15c
14003d15cloc_14003d15c:
14003d15csub rbx, rsi
14003d15fmov eax, 0x7fffffff
14003d164cmp rbx, 0x7fffffff
14003d16bjg 0x14003d17c
14003d16dcmp rbx, 0xffffffff80000000
14003d174mov eax, 0xffffffff80000000
14003d179cmovge eax, ebx
14003d17c
14003d17cloc_14003d17c:
14003d17cadd rsp, 40
14003d180pop rbx
14003d181pop rsi
14003d182pop rdi
14003d183pop rbp
14003d184ret
14003d120

14003d185
14003d185 // align 0x10

14003d190
14003d190std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
14003d190push rsi
14003d191push rbx
14003d192sub rsp, 40
14003d196mov rbx, [rcx+8]
14003d19amov rsi, [rdx+8]
14003d19emov r8, rbx
14003d1a1cmp rsi, rbx
14003d1a4cmovbe r8, rsi
14003d1a8test r8, r8
14003d1abje 0x14003d1bc
14003d1admov rdx, [rdx]
14003d1b0mov rcx, [rcx]
14003d1b3call memcmp
14003d1b8test eax, eax
14003d1bajne 0x14003d1dc
14003d1bc
14003d1bcloc_14003d1bc:
14003d1bcsub rbx, rsi
14003d1bfmov eax, 0x7fffffff
14003d1c4cmp rbx, 0x7fffffff
14003d1cbjg 0x14003d1dc
14003d1cdcmp rbx, 0xffffffff80000000
14003d1d4mov eax, 0xffffffff80000000
14003d1d9cmovge eax, ebx
14003d1dc
14003d1dcloc_14003d1dc:
14003d1dcadd rsp, 40
14003d1e0pop rbx
14003d1e1pop rsi
14003d1e2ret
14003d190

14003d1e3
14003d1e3 // align 0x10

14003d1f0
14003d1f0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(unsigned long long, unsigned long long, char const*) const:
14003d1f0push r12
14003d1f2push rbp
14003d1f3push rdi
14003d1f4push rsi
14003d1f5push rbx
14003d1f6sub rsp, 32
14003d1famov rbx, [rcx+8]
14003d1femov r12, rcx
14003d201mov rsi, rdx
14003d204mov rbp, r9
14003d207cmp rbx, rdx
14003d20ajb 0x14003d26e
14003d20csub rbx, rdx
14003d20fmov rcx, r9
14003d212cmp rbx, r8
14003d215cmova rbx, r8
14003d219call strlen
14003d21ecmp rax, rbx
14003d221mov r8, rbx
14003d224mov rdi, rax
14003d227cmovbe r8, rax
14003d22btest r8, r8
14003d22eje 0x14003d243
14003d230add rsi, [r12]
14003d234mov rdx, rbp
14003d237mov rcx, rsi
14003d23acall memcmp
14003d23ftest eax, eax
14003d241jne 0x14003d263
14003d243
14003d243loc_14003d243:
14003d243sub rbx, rdi
14003d246mov eax, 0x7fffffff
14003d24bcmp rbx, 0x7fffffff
14003d252jg 0x14003d263
14003d254cmp rbx, 0xffffffff80000000
14003d25bmov eax, 0xffffffff80000000
14003d260cmovge eax, ebx
14003d263
14003d263loc_14003d263:
14003d263add rsp, 32
14003d267pop rbx
14003d268pop rsi
14003d269pop rdi
14003d26apop rbp
14003d26bpop r12
14003d26dret
14003d26e
14003d26eloc_14003d26e:
14003d26emov r8, rdx
14003d271mov r9, rbx
14003d274lea rdx, [rip+0x154c2b]
14003d27blea rcx, [rip+0x154af6]
14003d282call std::__throw_out_of_range_fmt(char const*, ...)
14003d287nop
14003d1f0

14003d288
14003d288 // align 0x10

14003d290
14003d290std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(unsigned long long, unsigned long long, char const*, unsigned long long) const:
14003d290push rsi
14003d291push rbx
14003d292sub rsp, 40
14003d296mov rbx, [rcx+8]
14003d29amov rsi, [rsp+96]
14003d29fcmp rbx, rdx
14003d2a2jb 0x14003d2f6
14003d2a4sub rbx, rdx
14003d2a7cmp rbx, r8
14003d2aacmova rbx, r8
14003d2aemov r8, rsi
14003d2b1cmp rbx, rsi
14003d2b4cmovbe r8, rbx
14003d2b8test r8, r8
14003d2bbje 0x14003d2cf
14003d2bdadd rdx, [rcx]
14003d2c0mov rcx, rdx
14003d2c3mov rdx, r9
14003d2c6call memcmp
14003d2cbtest eax, eax
14003d2cdjne 0x14003d2ef
14003d2cf
14003d2cfloc_14003d2cf:
14003d2cfsub rbx, rsi
14003d2d2mov eax, 0x7fffffff
14003d2d7cmp rbx, 0x7fffffff
14003d2dejg 0x14003d2ef
14003d2e0cmp rbx, 0xffffffff80000000
14003d2e7mov eax, 0xffffffff80000000
14003d2eccmovge eax, ebx
14003d2ef
14003d2efloc_14003d2ef:
14003d2efadd rsp, 40
14003d2f3pop rbx
14003d2f4pop rsi
14003d2f5ret
14003d2f6
14003d2f6loc_14003d2f6:
14003d2f6mov r8, rdx
14003d2f9mov r9, rbx
14003d2fclea rdx, [rip+0x154ba3]
14003d303lea rcx, [rip+0x154a6e]
14003d30acall std::__throw_out_of_range_fmt(char const*, ...)
14003d30fnop
14003d290

14003d310
14003d310std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(unsigned long long, unsigned long long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
14003d310push rsi
14003d311push rbx
14003d312sub rsp, 40
14003d316mov rbx, [rcx+8]
14003d31acmp rbx, rdx
14003d31djb 0x14003d378
14003d31fsub rbx, rdx
14003d322mov rsi, [r9+8]
14003d326cmp rbx, r8
14003d329cmova rbx, r8
14003d32dcmp rsi, rbx
14003d330mov r8, rbx
14003d333cmovbe r8, rsi
14003d337test r8, r8
14003d33aje 0x14003d351
14003d33cmov rax, [r9]
14003d33fadd rdx, [rcx]
14003d342mov rcx, rdx
14003d345mov rdx, rax
14003d348call memcmp
14003d34dtest eax, eax
14003d34fjne 0x14003d371
14003d351
14003d351loc_14003d351:
14003d351sub rbx, rsi
14003d354mov eax, 0x7fffffff
14003d359cmp rbx, 0x7fffffff
14003d360jg 0x14003d371
14003d362cmp rbx, 0xffffffff80000000
14003d369mov eax, 0xffffffff80000000
14003d36ecmovge eax, ebx
14003d371
14003d371loc_14003d371:
14003d371add rsp, 40
14003d375pop rbx
14003d376pop rsi
14003d377ret
14003d378
14003d378loc_14003d378:
14003d378mov r8, rdx
14003d37bmov r9, rbx
14003d37elea rdx, [rip+0x154b21]
14003d385lea rcx, [rip+0x1549ec]
14003d38ccall std::__throw_out_of_range_fmt(char const*, ...)
14003d391nop
14003d310

14003d392
14003d392 // align 0x10

14003d3a0
14003d3a0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::compare(unsigned long long, unsigned long long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long long, unsigned long long) const:
14003d3a0push rsi
14003d3a1push rbx
14003d3a2sub rsp, 40
14003d3a6mov rbx, [rcx+8]
14003d3aamov rax, [rsp+96]
14003d3afmov r10, rcx
14003d3b2cmp rbx, rdx
14003d3b5jb 0x14003d424
14003d3b7mov rsi, [r9+8]
14003d3bbcmp rsi, rax
14003d3bejb 0x14003d43d
14003d3c0sub rbx, rdx
14003d3c3mov rcx, [rsp+104]
14003d3c8cmp rbx, r8
14003d3cbcmova rbx, r8
14003d3cfsub rsi, rax
14003d3d2cmp rsi, rcx
14003d3d5cmova rsi, rcx
14003d3d9mov r8, rbx
14003d3dccmp rsi, rbx
14003d3dfcmovbe r8, rsi
14003d3e3test r8, r8
14003d3e6je 0x14003d3fd
14003d3e8add rdx, [r10]
14003d3ebadd rax, [r9]
14003d3eemov rcx, rdx
14003d3f1mov rdx, rax
14003d3f4call memcmp
14003d3f9test eax, eax
14003d3fbjne 0x14003d41d
14003d3fd
14003d3fdloc_14003d3fd:
14003d3fdsub rbx, rsi
14003d400mov eax, 0x7fffffff
14003d405cmp rbx, 0x7fffffff
14003d40cjg 0x14003d41d
14003d40ecmp rbx, 0xffffffff80000000
14003d415mov eax, 0xffffffff80000000
14003d41acmovge eax, ebx
14003d41d
14003d41dloc_14003d41d:
14003d41dadd rsp, 40
14003d421pop rbx
14003d422pop rsi
14003d423ret
14003d424
14003d424loc_14003d424:
14003d424mov r8, rdx
14003d427mov r9, rbx
14003d42alea rdx, [rip+0x154a75]
14003d431lea rcx, [rip+0x154940]
14003d438call std::__throw_out_of_range_fmt(char const*, ...)
14003d43d
14003d43dloc_14003d43d:
14003d43dmov r9, rsi
14003d440mov r8, rax
14003d443lea rdx, [rip+0x154a5c]
14003d44alea rcx, [rip+0x154927]
14003d451call std::__throw_out_of_range_fmt(char const*, ...)
14003d456nop
14003d3a0

14003d457
14003d457 // align 0x10

14003d460
14003d460std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::crbegin() const:
14003d460mov rax, rcx
14003d463mov rcx, [rdx]
14003d466add rcx, [rdx+8]
14003d46amov [rax], rcx
14003d46dret
14003d460

14003d46e
14003d46e // align 0x10

14003d470
14003d470std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_check(unsigned long long, char const*) const:
14003d470push rbp
14003d471mov rbp, rsp
14003d474sub rsp, 32
14003d478mov [rbp+16], rcx
14003d47cmov [rbp+24], rdx
14003d480mov [rbp+32], r8
14003d484mov rax, [rbp+16]
14003d488mov rcx, rax
14003d48bcall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003d490cmp rax, [rbp+24]
14003d494setb al
14003d497test al, al
14003d499je 0x14003d4c4
14003d49bmov rax, [rbp+16]
14003d49fmov rcx, rax
14003d4a2call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003d4a7mov rdx, rax
14003d4aamov r8, [rbp+24]
14003d4aemov rax, [rbp+32]
14003d4b2lea rcx, [rip+0xcbfa7]
14003d4b9mov r9, rdx
14003d4bcmov rdx, rax
14003d4bfcall std::__throw_out_of_range_fmt(char const*, ...)
14003d4c4
14003d4c4loc_14003d4c4:
14003d4c4mov rax, [rbp+24]
14003d4c8add rsp, 32
14003d4ccpop rbp
14003d4cdret
14003d470

14003d4ce
14003d4ce // align 0x10

14003d4d0
14003d4d0std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_limit(unsigned long long, unsigned long long) const:
14003d4d0push rbp
14003d4d1mov rbp, rsp
14003d4d4sub rsp, 48
14003d4d8mov [rbp+16], rcx
14003d4dcmov [rbp+24], rdx
14003d4e0mov [rbp+32], r8
14003d4e4mov rax, [rbp+16]
14003d4e8mov rcx, rax
14003d4ebcall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003d4f0sub rax, [rbp+24]
14003d4f4cmp [rbp+32], rax
14003d4f8setb al
14003d4fbmov [rbp-1], al
14003d4fecmp [rbp-1], 0
14003d502je 0x14003d50a
14003d504mov rax, [rbp+32]
14003d508jmp 0x14003d51a
14003d50a
14003d50aloc_14003d50a:
14003d50amov rax, [rbp+16]
14003d50emov rcx, rax
14003d511call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003d516sub rax, [rbp+24]
14003d51a
14003d51aloc_14003d51a:
14003d51aadd rsp, 48
14003d51epop rbp
14003d51fret
14003d4d0

14003d520
14003d520std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::capacity() const:
14003d520push rbp
14003d521mov rbp, rsp
14003d524sub rsp, 48
14003d528mov [rbp+16], rcx
14003d52cmov rax, [rbp+16]
14003d530mov rcx, rax
14003d533call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_is_local() const
14003d538test al, al
14003d53aje 0x14003d546
14003d53cmov [rbp-8], 15
14003d544jmp 0x14003d552
14003d546
14003d546loc_14003d546:
14003d546mov rax, [rbp+16]
14003d54amov rax, [rax+16]
14003d54emov [rbp-8], rax
14003d552
14003d552loc_14003d552:
14003d552cmp [rbp-8], 14
14003d557jbe 0x14003d56b
14003d559mov rax, [rbp+16]
14003d55dmov rcx, rax
14003d560call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::max_size() const
14003d565cmp rax, [rbp-8]
14003d569jae 0x14003d572
14003d56b
14003d56bloc_14003d56b:
14003d56bmov eax, 1
14003d570jmp 0x14003d577
14003d572
14003d572loc_14003d572:
14003d572mov eax, 0
14003d577
14003d577loc_14003d577:
14003d577test al, al
14003d579mov rax, [rbp-8]
14003d57dadd rsp, 48
14003d581pop rbp
14003d582ret
14003d520

14003d583
14003d583 // align 0x10

14003d590
14003d590std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::max_size() const:
14003d590push rbp
14003d591mov rbp, rsp
14003d594sub rsp, 80
14003d598mov [rbp+16], rcx
14003d59cmov rax, 0x7fffffffffffffff
14003d5a6mov [rbp-32], rax
14003d5aamov rax, [rbp+16]
14003d5aemov rcx, rax
14003d5b1call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_get_allocator() const
14003d5b6mov [rbp-8], rax
14003d5bamov rax, [rbp-8]
14003d5bemov [rbp-16], rax
14003d5c2mov rax, [rbp-16]
14003d5c6mov [rbp-24], rax
14003d5camov rax, 0x7fffffffffffffff
14003d5d4nop
14003d5d5nop
14003d5d6mov [rbp-40], rax
14003d5dalea rdx, [rbp-40]
14003d5delea rax, [rbp-32]
14003d5e2mov rcx, rax
14003d5e5call unsigned long long const& std::min<unsigned long long>(unsigned long long const&, unsigned long long const&)
14003d5eamov rax, [rax]
14003d5edsub rax, 1
14003d5f1add rsp, 80
14003d5f5pop rbp
14003d5f6ret
14003d590

14003d5f7
14003d5f7 // align 0x10

14003d600
14003d600std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator std::basic_string_view<char, std::char_traits<char>>() const:
14003d600push rbp
14003d601push rbx
14003d602sub rsp, 40
14003d606lea rbp, [rsp+32]
14003d60bmov [rbp+32], rcx
14003d60fmov [rbp+40], rdx
14003d613mov rax, [rbp+40]
14003d617mov rcx, rax
14003d61acall std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::size() const
14003d61fmov rbx, rax
14003d622mov rax, [rbp+40]
14003d626mov rcx, rax
14003d629call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::data() const
14003d62emov rdx, rax
14003d631mov rax, [rbp+32]
14003d635mov r8, rbx
14003d638mov rcx, rax
14003d63bcall std::basic_string_view<char, std::char_traits<char>>::basic_string_view(char const*, unsigned long long)
14003d640mov rax, [rbp+32]
14003d644add rsp, 40
14003d648pop rbx
14003d649pop rbp
14003d64aret
14003d600

14003d64b
14003d64b // align 0x10

14003d650
14003d650std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::operator[](unsigned long long) const:
14003d650mov rax, [rcx]
14003d653add rax, rdx
14003d656ret
14003d650

14003d657
14003d657 // align 0x10

14003d660
14003d660std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_disjunct(wchar_t const*) const:
14003d660mov eax, 1
14003d665mov r8, rcx
14003d668mov rcx, [rcx]
14003d66bcmp rdx, rcx
14003d66ejb 0x14003d67e
14003d670mov rax, [r8+8]
14003d674lea rax, [rcx+2*rax]
14003d678cmp rax, rdx
14003d67bsetb al
14003d67e
14003d67eloc_14003d67e:
14003d67eret
14003d660

14003d67f
14003d67f // align 0x10

14003d680
14003d680std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_is_local() const:
14003d680push rbp
14003d681push rbx
14003d682sub rsp, 40
14003d686lea rbp, [rsp+32]
14003d68bmov [rbp+32], rcx
14003d68fmov rax, [rbp+32]
14003d693mov rcx, rax
14003d696call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_data() const
14003d69bmov rbx, rax
14003d69emov rax, [rbp+32]
14003d6a2mov rcx, rax
14003d6a5call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_local_data() const
14003d6aacmp rbx, rax
14003d6adsete al
14003d6b0test al, al
14003d6b2je 0x14003d6c7
14003d6b4mov rax, [rbp+32]
14003d6b8mov rax, [rax+8]
14003d6bccmp rax, 7
14003d6c0mov eax, 1
14003d6c5jmp 0x14003d6cc
14003d6c7
14003d6c7loc_14003d6c7:
14003d6c7mov eax, 0
14003d6cc
14003d6ccloc_14003d6cc:
14003d6ccadd rsp, 40
14003d6d0pop rbx
14003d6d1pop rbp
14003d6d2ret
14003d680

14003d6d3
14003d6d3 // align 0x10

14003d6e0
14003d6e0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(wchar_t const*, unsigned long long) const:
14003d6e0push rbx
14003d6e1sub rsp, 48
14003d6e5mov rbx, rcx
14003d6e8mov rcx, rdx
14003d6ebmov [rsp+40], r8
14003d6f0mov [rsp+32], rdx
14003d6f5call wcslen
14003d6famov r8, [rsp+40]
14003d6ffmov rdx, [rsp+32]
14003d704mov rcx, rbx
14003d707mov r9, rax
14003d70aadd rsp, 48
14003d70epop rbx
14003d70fjmp 0x14003d720
14003d6e0

14003d714
14003d714 // align 0x10

14003d720
14003d720std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(wchar_t const*, unsigned long long, unsigned long long) const:
14003d720mov r10, [rcx+8]
14003d724test r10, r10
14003d727je 0x14003d77e
14003d729test r9, r9
14003d72cje 0x14003d77e
14003d72esub r10, 1
14003d732cmp r10, r8
14003d735cmova r10, r8
14003d739test rdx, rdx
14003d73cje 0x14003d770
14003d73emov r11, [rcx]
14003d741
14003d741loc_14003d741:
14003d741movzx r8l, [r11+2*r10]
14003d746mov rcx, r9
14003d749mov rax, rdx
14003d74cnop [rax]
14003d750
14003d750loc_14003d750:
14003d750cmp r8w, [rax]
14003d754je 0x14003d766
14003d756add rax, 2
14003d75asub rcx, 1
14003d75ejne 0x14003d750
14003d760sub r10, 1
14003d764jae 0x14003d741
14003d766
14003d766loc_14003d766:
14003d766mov rax, r10
14003d769ret
14003d76a
14003d76a 66 0f 1f 44 00 00 f..D..
14003d770
14003d770loc_14003d770:
14003d770sub r10, 1
14003d774jb 0x14003d766
14003d776sub r10, 1
14003d77ajae 0x14003d770
14003d77cjmp 0x14003d766
14003d77e
14003d77eloc_14003d77e:
14003d77emov r10, -1
14003d785mov rax, r10
14003d788ret
14003d720

14003d789
14003d789 // align 0x10

14003d790
14003d790std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, unsigned long long) const:
14003d790mov rax, [rdx]
14003d793mov r9, [rdx+8]
14003d797mov rdx, rax
14003d79ajmp 0x14003d720
14003d790

14003d79f
14003d79f // align 0x10

14003d7a0
14003d7a0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_of(wchar_t, unsigned long long) const:
14003d7a0movzx edx, dx
14003d7a3jmp 0x14003e010
14003d7a0

14003d7a8
14003d7a8 // align 0x10

14003d7b0
14003d7b0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_local_data() const:
14003d7b0push rbp
14003d7b1mov rbp, rsp
14003d7b4sub rsp, 32
14003d7b8mov [rbp+16], rcx
14003d7bcmov rax, [rbp+16]
14003d7c0add rax, 16
14003d7c4mov rcx, rax
14003d7c7call std::__ptr_traits_ptr_to<wchar_t const*, wchar_t const, false>::pointer_to(wchar_t const&)
14003d7ccadd rsp, 32
14003d7d0pop rbp
14003d7d1ret
14003d7b0

14003d7d2
14003d7d2 // align 0x10

14003d7e0
14003d7e0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(wchar_t const*, unsigned long long) const:
14003d7e0push rbx
14003d7e1sub rsp, 48
14003d7e5mov rbx, rcx
14003d7e8mov rcx, rdx
14003d7ebmov [rsp+40], r8
14003d7f0mov [rsp+32], rdx
14003d7f5call wcslen
14003d7famov r8, [rsp+40]
14003d7ffmov rdx, [rsp+32]
14003d804mov rcx, rbx
14003d807mov r9, rax
14003d80aadd rsp, 48
14003d80epop rbx
14003d80fjmp 0x14003d820
14003d7e0

14003d814
14003d814 // align 0x10

14003d820
14003d820std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(wchar_t const*, unsigned long long, unsigned long long) const:
14003d820push rbx
14003d821mov r10, -1
14003d828test r9, r9
14003d82bje 0x14003d880
14003d82dmov rbx, [rcx+8]
14003d831mov r10, r8
14003d834nop [rax+rax]
14003d83fnop
14003d840
14003d840loc_14003d840:
14003d840cmp r10, rbx
14003d843jae 0x14003d879
14003d845test rdx, rdx
14003d848je 0x14003d888
14003d84amov r11, [rcx]
14003d84d
14003d84dloc_14003d84d:
14003d84dmovzx r8l, [r11+2*r10]
14003d852mov rcx, r9
14003d855mov rax, rdx
14003d858nop [rax+rax]
14003d860
14003d860loc_14003d860:
14003d860cmp r8w, [rax]
14003d864je 0x14003d880
14003d866add rax, 2
14003d86asub rcx, 1
14003d86ejne 0x14003d860
14003d870add r10, 1
14003d874cmp r10, rbx
14003d877jb 0x14003d84d
14003d879
14003d879loc_14003d879:
14003d879mov r10, -1
14003d880
14003d880loc_14003d880:
14003d880mov rax, r10
14003d883pop rbx
14003d884ret
14003d885
14003d885 0f 1f 00 ...
14003d888
14003d888loc_14003d888:
14003d888add r10, 1
14003d88cjmp 0x14003d840
14003d820

14003d88e
14003d88e // align 0x10

14003d890
14003d890std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, unsigned long long) const:
14003d890mov rax, [rdx]
14003d893mov r9, [rdx+8]
14003d897mov rdx, rax
14003d89ajmp 0x14003d820
14003d890

14003d89f
14003d89f // align 0x10

14003d8a0
14003d8a0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_of(wchar_t, unsigned long long) const:
14003d8a0movzx edx, dx
14003d8a3jmp 0x14003ddf0
14003d8a0

14003d8a8
14003d8a8 // align 0x10

14003d8b0
14003d8b0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::get_allocator() const:
14003d8b0mov rax, rcx
14003d8b3ret
14003d8b0

14003d8b4
14003d8b4 // align 0x10

14003d8c0
14003d8c0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_check_length(unsigned long long, unsigned long long, char const*) const:
14003d8c0push rbp
14003d8c1push rbx
14003d8c2sub rsp, 40
14003d8c6lea rbp, [rsp+32]
14003d8cbmov [rbp+32], rcx
14003d8cfmov [rbp+40], rdx
14003d8d3mov [rbp+48], r8
14003d8d7mov [rbp+56], r9
14003d8dbmov rax, [rbp+32]
14003d8dfmov rcx, rax
14003d8e2call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::max_size() const
14003d8e7mov rbx, rax
14003d8eamov rax, [rbp+32]
14003d8eemov rcx, rax
14003d8f1call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003d8f6mov rdx, [rbp+40]
14003d8fasub rdx, rax
14003d8fdlea rax, [rbx+rdx]
14003d901cmp rax, [rbp+48]
14003d905setb al
14003d908test al, al
14003d90aje 0x14003d918
14003d90cmov rax, [rbp+56]
14003d910mov rcx, rax
14003d913call std::__throw_length_error(char const*)
14003d918
14003d918loc_14003d918:
14003d918nop
14003d919add rsp, 40
14003d91dpop rbx
14003d91epop rbp
14003d91fret
14003d8c0

14003d920
14003d920std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_get_allocator() const:
14003d920push rbp
14003d921mov rbp, rsp
14003d924mov [rbp+16], rcx
14003d928mov rax, [rbp+16]
14003d92cpop rbp
14003d92dret
14003d920

14003d92e
14003d92e // align 0x10

14003d930
14003d930std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(wchar_t const*, unsigned long long) const:
14003d930push rbx
14003d931sub rsp, 48
14003d935mov rbx, rcx
14003d938mov rcx, rdx
14003d93bmov [rsp+40], r8
14003d940mov [rsp+32], rdx
14003d945call wcslen
14003d94amov r8, [rsp+40]
14003d94fmov rdx, [rsp+32]
14003d954mov rcx, rbx
14003d957mov r9, rax
14003d95aadd rsp, 48
14003d95epop rbx
14003d95fjmp 0x14003d970
14003d930

14003d964
14003d964 // align 0x10

14003d970
14003d970std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(wchar_t const*, unsigned long long, unsigned long long) const:
14003d970mov r10, -1
14003d977mov rax, [rcx+8]
14003d97btest rax, rax
14003d97eje 0x14003d993
14003d980sub rax, 1
14003d984mov r10, r8
14003d987cmp rax, r8
14003d98acmovbe r10, rax
14003d98etest r9, r9
14003d991jne 0x14003d997
14003d993
14003d993loc_14003d993:
14003d993mov rax, r10
14003d996ret
14003d997
14003d997loc_14003d997:
14003d997test rdx, rdx
14003d99aje 0x14003d993
14003d99cmov r11, [rcx]
14003d99fmovzx r8l, [r11+2*r10]
14003d9a4nop [rax+rax]
14003d9afnop
14003d9b0
14003d9b0loc_14003d9b0:
14003d9b0mov rax, rdx
14003d9b3mov rcx, r9
14003d9b6cmp [rax], r8w
14003d9baje 0x14003d9d0
14003d9bcnop [rax]
14003d9c0
14003d9c0loc_14003d9c0:
14003d9c0add rax, 2
14003d9c4sub rcx, 1
14003d9c8je 0x14003d993
14003d9cacmp [rax], r8w
14003d9cejne 0x14003d9c0
14003d9d0
14003d9d0loc_14003d9d0:
14003d9d0test r10, r10
14003d9d3je 0x14003d9e0
14003d9d5sub r10, 1
14003d9d9movzx r8l, [r11+2*r10]
14003d9dejmp 0x14003d9b0
14003d9e0
14003d9e0loc_14003d9e0:
14003d9e0mov r10, -1
14003d9e7mov rax, r10
14003d9earet
14003d970

14003d9eb
14003d9eb // align 0x10

14003d9f0
14003d9f0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, unsigned long long) const:
14003d9f0mov rax, [rdx]
14003d9f3mov r9, [rdx+8]
14003d9f7mov rdx, rax
14003d9fajmp 0x14003d970
14003d9f0

14003d9ff
14003d9ff // align 0x10

14003da00
14003da00std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_last_not_of(wchar_t, unsigned long long) const:
14003da00mov rax, -1
14003da07mov r9, rcx
14003da0amov rcx, [rcx+8]
14003da0etest rcx, rcx
14003da11je 0x14003da3c
14003da13sub rcx, 1
14003da17mov rax, r8
14003da1acmp rcx, r8
14003da1dcmovbe rax, rcx
14003da21mov rcx, [r9]
14003da24jmp 0x14003da36
14003da26
14003da26 66 2e 0f 1f 84 00 00 00 00 00 f.........
14003da30
14003da30loc_14003da30:
14003da30sub rax, 1
14003da34jb 0x14003da3c
14003da36
14003da36loc_14003da36:
14003da36cmp [rcx+2*rax], dx
14003da3aje 0x14003da30
14003da3c
14003da3cloc_14003da3c:
14003da3cret
14003da00

14003da3d
14003da3d // align 0x10

14003da40
14003da40std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(wchar_t const*, unsigned long long) const:
14003da40push rbx
14003da41sub rsp, 48
14003da45mov rbx, rcx
14003da48mov rcx, rdx
14003da4bmov [rsp+40], r8
14003da50mov [rsp+32], rdx
14003da55call wcslen
14003da5amov r8, [rsp+40]
14003da5fmov rdx, [rsp+32]
14003da64mov rcx, rbx
14003da67mov r9, rax
14003da6aadd rsp, 48
14003da6epop rbx
14003da6fjmp 0x14003da80
14003da40

14003da74
14003da74 // align 0x10

14003da80
14003da80std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(wchar_t const*, unsigned long long, unsigned long long) const:
14003da80push rbx
14003da81mov rax, r8
14003da84mov r8, [rcx+8]
14003da88cmp rax, r8
14003da8bjae 0x14003da94
14003da8dtest rdx, rdx
14003da90jne 0x14003da9d
14003da92
14003da92loc_14003da92:
14003da92pop rbx
14003da93ret
14003da94
14003da94loc_14003da94:
14003da94mov rax, -1
14003da9bpop rbx
14003da9cret
14003da9d
14003da9dloc_14003da9d:
14003da9dtest r9, r9
14003daa0je 0x14003da92
14003daa2mov rbx, [rcx]
14003daa5movzx r11l, [rbx+2*rax]
14003daaanop [rax+rax]
14003dab0
14003dab0loc_14003dab0:
14003dab0mov rcx, rdx
14003dab3mov r10, r9
14003dab6cmp [rcx], r11w
14003dabaje 0x14003dad0
14003dabcnop [rax]
14003dac0
14003dac0loc_14003dac0:
14003dac0add rcx, 2
14003dac4sub r10, 1
14003dac8je 0x14003da92
14003dacacmp [rcx], r11w
14003dacejne 0x14003dac0
14003dad0
14003dad0loc_14003dad0:
14003dad0add rax, 1
14003dad4cmp rax, r8
14003dad7je 0x14003da94
14003dad9movzx r11l, [rbx+2*rax]
14003dadejmp 0x14003dab0
14003da80

14003dae0
14003dae0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, unsigned long long) const:
14003dae0mov rax, [rdx]
14003dae3mov r9, [rdx+8]
14003dae7mov rdx, rax
14003daeajmp 0x14003da80
14003dae0

14003daef
14003daef // align 0x20

14003db00
14003db00std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find_first_not_of(wchar_t, unsigned long long) const:
14003db00mov r9l, edx
14003db03mov rdx, [rcx+8]
14003db07jmp 0x14003db2e
14003db09
14003db09 66 66 2e 0f 1f 84 00 ff.....
14003db10 00 00 00 00 66 66 2e 0f 1f 84 00 00 00 00 00 90 ....ff..........
14003db20
14003db20loc_14003db20:
14003db20mov rax, [rcx]
14003db23cmp [rax+2*r8], r9w
14003db28jne 0x14003db40
14003db2aadd r8, 1
14003db2e
14003db2eloc_14003db2e:
14003db2ecmp r8, rdx
14003db31jb 0x14003db20
14003db33mov rax, -1
14003db3aret
14003db3b
14003db3b 0f 1f 44 00 00 ..D..
14003db40
14003db40loc_14003db40:
14003db40mov rax, r8
14003db43ret
14003db00

14003db44
14003db44 // align 0x20

14003db60
14003db60std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::at(unsigned long long) const:
14003db60sub rsp, 40
14003db64mov r8, [rcx+8]
14003db68cmp rdx, r8
14003db6bjae 0x14003db79
14003db6dmov rax, [rcx]
14003db70lea rax, [rax+2*rdx]
14003db74add rsp, 40
14003db78ret
14003db79
14003db79loc_14003db79:
14003db79lea rcx, [rip+0x155270]
14003db80call std::__throw_out_of_range_fmt(char const*, ...)
14003db85nop
14003db60

14003db86
14003db86 // align 0x10

14003db90
14003db90std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::end() const:
14003db90mov rdx, [rcx+8]
14003db94mov rax, [rcx]
14003db97lea rax, [rax+2*rdx]
14003db9bret
14003db90

14003db9c
14003db9c // align 0x10

14003dba0
14003dba0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::back() const:
14003dba0push rbp
14003dba1mov rbp, rsp
14003dba4sub rsp, 32
14003dba8mov [rbp+16], rcx
14003dbacmov rax, [rbp+16]
14003dbb0mov rcx, rax
14003dbb3call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::empty() const
14003dbb8movzx eax, al
14003dbbbtest eax, eax
14003dbbdsetne al
14003dbc0test al, al
14003dbc2je 0x14003dbec
14003dbc4lea rcx, [rip+0xcb1be]
14003dbcblea rdx, [rip+0xcb1c6]
14003dbd2lea rax, [rip+0xcb177]
14003dbd9mov r9, rcx
14003dbdcmov r8, rdx
14003dbdfmov edx, 1464
14003dbe4mov rcx, rax
14003dbe7call std::__glibcxx_assert_fail(char const*, int, char const, char const)
14003dbec
14003dbecloc_14003dbec:
14003dbecmov rax, [rbp+16]
14003dbf0mov rcx, rax
14003dbf3call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003dbf8lea rdx, [rax-1]
14003dbfcmov rax, [rbp+16]
14003dc00mov rcx, rax
14003dc03call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator[](unsigned long long) const
14003dc08add rsp, 32
14003dc0cpop rbp
14003dc0dret
14003dba0

14003dc0e
14003dc0e // align 0x10

14003dc10
14003dc10std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::cend() const:
14003dc10mov rdx, [rcx+8]
14003dc14mov rax, [rcx]
14003dc17lea rax, [rax+2*rdx]
14003dc1bret
14003dc10

14003dc1c
14003dc1c // align 0x10

14003dc20
14003dc20std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::copy(wchar_t*, unsigned long long, unsigned long long) const:
14003dc20sub rsp, 56
14003dc24mov r10, rcx
14003dc27mov rax, r9
14003dc2amov rcx, rdx
14003dc2dmov r9, [r10+8]
14003dc31cmp r9, rax
14003dc34jb 0x14003dc7e
14003dc36sub r9, rax
14003dc39cmp r9, r8
14003dc3ccmova r9, r8
14003dc40test r9, r9
14003dc43je 0x14003dc65
14003dc45mov rdx, [r10]
14003dc48lea rdx, [rdx+2*rax]
14003dc4ccmp r9, 1
14003dc50je 0x14003dc70
14003dc52lea r8, [r9+r9]
14003dc56mov [rsp+40], r9
14003dc5bcall memcpy
14003dc60mov r9, [rsp+40]
14003dc65
14003dc65loc_14003dc65:
14003dc65mov rax, r9
14003dc68add rsp, 56
14003dc6cret
14003dc6d
14003dc6d 0f 1f 00 ...
14003dc70
14003dc70loc_14003dc70:
14003dc70movzx eax, [rdx]
14003dc73mov [rcx], ax
14003dc76mov rax, r9
14003dc79add rsp, 56
14003dc7dret
14003dc7e
14003dc7eloc_14003dc7e:
14003dc7emov r8, rax
14003dc81lea rdx, [rip+0x15524b]
14003dc88lea rcx, [rip+0x155129]
14003dc8fcall std::__throw_out_of_range_fmt(char const*, ...)
14003dc94nop
14003dc20

14003dc95
14003dc95 // align 0x10

14003dca0
14003dca0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::data() const:
14003dca0push rbp
14003dca1mov rbp, rsp
14003dca4sub rsp, 32
14003dca8mov [rbp+16], rcx
14003dcacmov rax, [rbp+16]
14003dcb0mov rcx, rax
14003dcb3call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_data() const
14003dcb8add rsp, 32
14003dcbcpop rbp
14003dcbdret
14003dca0

14003dcbe
14003dcbe // align 0x10

14003dcc0
14003dcc0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(wchar_t const*, unsigned long long) const:
14003dcc0push rbx
14003dcc1sub rsp, 48
14003dcc5mov rbx, rcx
14003dcc8mov rcx, rdx
14003dccbmov [rsp+40], r8
14003dcd0mov [rsp+32], rdx
14003dcd5call wcslen
14003dcdamov r8, [rsp+40]
14003dcdfmov rdx, [rsp+32]
14003dce4mov rcx, rbx
14003dce7mov r9, rax
14003dceaadd rsp, 48
14003dceepop rbx
14003dcefjmp 0x14003dd00
14003dcc0

14003dcf4
14003dcf4 // align 0x10

14003dd00
14003dd00std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(wchar_t const*, unsigned long long, unsigned long long) const:
14003dd00push rsi
14003dd01push rbx
14003dd02mov r11, [rcx+8]
14003dd06mov rbx, rcx
14003dd09mov r10, rdx
14003dd0ctest r9, r9
14003dd0fje 0x14003ddc8
14003dd15mov rax, -1
14003dd1ccmp r8, r11
14003dd1fjae 0x14003dd76
14003dd21mov rdx, r11
14003dd24sub rdx, r8
14003dd27cmp rdx, r9
14003dd2ajb 0x14003dd76
14003dd2cmov rbx, [rbx]
14003dd2fmovzx ecx, [r10]
14003dd33lea rax, [rbx+2*r8]
14003dd37mov r8l, 1
14003dd3dlea r11, [rbx+2*r11]
14003dd41sub r8, r9
14003dd44nop [rax+rax]
14003dd4fnop
14003dd50
14003dd50loc_14003dd50:
14003dd50add rdx, r8
14003dd53je 0x14003dd6f
14003dd55test rax, rax
14003dd58je 0x14003dd6f
14003dd5anop [rax+rax]
14003dd60
14003dd60loc_14003dd60:
14003dd60cmp cx, [rax]
14003dd63je 0x14003dd80
14003dd65add rax, 2
14003dd69sub rdx, 1
14003dd6djne 0x14003dd60
14003dd6f
14003dd6floc_14003dd6f:
14003dd6fmov rax, -1
14003dd76
14003dd76loc_14003dd76:
14003dd76pop rbx
14003dd77pop rsi
14003dd78ret
14003dd79
14003dd79 0f 1f 80 00 00 00 00 .......
14003dd80
14003dd80loc_14003dd80:
14003dd80cmp r10, rax
14003dd83je 0x14003dd9b
14003dd85xor edx, edx
14003dd87
14003dd87loc_14003dd87:
14003dd87movzx esi, [r10+2*rdx]
14003dd8ccmp [rax+2*rdx], si
14003dd90jne 0x14003dda8
14003dd92add rdx, 1
14003dd96cmp r9, rdx
14003dd99jne 0x14003dd87
14003dd9b
14003dd9bloc_14003dd9b:
14003dd9bsub rax, rbx
14003dd9esar rax, 1
14003dda1pop rbx
14003dda2pop rsi
14003dda3ret
14003dda4
14003dda4 0f 1f 40 00 ..@.
14003dda8
14003dda8loc_14003dda8:
14003dda8add rax, 2
14003ddacmov rdx, r11
14003ddafsub rdx, rax
14003ddb2sar rdx, 1
14003ddb5cmp rdx, r9
14003ddb8jae 0x14003dd50
14003ddbamov rax, -1
14003ddc1jmp 0x14003dd76
14003ddc3
14003ddc3 0f 1f 44 00 00 ..D..
14003ddc8
14003ddc8loc_14003ddc8:
14003ddc8cmp r11, r8
14003ddcbmov rax, -1
14003ddd2cmovae rax, r8
14003ddd6pop rbx
14003ddd7pop rsi
14003ddd8ret
14003dd00

14003ddd9
14003ddd9 // align 0x10

14003dde0
14003dde0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, unsigned long long) const:
14003dde0mov rax, [rdx]
14003dde3mov r9, [rdx+8]
14003dde7mov rdx, rax
14003ddeajmp 0x14003dd00
14003dde0