Similarity

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

14003ddef
14003ddef // align 0x10

14003ddf0
14003ddf0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::find(wchar_t, unsigned long long) const:
14003ddf0mov r9, -1
14003ddf7mov rax, rcx
14003ddfamov ecx, edx
14003ddfcmov rdx, [rax+8]
14003de00cmp r8, rdx
14003de03jae 0x14003de36
14003de05mov r10, [rax]
14003de08lea rax, [r10+2*r8]
14003de0ctest rax, rax
14003de0fje 0x14003de36
14003de11sub rdx, r8
14003de14nop [rax+rax]
14003de1fnop
14003de20
14003de20loc_14003de20:
14003de20cmp [rax], cx
14003de23je 0x14003de40
14003de25add rax, 2
14003de29sub rdx, 1
14003de2djne 0x14003de20
14003de2fmov r9, -1
14003de36
14003de36loc_14003de36:
14003de36mov rax, r9
14003de39ret
14003de3a
14003de3a 66 0f 1f 44 00 00 f..D..
14003de40
14003de40loc_14003de40:
14003de40sub rax, r10
14003de43sar rax, 1
14003de46mov r9, rax
14003de49mov rax, r9
14003de4cret
14003ddf0

14003de4d
14003de4d // align 0x10

14003de50
14003de50std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rend() const:
14003de50mov rdx, [rdx]
14003de53mov rax, rcx
14003de56mov [rcx], rdx
14003de59ret
14003de50

14003de5a
14003de5a // align 0x10

14003de60
14003de60std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const:
14003de60push rbp
14003de61mov rbp, rsp
14003de64sub rsp, 48
14003de68mov [rbp+16], rcx
14003de6cmov rax, [rbp+16]
14003de70mov rax, [rax+8]
14003de74mov [rbp-8], rax
14003de78mov rax, [rbp+16]
14003de7cmov rcx, rax
14003de7fcall std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::max_size() const
14003de84cmp rax, [rbp-8]
14003de88setb al
14003de8btest al, al
14003de8dmov rax, [rbp-8]
14003de91add rsp, 48
14003de95pop rbp
14003de96ret
14003de60

14003de97
14003de97 // align 0x10

14003dea0
14003dea0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::begin() const:
14003dea0mov rax, [rcx]
14003dea3ret
14003dea0

14003dea4
14003dea4 // align 0x10

14003deb0
14003deb0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::c_str() const:
14003deb0push rbp
14003deb1mov rbp, rsp
14003deb4sub rsp, 32
14003deb8mov [rbp+16], rcx
14003debcmov rax, [rbp+16]
14003dec0mov rcx, rax
14003dec3call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_data() const
14003dec8add rsp, 32
14003deccpop rbp
14003decdret
14003deb0

14003dece
14003dece // align 0x10

14003ded0
14003ded0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::crend() const:
14003ded0mov rdx, [rdx]
14003ded3mov rax, rcx
14003ded6mov [rcx], rdx
14003ded9ret
14003ded0

14003deda
14003deda // align 0x10

14003dee0
14003dee0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::empty() const:
14003dee0push rbp
14003dee1mov rbp, rsp
14003dee4mov [rbp+16], rcx
14003dee8mov rax, [rbp+16]
14003deecmov rax, [rax+8]
14003def0test rax, rax
14003def3sete al
14003def6pop rbp
14003def7ret
14003dee0

14003def8
14003def8 // align 0x10

14003df00
14003df00std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::front() const:
14003df00mov rax, [rcx]
14003df03ret
14003df00

14003df04
14003df04 // align 0x10

14003df10
14003df10std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(wchar_t const*, unsigned long long) const:
14003df10push rbx
14003df11sub rsp, 48
14003df15mov rbx, rcx
14003df18mov rcx, rdx
14003df1bmov [rsp+40], r8
14003df20mov [rsp+32], rdx
14003df25call wcslen
14003df2amov r8, [rsp+40]
14003df2fmov rdx, [rsp+32]
14003df34mov rcx, rbx
14003df37mov r9, rax
14003df3aadd rsp, 48
14003df3epop rbx
14003df3fjmp 0x14003df60
14003df10

14003df44
14003df44 // align 0x20

14003df60
14003df60std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(wchar_t const*, unsigned long long, unsigned long long) const:
14003df60push rbx
14003df61mov r10, -1
14003df68mov rax, [rcx+8]
14003df6ccmp rax, r9
14003df6fjb 0x14003dfd3
14003df71sub rax, r9
14003df74cmp rax, r8
14003df77cmovbe r8, rax
14003df7btest r9, r9
14003df7emov rax, [rcx]
14003df81mov r10, r8
14003df84sete r8b
14003df88test rdx, rdx
14003df8bsetne r11b
14003df8flea rcx, [rax+2*r10]
14003df93
14003df93loc_14003df93:
14003df93cmp rdx, rcx
14003df96je 0x14003dfd3
14003df98test r8b, r8b
14003df9bjne 0x14003dfd3
14003df9dtest rcx, rcx
14003dfa0setne al
14003dfa3cmp al, r11b
14003dfa6jne 0x14003dfe0
14003dfa8xor eax, eax
14003dfaanop [rax+rax]
14003dfb5nop [rax+rax]
14003dfc0
14003dfc0loc_14003dfc0:
14003dfc0movzx ebx, [rdx+2*rax]
14003dfc4cmp [rcx+2*rax], bx
14003dfc8jne 0x14003dfe0
14003dfcaadd rax, 1
14003dfcecmp r9, rax
14003dfd1jne 0x14003dfc0
14003dfd3
14003dfd3loc_14003dfd3:
14003dfd3mov rax, r10
14003dfd6pop rbx
14003dfd7ret
14003dfd8
14003dfd8 0f 1f 84 00 00 00 00 00 ........
14003dfe0
14003dfe0loc_14003dfe0:
14003dfe0sub rcx, 2
14003dfe4test r10, r10
14003dfe7je 0x14003dff0
14003dfe9sub r10, 1
14003dfedjmp 0x14003df93
14003dfef
14003dfef 90 .
14003dff0
14003dff0loc_14003dff0:
14003dff0mov r10, -1
14003dff7jmp 0x14003dfd3
14003df60

14003dff9
14003dff9 // align 0x10

14003e000
14003e000std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, unsigned long long) const:
14003e000mov rax, [rdx]
14003e003mov r9, [rdx+8]
14003e007mov rdx, rax
14003e00ajmp 0x14003df60
14003e000

14003e00f
14003e00f // align 0x10

14003e010
14003e010std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rfind(wchar_t, unsigned long long) const:
14003e010mov rax, -1
14003e017mov r9, rcx
14003e01amov rcx, [rcx+8]
14003e01etest rcx, rcx
14003e021je 0x14003e056
14003e023sub rcx, 1
14003e027cmp rcx, r8
14003e02acmova rcx, r8
14003e02elea rax, [rcx+1]
14003e032mov rcx, [r9]
14003e035nop [rax+rax]
14003e040
14003e040loc_14003e040:
14003e040sub rax, 1
14003e044cmp [rcx+2*rax], dx
14003e048je 0x14003e056
14003e04atest rax, rax
14003e04djne 0x14003e040
14003e04fmov rax, -1
14003e056
14003e056loc_14003e056:
14003e056ret
14003e010

14003e057
14003e057 // align 0x10

14003e060
14003e060std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::cbegin() const:
14003e060mov rax, [rcx]
14003e063ret
14003e060

14003e064
14003e064 // align 0x10

14003e070
14003e070std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::length() const:
14003e070push rbp
14003e071mov rbp, rsp
14003e074sub rsp, 32
14003e078mov [rbp+16], rcx
14003e07cmov rax, [rbp+16]
14003e080mov rcx, rax
14003e083call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003e088add rsp, 32
14003e08cpop rbp
14003e08dret
14003e070

14003e08e
14003e08e // align 0x10

14003e090
14003e090std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::rbegin() const:
14003e090mov rax, rcx
14003e093mov rcx, [rdx+8]
14003e097mov rdx, [rdx]
14003e09alea rdx, [rdx+2*rcx]
14003e09emov [rax], rdx
14003e0a1ret
14003e090

14003e0a2
14003e0a2 // align 0x10

14003e0b0
14003e0b0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::substr(unsigned long long, unsigned long long) const:
14003e0b0push rbp
14003e0b1mov rbp, rsp
14003e0b4sub rsp, 32
14003e0b8mov [rbp+16], rcx
14003e0bcmov [rbp+24], rdx
14003e0c0mov [rbp+32], r8
14003e0c4mov [rbp+40], r9
14003e0c8lea rcx, [rip+0xcadd1]
14003e0cfmov rdx, [rbp+32]
14003e0d3mov rax, [rbp+24]
14003e0d7mov r8, rcx
14003e0damov rcx, rax
14003e0ddcall std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_check(unsigned long long, char const*) const
14003e0e2mov rcx, rax
14003e0e5mov r8, [rbp+40]
14003e0e9mov rdx, [rbp+24]
14003e0edmov rax, [rbp+16]
14003e0f1mov r9, r8
14003e0f4mov r8, rcx
14003e0f7mov rcx, rax
14003e0facall std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::basic_string(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, unsigned long long, unsigned long long)
14003e0ffmov rax, [rbp+16]
14003e103add rsp, 32
14003e107pop rbp
14003e108ret
14003e0b0

14003e109
14003e109 // align 0x10

14003e110
14003e110std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_data() const:
14003e110push rbp
14003e111mov rbp, rsp
14003e114mov [rbp+16], rcx
14003e118mov rax, [rbp+16]
14003e11cmov rax, [rax]
14003e11fpop rbp
14003e120ret
14003e110

14003e121
14003e121 // align 0x20

14003e140
14003e140std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(wchar_t const*) const:
14003e140push rdi
14003e141push rsi
14003e142push rbx
14003e143sub rsp, 32
14003e147mov rsi, [rcx+8]
14003e14bmov rdi, rcx
14003e14emov rcx, rdx
14003e151mov rbx, rdx
14003e154call wcslen
14003e159mov rcx, rsi
14003e15cmov rdx, [rdi]
14003e15fcmp rax, rsi
14003e162mov r8, rax
14003e165cmovbe rcx, rax
14003e169test rcx, rcx
14003e16cje 0x14003e1c0
14003e16ecmp rbx, rdx
14003e171je 0x14003e1c0
14003e173test rdx, rdx
14003e176setne r9b
14003e17atest rbx, rbx
14003e17dsetne al
14003e180cmp r9b, al
14003e183je 0x14003e198
14003e185neg rbx
14003e188sbb eax, eax
14003e18aor eax, 1
14003e18dadd rsp, 32
14003e191pop rbx
14003e192pop rsi
14003e193pop rdi
14003e194ret
14003e195
14003e195 0f 1f 00 ...
14003e198
14003e198loc_14003e198:
14003e198xor eax, eax
14003e19anop [rax+rax]
14003e1a0
14003e1a0loc_14003e1a0:
14003e1a0movzx edi, [rbx+2*rax]
14003e1a4cmp [rdx+2*rax], di
14003e1a8jne 0x14003e1f0
14003e1aaadd rax, 1
14003e1aecmp rcx, rax
14003e1b1jne 0x14003e1a0
14003e1b3nop [rax+rax]
14003e1benop
14003e1c0
14003e1c0loc_14003e1c0:
14003e1c0sub rsi, r8
14003e1c3mov eax, 0x7fffffff
14003e1c8cmp rsi, 0x7fffffff
14003e1cfjg 0x14003e1e0
14003e1d1cmp rsi, 0xffffffff80000000
14003e1d8mov eax, 0xffffffff80000000
14003e1ddcmovge eax, esi
14003e1e0
14003e1e0loc_14003e1e0:
14003e1e0add rsp, 32
14003e1e4pop rbx
14003e1e5pop rsi
14003e1e6pop rdi
14003e1e7ret
14003e1e8
14003e1e8 0f 1f 84 00 00 00 00 00 ........
14003e1f0
14003e1f0loc_14003e1f0:
14003e1f0sbb eax, eax
14003e1f2or eax, 1
14003e1f5add rsp, 32
14003e1f9pop rbx
14003e1fapop rsi
14003e1fbpop rdi
14003e1fcret
14003e140

14003e1fd
14003e1fd // align 0x10

14003e200
14003e200std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) const:
14003e200mov rax, rcx
14003e203mov rcx, rdx
14003e206mov r10, [rcx+8]
14003e20amov rdx, [rax+8]
14003e20emov rcx, [rcx]
14003e211mov r8, [rax]
14003e214cmp r10, rdx
14003e217mov r9, rdx
14003e21acmovbe r9, r10
14003e21etest r9, r9
14003e221je 0x14003e280
14003e223cmp rcx, r8
14003e226je 0x14003e280
14003e228test r8, r8
14003e22bsetne r11b
14003e22ftest rcx, rcx
14003e232setne al
14003e235cmp r11b, al
14003e238je 0x14003e248
14003e23aneg rcx
14003e23dsbb eax, eax
14003e23for eax, 1
14003e242
14003e242loc_14003e242:
14003e242ret
14003e243
14003e243 0f 1f 44 00 00 ..D..
14003e248
14003e248loc_14003e248:
14003e248xor eax, eax
14003e24anop [rax+rax]
14003e255nop [rax+rax]
14003e260
14003e260loc_14003e260:
14003e260movzx r11l, [rcx+2*rax]
14003e265cmp [r8+2*rax], r11w
14003e26ajne 0x14003e2a8
14003e26cadd rax, 1
14003e270cmp r9, rax
14003e273jne 0x14003e260
14003e275nop [rax+rax]
14003e280
14003e280loc_14003e280:
14003e280sub rdx, r10
14003e283mov eax, 0x7fffffff
14003e288cmp rdx, 0x7fffffff
14003e28fjg 0x14003e242
14003e291cmp rdx, 0xffffffff80000000
14003e298mov eax, 0xffffffff80000000
14003e29dcmovge eax, edx
14003e2a0ret
14003e2a1
14003e2a1 0f 1f 80 00 00 00 00 .......
14003e2a8
14003e2a8loc_14003e2a8:
14003e2a8sbb eax, eax
14003e2aaor eax, 1
14003e2adret
14003e200

14003e2ae
14003e2ae // align 0x20

14003e2c0
14003e2c0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(unsigned long long, unsigned long long, wchar_t const*) const:
14003e2c0push rbp
14003e2c1push rdi
14003e2c2push rsi
14003e2c3push rbx
14003e2c4sub rsp, 40
14003e2c8mov rbx, [rcx+8]
14003e2ccmov rbp, rcx
14003e2cfmov rdi, rdx
14003e2d2mov rsi, r9
14003e2d5cmp rbx, rdx
14003e2d8jb 0x14003e39e
14003e2desub rbx, rdx
14003e2e1mov rcx, r9
14003e2e4cmp rbx, r8
14003e2e7cmova rbx, r8
14003e2ebcall wcslen
14003e2f0cmp rax, rbx
14003e2f3mov rcx, rbx
14003e2f6mov r8, rax
14003e2f9cmovbe rcx, rax
14003e2fdmov rax, [rbp]
14003e301lea rdx, [rax+2*rdi]
14003e305test rcx, rcx
14003e308je 0x14003e360
14003e30acmp rdx, rsi
14003e30dje 0x14003e360
14003e30ftest rdx, rdx
14003e312setne r9b
14003e316test rsi, rsi
14003e319setne al
14003e31ccmp r9b, al
14003e31fje 0x14003e338
14003e321neg rsi
14003e324sbb eax, eax
14003e326or eax, 1
14003e329add rsp, 40
14003e32dpop rbx
14003e32epop rsi
14003e32fpop rdi
14003e330pop rbp
14003e331ret
14003e332
14003e332 66 0f 1f 44 00 00 f..D..
14003e338
14003e338loc_14003e338:
14003e338xor eax, eax
14003e33anop [rax+rax]
14003e340
14003e340loc_14003e340:
14003e340movzx edi, [rsi+2*rax]
14003e344cmp [rdx+2*rax], di
14003e348jne 0x14003e390
14003e34aadd rax, 1
14003e34ecmp rcx, rax
14003e351jne 0x14003e340
14003e353nop [rax+rax]
14003e35enop
14003e360
14003e360loc_14003e360:
14003e360sub rbx, r8
14003e363mov eax, 0x7fffffff
14003e368cmp rbx, 0x7fffffff
14003e36fjg 0x14003e380
14003e371cmp rbx, 0xffffffff80000000
14003e378mov eax, 0xffffffff80000000
14003e37dcmovge eax, ebx
14003e380
14003e380loc_14003e380:
14003e380add rsp, 40
14003e384pop rbx
14003e385pop rsi
14003e386pop rdi
14003e387pop rbp
14003e388ret
14003e389
14003e389 0f 1f 80 00 00 00 00 .......
14003e390
14003e390loc_14003e390:
14003e390sbb eax, eax
14003e392or eax, 1
14003e395add rsp, 40
14003e399pop rbx
14003e39apop rsi
14003e39bpop rdi
14003e39cpop rbp
14003e39dret
14003e39e
14003e39eloc_14003e39e:
14003e39emov r8, rdx
14003e3a1mov r9, rbx
14003e3a4lea rdx, [rip+0x154b3b]
14003e3ablea rcx, [rip+0x154a06]
14003e3b2call std::__throw_out_of_range_fmt(char const*, ...)
14003e3b7nop
14003e2c0

14003e3b8
14003e3b8 // align 0x10

14003e3c0
14003e3c0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(unsigned long long, unsigned long long, wchar_t const*, unsigned long long) const:
14003e3c0sub rsp, 40
14003e3c4mov rax, [rcx+8]
14003e3c8mov r10, [rsp+80]
14003e3cdmov r11, rcx
14003e3d0cmp rax, rdx
14003e3d3jb 0x14003e49a
14003e3d9sub rax, rdx
14003e3dcmov rcx, r10
14003e3dfcmp rax, r8
14003e3e2cmovbe r8, rax
14003e3e6mov rax, [r11]
14003e3e9cmp r8, r10
14003e3eclea rdx, [rax+2*rdx]
14003e3f0cmovbe rcx, r8
14003e3f4test rcx, rcx
14003e3f7je 0x14003e460
14003e3f9cmp rdx, r9
14003e3fcje 0x14003e460
14003e3fetest rdx, rdx
14003e401setne r11b
14003e405test r9, r9
14003e408setne al
14003e40bcmp r11b, al
14003e40eje 0x14003e420
14003e410neg r9
14003e413sbb eax, eax
14003e415or eax, 1
14003e418add rsp, 40
14003e41cret
14003e41d
14003e41d 0f 1f 00 ...
14003e420
14003e420loc_14003e420:
14003e420xor eax, eax
14003e422nop [rax+rax]
14003e42dnop [rax+rax]
14003e438nop [rax+rax]
14003e440
14003e440loc_14003e440:
14003e440movzx r11l, [r9+2*rax]
14003e445cmp [rdx+2*rax], r11w
14003e44ajne 0x14003e490
14003e44cadd rax, 1
14003e450cmp rcx, rax
14003e453jne 0x14003e440
14003e455nop [rax+rax]
14003e460
14003e460loc_14003e460:
14003e460sub r8, r10
14003e463mov eax, 0x7fffffff
14003e468cmp r8, 0x7fffffff
14003e46fjg 0x14003e481
14003e471cmp r8, 0xffffffff80000000
14003e478mov eax, 0xffffffff80000000
14003e47dcmovge eax, r8l
14003e481
14003e481loc_14003e481:
14003e481add rsp, 40
14003e485ret
14003e486
14003e486 66 2e 0f 1f 84 00 00 00 00 00 f.........
14003e490
14003e490loc_14003e490:
14003e490sbb eax, eax
14003e492or eax, 1
14003e495add rsp, 40
14003e499ret
14003e49a
14003e49aloc_14003e49a:
14003e49amov r8, rdx
14003e49dmov r9, rax
14003e4a0lea rdx, [rip+0x154a3f]
14003e4a7lea rcx, [rip+0x15490a]
14003e4aecall std::__throw_out_of_range_fmt(char const*, ...)
14003e4b3nop
14003e3c0

14003e4b4
14003e4b4 // align 0x10

14003e4c0
14003e4c0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(unsigned long long, unsigned long long, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) const:
14003e4c0push rbx
14003e4c1sub rsp, 32
14003e4c5mov rax, [rcx+8]
14003e4c9mov rbx, rcx
14003e4cccmp rax, rdx
14003e4cfjb 0x14003e59b
14003e4d5sub rax, rdx
14003e4d8mov r11, [r9+8]
14003e4dcmov rcx, [r9]
14003e4dfcmp rax, r8
14003e4e2cmovbe r8, rax
14003e4e6mov rax, [rbx]
14003e4e9cmp r11, r8
14003e4ecmov r10, r8
14003e4eflea rdx, [rax+2*rdx]
14003e4f3cmovbe r10, r11
14003e4f7test r10, r10
14003e4faje 0x14003e560
14003e4fccmp rdx, rcx
14003e4ffje 0x14003e560
14003e501test rdx, rdx
14003e504setne r9b
14003e508test rcx, rcx
14003e50bsetne al
14003e50ecmp r9b, al
14003e511je 0x14003e528
14003e513neg rcx
14003e516sbb eax, eax
14003e518or eax, 1
14003e51badd rsp, 32
14003e51fpop rbx
14003e520ret
14003e521
14003e521 0f 1f 80 00 00 00 00 .......
14003e528
14003e528loc_14003e528:
14003e528xor eax, eax
14003e52anop [rax+rax]
14003e535nop [rax+rax]
14003e540
14003e540loc_14003e540:
14003e540movzx ebx, [rcx+2*rax]
14003e544cmp [rdx+2*rax], bx
14003e548jne 0x14003e590
14003e54aadd rax, 1
14003e54ecmp r10, rax
14003e551jne 0x14003e540
14003e553nop [rax+rax]
14003e55enop
14003e560
14003e560loc_14003e560:
14003e560sub r8, r11
14003e563mov eax, 0x7fffffff
14003e568cmp r8, 0x7fffffff
14003e56fjg 0x14003e581
14003e571cmp r8, 0xffffffff80000000
14003e578mov eax, 0xffffffff80000000
14003e57dcmovge eax, r8l
14003e581
14003e581loc_14003e581:
14003e581add rsp, 32
14003e585pop rbx
14003e586ret
14003e587
14003e587 66 0f 1f 84 00 00 00 00 00 f........
14003e590
14003e590loc_14003e590:
14003e590sbb eax, eax
14003e592or eax, 1
14003e595add rsp, 32
14003e599pop rbx
14003e59aret
14003e59b
14003e59bloc_14003e59b:
14003e59bmov r8, rdx
14003e59emov r9, rax
14003e5a1lea rdx, [rip+0x15493e]
14003e5a8lea rcx, [rip+0x154809]
14003e5afcall std::__throw_out_of_range_fmt(char const*, ...)
14003e5b4nop
14003e4c0

14003e5b5
14003e5b5 // align 0x10

14003e5c0
14003e5c0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::compare(unsigned long long, unsigned long long, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, unsigned long long, unsigned long long) const:
14003e5c0push rbx
14003e5c1sub rsp, 32
14003e5c5mov r10, [rsp+80]
14003e5camov rbx, rcx
14003e5cdmov rcx, [rcx+8]
14003e5d1cmp rcx, rdx
14003e5d4jb 0x14003e6bb
14003e5damov rax, [r9+8]
14003e5decmp rax, r10
14003e5e1jb 0x14003e6d4
14003e5e7sub rcx, rdx
14003e5eacmp rcx, r8
14003e5edcmovbe r8, rcx
14003e5f1mov rcx, [rsp+88]
14003e5f6sub rax, r10
14003e5f9cmp rax, rcx
14003e5fcmov r11, r8
14003e5ffcmova rax, rcx
14003e603mov rcx, [r9]
14003e606mov r9, [rbx]
14003e609cmp rax, r8
14003e60clea rcx, [rcx+2*r10]
14003e610lea r9, [r9+2*rdx]
14003e614cmovbe r11, rax
14003e618test r11, r11
14003e61bje 0x14003e680
14003e61dcmp rcx, r9
14003e620je 0x14003e680
14003e622test r9, r9
14003e625setne r10b
14003e629test rcx, rcx
14003e62csetne dl
14003e62fcmp r10b, dl
14003e632je 0x14003e648
14003e634neg rcx
14003e637sbb eax, eax
14003e639or eax, 1
14003e63cadd rsp, 32
14003e640pop rbx
14003e641ret
14003e642
14003e642 66 0f 1f 44 00 00 f..D..
14003e648
14003e648loc_14003e648:
14003e648xor edx, edx
14003e64anop [rax+rax]
14003e655nop [rax+rax]
14003e660
14003e660loc_14003e660:
14003e660movzx ebx, [rcx+2*rdx]
14003e664cmp [r9+2*rdx], bx
14003e669jne 0x14003e6b0
14003e66badd rdx, 1
14003e66fcmp r11, rdx
14003e672jne 0x14003e660
14003e674nop [rax+rax]
14003e67fnop
14003e680
14003e680loc_14003e680:
14003e680sub r8, rax
14003e683mov eax, 0x7fffffff
14003e688cmp r8, 0x7fffffff
14003e68fjg 0x14003e6a1
14003e691cmp r8, 0xffffffff80000000
14003e698mov eax, 0xffffffff80000000
14003e69dcmovge eax, r8l
14003e6a1
14003e6a1loc_14003e6a1:
14003e6a1add rsp, 32
14003e6a5pop rbx
14003e6a6ret
14003e6a7
14003e6a7 66 0f 1f 84 00 00 00 00 00 f........
14003e6b0
14003e6b0loc_14003e6b0:
14003e6b0sbb eax, eax
14003e6b2or eax, 1
14003e6b5add rsp, 32
14003e6b9pop rbx
14003e6baret
14003e6bb
14003e6bbloc_14003e6bb:
14003e6bbmov r9, rcx
14003e6bemov r8, rdx
14003e6c1lea rcx, [rip+0x1546f0]
14003e6c8lea rdx, [rip+0x154817]
14003e6cfcall std::__throw_out_of_range_fmt(char const*, ...)
14003e6d4
14003e6d4loc_14003e6d4:
14003e6d4mov r9, rax
14003e6d7mov r8, r10
14003e6dalea rdx, [rip+0x154805]
14003e6e1lea rcx, [rip+0x1546d0]
14003e6e8call std::__throw_out_of_range_fmt(char const*, ...)
14003e6ednop
14003e5c0

14003e6ee
14003e6ee // align 0x20

14003e700
14003e700std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::crbegin() const:
14003e700mov rax, rcx
14003e703mov rcx, [rdx+8]
14003e707mov rdx, [rdx]
14003e70alea rdx, [rdx+2*rcx]
14003e70emov [rax], rdx
14003e711ret
14003e700

14003e712
14003e712 // align 0x10

14003e720
14003e720std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_check(unsigned long long, char const*) const:
14003e720push rbp
14003e721mov rbp, rsp
14003e724sub rsp, 32
14003e728mov [rbp+16], rcx
14003e72cmov [rbp+24], rdx
14003e730mov [rbp+32], r8
14003e734mov rax, [rbp+16]
14003e738mov rcx, rax
14003e73bcall std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003e740cmp rax, [rbp+24]
14003e744setb al
14003e747test al, al
14003e749je 0x14003e774
14003e74bmov rax, [rbp+16]
14003e74fmov rcx, rax
14003e752call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003e757mov rdx, rax
14003e75amov r8, [rbp+24]
14003e75emov rax, [rbp+32]
14003e762lea rcx, [rip+0xcacf7]
14003e769mov r9, rdx
14003e76cmov rdx, rax
14003e76fcall std::__throw_out_of_range_fmt(char const*, ...)
14003e774
14003e774loc_14003e774:
14003e774mov rax, [rbp+24]
14003e778add rsp, 32
14003e77cpop rbp
14003e77dret
14003e720

14003e77e
14003e77e // align 0x10

14003e780
14003e780std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_limit(unsigned long long, unsigned long long) const:
14003e780push rbp
14003e781mov rbp, rsp
14003e784sub rsp, 48
14003e788mov [rbp+16], rcx
14003e78cmov [rbp+24], rdx
14003e790mov [rbp+32], r8
14003e794mov rax, [rbp+16]
14003e798mov rcx, rax
14003e79bcall std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003e7a0sub rax, [rbp+24]
14003e7a4cmp [rbp+32], rax
14003e7a8setb al
14003e7abmov [rbp-1], al
14003e7aecmp [rbp-1], 0
14003e7b2je 0x14003e7ba
14003e7b4mov rax, [rbp+32]
14003e7b8jmp 0x14003e7ca
14003e7ba
14003e7baloc_14003e7ba:
14003e7bamov rax, [rbp+16]
14003e7bemov rcx, rax
14003e7c1call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003e7c6sub rax, [rbp+24]
14003e7ca
14003e7caloc_14003e7ca:
14003e7caadd rsp, 48
14003e7cepop rbp
14003e7cfret
14003e780

14003e7d0
14003e7d0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::capacity() const:
14003e7d0push rbp
14003e7d1mov rbp, rsp
14003e7d4sub rsp, 48
14003e7d8mov [rbp+16], rcx
14003e7dcmov rax, [rbp+16]
14003e7e0mov rcx, rax
14003e7e3call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_is_local() const
14003e7e8test al, al
14003e7eaje 0x14003e7f6
14003e7ecmov [rbp-8], 7
14003e7f4jmp 0x14003e802
14003e7f6
14003e7f6loc_14003e7f6:
14003e7f6mov rax, [rbp+16]
14003e7famov rax, [rax+16]
14003e7femov [rbp-8], rax
14003e802
14003e802loc_14003e802:
14003e802cmp [rbp-8], 6
14003e807jbe 0x14003e81b
14003e809mov rax, [rbp+16]
14003e80dmov rcx, rax
14003e810call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::max_size() const
14003e815cmp rax, [rbp-8]
14003e819jae 0x14003e822
14003e81b
14003e81bloc_14003e81b:
14003e81bmov eax, 1
14003e820jmp 0x14003e827
14003e822
14003e822loc_14003e822:
14003e822mov eax, 0
14003e827
14003e827loc_14003e827:
14003e827test al, al
14003e829mov rax, [rbp-8]
14003e82dadd rsp, 48
14003e831pop rbp
14003e832ret
14003e7d0

14003e833
14003e833 // align 0x10

14003e840
14003e840std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::max_size() const:
14003e840push rbp
14003e841mov rbp, rsp
14003e844sub rsp, 80
14003e848mov [rbp+16], rcx
14003e84cmov rax, 0x3fffffffffffffff
14003e856mov [rbp-32], rax
14003e85amov rax, [rbp+16]
14003e85emov rcx, rax
14003e861call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_get_allocator() const
14003e866mov [rbp-8], rax
14003e86amov rax, [rbp-8]
14003e86emov [rbp-16], rax
14003e872mov rax, [rbp-16]
14003e876mov [rbp-24], rax
14003e87amov rax, 0x3fffffffffffffff
14003e884nop
14003e885nop
14003e886mov [rbp-40], rax
14003e88alea rdx, [rbp-40]
14003e88elea rax, [rbp-32]
14003e892mov rcx, rax
14003e895call unsigned long long const& std::min<unsigned long long>(unsigned long long const&, unsigned long long const&)
14003e89amov rax, [rax]
14003e89dsub rax, 1
14003e8a1add rsp, 80
14003e8a5pop rbp
14003e8a6ret
14003e840

14003e8a7
14003e8a7 // align 0x10

14003e8b0
14003e8b0std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator std::basic_string_view<wchar_t, std::char_traits<wchar_t>>() const:
14003e8b0push rbp
14003e8b1push rbx
14003e8b2sub rsp, 40
14003e8b6lea rbp, [rsp+32]
14003e8bbmov [rbp+32], rcx
14003e8bfmov [rbp+40], rdx
14003e8c3mov rax, [rbp+40]
14003e8c7mov rcx, rax
14003e8cacall std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003e8cfmov rbx, rax
14003e8d2mov rax, [rbp+40]
14003e8d6mov rcx, rax
14003e8d9call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::data() const
14003e8demov rdx, rax
14003e8e1mov rax, [rbp+32]
14003e8e5mov r8, rbx
14003e8e8mov rcx, rax
14003e8ebcall std::basic_string_view<wchar_t, std::char_traits<wchar_t>>::basic_string_view(wchar_t const*, unsigned long long)
14003e8f0mov rax, [rbp+32]
14003e8f4add rsp, 40
14003e8f8pop rbx
14003e8f9pop rbp
14003e8faret
14003e8b0

14003e8fb
14003e8fb // align 0x10

14003e900
14003e900std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::operator[](unsigned long long) const:
14003e900push rbp
14003e901mov rbp, rsp
14003e904sub rsp, 32
14003e908mov [rbp+16], rcx
14003e90cmov [rbp+24], rdx
14003e910mov rax, [rbp+16]
14003e914mov rcx, rax
14003e917call std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::size() const
14003e91ccmp rax, [rbp+24]
14003e920setb al
14003e923movzx eax, al
14003e926test eax, eax
14003e928setne al
14003e92btest al, al
14003e92dje 0x14003e957
14003e92flea rcx, [rip+0xca2dc]
14003e936lea rdx, [rip+0xca9e3]
14003e93dlea rax, [rip+0xca40c]
14003e944mov r9, rcx
14003e947mov r8, rdx
14003e94amov edx, 1349
14003e94fmov rcx, rax
14003e952call std::__glibcxx_assert_fail(char const*, int, char const, char const)
14003e957
14003e957loc_14003e957:
14003e957mov rax, [rbp+16]
14003e95bmov rcx, rax
14003e95ecall std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>::_M_data() const
14003e963mov rdx, [rbp+24]
14003e967add rdx, rdx
14003e96aadd rax, rdx
14003e96dadd rsp, 32
14003e971pop rbp
14003e972ret
14003e900