Similarity

0013b31b
0013b31bregex_automata::hybrid::dfa::Lazy::cache_next_state:
0013b31bpush rbp
0013b31cpush r15
0013b31epush r14
0013b320push r13
0013b322push r12
0013b324push rbx
0013b325sub rsp, 296
0013b32cmov [rsp+16], edx
0013b330mov rbx, [rdi]
0013b333mov [rsp+104], rdi
0013b338mov r15, [rdi+8]
0013b33cmov cl, [rbx+392]
0013b342mov rax, [r15+320]
0013b349mov [rsp+224], rax
0013b351movups x0, [r15+304]
0013b359movaps [rsp+208], x0
0013b361mov [r15+304], 1
0013b36cxorps x0, x0
0013b36fmovups [r15+312], x0
0013b377mov al, [rbx+120]
0013b37acmp al, 2
0013b37csete dl
0013b37for dl, al
0013b381mov [rsp+23], dl
0013b385lea rax, [r15+168]
0013b38cmov [rsp+80], rax
0013b391mov [rsp+76], esi
0013b395mov edx, esi
0013b397and edx, 0x7ffffff
0013b39dshr rdx, cl
0013b3a0lea rax, [r15+280]
0013b3a7mov [rsp+112], rax
0013b3aclea rax, [r15+96]
0013b3b0mov [rsp+176], rax
0013b3b8mov rdi, [r15+96]
0013b3bcmov rsi, [r15+112]
0013b3c0lea rcx, [rip+0xb2d71]
0013b3c7call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013b3ccmov rcx, rax
0013b3cfand [r15+216], 0
0013b3d7and [r15+272], 0
0013b3dfmov [rsp+64], rbx
0013b3e4mov rax, [rbx+384]
0013b3ebmov [rsp+32], rax
0013b3f0mov al, [rax+388]
0013b3f6mov [rsp+15], al
0013b3famov rbx, [rcx]
0013b3fdmov [rsp+24], rcx
0013b402mov r14, [rcx+8]
0013b406add rbx, 16
0013b40amov rdi, rbx
0013b40dmov rsi, r14
0013b410call regex_automata::util::determinize::state::Repr::encoded_pattern_len
0013b415test rax, rax
0013b418lea rax, [4*rax+13]
0013b420push 9
0013b422pop rdi
0013b423cmovne rdi, rax
0013b427lea rcx, [rip+0xb588a]
0013b42emov rsi, rbx
0013b431mov rdx, r14
0013b434call _<core::ops::range::RangeFrom<usize> as core::slice::index::SliceIndex<[T]>>::index
0013b439mov rbx, rax
0013b43cmov r14, rdx
0013b43fmov r13, [r15+184]
0013b446xor ebp, ebp
0013b448xor r12l, r12l
0013b44b
0013b44bloc_13b44b:
0013b44btest r14, r14
0013b44eje 0x13b557
0013b454xor eax, eax
0013b456xor edi, edi
0013b458xor ecx, ecx
0013b45axor edx, edx
0013b45c
0013b45cloc_13b45c:
0013b45ccmp r14, rdi
0013b45fje 0x13b479
0013b461movzx esi, [rbx+rdi]
0013b465test sil, sil
0013b468jns 0x13b47d
0013b46aand esi, 127
0013b46dshl esi, cl
0013b46finc rdi
0013b472or edx, esi
0013b474add ecx, 7
0013b477jmp 0x13b45c
0013b479
0013b479loc_13b479:
0013b479xor edi, edi
0013b47bjmp 0x13b486
0013b47d
0013b47dloc_13b47d:
0013b47dshl esi, cl
0013b47for esi, edx
0013b481inc rdi
0013b484mov eax, esi
0013b486
0013b486loc_13b486:
0013b486mov ecx, eax
0013b488shr ecx, 1
0013b48aand eax, 1
0013b48dneg eax
0013b48fxor eax, ecx
0013b491add r12l, eax
0013b494mov rsi, rbx
0013b497mov rdx, r14
0013b49alea rcx, [rip+0xb582f]
0013b4a1call _<core::ops::range::RangeFrom<usize> as core::slice::index::SliceIndex<[T]>>::index
0013b4a6mov rbx, rax
0013b4a9mov r14, rdx
0013b4acmov [rsp+100], r12l
0013b4b1mov rdi, [r15+192]
0013b4b8mov rsi, [r15+208]
0013b4bfmov rdx, r12
0013b4c2lea rcx, [rip+0xb5aef]
0013b4c9call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013b4cemov edx, [rax]
0013b4d0cmp rbp, rdx
0013b4d3jbe 0x13b4f8
0013b4d5mov rdi, [r15+168]
0013b4dcmov rsi, [r15+184]
0013b4e3lea rcx, [rip+0xb5ae6]
0013b4eacall _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013b4efcmp [rax], r12l
0013b4f2je 0x13b44b
0013b4f8
0013b4f8loc_13b4f8:
0013b4f8mov [rsp+184], rbp
0013b500cmp rbp, r13
0013b503jae 0x13be06
0013b509mov edx, ebp
0013b50bmov rdi, [r15+168]
0013b512mov rsi, [r15+184]
0013b519lea rcx, [rip+0xb5a68]
0013b520call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013b525mov [rax], r12l
0013b528mov edx, [rsp+100]
0013b52cmov rdi, [r15+192]
0013b533mov rsi, [r15+208]
0013b53alea rcx, [rip+0xb5a5f]
0013b541call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013b546mov [rax], ebp
0013b548inc rbp
0013b54bmov [r15+216], rbp
0013b552jmp 0x13b44b
0013b557
0013b557loc_13b557:
0013b557mov r12, [rsp+24]
0013b55cmov rdi, [r12]
0013b560mov rsi, [r12+8]
0013b565call regex_automata::util::determinize::state::State::look_need
0013b56atest eax, eax
0013b56cmov r13, [rsp+64]
0013b571je 0x13b77f
0013b577mov rdi, [r12]
0013b57bmov rsi, [r12+8]
0013b580call regex_automata::util::determinize::state::State::look_have
0013b585mov ebx, eax
0013b587mov ecx, [rsp+16]
0013b58bmov ebp, ecx
0013b58dshr ebp, 8
0013b590test cl, 1
0013b593jne 0x13b5ad
0013b595cmp bpl, 10
0013b599je 0x13b5b2
0013b59bmovzx eax, bpl
0013b59fcmp eax, 13
0013b5a2jne 0x13b5d2
0013b5a4cmp [rsp+15], 0
0013b5a9jne 0x13b5b9
0013b5abjmp 0x13b5cf
0013b5ad
0013b5adloc_13b5ad:
0013b5ador ebx, 42
0013b5b0jmp 0x13b5d2
0013b5b2
0013b5b2loc_13b5b2:
0013b5b2cmp [rsp+15], 0
0013b5b7jne 0x13b5cf
0013b5b9
0013b5b9loc_13b5b9:
0013b5b9mov rdi, [r12]
0013b5bdmov rsi, [r12+8]
0013b5c2call regex_automata::util::determinize::state::State::is_half_crlf
0013b5c7mov ecx, [rsp+16]
0013b5cbtest al, al
0013b5cdjne 0x13b5d2
0013b5cf
0013b5cfloc_13b5cf:
0013b5cfor ebx, 32
0013b5d2
0013b5d2loc_13b5d2:
0013b5d2mov r14l, ebx
0013b5d5or r14l, 8
0013b5d9mov rax, [rsp+32]
0013b5decmp [rax+384], bpl
0013b5e5cmovne r14l, ebx
0013b5e9test cl, 1
0013b5eccmovne r14l, ebx
0013b5f0mov rdi, [r12]
0013b5f4mov rsi, [r12+8]
0013b5f9call regex_automata::util::determinize::state::State::is_half_crlf
0013b5fetest al, al
0013b600je 0x13b629
0013b602cmp [rsp+15], 0
0013b607je 0x13b618
0013b609test [rsp+16], 1
0013b60ejne 0x13b625
0013b610cmp bpl, 13
0013b614je 0x13b629
0013b616jmp 0x13b625
0013b618
0013b618loc_13b618:
0013b618test [rsp+16], 1
0013b61djne 0x13b625
0013b61fcmp bpl, 10
0013b623je 0x13b629
0013b625
0013b625loc_13b625:
0013b625or r14l, 16
0013b629
0013b629loc_13b629:
0013b629mov rdi, [r12]
0013b62dmov rsi, [r12+8]
0013b632call regex_automata::util::determinize::state::State::is_from_word
0013b637lea r12, [rip-0xe454d]
0013b63etest [rsp+16], 1
0013b643jne 0x13b66a
0013b645movzx ecx, bpl
0013b649mov cl, [rcx+r12]
0013b64dtest cl, cl
0013b64fsetne dl
0013b652xor al, dl
0013b654mov eax, 320
0013b659mov ebx, 640
0013b65ecmovne ebx, eax
0013b661or ebx, r14l
0013b664test cl, cl
0013b666jne 0x13b687
0013b668jmp 0x13b681
0013b66a
0013b66aloc_13b66a:
0013b66atest al, al
0013b66cje 0x13b677
0013b66eor r14l, 320
0013b675jmp 0x13b67e
0013b677
0013b677loc_13b677:
0013b677or r14l, 640
0013b67e
0013b67eloc_13b67e:
0013b67emov ebx, r14l
0013b681
0013b681loc_13b681:
0013b681or ebx, 0x28000
0013b687
0013b687loc_13b687:
0013b687mov rax, [rsp+24]
0013b68cmov rdi, [rax]
0013b68fmov rsi, [rax+8]
0013b693call regex_automata::util::determinize::state::State::is_from_word
0013b698test al, al
0013b69aje 0x13b6ae
0013b69ctest [rsp+16], 1
0013b6a1jne 0x13b6e2
0013b6a3movzx eax, bpl
0013b6a7cmp [rax+r12], 0
0013b6acje 0x13b6e2
0013b6ae
0013b6aeloc_13b6ae:
0013b6aemov rax, [rsp+24]
0013b6b3mov rdi, [rax]
0013b6b6mov rsi, [rax+8]
0013b6bacall regex_automata::util::determinize::state::State::is_from_word
0013b6bftest al, al
0013b6c1jne 0x13b6e8
0013b6c3mov eax, [rsp+16]
0013b6c7and eax, 1
0013b6cajne 0x13b6e8
0013b6ccmovzx eax, bpl
0013b6d0mov ecx, ebx
0013b6d2or ecx, 5120
0013b6d8cmp [rax+r12], 0
0013b6ddcmovne ebx, ecx
0013b6e0jmp 0x13b6e8
0013b6e2
0013b6e2loc_13b6e2:
0013b6e2or ebx, 10240
0013b6e8
0013b6e8loc_13b6e8:
0013b6e8mov r14, [rsp+24]
0013b6edmov rdi, [r14]
0013b6f0mov rsi, [r14+8]
0013b6f4call regex_automata::util::determinize::state::State::look_have
0013b6f9mov ebp, eax
0013b6fbnot ebp
0013b6fdmov rdi, [r14]
0013b700mov rsi, [r14+8]
0013b704call regex_automata::util::determinize::state::State::look_need
0013b709and eax, ebp
0013b70btest eax, ebx
0013b70dje 0x13b77f
0013b70fmov rdi, [rsp+80]
0013b714call regex_automata::util::sparse_set::SparseSet::iter
0013b719mov r12, rax
0013b71cmov r13, rdx
0013b71flea r14, [r15+224]
0013b726mov rbp, [rsp+112]
0013b72b
0013b72bloc_13b72b:
0013b72bcmp r12, r13
0013b72eje 0x13b753
0013b730mov esi, [r12]
0013b734add r12, 4
0013b738mov rax, [rsp+64]
0013b73dmov rdi, [rax+384]
0013b744mov edx, ebx
0013b746mov rcx, rbp
0013b749mov r8, r14
0013b74ccall regex_automata::util::determinize::epsilon_closure
0013b751jmp 0x13b72b
0013b753
0013b753loc_13b753:
0013b753push -7
0013b755pop rax
0013b756mov r13, [rsp+64]
0013b75b
0013b75bloc_13b75b:
0013b75btest rax, rax
0013b75eje 0x13b777
0013b760mov rcx, [r14+8*rax]
0013b764mov rdx, [r14+8*rax+56]
0013b769mov [r14+8*rax], rdx
0013b76dmov [r14+8*rax+56], rcx
0013b772inc rax
0013b775jmp 0x13b75b
0013b777
0013b777loc_13b777:
0013b777and [r15+272], 0
0013b77f
0013b77floc_13b77f:
0013b77flea rdi, [rsp+40]
0013b784lea rsi, [rsp+208]
0013b78ccall regex_automata::util::determinize::state::StateBuilderEmpty::into_matches
0013b791mov rax, [rsp+32]
0013b796mov eax, [rax+376]
0013b79ctest al, 60
0013b79eje 0x13b7fe
0013b7a0mov edx, [rsp+16]
0013b7a4test dl, 1
0013b7a7jne 0x13b802
0013b7a9mov ecx, edx
0013b7abshr ecx, 8
0013b7aemov rsi, [rsp+32]
0013b7b3cmp [rsi+384], cl
0013b7b9jne 0x13b802
0013b7bblea rbx, [rsp+40]
0013b7c0mov rdi, rbx
0013b7c3call regex_automata::util::determinize::state::ReprVec::look_have
0013b7c8mov ebp, eax
0013b7caor ebp, 4
0013b7cdmov rdi, [rbx]
0013b7d0mov rsi, [rbx+16]
0013b7d4lea rcx, [rip+0xb5585]
0013b7dbpush 1
0013b7ddpop rdx
0013b7decall _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013b7e3mov edi, ebp
0013b7e5mov rsi, rax
0013b7e8call regex_automata::util::look::LookSet::write_repr
0013b7edmov edx, [rsp+16]
0013b7f1mov rax, [rsp+32]
0013b7f6mov eax, [rax+376]
0013b7fcjmp 0x13b802
0013b7fe
0013b7feloc_13b7fe:
0013b7femov edx, [rsp+16]
0013b802
0013b802loc_13b802:
0013b802test al, 48
0013b804je 0x13b862
0013b806mov ecx, edx
0013b808and ecx, 65281
0013b80ecmp [rsp+15], 0
0013b813je 0x13bc46
0013b819cmp ecx, 3328
0013b81fjne 0x13b862
0013b821
0013b821loc_13b821:
0013b821lea rbx, [rsp+40]
0013b826mov rdi, rbx
0013b829call regex_automata::util::determinize::state::ReprVec::look_have
0013b82emov ebp, eax
0013b830or ebp, 16
0013b833mov rdi, [rbx]
0013b836mov rsi, [rbx+16]
0013b83alea rcx, [rip+0xb551f]
0013b841push 1
0013b843pop rdx
0013b844call _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013b849mov edi, ebp
0013b84bmov rsi, rax
0013b84ecall regex_automata::util::look::LookSet::write_repr
0013b853mov edx, [rsp+16]
0013b857mov rax, [rsp+32]
0013b85cmov eax, [rax+376]
0013b862
0013b862loc_13b862:
0013b862and edx, 1
0013b865mov [rsp+88], edx
0013b869mov [rsp+24], edx
0013b86dtest eax, 0x3ffc0
0013b872je 0x13b8d4
0013b874cmp [rsp+88], 0
0013b879jne 0x13b897
0013b87bmov eax, [rsp+16]
0013b87fmovzx eax, ah
0013b882lea rcx, [rip-0xe4798]
0013b889mov [rsp+24], 0
0013b891cmp [rax+rcx], 0
0013b895jne 0x13b8d4
0013b897
0013b897loc_13b897:
0013b897lea rbx, [rsp+40]
0013b89cmov rdi, rbx
0013b89fcall regex_automata::util::determinize::state::ReprVec::look_have
0013b8a4mov ebp, eax
0013b8a6or ebp, 0x14000
0013b8acmov rdi, [rbx]
0013b8afmov rsi, [rbx+16]
0013b8b3lea rcx, [rip+0xb54a6]
0013b8bapush 1
0013b8bcpop rdx
0013b8bdcall _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013b8c2mov edi, ebp
0013b8c4mov rsi, rax
0013b8c7call regex_automata::util::look::LookSet::write_repr
0013b8ccmov eax, [rsp+88]
0013b8d0mov [rsp+24], eax
0013b8d4
0013b8d4loc_13b8d4:
0013b8d4mov rdi, [rsp+80]
0013b8d9call regex_automata::util::sparse_set::SparseSet::iter
0013b8demov r14, rax
0013b8e1mov rbx, rdx
0013b8e4mov ecx, [rsp+16]
0013b8e8shr ecx, 8
0013b8eblea rax, [r15+224]
0013b8f2mov [rsp+120], rax
0013b8f7lea rbp, [rip-0xfd646]
0013b8femov [rsp+80], ecx
0013b902movzx eax, cl
0013b905mov [rsp+96], eax
0013b909
0013b909loc_13b909:
0013b909cmp r14, rbx
0013b90cje 0x13ba47
0013b912mov esi, [r14]
0013b915add r14, 4
0013b919mov rdi, [r13+384]
0013b920call regex_automata::nfa::thompson::nfa::NFA::state
0013b925mov ecx, [rax]
0013b927movsxd rcx, [rbp+4*rcx]
0013b92cadd rcx, rbp
0013b92fjmp rcx
0013b931cmp [rsp+88], 0
0013b936jne 0x13b909
0013b938mov ecx, [rsp+80]
0013b93ccmp [rax+8], cl
0013b93fja 0x13b909
0013b941mov ecx, [rsp+80]
0013b945cmp [rax+9], cl
0013b948jb 0x13b909
0013b94amov r12l, [rax+4]
0013b94ejmp 0x13b98a
0013b950cmp [rsp+24], 0
0013b955jne 0x13b909
0013b957mov rdi, [rax+8]
0013b95bmov rsi, [rax+16]
0013b95fmov edx, [rsp+96]
0013b963call regex_automata::nfa::thompson::nfa::SparseTransitions::matches_byte
0013b968jmp 0x13b982
0013b96acmp [rsp+24], 0
0013b96fjne 0x13b909
0013b971mov rdi, [rax+8]
0013b975mov rsi, [rax+16]
0013b979mov edx, [rsp+96]
0013b97dcall regex_automata::nfa::thompson::nfa::DenseTransitions::matches_byte
0013b982
0013b982loc_13b982:
0013b982cmp eax, 1
0013b985jne 0x13b909
0013b987mov r12l, edx
0013b98a
0013b98aloc_13b98a:
0013b98amov rdi, [rsp+40]
0013b98fmov rsi, [rsp+56]
0013b994call regex_automata::util::determinize::state::StateBuilderMatches::look_have
0013b999mov rdi, [r13+384]
0013b9a0mov esi, r12l
0013b9a3mov edx, eax
0013b9a5mov rcx, [rsp+112]
0013b9aamov r8, [rsp+120]
0013b9afcall regex_automata::util::determinize::epsilon_closure
0013b9b4jmp 0x13b909
0013b9b9mov r12l, [rax+4]
0013b9bdmov rdi, [rsp+40]
0013b9c2mov rsi, [rsp+56]
0013b9c7call regex_automata::util::determinize::state::Repr::has_pattern_ids
0013b9cctest al, al
0013b9cejne 0x13ba2f
0013b9d0test r12l, r12l
0013b9d3lea rdi, [rsp+40]
0013b9d8je 0x13ba1e
0013b9dacall alloc::vec::Vec<T,A>::extend_trusted
0013b9dfmov r13, [rsp+40]
0013b9e4mov rsi, [rsp+56]
0013b9e9mov rdi, r13
0013b9eclea rdx, [rip+0xb5325]
0013b9f3call _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013b9f8or [r13], 2
0013b9fdmov rdi, [rsp+40]
0013ba02mov rsi, [rsp+56]
0013ba07call regex_automata::util::determinize::state::Repr::is_match
0013ba0clea rdi, [rsp+40]
0013ba11test al, al
0013ba13je 0x13ba25
0013ba15xor esi, esi
0013ba17call regex_automata::util::determinize::state::write_u32
0013ba1cjmp 0x13ba2a
0013ba1e
0013ba1eloc_13ba1e:
0013ba1ecall regex_automata::util::determinize::state::ReprVec::set_is_match
0013ba23jmp 0x13ba3c
0013ba25
0013ba25loc_13ba25:
0013ba25call regex_automata::util::determinize::state::ReprVec::set_is_match
0013ba2a
0013ba2aloc_13ba2a:
0013ba2amov r13, [rsp+64]
0013ba2f
0013ba2floc_13ba2f:
0013ba2flea rdi, [rsp+40]
0013ba34mov esi, r12l
0013ba37call regex_automata::util::determinize::state::write_u32
0013ba3c
0013ba3cloc_13ba3c:
0013ba3ctest [rsp+23], 1
0013ba41je 0x13b909
0013ba47
0013ba47loc_13ba47:
0013ba47cmp [r15+272], 0
0013ba4fje 0x13bac4
0013ba51mov rax, [rsp+32]
0013ba56mov eax, [rax+376]
0013ba5ctest eax, 0x3ffc0
0013ba61je 0x13ba96
0013ba63cmp [rsp+24], 0
0013ba68jne 0x13ba96
0013ba6amovzx ecx, [rsp+80]
0013ba6flea rdx, [rip-0xe4985]
0013ba76cmp [rcx+rdx], 0
0013ba7aje 0x13ba96
0013ba7cmov rdi, [rsp+40]
0013ba81mov rsi, [rsp+56]
0013ba86call regex_automata::util::determinize::state::StateBuilderMatches::set_is_from_word
0013ba8bmov rax, [rsp+32]
0013ba90mov eax, [rax+376]
0013ba96
0013ba96loc_13ba96:
0013ba96test al, 48
0013ba98je 0x13bac4
0013ba9amov eax, [rsp+16]
0013ba9eand eax, 65281
0013baa3cmp [rsp+15], 0
0013baa8je 0x13bc57
0013baaecmp eax, 2560
0013bab3jne 0x13bac4
0013bab5
0013bab5loc_13bab5:
0013bab5mov rdi, [rsp+40]
0013babamov rsi, [rsp+56]
0013babfcall regex_automata::util::determinize::state::StateBuilderMatches::set_is_half_crlf
0013bac4
0013bac4loc_13bac4:
0013bac4mov rax, [rsp+56]
0013bac9lea rsi, [rsp+240]
0013bad1mov [rsi+16], rax
0013bad5movups x0, [rsp+40]
0013badamovaps [rsi], x0
0013baddlea rbx, [rsp+128]
0013bae5mov rdi, rbx
0013bae8call regex_automata::util::determinize::state::StateBuilderMatches::into_nfa
0013baedmov rdi, [r13+384]
0013baf4mov rsi, [rsp+120]
0013baf9mov rdx, rbx
0013bafccall regex_automata::util::determinize::add_nfa_states
0013bb01movups x0, [rbx]
0013bb04movaps [rsp+192], x0
0013bb0cmov r14, [rbx+16]
0013bb10mov rbx, [rbx+24]
0013bb14mov rdi, r15
0013bb17call regex_automata::hybrid::dfa::Cache::memory_usage
0013bb1cmov cl, [r13+392]
0013bb23push 4
0013bb25pop rdx
0013bb26shl rdx, cl
0013bb29add rax, r14
0013bb2cadd rax, rdx
0013bb2fadd rax, 36
0013bb33mov rcx, [r13+688]
0013bb3amov [rsp+24], rax
0013bb3fmov [rsp+88], rcx
0013bb44cmp rax, rcx
0013bb47jbe 0x13bb8e
0013bb49mov rdi, r13
0013bb4cmov rsi, r15
0013bb4fmov ebp, [rsp+76]
0013bb53mov edx, ebp
0013bb55call regex_automata::hybrid::dfa::LazyRef::get_cached_state
0013bb5amov r12, [rax]
0013bb5dlock inc [r12]
0013bb62jle 0x13be7c
0013bb68mov r13, [rax+8]
0013bb6clea rdi, [r15+24]
0013bb70call core::ptr::drop_in_place<regex_automata::hybrid::dfa::StateSaver>
0013bb75mov [r15+24], 1
0013bb7dmov [r15+28], ebp
0013bb81mov [r15+32], r12
0013bb85mov [r15+40], r13
0013bb89mov r13, [rsp+64]
0013bb8e
0013bb8eloc_13bb8e:
0013bb8emovaps x0, [rsp+192]
0013bb96movaps [rsp+128], x0
0013bb9emov [rsp+144], r14
0013bba6mov [rsp+152], rbx
0013bbaelea rbx, [r15+120]
0013bbb2mov r12, [rsp+128]
0013bbbamov rdi, rbx
0013bbbdmov rsi, r12
0013bbc0mov rdx, r14
0013bbc3call std::collections::hash::map::HashMap<K,V,S>::get
0013bbc8test rax, rax
0013bbcbje 0x13bbeb
0013bbcdmov ebp, [rax]
0013bbcflea rsi, [rsp+128]
0013bbd7mov rdi, r15
0013bbdacall regex_automata::hybrid::dfa::Lazy::put_state_builder
0013bbdfxor ebx, ebx
0013bbe1mov r12l, [rsp+76]
0013bbe6jmp 0x13bd2f
0013bbeb
0013bbebloc_13bbeb:
0013bbebmov rdi, r12
0013bbeemov rsi, r14
0013bbf1call regex_automata::util::determinize::state::StateBuilderNFA::to_state
0013bbf6mov rbp, rax
0013bbf9mov r12, rdx
0013bbfcmov [rsp+40], rax
0013bc01mov [rsp+48], rdx
0013bc06mov rdi, r13
0013bc09mov rsi, r15
0013bc0ccall regex_automata::hybrid::dfa::LazyRef::state_fits_in_cache
0013bc11test al, al
0013bc13jne 0x13bc23
0013bc15mov rdi, [rsp+104]
0013bc1acall regex_automata::hybrid::dfa::Lazy::try_clear_cache
0013bc1ftest al, al
0013bc21jne 0x13bc31
0013bc23
0013bc23loc_13bc23:
0013bc23mov rdi, [rsp+104]
0013bc28call regex_automata::hybrid::dfa::Lazy::next_state_id
0013bc2dtest eax, eax
0013bc2fje 0x13bc67
0013bc31
0013bc31loc_13bc31:
0013bc31lea rdi, [rsp+40]
0013bc36call core::ptr::drop_in_place<regex_automata::util::determinize::state::State>
0013bc3bpush 1
0013bc3dpop rbx
0013bc3exor r14l, r14l
0013bc41jmp 0x13bd15
0013bc46
0013bc46loc_13bc46:
0013bc46cmp ecx, 2560
0013bc4cje 0x13b821
0013bc52jmp 0x13b862
0013bc57
0013bc57loc_13bc57:
0013bc57cmp eax, 3328
0013bc5cje 0x13bab5
0013bc62jmp 0x13bac4
0013bc67
0013bc67loc_13bc67:
0013bc67mov r14l, edx
0013bc6amov [rsp+32], rbp
0013bc6fmov rdi, rbp
0013bc72mov rsi, r12
0013bc75call regex_automata::util::determinize::state::State::is_match
0013bc7amov ebp, r14l
0013bc7dor ebp, 0x8000000
0013bc83test al, al
0013bc85cmove ebp, r14l
0013bc89lea r14, [r15+48]
0013bc8dcall regex_automata::hybrid::dfa::LazyRef::unknown_id
0013bc92mov cl, [r13+392]
0013bc99push 1
0013bc9bpop rsi
0013bc9cshl rsi, cl
0013bc9fmov rdi, r14
0013bca2mov edx, eax
0013bca4call alloc::vec::Vec<T,A>::extend_trusted
0013bca9lea r14, [r13+656]
0013bcb0mov rdi, r14
0013bcb3call _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013bcb8test al, al
0013bcbajne 0x13bcce
0013bcbcmov rdi, r13
0013bcbfmov esi, ebp
0013bcc1call regex_automata::hybrid::dfa::LazyRef::is_sentinel
0013bcc6test al, al
0013bcc8je 0x13bdbe
0013bcce
0013bcceloc_13bcce:
0013bcceadd [r15+328], r12
0013bcd5mov r14, [rsp+32]
0013bcdalock inc [r14]
0013bcdejle 0x13be7c
0013bce4mov rdi, [rsp+176]
0013bcecmov rsi, r14
0013bcefmov rdx, r12
0013bcf2call alloc::vec::Vec<T,A>::push
0013bcf7mov rdi, rbx
0013bcfamov rsi, r14
0013bcfdmov rdx, r12
0013bd00mov ecx, ebp
0013bd02call hashbrown::map::HashMap<K,V,S,A>::insert
0013bd07mov rax, [rsp+104]
0013bd0cmov r15, [rax+8]
0013bd10xor ebx, ebx
0013bd12mov r14b, 1
0013bd15
0013bd15loc_13bd15:
0013bd15lea rsi, [rsp+128]
0013bd1dmov rdi, r15
0013bd20call regex_automata::hybrid::dfa::Lazy::put_state_builder
0013bd25test r14b, r14b
0013bd28mov r12l, [rsp+76]
0013bd2dje 0x13bda8
0013bd2f
0013bd2floc_13bd2f:
0013bd2fmov rax, [rsp+88]
0013bd34cmp [rsp+24], rax
0013bd39jbe 0x13bd8e
0013bd3bmov rax, [r15+40]
0013bd3fmov [rsp+144], rax
0013bd47movups x0, [r15+24]
0013bd4cmovaps [rsp+128], x0
0013bd54and [r15+24], 0
0013bd59mov eax, [rsp+128]
0013bd60test rax, rax
0013bd63je 0x13bd75
0013bd65cmp eax, 1
0013bd68mov r12l, [rsp+132]
0013bd70xor r14l, r14l
0013bd73jmp 0x13bd78
0013bd75
0013bd75loc_13bd75:
0013bd75mov r14b, 1
0013bd78
0013bd78loc_13bd78:
0013bd78lea rdi, [rsp+128]
0013bd80call core::ptr::drop_in_place<regex_automata::hybrid::dfa::StateSaver>
0013bd85test r14b, r14b
0013bd88jne 0x13be80
0013bd8e
0013bd8eloc_13bd8e:
0013bd8emov rax, [rsp+104]
0013bd93mov rdi, [rax]
0013bd96mov rsi, r15
0013bd99mov edx, r12l
0013bd9cmov ecx, [rsp+16]
0013bda0mov r8l, ebp
0013bda3call regex_automata::hybrid::dfa::Lazy::set_transition
0013bda8
0013bda8loc_13bda8:
0013bda8mov eax, ebx
0013bdaamov edx, ebp
0013bdacadd rsp, 296
0013bdb3pop rbx
0013bdb4pop r12
0013bdb6pop r13
0013bdb8pop r14
0013bdbapop r15
0013bdbcpop rbp
0013bdbdret
0013bdbe
0013bdbeloc_13bdbe:
0013bdbemov rdi, r13
0013bdc1call regex_automata::hybrid::dfa::LazyRef::quit_id
0013bdc6mov r13l, eax
0013bdc9mov rax, r14
0013bdcclea r14, [rsp+240]
0013bdd4mov [r14], rax
0013bdd7and [r14+8], 0
0013bddc
0013bddcloc_13bddc:
0013bddcmov rdi, r14
0013bddfcall _<regex_automata::util::alphabet::ByteSetIter as core::iter::traits::iterator::Iterator>::next
0013bde4test al, 1
0013bde6je 0x13bcce
0013bdecmovzx ecx, dl
0013bdefshl ecx, 8
0013bdf2mov rdi, [rsp+64]
0013bdf7mov rsi, r15
0013bdfamov edx, ebp
0013bdfcmov r8l, r13l
0013bdffcall regex_automata::hybrid::dfa::Lazy::set_transition
0013be04jmp 0x13bddc
0013be06
0013be06loc_13be06:
0013be06lea rax, [rsp+40]
0013be0bmov [rax], r13
0013be0elea rcx, [rsp+184]
0013be16lea rdx, [rsp+128]
0013be1emov [rdx], rcx
0013be21lea rcx, [rip-0x71105]
0013be28mov [rdx+8], rcx
0013be2cmov [rdx+16], rax
0013be30mov [rdx+24], rcx
0013be34lea rax, [rsp+100]
0013be39mov [rdx+32], rax
0013be3dlea rax, [rip+0xb50fc]
0013be44lea rdi, [rsp+240]
0013be4cmov [rdi], rax
0013be4fpush 3
0013be51pop rax
0013be52mov [rdi+8], rax
0013be56and [rdi+32], 0
0013be5blea rcx, [rip-0x10a60]
0013be62mov [rdx+40], rcx
0013be66mov [rdi+16], rdx
0013be6amov [rdi+24], rax
0013be6elea rsi, [rip+0xb50fb]
0013be75call core::panicking::panic_fmt
0013be7aud2
0013be7c
0013be7cloc_13be7c:
0013be7cud2
0013be7eud2
0013be80
0013be80loc_13be80:
0013be80lea rdi, [rip-0xe63b5]
0013be87lea rdx, [rip+0xb23aa]
0013be8epush 40
0013be90pop rsi
0013be91call core::option::expect_failed
0013be96ud2
0013b31b

0013be98
0013be98regex_automata::util::determinize::state::State::look_need:
0013be98add rdi, 16
0013be9cjmp 0x12d03f
0013be98

0013bea1
0013bea1regex_automata::util::determinize::state::State::look_have:
0013bea1add rdi, 16
0013bea5jmp 0x12d01d
0013bea1

0013beaa
0013beaaregex_automata::util::determinize::state::State::is_half_crlf:
0013beaatest rsi, rsi
0013beadje 0x13beb8
0013beafmov al, [rdi+16]
0013beb2and al, 8
0013beb4shr al, 3
0013beb7ret
0013beb8
0013beb8loc_13beb8:
0013beb8push rax
0013beb9lea rdx, [rip+0xb4d98]
0013bec0xor edi, edi
0013bec2xor esi, esi
0013bec4call core::panicking::panic_bounds_check
0013bec9ud2
0013beaa

0013becb
0013becbregex_automata::util::determinize::state::State::is_from_word:
0013becbtest rsi, rsi
0013beceje 0x13bed9
0013bed0mov al, [rdi+16]
0013bed3and al, 4
0013bed5shr al, 2
0013bed8ret
0013bed9
0013bed9loc_13bed9:
0013bed9push rax
0013bedalea rdx, [rip+0xb4d5f]
0013bee1xor edi, edi
0013bee3xor esi, esi
0013bee5call core::panicking::panic_bounds_check
0013beeaud2
0013becb

0013beec
0013beecregex_automata::util::determinize::epsilon_closure:
0013beecpush rbp
0013beedpush r15
0013beefpush r14
0013bef1push r13
0013bef3push r12
0013bef5push rbx
0013bef6sub rsp, 184
0013befdmov [rsp+16], r8
0013bf02mov [rsp+36], edx
0013bf06cmp [rcx+16], 0
0013bf0bjne 0x13c200
0013bf11mov r12, rcx
0013bf14mov ebx, esi
0013bf16mov rbp, rdi
0013bf19call regex_automata::nfa::thompson::nfa::NFA::state
0013bf1emov eax, [rax]
0013bf20add rax, -3
0013bf24cmp rax, 4
0013bf28jae 0x13c0dd
0013bf2emov rdi, r12
0013bf31mov esi, ebx
0013bf33call alloc::vec::Vec<T,A>::push
0013bf38mov rbx, [rsp+16]
0013bf3dmov r13, [rbx+24]
0013bf41mov rax, [rbx+40]
0013bf45mov [rsp+64], rax
0013bf4amov rax, [rbx]
0013bf4dmov [rsp+48], rax
0013bf52mov rax, [rbx+16]
0013bf56mov [rsp+56], rax
0013bf5bmov r14, [rbx+48]
0013bf5fmov [rsp+72], rbp
0013bf64mov [rsp+40], r13
0013bf69
0013bf69loc_13bf69:
0013bf69mov rax, [r12+16]
0013bf6etest rax, rax
0013bf71je 0x13c17e
0013bf77lea rcx, [rax-1]
0013bf7bmov [r12+16], rcx
0013bf80mov rcx, [r12]
0013bf84mov r15l, [rcx+4*rax-4]
0013bf89
0013bf89loc_13bf89:
0013bf89mov [rsp+12], r15l
0013bf8emov edx, r15l
0013bf91mov rdi, r13
0013bf94mov rsi, [rsp+64]
0013bf99lea rcx, [rip+0xb5018]
0013bfa0call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013bfa5mov edx, [rax]
0013bfa7cmp r14, rdx
0013bfaajbe 0x13bfc7
0013bfacmov rdi, [rsp+48]
0013bfb1mov rsi, [rsp+56]
0013bfb6lea rcx, [rip+0xb5013]
0013bfbdcall _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013bfc2cmp [rax], r15l
0013bfc5je 0x13bf69
0013bfc7
0013bfc7loc_13bfc7:
0013bfc7mov [rsp+24], r14
0013bfccmov rsi, [rsp+56]
0013bfd1cmp r14, rsi
0013bfd4jae 0x13c190
0013bfdamov edx, r14l
0013bfddmov rdi, [rsp+48]
0013bfe2lea rcx, [rip+0xb4f9f]
0013bfe9call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013bfeemov [rax], r15l
0013bff1mov edx, [rsp+12]
0013bff5mov rdi, r13
0013bff8mov rsi, [rsp+64]
0013bffdlea rcx, [rip+0xb4f9c]
0013c004call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013c009mov [rax], r14l
0013c00cinc r14
0013c00fmov [rbx+48], r14
0013c013mov rdi, rbp
0013c016mov esi, r15l
0013c019call regex_automata::nfa::thompson::nfa::NFA::state
0013c01emov ecx, [rax]
0013c020lea rdx, [rip-0xfdd4b]
0013c027movsxd rcx, [rdx+4*rcx]
0013c02badd rcx, rdx
0013c02ejmp rcx
0013c030mov r15l, [rax+4]
0013c034mov ecx, [rsp+36]
0013c038test [rax+8], ecx
0013c03bjne 0x13bf89
0013c041jmp 0x13bf69
0013c046mov r15l, [rax+4]
0013c04amov esi, [rax+8]
0013c04dmov rdi, r12
0013c050call alloc::vec::Vec<T,A>::push
0013c055jmp 0x13bf89
0013c05amov r13, r12
0013c05dmov r12, [rax+16]
0013c061test r12, r12
0013c064je 0x13c0d0
0013c066mov rbx, [rax+8]
0013c06amov r15l, [rbx]
0013c06dmov rax, 0x3fffffffffffffff
0013c077lea rsi, [r12+rax]
0013c07band rsi, rax
0013c07emov rbp, r13
0013c081mov rdi, r13
0013c084call alloc::vec::Vec<T,A>::reserve
0013c089mov rcx, [r13]
0013c08dmov rax, [r13+16]
0013c091dec r12
0013c094mov rdx, r12
0013c097
0013c097loc_13c097:
0013c097sub rdx, 1
0013c09bjb 0x13c0b5
0013c09dmov esi, [rbx+4*r12]
0013c0a1mov [rcx+4*rax], esi
0013c0a4inc rax
0013c0a7mov r12, rdx
0013c0aajmp 0x13c097
0013c0acmov r15l, [rax+4]
0013c0b0jmp 0x13bf89
0013c0b5
0013c0b5loc_13c0b5:
0013c0b5mov r12, r13
0013c0b8mov [r13+16], rax
0013c0bcmov rbx, [rsp+16]
0013c0c1mov rbp, [rsp+72]
0013c0c6mov r13, [rsp+40]
0013c0cbjmp 0x13bf89
0013c0d0
0013c0d0loc_13c0d0:
0013c0d0mov r12, r13
0013c0d3mov r13, [rsp+40]
0013c0d8jmp 0x13bf69
0013c0dd
0013c0ddloc_13c0dd:
0013c0ddmov [rsp+12], ebx
0013c0e1mov edx, ebx
0013c0e3mov r12, [rsp+16]
0013c0e8mov r14, [r12+24]
0013c0edmov r15, [r12+40]
0013c0f2lea rcx, [rip+0xb4ebf]
0013c0f9mov rdi, r14
0013c0fcmov rsi, r15
0013c0ffcall _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013c104mov edx, [rax]
0013c106mov r13, [r12+48]
0013c10bcmp r13, rdx
0013c10ejbe 0x13c12e
0013c110mov rdi, [r12]
0013c114mov r12, [r12+16]
0013c119lea rcx, [rip+0xb4eb0]
0013c120mov rsi, r12
0013c123call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013c128cmp [rax], ebx
0013c12ajne 0x13c133
0013c12cjmp 0x13c17e
0013c12e
0013c12eloc_13c12e:
0013c12emov r12, [r12+16]
0013c133
0013c133loc_13c133:
0013c133mov [rsp+24], r13
0013c138cmp r13, r12
0013c13bjae 0x13c218
0013c141mov edx, r13l
0013c144mov rbp, [rsp+16]
0013c149mov rdi, [rbp]
0013c14dlea rcx, [rip+0xb4e34]
0013c154mov rsi, r12
0013c157call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013c15cmov [rax], ebx
0013c15emov edx, [rsp+12]
0013c162lea rcx, [rip+0xb4e37]
0013c169mov rdi, r14
0013c16cmov rsi, r15
0013c16fcall _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013c174mov [rax], r13l
0013c177inc r13
0013c17amov [rbp+48], r13
0013c17e
0013c17eloc_13c17e:
0013c17eadd rsp, 184
0013c185pop rbx
0013c186pop r12
0013c188pop r13
0013c18apop r14
0013c18cpop r15
0013c18epop rbp
0013c18fret
0013c190
0013c190loc_13c190:
0013c190lea rax, [rsp+80]
0013c195mov [rax], rsi
0013c198
0013c198loc_13c198:
0013c198lea rcx, [rsp+24]
0013c19dlea rdx, [rsp+136]
0013c1a5mov [rdx], rcx
0013c1a8lea rcx, [rip-0x7148c]
0013c1afmov [rdx+8], rcx
0013c1b3mov [rdx+16], rax
0013c1b7mov [rdx+24], rcx
0013c1bblea rax, [rsp+12]
0013c1c0mov [rdx+32], rax
0013c1c4lea rax, [rip+0xb4d75]
0013c1cblea rdi, [rsp+88]
0013c1d0mov [rdi], rax
0013c1d3push 3
0013c1d5pop rax
0013c1d6mov [rdi+8], rax
0013c1daand [rdi+32], 0
0013c1dflea rcx, [rip-0x10de4]
0013c1e6mov [rdx+40], rcx
0013c1eamov [rdi+16], rdx
0013c1eemov [rdi+24], rax
0013c1f2lea rsi, [rip+0xb4d77]
0013c1f9call core::panicking::panic_fmt
0013c1feud2
0013c200
0013c200loc_13c200:
0013c200lea rdi, [rip-0xe544e]
0013c207lea rdx, [rip+0xb4be2]
0013c20epush 34
0013c210pop rsi
0013c211call core::panicking::panic
0013c216ud2
0013c218
0013c218loc_13c218:
0013c218lea rax, [rsp+80]
0013c21dmov [rax], r12
0013c220jmp 0x13c198
0013beec

0013c225
0013c225regex_automata::util::determinize::state::ReprVec::look_have:
0013c225mov rax, [rdi]
0013c228mov rsi, [rdi+16]
0013c22cmov rdi, rax
0013c22fjmp 0x12d01d
0013c225

0013c234
0013c234_<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut:
0013c234mov rax, rdi
0013c237mov rdi, rsi
0013c23asub rdi, rdx
0013c23djb 0x13c246
0013c23fadd rax, rdx
0013c242mov rdx, rdi
0013c245ret
0013c246
0013c246loc_13c246:
0013c246push rax
0013c247mov rdi, rdx
0013c24amov rdx, rcx
0013c24dcall core::slice::index::slice_start_index_len_fail
0013c252ud2
0013c234

0013c254
0013c254regex_automata::util::look::LookSet::write_repr:
0013c254push rax
0013c255test rdx, rdx
0013c258je 0x13c288
0013c25amov [rsi], dil
0013c25dcmp rdx, 1
0013c261je 0x13c295
0013c263mov eax, edi
0013c265shr eax, 8
0013c268mov [rsi+1], al
0013c26bcmp rdx, 2
0013c26fjbe 0x13c2a0
0013c271mov eax, edi
0013c273shr eax, 16
0013c276mov [rsi+2], al
0013c279cmp rdx, 3
0013c27dje 0x13c2ab
0013c27fshr edi, 24
0013c282mov [rsi+3], dil
0013c286pop rax
0013c287ret
0013c288
0013c288loc_13c288:
0013c288lea rdx, [rip+0xb4289]
0013c28fxor edi, edi
0013c291xor esi, esi
0013c293jmp 0x13c2b8
0013c295
0013c295loc_13c295:
0013c295lea rdx, [rip+0xb4294]
0013c29cpush 1
0013c29ejmp 0x13c2b4
0013c2a0
0013c2a0loc_13c2a0:
0013c2a0lea rdx, [rip+0xb42a1]
0013c2a7push 2
0013c2a9jmp 0x13c2b4
0013c2ab
0013c2abloc_13c2ab:
0013c2ablea rdx, [rip+0xb42ae]
0013c2b2push 3
0013c2b4
0013c2b4loc_13c2b4:
0013c2b4pop rdi
0013c2b5mov rsi, rdi
0013c2b8
0013c2b8loc_13c2b8:
0013c2b8call core::panicking::panic_bounds_check
0013c2bdud2
0013c254

0013c2bf
0013c2bfregex_automata::nfa::thompson::nfa::SparseTransitions::matches_byte:
0013c2bfadd rdi, -8
0013c2c3shl rsi, 3
0013c2c7
0013c2c7loc_13c2c7:
0013c2c7xor eax, eax
0013c2c9test rsi, rsi
0013c2ccje 0x13c2ea
0013c2cecmp [rdi+12], dl
0013c2d1ja 0x13c2ea
0013c2d3lea rax, [rdi+8]
0013c2d7add rsi, -8
0013c2dbcmp [rdi+13], dl
0013c2demov rdi, rax
0013c2e1jb 0x13c2c7
0013c2e3mov ecx, [rax]
0013c2e5push 1
0013c2e7pop rax
0013c2e8jmp 0x13c2ea
0013c2ea
0013c2ealoc_13c2ea:
0013c2eamov edx, ecx
0013c2ecret
0013c2bf

0013c2ed
0013c2edregex_automata::nfa::thompson::nfa::DenseTransitions::matches_byte:
0013c2edmov rax, rdi
0013c2f0movzx edi, dl
0013c2f3cmp rdi, rsi
0013c2f6jae 0x13c303
0013c2f8mov edx, [rax+4*rdi]
0013c2fbxor eax, eax
0013c2fdtest edx, edx
0013c2ffsetne al
0013c302ret
0013c303
0013c303loc_13c303:
0013c303push rax
0013c304lea rdx, [rip+0xb3c25]
0013c30bcall core::panicking::panic_bounds_check
0013c310ud2
0013c2ed

0013c312
0013c312regex_automata::util::determinize::state::StateBuilderMatches::look_have:
0013c312push rax
0013c313mov rdx, rsi
0013c316mov rsi, rdi
0013c319lea rcx, [rip+0xb48d8]
0013c320push 1
0013c322pop rdi
0013c323call _<core::ops::range::RangeFrom<usize> as core::slice::index::SliceIndex<[T]>>::index
0013c328mov rdi, rax
0013c32bmov rsi, rdx
0013c32epop rax
0013c32fjmp 0x12d0ae
0013c312

0013c334
0013c334_<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut:
0013c334test rsi, rsi
0013c337je 0x13c33d
0013c339mov rax, rdi
0013c33cret
0013c33d
0013c33dloc_13c33d:
0013c33dpush rax
0013c33exor edi, edi
0013c340xor esi, esi
0013c342call core::panicking::panic_bounds_check
0013c347ud2
0013c334

0013c349
0013c349regex_automata::util::determinize::state::ReprVec::set_is_match:
0013c349push rbx
0013c34amov rbx, [rdi]
0013c34dmov rsi, [rdi+16]
0013c351lea rdx, [rip+0xb49a8]
0013c358mov rdi, rbx
0013c35bcall _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c360or [rbx], 1
0013c363pop rbx
0013c364ret
0013c349

0013c365
0013c365regex_automata::util::determinize::state::write_u32:
0013c365push r15
0013c367push r14
0013c369push rbx
0013c36amov ebx, esi
0013c36cmov r14, rdi
0013c36fmov r15, [rdi+16]
0013c373call alloc::vec::Vec<T,A>::extend_trusted
0013c378mov rdi, [r14]
0013c37bmov rsi, [r14+16]
0013c37flea rcx, [rip+0xb4a52]
0013c386mov rdx, r15
0013c389call _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c38emov edi, ebx
0013c390mov rsi, rax
0013c393pop rbx
0013c394pop r14
0013c396pop r15
0013c398jmp 0x13a3b2
0013c365

0013c39d
0013c39dregex_automata::util::determinize::state::StateBuilderMatches::set_is_from_word:
0013c39dpush rbx
0013c39emov rbx, rdi
0013c3a1lea rdx, [rip+0xb4988]
0013c3a8call _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c3ador [rbx], 4
0013c3b0pop rbx
0013c3b1ret
0013c39d

0013c3b2
0013c3b2regex_automata::util::determinize::state::StateBuilderMatches::set_is_half_crlf:
0013c3b2push rbx
0013c3b3mov rbx, rdi
0013c3b6lea rdx, [rip+0xb498b]
0013c3bdcall _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c3c2or [rbx], 8
0013c3c5pop rbx
0013c3c6ret
0013c3b2

0013c3c7
0013c3c7regex_automata::util::determinize::add_nfa_states:
0013c3c7push rbp
0013c3c8push r15
0013c3capush r14
0013c3ccpush r13
0013c3cepush r12
0013c3d0push rbx
0013c3d1push rax
0013c3d2mov rbx, rdx
0013c3d5mov r14, rdi
0013c3d8mov rdi, rsi
0013c3dbcall regex_automata::util::sparse_set::SparseSet::iter
0013c3e0mov r15, rax
0013c3e3mov r12, rdx
0013c3e6lea rbp, [rip-0xfe0ed]
0013c3edmov [rsp], r14
0013c3f1
0013c3f1loc_13c3f1:
0013c3f1cmp r15, r12
0013c3f4je 0x13c46f
0013c3f6mov r13l, [r15]
0013c3f9add r15, 4
0013c3fdmov rdi, r14
0013c400mov esi, r13l
0013c403call regex_automata::nfa::thompson::nfa::NFA::state
0013c408mov ecx, [rax]
0013c40amovsxd rcx, [rbp+4*rcx]
0013c40fadd rcx, rbp
0013c412jmp rcx
0013c414mov rdi, rbx
0013c417mov esi, r13l
0013c41acall regex_automata::util::determinize::state::StateBuilderNFA::add_nfa_state_id
0013c41fjmp 0x13c3f1
0013c421mov ebp, [rax+8]
0013c424mov rdi, rbx
0013c427mov esi, r13l
0013c42acall regex_automata::util::determinize::state::StateBuilderNFA::add_nfa_state_id
0013c42fmov r13, [rbx]
0013c432mov r14, [rbx+16]
0013c436mov rdi, r13
0013c439mov rsi, r14
0013c43ccall regex_automata::util::determinize::state::Repr::look_need
0013c441or ebp, eax
0013c443mov rdi, r13
0013c446mov rsi, r14
0013c449mov r14, [rsp]
0013c44dpush 5
0013c44fpop rdx
0013c450lea rcx, [rip+0xb4921]
0013c457call _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c45cmov edi, ebp
0013c45elea rbp, [rip-0xfe165]
0013c465mov rsi, rax
0013c468call regex_automata::util::look::LookSet::write_repr
0013c46djmp 0x13c3f1
0013c46f
0013c46floc_13c46f:
0013c46fmov rdi, [rbx]
0013c472mov rsi, [rbx+16]
0013c476call regex_automata::util::determinize::state::Repr::look_need
0013c47btest eax, eax
0013c47dje 0x13c48e
0013c47fadd rsp, 8
0013c483pop rbx
0013c484pop r12
0013c486pop r13
0013c488pop r14
0013c48apop r15
0013c48cpop rbp
0013c48dret
0013c48e
0013c48eloc_13c48e:
0013c48emov rdi, rbx
0013c491call regex_automata::util::determinize::state::ReprVec::look_have
0013c496mov rdi, [rbx]
0013c499mov rsi, [rbx+16]
0013c49dlea rcx, [rip+0xb48bc]
0013c4a4push 1
0013c4a6pop rdx
0013c4a7call _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c4acxor edi, edi
0013c4aemov rsi, rax
0013c4b1add rsp, 8
0013c4b5pop rbx
0013c4b6pop r12
0013c4b8pop r13
0013c4bapop r14
0013c4bcpop r15
0013c4bepop rbp
0013c4bfjmp 0x13c254
0013c3c7

0013c4c4
0013c4c4std::collections::hash::map::HashMap<K,V,S>::get:
0013c4c4push rbp
0013c4c5push r15
0013c4c7push r14
0013c4c9push r13
0013c4cbpush r12
0013c4cdpush rbx
0013c4cesub rsp, 120
0013c4d2cmp [rdi+24], 0
0013c4d7je 0x13c648
0013c4ddmov r12, rdi
0013c4e0mov rax, [rdi+32]
0013c4e4mov rcx, [rdi+40]
0013c4e8mov r9, 0x736f6d6570736575
0013c4f2xor r9, rax
0013c4f5mov r10, 0x646f72616e646f6d
0013c4ffxor r10, rcx
0013c502mov rdi, 0x6c7967656e657261
0013c50cxor rdi, rax
0013c50fmov r8, 0x7465646279746573
0013c519xor r8, rcx
0013c51clea rbx, [rsp+48]
0013c521mov [rbx], r9
0013c524mov [rbx+8], rdi
0013c528mov [rbx+16], r10
0013c52cmov [rbx+24], r8
0013c530mov [rbx+32], rax
0013c534mov [rbx+40], rcx
0013c538xorps x0, x0
0013c53bmovups [rbx+48], x0
0013c53fand [rbx+64], 0
0013c544mov [rsp+8], rsi
0013c549mov rdi, rsi
0013c54cmov r14, rdx
0013c54fmov rsi, rdx
0013c552mov rdx, rbx
0013c555call core::hash::impls::_<impl core::hash::Hash for [T]>::hash
0013c55amov rdi, rbx
0013c55dcall _<std::collections::hash::map::DefaultHasher as core::hash::Hasher>::finish
0013c562mov rbp, [r12]
0013c566mov rbx, [r12+8]
0013c56bmov r15, rbx
0013c56eand r15, rax
0013c571shr rax, 57
0013c575movd x0, eax
0013c579punpcklbw x0, x0
0013c57dpshuflw x0, x0, 0
0013c582pshufd x1, x0, 0
0013c587xor eax, eax
0013c589mov [rsp], rax
0013c58dmovdqa [rsp+16], x1
0013c593
0013c593loc_13c593:
0013c593movdqu x0, [rbp+r15]
0013c59amovdqa [rsp+32], x0
0013c5a0pcmpeqb x0, x1
0013c5a4pmovmskb eax, x0
0013c5a8mov [rsp+48], ax
0013c5ad
0013c5adloc_13c5ad:
0013c5adlea rdi, [rsp+48]
0013c5b2call _<hashbrown::raw::bitmask::BitMaskIter as core::iter::traits::iterator::Iterator>::next
0013c5b7mov r12, rax
0013c5batest rax, rax
0013c5bdje 0x13c5f3
0013c5bfmov r13, rdx
0013c5c2add r13, r15
0013c5c5and r13, rbx
0013c5c8mov rax, r13
0013c5cbneg rax
0013c5ceimul rax, rax, 24
0013c5d2mov rdx, [rbp+rax-24]
0013c5d7mov rcx, [rbp+rax-16]
0013c5dcadd rdx, 16
0013c5e0mov rdi, [rsp+8]
0013c5e5mov rsi, r14
0013c5e8call _<[A] as core::slice::cmp::SlicePartialEq>::equal
0013c5edtest al, al
0013c5efje 0x13c5ad
0013c5f1jmp 0x13c62a
0013c5f3
0013c5f3loc_13c5f3:
0013c5f3movdqa x0, [rsp+32]
0013c5f9pcmpeqb x0, [rip-0x103951]
0013c601pmovmskb eax, x0
0013c605test eax, eax
0013c607jne 0x13c62a
0013c609mov rax, [rsp]
0013c60dadd r15, rax
0013c610add r15, 16
0013c614add rax, 16
0013c618mov [rsp], rax
0013c61cand r15, rbx
0013c61fmovdqa x1, [rsp+16]
0013c625jmp 0x13c593
0013c62a
0013c62aloc_13c62a:
0013c62aneg r13
0013c62dimul rax, r13, 24
0013c631add rbp, rax
0013c634test r12, r12
0013c637cmove rbp, r12
0013c63badd rbp, -24
0013c63ftest r12, r12
0013c642cmove rbp, r12
0013c646jmp 0x13c64a
0013c648
0013c648loc_13c648:
0013c648xor ebp, ebp
0013c64a
0013c64aloc_13c64a:
0013c64alea rax, [rbp+16]
0013c64etest rbp, rbp
0013c651cmove rax, rbp
0013c655add rsp, 120
0013c659pop rbx
0013c65apop r12
0013c65cpop r13
0013c65epop r14
0013c660pop r15
0013c662pop rbp
0013c663ret
0013c4c4

0013c664
0013c664regex_automata::hybrid::dfa::Lazy::put_state_builder:
0013c664mov rax, [rdi+304]
0013c66bmov rcx, [rdi+312]
0013c672movups x0, [rsi]
0013c675movups [rdi+304], x0
0013c67cand [rdi+320], 0
0013c684mov rdi, rax
0013c687mov rsi, rcx
0013c68ajmp 0x1137a0
0013c664

0013c68f
0013c68fregex_automata::hybrid::dfa::LazyRef::get_cached_state:
0013c68fand edx, 0x7ffffff
0013c695mov cl, [rdi+392]
0013c69bshr rdx, cl
0013c69emov rdi, [rsi+96]
0013c6a2mov rsi, [rsi+112]
0013c6a6lea rcx, [rip+0xb1c7b]
0013c6adjmp 0x119f56
0013c68f

0013c6b2
0013c6b2regex_automata::util::determinize::state::StateBuilderNFA::add_nfa_state_id:
0013c6b2push r15
0013c6b4push r14
0013c6b6push rbx
0013c6b7mov ebx, esi
0013c6b9mov r14, rdi
0013c6bcmov r15l, esi
0013c6bfsub r15l, [rdi+24]
0013c6c3lea eax, [r15+r15]
0013c6c7sar r15l, 31
0013c6cbxor r15l, eax
0013c6ce
0013c6celoc_13c6ce:
0013c6cecmp r15l, 128
0013c6d5jb 0x13c6ed
0013c6d7mov eax, r15l
0013c6daor al, 128
0013c6dcmovzx esi, al
0013c6dfmov rdi, r14
0013c6e2call alloc::vec::Vec<T,A>::push
0013c6e7shr r15l, 7
0013c6ebjmp 0x13c6ce
0013c6ed
0013c6edloc_13c6ed:
0013c6edmovzx esi, r15b
0013c6f1mov rdi, r14
0013c6f4call alloc::vec::Vec<T,A>::push
0013c6f9mov [r14+24], ebx
0013c6fdpop rbx
0013c6fepop r14
0013c700pop r15
0013c702ret
0013c6b2

0013c703
0013c703alloc::vec::Vec<T,A>::push:
0013c703push rbp
0013c704push rbx
0013c705push rax
0013c706mov ebp, esi
0013c708mov rbx, rdi
0013c70bmov rsi, [rdi+16]
0013c70fcmp rsi, [rdi+8]
0013c713jne 0x13c721
0013c715mov rdi, rbx
0013c718call alloc::raw_vec::RawVec<T,A>::reserve_for_push
0013c71dmov rsi, [rbx+16]
0013c721
0013c721loc_13c721:
0013c721mov rax, [rbx]
0013c724mov [rax+rsi], bpl
0013c728inc rsi
0013c72bmov [rbx+16], rsi
0013c72fadd rsp, 8
0013c733pop rbx
0013c734pop rbp
0013c735ret
0013c703

0013c736
0013c736regex_automata::hybrid::dfa::Lazy::cache_start_group:
0013c736push rbp
0013c737push r15
0013c739push r14
0013c73bpush r13
0013c73dpush r12
0013c73fpush rbx
0013c740sub rsp, 184
0013c747mov ebx, ecx
0013c749mov eax, edx
0013c74btest esi, esi
0013c74dje 0x13c76b
0013c74fcmp esi, 1
0013c752jne 0x13c80d
0013c758mov [rsp+28], esi
0013c75cmov [rsp+48], rax
0013c761mov r13, [rdi]
0013c764mov eax, 368
0013c769jmp 0x13c77c
0013c76b
0013c76bloc_13c76b:
0013c76bmov [rsp+28], esi
0013c76fmov [rsp+48], rax
0013c774mov r13, [rdi]
0013c777mov eax, 372
0013c77c
0013c77cloc_13c77c:
0013c77cadd rax, [r13+384]
0013c783
0013c783loc_13c783:
0013c783mov r14l, [rax]
0013c786mov [rsp+40], rdi
0013c78bmov r15, [rdi+8]
0013c78fmov rax, [r15+320]
0013c796lea rsi, [rsp+96]
0013c79bmov [rsi+16], rax
0013c79fmovups x0, [r15+304]
0013c7a7movaps [rsi], x0
0013c7aamov [r15+304], 1
0013c7b5xorps x0, x0
0013c7b8movups [r15+312], x0
0013c7c0mov rdi, rsp
0013c7c3call regex_automata::util::determinize::state::StateBuilderEmpty::into_matches
0013c7c8mov rcx, [r13+384]
0013c7cfmov al, [rcx+388]
0013c7d5movzx ebp, [rcx+384]
0013c7dcmov r12l, [rcx+376]
0013c7e3movzx edx, bl
0013c7e6lea rcx, [rip-0xfe4c9]
0013c7edmov [rsp+56], rdx
0013c7f2movsxd rdx, [rcx+4*rdx]
0013c7f6add rdx, rcx
0013c7f9jmp rdx
0013c7fbtest r12l, 0x3ffc0
0013c802jne 0x13c9a2
0013c808jmp 0x13ca9d
0013c80d
0013c80dloc_13c80d:
0013c80dmov r13, [rdi]
0013c810test [r13+121], 1
0013c815jne 0x13c820
0013c817mov ebp, edx
0013c819push 2
0013c81bjmp 0x13cc2d
0013c820
0013c820loc_13c820:
0013c820mov rcx, [r13+384]
0013c827cmp [rcx+352], rax
0013c82ejbe 0x13c9b5
0013c834mov [rsp+28], esi
0013c838mov [rsp+48], rax
0013c83dlea rax, [4*rax]
0013c845add rax, [rcx+336]
0013c84cjmp 0x13c783
0013c851test r12b, 3
0013c855je 0x13c890
0013c857mov rbx, rsp
0013c85amov rdi, rbx
0013c85dcall regex_automata::util::determinize::state::ReprVec::look_have
0013c862mov ebp, r14l
0013c865mov r14l, eax
0013c868or r14l, 1
0013c86cmov rdi, [rbx]
0013c86fmov rsi, [rbx+16]
0013c873lea rcx, [rip+0xb44e6]
0013c87apush 1
0013c87cpop rdx
0013c87dcall _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c882mov edi, r14l
0013c885mov r14l, ebp
0013c888mov rsi, rax
0013c88bcall regex_automata::util::look::LookSet::write_repr
0013c890
0013c890loc_13c890:
0013c890test r12b, 60
0013c894je 0x13ca58
0013c89amov rbx, rsp
0013c89dmov rdi, rbx
0013c8a0call regex_automata::util::determinize::state::ReprVec::look_have
0013c8a5mov ebp, r14l
0013c8a8mov r14l, eax
0013c8abor r14l, 20
0013c8afjmp 0x13ca34
0013c8b4test al, al
0013c8b6je 0x13c9c4
0013c8bctest r12b, 48
0013c8c0je 0x13c8d0
0013c8c2mov rdi, [rsp]
0013c8c6mov rsi, [rsp+16]
0013c8cbcall regex_automata::util::determinize::state::StateBuilderMatches::set_is_half_crlf
0013c8d0
0013c8d0loc_13c8d0:
0013c8d0test r12b, 60
0013c8d4je 0x13ca58
0013c8damov rdi, rsp
0013c8ddcall regex_automata::util::determinize::state::ReprVec::look_have
0013c8e2mov ebx, eax
0013c8e4or ebx, 4
0013c8e7jmp 0x13c9db
0013c8ectest r12b, 48
0013c8f0je 0x13ca12
0013c8f6test al, al
0013c8f8je 0x13ca04
0013c8femov rbx, rsp
0013c901mov rdi, rbx
0013c904call regex_automata::util::determinize::state::ReprVec::look_have
0013c909mov [rsp+32], r14l
0013c90emov r14l, eax
0013c911or r14l, 16
0013c915mov rdi, [rbx]
0013c918mov rsi, [rbx+16]
0013c91clea rcx, [rip+0xb443d]
0013c923push 1
0013c925pop rdx
0013c926call _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c92bmov edi, r14l
0013c92emov r14l, [rsp+32]
0013c933mov rsi, rax
0013c936call regex_automata::util::look::LookSet::write_repr
0013c93bjmp 0x13ca12
0013c940test r12b, 60
0013c944je 0x13c983
0013c946mov rbx, rsp
0013c949mov rdi, rbx
0013c94ccall regex_automata::util::determinize::state::ReprVec::look_have
0013c951mov [rsp+32], r14l
0013c956mov r14l, eax
0013c959or r14l, 4
0013c95dmov rdi, [rbx]
0013c960mov rsi, [rbx+16]
0013c964lea rcx, [rip+0xb43f5]
0013c96bpush 1
0013c96dpop rdx
0013c96ecall _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c973mov edi, r14l
0013c976mov r14l, [rsp+32]
0013c97bmov rsi, rax
0013c97ecall regex_automata::util::look::LookSet::write_repr
0013c983
0013c983loc_13c983:
0013c983test r12l, 0x3ffc0
0013c98aje 0x13ca9d
0013c990lea rax, [rip-0xe58a6]
0013c997cmp [rbp+rax], 0
0013c99cje 0x13ca61
0013c9a2
0013c9a2loc_13c9a2:
0013c9a2mov rdi, [rsp]
0013c9a6mov rsi, [rsp+16]
0013c9abcall regex_automata::util::determinize::state::StateBuilderMatches::set_is_from_word
0013c9b0jmp 0x13ca9d
0013c9b5
0013c9b5loc_13c9b5:
0013c9b5mov rdi, r13
0013c9b8call regex_automata::hybrid::dfa::LazyRef::dead_id
0013c9bdmov ebp, eax
0013c9bfjmp 0x13cc2b
0013c9c4
0013c9c4loc_13c9c4:
0013c9c4test r12b, 60
0013c9c8je 0x13ca58
0013c9cemov rdi, rsp
0013c9d1call regex_automata::util::determinize::state::ReprVec::look_have
0013c9d6mov ebx, eax
0013c9d8or ebx, 16
0013c9db
0013c9dbloc_13c9db:
0013c9dbmov rdi, [rsp]
0013c9dfmov rsi, [rsp+16]
0013c9e4lea rcx, [rip+0xb4375]
0013c9ebpush 1
0013c9edpop rdx
0013c9eecall _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013c9f3mov edi, ebx
0013c9f5mov rsi, rax
0013c9f8call regex_automata::util::look::LookSet::write_repr
0013c9fdcmp ebp, 10
0013ca00je 0x13ca1f
0013ca02jmp 0x13ca58
0013ca04
0013ca04loc_13ca04:
0013ca04mov rdi, [rsp]
0013ca08mov rsi, [rsp+16]
0013ca0dcall regex_automata::util::determinize::state::StateBuilderMatches::set_is_half_crlf
0013ca12
0013ca12loc_13ca12:
0013ca12cmp ebp, 13
0013ca15jne 0x13ca58
0013ca17mov eax, r12l
0013ca1aand eax, 60
0013ca1dje 0x13ca58
0013ca1f
0013ca1floc_13ca1f:
0013ca1fmov rbx, rsp
0013ca22mov rdi, rbx
0013ca25call regex_automata::util::determinize::state::ReprVec::look_have
0013ca2amov ebp, r14l
0013ca2dmov r14l, eax
0013ca30or r14l, 4
0013ca34
0013ca34loc_13ca34:
0013ca34mov rdi, [rbx]
0013ca37mov rsi, [rbx+16]
0013ca3blea rcx, [rip+0xb431e]
0013ca42push 1
0013ca44pop rdx
0013ca45call _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013ca4amov edi, r14l
0013ca4dmov r14l, ebp
0013ca50mov rsi, rax
0013ca53call regex_automata::util::look::LookSet::write_repr
0013ca58
0013ca58loc_13ca58:
0013ca58test r12l, 0x3ffc0
0013ca5fje 0x13ca9d
0013ca61
0013ca61loc_13ca61:
0013ca61mov rbx, rsp
0013ca64mov rdi, rbx
0013ca67call regex_automata::util::determinize::state::ReprVec::look_have
0013ca6cmov ebp, r14l
0013ca6fmov r14l, eax
0013ca72or r14l, 0x14000
0013ca79mov rdi, [rbx]
0013ca7cmov rsi, [rbx+16]
0013ca80lea rcx, [rip+0xb42d9]
0013ca87push 1
0013ca89pop rdx
0013ca8acall _<alloc::vec::Vec<T,A> as core::ops::index::IndexMut>::index_mut
0013ca8fmov edi, r14l
0013ca92mov r14l, ebp
0013ca95mov rsi, rax
0013ca98call regex_automata::util::look::LookSet::write_repr
0013ca9d
0013ca9dloc_13ca9d:
0013ca9dand [r15+216], 0
0013caa5lea rbx, [r15+168]
0013caacmov rdi, [rsp]
0013cab0mov rsi, [rsp+16]
0013cab5call regex_automata::util::determinize::state::StateBuilderMatches::look_have
0013cabalea rcx, [r15+280]
0013cac1mov rdi, [r13+384]
0013cac8mov esi, r14l
0013cacbmov edx, eax
0013cacdmov r8, rbx
0013cad0call regex_automata::util::determinize::epsilon_closure
0013cad5mov rax, [rsp+16]
0013cadalea r14, [rsp+96]
0013cadfmov [r14+16], rax
0013cae3movups x0, [rsp]
0013cae7movaps [r14], x0
0013caeblea r12, [rsp+152]
0013caf3mov rdi, r12
0013caf6mov rsi, r14
0013caf9call regex_automata::util::determinize::state::StateBuilderMatches::into_nfa
0013cafemov rdi, [r13+384]
0013cb05mov rsi, rbx
0013cb08mov rdx, r12
0013cb0bcall regex_automata::util::determinize::add_nfa_states
0013cb10movzx ebp, [r13+124]
0013cb15movups x0, [r12]
0013cb1amovups x1, [r12+16]
0013cb20movaps [r14], x0
0013cb24movaps [r14+16], x1
0013cb29lea r12, [r15+120]
0013cb2dmov rbx, [r14]
0013cb30mov r14, [r14+16]
0013cb34mov rdi, r12
0013cb37mov rsi, rbx
0013cb3amov rdx, r14
0013cb3dcall std::collections::hash::map::HashMap<K,V,S>::get
0013cb42test rax, rax
0013cb45je 0x13cb4d
0013cb47mov ebp, [rax]
0013cb49
0013cb49loc_13cb49:
0013cb49xor ebx, ebx
0013cb4bjmp 0x13cba6
0013cb4d
0013cb4dloc_13cb4d:
0013cb4dmov rdi, rbx
0013cb50mov rsi, r14
0013cb53call regex_automata::util::determinize::state::StateBuilderNFA::to_state
0013cb58mov r14, rdx
0013cb5bmov [rsp+32], rax
0013cb60mov [rsp+64], rax
0013cb65mov [rsp+72], rdx
0013cb6amov rdi, r13
0013cb6dmov rsi, r15
0013cb70call regex_automata::hybrid::dfa::LazyRef::state_fits_in_cache
0013cb75test al, al
0013cb77jne 0x13cb87
0013cb79mov rdi, [rsp+40]
0013cb7ecall regex_automata::hybrid::dfa::Lazy::try_clear_cache
0013cb83test al, al
0013cb85jne 0x13cb99
0013cb87
0013cb87loc_13cb87:
0013cb87mov rdi, [rsp+40]
0013cb8ccall regex_automata::hybrid::dfa::Lazy::next_state_id
0013cb91test eax, eax
0013cb93je 0x13cc4a
0013cb99
0013cb99loc_13cb99:
0013cb99lea rdi, [rsp+64]
0013cb9ecall core::ptr::drop_in_place<regex_automata::util::determinize::state::State>
0013cba3push 1
0013cba5pop rbx
0013cba6
0013cba6loc_13cba6:
0013cba6lea rsi, [rsp+96]
0013cbabmov rdi, r15
0013cbaecall regex_automata::hybrid::dfa::Lazy::put_state_builder
0013cbb3test ebx, ebx
0013cbb5je 0x13cbbd
0013cbb7xor ebp, ebp
0013cbb9push 3
0013cbbbjmp 0x13cc2d
0013cbbd
0013cbbdloc_13cbbd:
0013cbbdmov rax, [rsp+40]
0013cbc2mov rbx, [rax]
0013cbc5mov rdi, rbx
0013cbc8mov rsi, r15
0013cbcbmov edx, ebp
0013cbcdcall regex_automata::hybrid::dfa::LazyRef::is_valid
0013cbd2test al, al
0013cbd4je 0x13cd35
0013cbdamov eax, [rsp+28]
0013cbdetest eax, eax
0013cbe0je 0x13cbf2
0013cbe2cmp eax, 1
0013cbe5jne 0x13cbf9
0013cbe7mov rdx, [rsp+56]
0013cbecadd rdx, 6
0013cbf0jmp 0x13cc15
0013cbf2
0013cbf2loc_13cbf2:
0013cbf2mov rdx, [rsp+56]
0013cbf7jmp 0x13cc15
0013cbf9
0013cbf9loc_13cbf9:
0013cbf9test [rbx+121], 1
0013cbfdje 0x13cd4d
0013cc03imul rax, [rsp+48], 6
0013cc09mov rdx, [rsp+56]
0013cc0eadd rdx, rax
0013cc11add rdx, 12
0013cc15
0013cc15loc_13cc15:
0013cc15mov rdi, [r15+72]
0013cc19mov rsi, [r15+88]
0013cc1dlea rcx, [rip+0xb16d4]
0013cc24call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013cc29mov [rax], ebp
0013cc2b
0013cc2bloc_13cc2b:
0013cc2bpush 5
0013cc2d
0013cc2dloc_13cc2d:
0013cc2dpop rax
0013cc2eshl rbp, 32
0013cc32or rbp, rax
0013cc35mov rax, rbp
0013cc38add rsp, 184
0013cc3fpop rbx
0013cc40pop r12
0013cc42pop r13
0013cc44pop r14
0013cc46pop r15
0013cc48pop rbp
0013cc49ret
0013cc4a
0013cc4aloc_13cc4a:
0013cc4amov ebx, edx
0013cc4cand ebp, 1
0013cc4fshl ebp, 28
0013cc52or ebx, ebp
0013cc54mov rdi, [rsp+32]
0013cc59mov rsi, r14
0013cc5ccall regex_automata::util::determinize::state::State::is_match
0013cc61mov ebp, ebx
0013cc63or ebp, 0x8000000
0013cc69test al, al
0013cc6bcmove ebp, ebx
0013cc6elea rbx, [r15+48]
0013cc72call regex_automata::hybrid::dfa::LazyRef::unknown_id
0013cc77mov cl, [r13+392]
0013cc7epush 1
0013cc80pop rsi
0013cc81shl rsi, cl
0013cc84mov rdi, rbx
0013cc87mov edx, eax
0013cc89call alloc::vec::Vec<T,A>::extend_trusted
0013cc8elea rbx, [r13+656]
0013cc95mov rdi, rbx
0013cc98call _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013cc9dtest al, al
0013cc9fjne 0x13ccaf
0013cca1mov rdi, r13
0013cca4mov esi, ebp
0013cca6call regex_automata::hybrid::dfa::LazyRef::is_sentinel
0013ccabtest al, al
0013ccadje 0x13ccf5
0013ccaf
0013ccafloc_13ccaf:
0013ccafadd [r15+328], r14
0013ccb6mov rbx, [rsp+32]
0013ccbblock inc [rbx]
0013ccbfjle 0x13cd84
0013ccc5add r15, 96
0013ccc9mov rdi, r15
0013ccccmov rsi, rbx
0013cccfmov rdx, r14
0013ccd2call alloc::vec::Vec<T,A>::push
0013ccd7mov rdi, r12
0013ccdamov rsi, rbx
0013ccddmov rdx, r14
0013cce0mov ecx, ebp
0013cce2call hashbrown::map::HashMap<K,V,S,A>::insert
0013cce7mov rax, [rsp+40]
0013ccecmov r15, [rax+8]
0013ccf0jmp 0x13cb49
0013ccf5
0013ccf5loc_13ccf5:
0013ccf5mov rdi, r13
0013ccf8call regex_automata::hybrid::dfa::LazyRef::quit_id
0013ccfdmov rcx, rbx
0013cd00mov ebx, eax
0013cd02lea rax, [rsp+80]
0013cd07mov [rax], rcx
0013cd0aand [rax+8], 0
0013cd0f
0013cd0floc_13cd0f:
0013cd0flea rdi, [rsp+80]
0013cd14call _<regex_automata::util::alphabet::ByteSetIter as core::iter::traits::iterator::Iterator>::next
0013cd19test al, 1
0013cd1bje 0x13ccaf
0013cd1dmovzx ecx, dl
0013cd20shl ecx, 8
0013cd23mov rdi, r13
0013cd26mov rsi, r15
0013cd29mov edx, ebp
0013cd2bmov r8l, ebx
0013cd2ecall regex_automata::hybrid::dfa::Lazy::set_transition
0013cd33jmp 0x13cd0f
0013cd35
0013cd35loc_13cd35:
0013cd35lea rdi, [rip-0xe721e]
0013cd3clea rdx, [rip+0xb1575]
0013cd43push 44
0013cd45pop rsi
0013cd46call core::panicking::panic
0013cd4bud2
0013cd4d
0013cd4dloc_13cd4d:
0013cd4dlea rax, [rip+0xb157c]
0013cd54lea rdi, [rsp+96]
0013cd59mov [rdi], rax
0013cd5cmov [rdi+8], 1
0013cd64lea rax, [rip-0xaba73]
0013cd6bmov [rdi+16], rax
0013cd6fxorps x0, x0
0013cd72movups [rdi+24], x0
0013cd76lea rsi, [rip+0xb1563]
0013cd7dcall core::panicking::panic_fmt
0013cd82ud2
0013cd84
0013cd84loc_13cd84:
0013cd84ud2
0013cd86ud2
0013c736

0013cd88
0013cd88regex_automata::hybrid::dfa::Config::prefilter:
0013cd88push r15
0013cd8apush r14
0013cd8cpush r12
0013cd8epush rbx
0013cd8fpush rax
0013cd90mov r12, rdx
0013cd93mov rbx, rsi
0013cd96mov r14, rdi
0013cd99lea r15, [rsi+88]
0013cd9dmov rdi, r15
0013cda0call core::ptr::drop_in_place<core::option::Option<core::option::Option<regex_automata::util::prefilter::Prefilter>>>
0013cda5movups x0, [r12]
0013cdaamovups x1, [r12+16]
0013cdb0movups [rbx+104], x1
0013cdb4movups [rbx+88], x0
0013cdb8cmp [rbx+124], 2
0013cdbcjne 0x13cdd6
0013cdbecmp [rbx+112], 3
0013cdc2lea rax, [rip-0xff189]
0013cdc9cmove r15, rax
0013cdcdcmp [r15+24], 2
0013cdd2setne [rbx+124]
0013cdd6
0013cdd6loc_13cdd6:
0013cdd6push 16
0013cdd8pop rcx
0013cdd9mov rdi, r14
0013cddcmov rsi, rbx
0013cddfrep movsq [rdi], [rsi]
0013cde2add rsp, 8
0013cde6pop rbx
0013cde7pop r12
0013cde9pop r14
0013cdebpop r15
0013cdedret
0013cd88

0013cdee
0013cdeeregex_automata::hybrid::dfa::Builder::configure:
0013cdeepush rbp
0013cdefpush r15
0013cdf1push r14
0013cdf3push r13
0013cdf5push r12
0013cdf7push rbx
0013cdf8sub rsp, 168
0013cdffmov r14, rsi
0013ce02mov rbx, rdi
0013ce05mov bpl, [rsi+120]
0013ce09mov r15b, [rdi+120]
0013ce0dmov al, [rsi+112]
0013ce10cmp al, 3
0013ce12jne 0x13ce24
0013ce14lea rsi, [rbx+88]
0013ce18lea rdi, [rsp+32]
0013ce1dcall _<core::option::Option<T> as core::clone::Clone>::clone
0013ce22jmp 0x13ce4b
0013ce24
0013ce24loc_13ce24:
0013ce24mov rcx, [r14+104]
0013ce28mov [rsp+48], rcx
0013ce2dmovups x0, [r14+88]
0013ce32movaps [rsp+32], x0
0013ce37mov [rsp+56], al
0013ce3bmov eax, [r14+113]
0013ce3fmov ecx, [r14+116]
0013ce43mov [rsp+57], eax
0013ce47mov [rsp+60], ecx
0013ce4b
0013ce4bloc_13ce4b:
0013ce4bmovzx eax, [r14+121]
0013ce50cmp [r14], 0
0013ce54movzx ecx, [r14+122]
0013ce59mov rdx, r14
0013ce5ccmove rdx, rbx
0013ce60push 1
0013ce62pop r8
0013ce64mov rsi, [rbx]
0013ce67cmovne rsi, r8
0013ce6bmov [rsp+88], rsi
0013ce70movzx esi, [r14+123]
0013ce75movups x0, [rdx+8]
0013ce79movups x1, [rdx+24]
0013ce7dmovzx edx, [rbx+123]
0013ce81movzx edi, [rbx+122]
0013ce85cmp sil, 2
0013ce89cmovne edx, esi
0013ce8cmov [rsp+28], edx
0013ce90movzx edx, [rbx+121]
0013ce94cmp cl, 2
0013ce97cmovne edi, ecx
0013ce9amov [rsp+24], edi
0013ce9emovaps [rsp+144], x1
0013cea6cmp al, 2
0013cea8cmovne edx, eax
0013ceabmov [rsp+20], edx
0013ceafmovaps [rsp+128], x0
0013ceb7cmp bpl, 2
0013cebbmovzx eax, r15b
0013cebfmovzx ecx, bpl
0013cec3cmove ecx, eax
0013cec6mov [rsp+16], ecx
0013cecamov eax, [r14+124]
0013cececmp al, 2
0013ced0jne 0x13ced5
0013ced2mov eax, [rbx+124]
0013ced5
0013ced5loc_13ced5:
0013ced5mov [rsp+12], eax
0013ced9cmp [r14+40], 0
0013cedejne 0x13ceea
0013cee0lea rax, [rbx+48]
0013cee4mov r8, [rbx+40]
0013cee8jmp 0x13ceee
0013ceea
0013ceealoc_13ceea:
0013ceealea rax, [r14+48]
0013ceee
0013ceeeloc_13ceee:
0013ceeemovzx ecx, [r14+125]
0013cef3cmp cl, 2
0013cef6movzx r15l, [rbx+125]
0013cefbcmovne r15l, ecx
0013ceffmov r12, [r14+56]
0013cf03mov r13, [r14+72]
0013cf07cmp r12, 2
0013cf0bjne 0x13cf17
0013cf0dlea rcx, [rbx+64]
0013cf11mov r12, [rbx+56]
0013cf15jmp 0x13cf1b
0013cf17
0013cf17loc_13cf17:
0013cf17lea rcx, [r14+64]
0013cf1b
0013cf1bloc_13cf1b:
0013cf1bmov rax, [rax]
0013cf1emov [rsp+80], rax
0013cf23mov rax, [rcx]
0013cf26mov [rsp+72], rax
0013cf2bmov rbp, r8
0013cf2ecmp r13, 2
0013cf32jne 0x13cf3e
0013cf34lea r14, [rbx+80]
0013cf38mov r13, [rbx+72]
0013cf3cjmp 0x13cf42
0013cf3e
0013cf3eloc_13cf3e:
0013cf3eadd r14, 80
0013cf42
0013cf42loc_13cf42:
0013cf42mov r14, [r14]
0013cf45movaps x0, [rsp+32]
0013cf4amovaps x1, [rsp+48]
0013cf4fmovaps [rsp+112], x1
0013cf54movaps [rsp+96], x0
0013cf59lea rdi, [rbx+88]
0013cf5dcall core::ptr::drop_in_place<core::option::Option<core::option::Option<regex_automata::util::prefilter::Prefilter>>>
0013cf62mov rax, [rsp+88]
0013cf67mov [rbx], rax
0013cf6amovaps x0, [rsp+128]
0013cf72movaps x1, [rsp+144]
0013cf7amovups [rbx+8], x0
0013cf7emovups [rbx+24], x1
0013cf82mov [rbx+40], rbp
0013cf86mov rax, [rsp+80]
0013cf8bmov [rbx+48], rax
0013cf8fmov [rbx+56], r12
0013cf93mov rax, [rsp+72]
0013cf98mov [rbx+64], rax
0013cf9cmov [rbx+72], r13
0013cfa0mov [rbx+80], r14
0013cfa4movaps x0, [rsp+96]
0013cfa9movaps x1, [rsp+112]
0013cfaemovups [rbx+88], x0
0013cfb2movups [rbx+104], x1
0013cfb6mov eax, [rsp+16]
0013cfbamov [rbx+120], al
0013cfbdmov eax, [rsp+20]
0013cfc1mov [rbx+121], al
0013cfc4mov eax, [rsp+24]
0013cfc8mov [rbx+122], al
0013cfcbmov eax, [rsp+28]
0013cfcfmov [rbx+123], al
0013cfd2mov eax, [rsp+12]
0013cfd6mov [rbx+124], al
0013cfd9mov [rbx+125], r15b
0013cfddmov rax, rbx
0013cfe0add rsp, 168
0013cfe7pop rbx
0013cfe8pop r12
0013cfeapop r13
0013cfecpop r14
0013cfeepop r15
0013cff0pop rbp
0013cff1ret
0013cdee

0013cff2
0013cff2regex_automata::hybrid::dfa::skip_empty_utf8_splits_overlapping:
0013cff2cmp [rsi], 0
0013cff6je 0x13d030
0013cff8push rbp
0013cff9push r15
0013cffbpush r14
0013cffdpush r13
0013cfffpush r12
0013d001push rbx
0013d002push rax
0013d003mov r12, rcx
0013d006mov r14, rsi
0013d009mov r15, rdi
0013d00cmov rax, [rsi+8]
0013d010mov ecx, [rdi]
0013d012dec rcx
0013d015cmp rcx, 2
0013d019jae 0x13d033
0013d01bmov rcx, [r15+16]
0013d01fcmp rcx, rax
0013d022jbe 0x13d070
0013d024mov rcx, [r15+8]
0013d028cmp [rcx+rax], -65
0013d02cjle 0x13d072
0013d02ejmp 0x13d076
0013d030
0013d030loc_13d030:
0013d030xor eax, eax
0013d032ret
0013d033
0013d033loc_13d033:
0013d033mov r13, rdx
0013d036mov rbp, [r15+8]
0013d03amov rbx, [r15+16]
0013d03e
0013d03eloc_13d03e:
0013d03ecmp rbx, rax
0013d041jbe 0x13d04c
0013d043cmp [rbp+rax], -65
0013d048jle 0x13d04e
0013d04ajmp 0x13d076
0013d04c
0013d04cloc_13d04c:
0013d04cje 0x13d076
0013d04e
0013d04eloc_13d04e:
0013d04emov rdi, r13
0013d051mov rsi, r12
0013d054mov rdx, r15
0013d057mov rcx, r14
0013d05acall regex_automata::hybrid::search::find_overlapping_fwd
0013d05ftest rax, rax
0013d062jne 0x13d078
0013d064mov rax, [r14+8]
0013d068cmp [r14], 0
0013d06cjne 0x13d03e
0013d06ejmp 0x13d076
0013d070
0013d070loc_13d070:
0013d070je 0x13d076
0013d072
0013d072loc_13d072:
0013d072and [r14], 0
0013d076
0013d076loc_13d076:
0013d076xor eax, eax
0013d078
0013d078loc_13d078:
0013d078add rsp, 8
0013d07cpop rbx
0013d07dpop r12
0013d07fpop r13
0013d081pop r14
0013d083pop r15
0013d085pop rbp
0013d086ret
0013cff2

0013d087
0013d087regex_automata::hybrid::search::find_overlapping_fwd:
0013d087push rbp
0013d088push r15
0013d08apush r14
0013d08cpush r13
0013d08epush r12
0013d090push rbx
0013d091sub rsp, 216
0013d098mov [rsp+8], rsi
0013d09dand [rcx], 0
0013d0a1mov r13, [rdx+24]
0013d0a5mov rax, [rdx+32]
0013d0a9mov [rsp+24], rax
0013d0aecmp r13, rax
0013d0b1jbe 0x13d0ca
0013d0b3
0013d0b3loc_13d0b3:
0013d0b3xor ebx, ebx
0013d0b5
0013d0b5loc_13d0b5:
0013d0b5mov rax, rbx
0013d0b8add rsp, 216
0013d0bfpop rbx
0013d0c0pop r12
0013d0c2pop r13
0013d0c4pop r14
0013d0c6pop r15
0013d0c8pop rbp
0013d0c9ret
0013d0ca
0013d0caloc_13d0ca:
0013d0camov r14, rcx
0013d0cdmov r12, rdx
0013d0d0mov rbx, rdi
0013d0d3mov ecx, [rdx]
0013d0d5lea rax, [rcx-1]
0013d0d9cmp rax, 2
0013d0ddjb 0x13d0fc
0013d0dflea rax, [rbx+88]
0013d0e3cmp [rbx+112], 3
0013d0e7lea rdx, [rip-0xff4ae]
0013d0eecmovne rdx, rax
0013d0f2cmp [rdx+24], 2
0013d0f6jne 0x13d1e2
0013d0fc
0013d0fcloc_13d0fc:
0013d0fccmp [r14+40], 0
0013d101je 0x13d165
0013d103mov r15l, [r14+44]
0013d107cmp [r14+24], 0
0013d10cje 0x13d14a
0013d10emov r13, [r14+32]
0013d112mov rdi, rbx
0013d115mov rsi, [rsp+8]
0013d11amov edx, r15l
0013d11dcall regex_automata::hybrid::dfa::DFA::match_len
0013d122cmp r13, rax
0013d125jae 0x13d14a
0013d127lea rax, [r13+1]
0013d12bpush 1
0013d12dpop r12
0013d12fmov [r14+24], r12
0013d133mov [r14+32], rax
0013d137mov rdi, rbx
0013d13amov rsi, [rsp+8]
0013d13fmov edx, r15l
0013d142mov rcx, r13
0013d145jmp 0x13d25e
0013d14a
0013d14aloc_13d14a:
0013d14amov r13, [r14+48]
0013d14einc r13
0013d151mov [r14+48], r13
0013d155cmp r13, [rsp+24]
0013d15aja 0x13d0b3
0013d160jmp 0x13d2d0
0013d165
0013d165loc_13d165:
0013d165mov rax, [rbx+384]
0013d16cmov [rsp+40], rax
0013d171mov [r14+48], r13
0013d175lea r15, [rsp+136]
0013d17dmov rdi, r15
0013d180mov rsi, r12
0013d183call regex_automata::util::start::Config::from_input_forward
0013d188mov ecx, [r15]
0013d18bmov eax, [r15+4]
0013d18fmov [rsp+16], rax
0013d194cmp [r15+8], 0
0013d199mov [rsp+48], ecx
0013d19dje 0x13d292
0013d1a3movzx ebp, [rsp+145]
0013d1ablea r15, [rbx+656]
0013d1b2mov rdi, r15
0013d1b5call _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013d1batest al, al
0013d1bcjne 0x13d1d0
0013d1bemov rdi, r15
0013d1c1mov esi, ebp
0013d1c3call aho_corasick::util::alphabet::ByteSet::contains
0013d1c8test al, al
0013d1cajne 0x13d3ef
0013d1d0
0013d1d0loc_13d1d0:
0013d1d0mov eax, ebp
0013d1d2mov al, [rbx+rax+128]
0013d1d9mov ecx, [rsp+48]
0013d1ddjmp 0x13d294
0013d1e2
0013d1e2loc_13d1e2:
0013d1e2mov [rsp+48], rdx
0013d1e7mov eax, [r12+4]
0013d1ecmov [rsp+72], eax
0013d1f0mov rax, [rbx+384]
0013d1f7mov [rsp+128], rax
0013d1ffmov eax, [rax+380]
0013d205mov [rsp+76], eax
0013d209cmp [r14+40], 0
0013d20emov [rsp+176], rcx
0013d216je 0x13d38c
0013d21cmov r15l, [r14+44]
0013d220cmp [r14+24], 0
0013d225je 0x13d277
0013d227mov rbp, [r14+32]
0013d22bmov rdi, rbx
0013d22emov rsi, [rsp+8]
0013d233mov edx, r15l
0013d236call regex_automata::hybrid::dfa::DFA::match_len
0013d23bcmp rbp, rax
0013d23ejae 0x13d277
0013d240lea rax, [rbp+1]
0013d244push 1
0013d246pop r12
0013d248mov [r14+24], r12
0013d24cmov [r14+32], rax
0013d250mov rdi, rbx
0013d253mov rsi, [rsp+8]
0013d258mov edx, r15l
0013d25bmov rcx, rbp
0013d25e
0013d25eloc_13d25e:
0013d25ecall regex_automata::hybrid::dfa::DFA::match_pattern
0013d263mov rcx, [r14+48]
0013d267mov [r14], r12
0013d26amov [r14+8], rcx
0013d26emov [r14+16], eax
0013d272jmp 0x13d0b3
0013d277
0013d277loc_13d277:
0013d277mov rbp, [r14+48]
0013d27binc rbp
0013d27emov [r14+48], rbp
0013d282cmp rbp, [rsp+24]
0013d287ja 0x13d0b3
0013d28djmp 0x13d4e1
0013d292
0013d292loc_13d292:
0013d292mov al, 2
0013d294
0013d294loc_13d294:
0013d294movzx ebp, al
0013d297mov rdx, rbp
0013d29atest ecx, ecx
0013d29cje 0x13d2ab
0013d29ecmp ecx, 1
0013d2a1jne 0x13d3fe
0013d2a7lea rdx, [rbp+6]
0013d2ab
0013d2abloc_13d2ab:
0013d2abmov rax, [rsp+8]
0013d2b0mov rdi, [rax+72]
0013d2b4mov rsi, [rax+88]
0013d2b8lea rcx, [rip+0xb1051]
0013d2bfcall _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013d2c4mov r15l, [rax]
0013d2c7
0013d2c7loc_13d2c7:
0013d2c7test r15l, r15l
0013d2cajs 0x13d9ef
0013d2d0
0013d2d0loc_13d2d0:
0013d2d0mov rdi, [rsp+8]
0013d2d5mov rsi, r13
0013d2d8call regex_automata::hybrid::dfa::Cache::search_start
0013d2ddmov rbp, [r12+8]
0013d2e2mov r12, [r12+16]
0013d2e7
0013d2e7loc_13d2e7:
0013d2e7cmp r13, [rsp+24]
0013d2ecjae 0x13d34d
0013d2eecmp r13, r12
0013d2f1jae 0x13db71
0013d2f7movzx ecx, [rbp+r13]
0013d2fdmov rdi, rbx
0013d300mov rsi, [rsp+8]
0013d305mov edx, r15l
0013d308call regex_automata::hybrid::dfa::DFA::next_state
0013d30dtest eax, eax
0013d30fjne 0x13d8d2
0013d315mov r15l, edx
0013d318cmp edx, 0x7ffffff
0013d31ejbe 0x13d337
0013d320mov [r14+40], 1
0013d328mov [r14+44], r15l
0013d32cbt r15, 28
0013d331jae 0x13d458
0013d337
0013d337loc_13d337:
0013d337inc r13
0013d33amov [r14+48], r13
0013d33emov rdi, [rsp+8]
0013d343mov rsi, r13
0013d346call regex_automata::hybrid::dfa::Cache::search_update
0013d34bjmp 0x13d2e7
0013d34d
0013d34dloc_13d34d:
0013d34dmov r13, [rsp+24]
0013d352cmp r13, r12
0013d355jae 0x13d430
0013d35bmovzx r12l, [rbp+r13]
0013d361mov rdi, rbx
0013d364mov rsi, [rsp+8]
0013d369mov edx, r15l
0013d36cmov ecx, r12l
0013d36fcall regex_automata::hybrid::dfa::DFA::next_state
0013d374test eax, eax
0013d376je 0x13d846
0013d37cmov rdi, r13
0013d37fcall regex_automata::util::search::MatchError::gave_up
0013d384mov rbx, rax
0013d387jmp 0x13d877
0013d38c
0013d38cloc_13d38c:
0013d38cmov [r14+48], r13
0013d390lea r15, [rsp+136]
0013d398mov rdi, r15
0013d39bmov rsi, r12
0013d39ecall regex_automata::util::start::Config::from_input_forward
0013d3a3mov esi, [r15]
0013d3a6mov eax, [r15+4]
0013d3aamov [rsp+16], rax
0013d3afcmp [r15+8], 0
0013d3b4mov [rsp+40], esi
0013d3b8je 0x13d4a0
0013d3bemovzx ebp, [rsp+145]
0013d3c6lea r15, [rbx+656]
0013d3cdmov rdi, r15
0013d3d0call _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013d3d5test al, al
0013d3d7jne 0x13d491
0013d3ddmov rdi, r15
0013d3e0mov esi, ebp
0013d3e2call aho_corasick::util::alphabet::ByteSet::contains
0013d3e7test al, al
0013d3e9je 0x13d491
0013d3ef
0013d3efloc_13d3ef:
0013d3efpush 4
0013d3f1pop rdi
0013d3f2mov eax, ebp
0013d3f4mov [rsp+16], rax
0013d3f9jmp 0x13d8a2
0013d3fe
0013d3feloc_13d3fe:
0013d3fetest [rbx+121], 1
0013d402je 0x13d89f
0013d408mov rax, [rsp+16]
0013d40dmov rdx, [rsp+40]
0013d412cmp [rdx+352], rax
0013d419jbe 0x13d8ee
0013d41fimul rax, rax, 6
0013d423lea rdx, [rax+rbp]
0013d427add rdx, 12
0013d42bjmp 0x13d2ab
0013d430
0013d430loc_13d430:
0013d430mov rdi, rbx
0013d433mov rsi, [rsp+8]
0013d438mov edx, r15l
0013d43bcall regex_automata::hybrid::dfa::DFA::next_eoi_state
0013d440test eax, eax
0013d442je 0x13d863
0013d448mov rdi, r12
0013d44bcall regex_automata::util::search::MatchError::gave_up
0013d450mov rbx, rax
0013d453jmp 0x13d872
0013d458
0013d458loc_13d458:
0013d458bt r15, 27
0013d45djb 0x13d813
0013d463bt r15, 30
0013d468jb 0x13d96c
0013d46ebt r15, 29
0013d473jae 0x13dc2c
0013d479mov rdi, [rsp+8]
0013d47emov rsi, r13
0013d481call regex_automata::hybrid::dfa::Cache::search_finish
0013d486movzx edi, [rbp+r13]
0013d48cjmp 0x13d8c8
0013d491
0013d491loc_13d491:
0013d491mov eax, ebp
0013d493mov al, [rbx+rax+128]
0013d49amov esi, [rsp+40]
0013d49ejmp 0x13d4a2
0013d4a0
0013d4a0loc_13d4a0:
0013d4a0mov al, 2
0013d4a2
0013d4a2loc_13d4a2:
0013d4a2movzx ebp, al
0013d4a5mov rdx, rbp
0013d4a8test esi, esi
0013d4aaje 0x13d4b9
0013d4accmp esi, 1
0013d4afjne 0x13d895
0013d4b5lea rdx, [rbp+6]
0013d4b9
0013d4b9loc_13d4b9:
0013d4b9mov rax, [rsp+8]
0013d4bemov rdi, [rax+72]
0013d4c2mov rsi, [rax+88]
0013d4c6lea rcx, [rip+0xb0e43]
0013d4cdcall _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013d4d2mov r15l, [rax]
0013d4d5
0013d4d5loc_13d4d5:
0013d4d5test r15l, r15l
0013d4d8js 0x13dae1
0013d4de
0013d4deloc_13d4de:
0013d4demov rbp, r13
0013d4e1
0013d4e1loc_13d4e1:
0013d4e1mov rdi, [rsp+8]
0013d4e6mov rsi, rbp
0013d4e9call regex_automata::hybrid::dfa::Cache::search_start
0013d4eemov rax, [r12+8]
0013d4f3mov [rsp+16], rax
0013d4f8mov rsi, [r12+16]
0013d4fdmov al, [r12+40]
0013d502mov [rsp+39], al
0013d506lea rax, [rbx+656]
0013d50dmov [rsp+160], rax
0013d515mov [rsp+40], rbx
0013d51amov al, [rbx+121]
0013d51dmov [rsp+38], al
0013d521mov rcx, [rsp+48]
0013d526mov rax, [rcx]
0013d529mov [rsp+192], rax
0013d531mov rax, [rcx+8]
0013d535mov [rsp+184], rax
0013d53dxor ebx, ebx
0013d53fmov r12, [rsp+24]
0013d544mov [rsp+48], rsi
0013d549
0013d549loc_13d549:
0013d549cmp rbp, r12
0013d54cjae 0x13d7c5
0013d552cmp rbp, rsi
0013d555jae 0x13dbfe
0013d55bmov rax, [rsp+16]
0013d560movzx ecx, [rax+rbp]
0013d564mov rdi, [rsp+40]
0013d569mov rsi, [rsp+8]
0013d56emov edx, r15l
0013d571call regex_automata::hybrid::dfa::DFA::next_state
0013d576test eax, eax
0013d578jne 0x13d80b
0013d57emov r15l, edx
0013d581cmp edx, 0x7ffffff
0013d587jbe 0x13d6ca
0013d58dmov [r14+40], 1
0013d595mov [r14+44], r15l
0013d599bt r15, 28
0013d59ejae 0x13d92d
0013d5a4mov [rsp], r12
0013d5a8lea rdi, [rsp+136]
0013d5b0mov rsi, [rsp+192]
0013d5b8mov rdx, [rsp+184]
0013d5c0mov rcx, [rsp+16]
0013d5c5mov r8, [rsp+48]
0013d5camov r9, rbp
0013d5cdcall regex_automata::util::prefilter::Prefilter::find
0013d5d2cmp [rsp+136], 0
0013d5dbje 0x13d0b5
0013d5e1mov r12, [rsp+144]
0013d5e9cmp r12, rbp
0013d5ecjbe 0x13d6c5
0013d5f2mov [r14+48], r12
0013d5f6cmp [rsp+76], 0
0013d5fbmov rsi, [rsp+48]
0013d600je 0x13d761
0013d606mov rax, [rsp+16]
0013d60bmov [rsp+88], rax
0013d610mov [rsp+96], rsi
0013d615mov [rsp+104], r13
0013d61amov rax, [rsp+24]
0013d61fmov [rsp+112], rax
0013d624mov rax, [rsp+176]
0013d62cmov [rsp+80], eax
0013d630mov eax, [rsp+72]
0013d634mov [rsp+84], eax
0013d638mov al, [rsp+39]
0013d63cmov [rsp+120], al
0013d640lea rdi, [rsp+80]
0013d645mov rsi, r12
0013d648call regex_automata::util::search::Input::set_start
0013d64dmov rcx, [rsp+104]
0013d652mov [rsp+168], rcx
0013d65asub rcx, 1
0013d65esetb [rsp+37]
0013d663mov [rsp+64], rcx
0013d668jb 0x13d6e8
0013d66acmp [rsp+96], rcx
0013d66fjbe 0x13d6e8
0013d671mov rax, [rsp+88]
0013d676movzx r15l, [rax+rcx]
0013d67bmov eax, [rsp+80]
0013d67fmov [rsp+60], eax
0013d683mov eax, [rsp+84]
0013d687mov [rsp+56], eax
0013d68bmov rbp, [rsp+160]
0013d693mov rdi, rbp
0013d696call _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013d69btest al, al
0013d69djne 0x13d6b2
0013d69fmov rdi, rbp
0013d6a2mov esi, r15l
0013d6a5call aho_corasick::util::alphabet::ByteSet::contains
0013d6aatest al, al
0013d6acjne 0x13dbbd
0013d6b2
0013d6b2loc_13d6b2:
0013d6b2mov rax, [rsp+40]
0013d6b7mov al, [rax+r15+128]
0013d6bfmov esi, [rsp+60]
0013d6c3jmp 0x13d6f6
0013d6c5
0013d6c5loc_13d6c5:
0013d6c5mov r12, [rsp+24]
0013d6ca
0013d6caloc_13d6ca:
0013d6cainc rbp
0013d6cdmov [r14+48], rbp
0013d6d1mov rdi, [rsp+8]
0013d6d6mov rsi, rbp
0013d6d9call regex_automata::hybrid::dfa::Cache::search_update
0013d6demov rsi, [rsp+48]
0013d6e3jmp 0x13d549
0013d6e8
0013d6e8loc_13d6e8:
0013d6e8mov esi, [rsp+80]
0013d6ecmov eax, [rsp+84]
0013d6f0mov [rsp+56], eax
0013d6f4mov al, 2
0013d6f6
0013d6f6loc_13d6f6:
0013d6f6movzx ebp, al
0013d6f9mov rdx, rbp
0013d6fctest esi, esi
0013d6femov [rsp+60], esi
0013d702je 0x13d73b
0013d704cmp esi, 1
0013d707jne 0x13d70f
0013d709lea rdx, [rbp+6]
0013d70djmp 0x13d73b
0013d70f
0013d70floc_13d70f:
0013d70ftest [rsp+38], 1
0013d714je 0x13dbb2
0013d71amov eax, [rsp+56]
0013d71emov rcx, [rsp+128]
0013d726cmp [rcx+352], rax
0013d72djbe 0x13d76e
0013d72fimul rax, rax, 6
0013d733lea rdx, [rax+rbp]
0013d737add rdx, 12
0013d73b
0013d73bloc_13d73b:
0013d73bmov rax, [rsp+8]
0013d740mov rdi, [rax+72]
0013d744mov rsi, [rax+88]
0013d748lea rcx, [rip+0xb0bc1]
0013d74fcall _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013d754mov r15l, [rax]
0013d757
0013d757loc_13d757:
0013d757test r15l, r15l
0013d75amov rsi, [rsp+48]
0013d75fjs 0x13d77d
0013d761
0013d761loc_13d761:
0013d761mov rbp, r12
0013d764mov r12, [rsp+24]
0013d769jmp 0x13d549
0013d76e
0013d76eloc_13d76e:
0013d76emov rdi, [rsp+40]
0013d773call regex_automata::hybrid::dfa::LazyRef::dead_id
0013d778mov r15l, eax
0013d77bjmp 0x13d757
0013d77d
0013d77dloc_13d77d:
0013d77dmov rax, [rsp+40]
0013d782mov [rsp+200], rax
0013d78amov rax, [rsp+8]
0013d78fmov [rsp+208], rax
0013d797lea rdi, [rsp+200]
0013d79fmov esi, [rsp+60]
0013d7a3mov edx, [rsp+56]
0013d7a7mov ecx, ebp
0013d7a9call regex_automata::hybrid::dfa::Lazy::cache_start_group
0013d7aemov r15, rax
0013d7b1shr r15, 32
0013d7b5cmp eax, 5
0013d7b8jne 0x13dc0f
0013d7bemov rsi, [rsp+48]
0013d7c3jmp 0x13d761
0013d7c5
0013d7c5loc_13d7c5:
0013d7c5cmp r12, rsi
0013d7c8jae 0x13d8fe
0013d7cemov r13, r12
0013d7d1mov rax, [rsp+16]
0013d7d6movzx r12l, [rax+r12]
0013d7dbmov rdi, [rsp+40]
0013d7e0mov rsi, [rsp+8]
0013d7e5mov edx, r15l
0013d7e8mov ecx, r12l
0013d7ebcall regex_automata::hybrid::dfa::DFA::next_state
0013d7f0test eax, eax
0013d7f2je 0x13da6b
0013d7f8mov rdi, r13
0013d7fbcall regex_automata::util::search::MatchError::gave_up
0013d800mov rbx, rax
0013d803mov r12, r13
0013d806jmp 0x13db99
0013d80b
0013d80bloc_13d80b:
0013d80bmov rdi, rbp
0013d80ejmp 0x13d8d5
0013d813
0013d813loc_13d813:
0013d813push 1
0013d815pop r12
0013d817mov [r14+24], r12
0013d81bmov [r14+32], r12
0013d81fmov rdi, rbx
0013d822mov rbx, [rsp+8]
0013d827mov rsi, rbx
0013d82amov edx, r15l
0013d82dxor ecx, ecx
0013d82fcall regex_automata::hybrid::dfa::DFA::match_pattern
0013d834mov [r14], r12
0013d837mov [r14+8], r13
0013d83bmov [r14+16], eax
0013d83fmov rdi, rbx
0013d842xor ebx, ebx
0013d844jmp 0x13d888
0013d846
0013d846loc_13d846:
0013d846mov ebp, edx
0013d848bt rdx, 27
0013d84cjb 0x13d979
0013d852bt rbp, 29
0013d856jb 0x13daa4
0013d85cxor ebx, ebx
0013d85emov r15l, ebp
0013d861jmp 0x13d872
0013d863
0013d863loc_13d863:
0013d863mov r15l, edx
0013d866bt rdx, 27
0013d86ajb 0x13d981
0013d870xor ebx, ebx
0013d872
0013d872loc_13d872:
0013d872mov r13, [rsp+24]
0013d877
0013d877loc_13d877:
0013d877mov [r14+40], 1
0013d87fmov [r14+44], r15l
0013d883
0013d883loc_13d883:
0013d883mov rdi, [rsp+8]
0013d888
0013d888loc_13d888:
0013d888mov rsi, r13
0013d88b
0013d88bloc_13d88b:
0013d88bcall regex_automata::hybrid::dfa::Cache::search_finish
0013d890jmp 0x13d0b5
0013d895
0013d895loc_13d895:
0013d895test [rbx+121], 1
0013d899jne 0x13d9c1
0013d89f
0013d89floc_13d89f:
0013d89fpush 2
0013d8a1pop rdi
0013d8a2
0013d8a2loc_13d8a2:
0013d8a2lea ecx, [rdi-3]
0013d8a5cmp ecx, 2
0013d8a8push 2
0013d8aapop rax
0013d8abcmovb eax, ecx
0013d8aetest eax, eax
0013d8b0je 0x13d8d2
0013d8b2cmp eax, 1
0013d8b5jne 0x13d8e2
0013d8b7test r13, r13
0013d8bamov rdi, [rsp+16]
0013d8bfje 0x13dc14
0013d8c5dec r13
0013d8c8
0013d8c8loc_13d8c8:
0013d8c8mov rsi, r13
0013d8cb
0013d8cbloc_13d8cb:
0013d8cbcall regex_automata::util::search::MatchError::quit
0013d8d0jmp 0x13d8da
0013d8d2
0013d8d2loc_13d8d2:
0013d8d2mov rdi, r13
0013d8d5
0013d8d5loc_13d8d5:
0013d8d5call regex_automata::util::search::MatchError::gave_up
0013d8da
0013d8daloc_13d8da:
0013d8damov rbx, rax
0013d8ddjmp 0x13d0b5
0013d8e2
0013d8e2loc_13d8e2:
0013d8e2mov rsi, [rsp+16]
0013d8e7
0013d8e7loc_13d8e7:
0013d8e7call regex_automata::util::search::MatchError::unsupported_anchored
0013d8ecjmp 0x13d8da
0013d8ee
0013d8eeloc_13d8ee:
0013d8eemov rdi, rbx
0013d8f1call regex_automata::hybrid::dfa::LazyRef::dead_id
0013d8f6mov r15l, eax
0013d8f9jmp 0x13d2c7
0013d8fe
0013d8feloc_13d8fe:
0013d8femov rbx, [rsp+40]
0013d903mov rdi, rbx
0013d906mov rsi, [rsp+8]
0013d90bmov edx, r15l
0013d90ecall regex_automata::hybrid::dfa::DFA::next_eoi_state
0013d913test eax, eax
0013d915je 0x13da90
0013d91bmov rdi, [rsp+48]
0013d920call regex_automata::util::search::MatchError::gave_up
0013d925mov rbx, rax
0013d928jmp 0x13db99
0013d92d
0013d92dloc_13d92d:
0013d92dbt r15, 27
0013d932jb 0x13da30
0013d938bt r15, 30
0013d93djb 0x13dacf
0013d943bt r15, 29
0013d948jae 0x13dc2c
0013d94emov rdi, [rsp+8]
0013d953mov rsi, rbp
0013d956call regex_automata::hybrid::dfa::Cache::search_finish
0013d95bmov rax, [rsp+16]
0013d960movzx edi, [rax+rbp]
0013d964mov rsi, rbp
0013d967jmp 0x13d8cb
0013d96c
0013d96cloc_13d96c:
0013d96cmov rdi, [rsp+8]
0013d971mov rsi, r13
0013d974jmp 0x13dad7
0013d979
0013d979loc_13d979:
0013d979mov r15l, ebp
0013d97cmov r12, [rsp+24]
0013d981
0013d981loc_13d981:
0013d981mov rdi, rbx
0013d984xor ebx, ebx
0013d986mov rsi, [rsp+8]
0013d98bmov edx, r15l
0013d98exor ecx, ecx
0013d990call regex_automata::hybrid::dfa::DFA::match_pattern
0013d995push 1
0013d997pop rcx
0013d998mov [r14], rcx
0013d99bmov [r14+8], r12
0013d99fmov [r14+16], eax
0013d9a3mov [r14+40], 1
0013d9abmov [r14+44], r15l
0013d9afmov [r14+24], rcx
0013d9b3mov [r14+32], rcx
0013d9b7mov r13, [rsp+24]
0013d9bcjmp 0x13d883
0013d9c1
0013d9c1loc_13d9c1:
0013d9c1mov rax, [rsp+128]
0013d9c9mov rcx, [rsp+16]
0013d9cecmp [rax+352], rcx
0013d9d5jbe 0x13dabf
0013d9dbmov rax, rcx
0013d9deimul rax, rcx, 6
0013d9e2lea rdx, [rax+rbp]
0013d9e6add rdx, 12
0013d9eajmp 0x13d4b9
0013d9ef
0013d9efloc_13d9ef:
0013d9eflea rdi, [rsp+80]
0013d9f4mov [rdi], rbx
0013d9f7mov rax, [rsp+8]
0013d9fcmov [rdi+8], rax
0013da00mov esi, [rsp+48]
0013da04mov rdx, [rsp+16]
0013da09mov ecx, ebp
0013da0bcall regex_automata::hybrid::dfa::Lazy::cache_start_group
0013da10mov rdi, rax
0013da13shr rax, 32
0013da17mov rcx, rax
0013da1amov [rsp+16], rax
0013da1fmov r15l, eax
0013da22cmp edi, 5
0013da25je 0x13d2d0
0013da2bjmp 0x13d8a2
0013da30
0013da30loc_13da30:
0013da30push 1
0013da32pop r12
0013da34mov [r14+24], r12
0013da38mov [r14+32], r12
0013da3cmov rdi, [rsp+40]
0013da41mov rbx, [rsp+8]
0013da46mov rsi, rbx
0013da49mov edx, r15l
0013da4cxor ecx, ecx
0013da4ecall regex_automata::hybrid::dfa::DFA::match_pattern
0013da53mov [r14], r12
0013da56mov [r14+8], rbp
0013da5amov [r14+16], eax
0013da5emov rdi, rbx
0013da61xor ebx, ebx
0013da63mov rsi, rbp
0013da66jmp 0x13d88b
0013da6b
0013da6bloc_13da6b:
0013da6bmov ebp, edx
0013da6dbt rdx, 27
0013da71jb 0x13db22
0013da77bt rbp, 29
0013da7bjb 0x13db83
0013da81xor ebx, ebx
0013da83mov r15l, ebp
0013da86mov r12, [rsp+24]
0013da8bjmp 0x13db99
0013da90
0013da90loc_13da90:
0013da90mov r15l, edx
0013da93bt rdx, 27
0013da97jb 0x13db34
0013da9dxor ebx, ebx
0013da9fjmp 0x13db99
0013daa4
0013daa4loc_13daa4:
0013daa4mov edi, r12l
0013daa7mov r13, [rsp+24]
0013daacmov rsi, r13
0013daafcall regex_automata::util::search::MatchError::quit
0013dab4mov rbx, rax
0013dab7mov r15l, ebp
0013dabajmp 0x13d877
0013dabf
0013dabfloc_13dabf:
0013dabfmov rdi, rbx
0013dac2call regex_automata::hybrid::dfa::LazyRef::dead_id
0013dac7mov r15l, eax
0013dacajmp 0x13d4d5
0013dacf
0013dacfloc_13dacf:
0013dacfmov rdi, [rsp+8]
0013dad4mov rsi, rbp
0013dad7
0013dad7loc_13dad7:
0013dad7call regex_automata::hybrid::dfa::Cache::search_finish
0013dadcjmp 0x13d0b3
0013dae1
0013dae1loc_13dae1:
0013dae1lea rdi, [rsp+80]
0013dae6mov [rdi], rbx
0013dae9mov rax, [rsp+8]
0013daeemov [rdi+8], rax
0013daf2mov esi, [rsp+40]
0013daf6mov rdx, [rsp+16]
0013dafbmov ecx, ebp
0013dafdcall regex_automata::hybrid::dfa::Lazy::cache_start_group
0013db02mov rdi, rax
0013db05mov r15, rax
0013db08shr r15, 32
0013db0cmov rax, r15
0013db0fmov [rsp+16], r15
0013db14cmp edi, 5
0013db17je 0x13d4de
0013db1djmp 0x13d8a2
0013db22
0013db22loc_13db22:
0013db22mov r15l, ebp
0013db25mov r12, [rsp+24]
0013db2amov r13, r12
0013db2dmov rbx, [rsp+40]
0013db32jmp 0x13db39
0013db34
0013db34loc_13db34:
0013db34mov r13, [rsp+48]
0013db39
0013db39loc_13db39:
0013db39mov rdi, rbx
0013db3cxor ebx, ebx
0013db3emov rsi, [rsp+8]
0013db43mov edx, r15l
0013db46xor ecx, ecx
0013db48call regex_automata::hybrid::dfa::DFA::match_pattern
0013db4dpush 1
0013db4fpop rcx
0013db50mov [r14], rcx
0013db53mov [r14+8], r13
0013db57mov [r14+16], eax
0013db5bmov [r14+40], 1
0013db63mov [r14+44], r15l
0013db67mov [r14+24], rcx
0013db6bmov [r14+32], rcx
0013db6fjmp 0x13dba5
0013db71
0013db71loc_13db71:
0013db71lea rdx, [rip+0xb08f8]
0013db78mov rdi, r13
0013db7bmov rsi, r12
0013db7ejmp 0x13dc08
0013db83
0013db83loc_13db83:
0013db83mov edi, r12l
0013db86mov r12, [rsp+24]
0013db8bmov rsi, r12
0013db8ecall regex_automata::util::search::MatchError::quit
0013db93mov rbx, rax
0013db96mov r15l, ebp
0013db99
0013db99loc_13db99:
0013db99mov [r14+40], 1
0013dba1mov [r14+44], r15l
0013dba5
0013dba5loc_13dba5:
0013dba5mov rdi, [rsp+8]
0013dbaamov rsi, r12
0013dbadjmp 0x13d88b
0013dbb2
0013dbb2loc_13dbb2:
0013dbb2mov eax, [rsp+56]
0013dbb6mov r15l, eax
0013dbb9push 2
0013dbbbjmp 0x13dbbf
0013dbbd
0013dbbdloc_13dbbd:
0013dbbdpush 4
0013dbbf
0013dbbfloc_13dbbf:
0013dbbfpop rdi
0013dbc0
0013dbc0loc_13dbc0:
0013dbc0mov rsi, [rsp+64]
0013dbc5lea ecx, [rdi-3]
0013dbc8cmp ecx, 2
0013dbcbpush 2
0013dbcdpop rax
0013dbcecmovb eax, ecx
0013dbd1test eax, eax
0013dbd3je 0x13dbe9
0013dbd5cmp eax, 1
0013dbd8jne 0x13dbf6
0013dbdacmp [rsp+37], 0
0013dbdfjne 0x13dc14
0013dbe1mov edi, r15l
0013dbe4jmp 0x13d8cb
0013dbe9
0013dbe9loc_13dbe9:
0013dbe9mov rdi, [rsp+168]
0013dbf1jmp 0x13d8d5
0013dbf6
0013dbf6loc_13dbf6:
0013dbf6mov esi, r15l
0013dbf9jmp 0x13d8e7
0013dbfe
0013dbfeloc_13dbfe:
0013dbfelea rdx, [rip+0xb086b]
0013dc05mov rdi, rbp
0013dc08
0013dc08loc_13dc08:
0013dc08call core::panicking::panic_bounds_check
0013dc0dud2
0013dc0f
0013dc0floc_13dc0f:
0013dc0fmov rdi, rax
0013dc12jmp 0x13dbc0
0013dc14
0013dc14loc_13dc14:
0013dc14lea rdi, [rip-0xe8210]
0013dc1blea rdx, [rip+0xb04b6]
0013dc22push 36
0013dc24pop rsi
0013dc25call core::option::expect_failed
0013dc2aud2
0013dc2c
0013dc2cloc_13dc2c:
0013dc2clea rax, [rip+0xb079d]
0013dc33lea rdi, [rsp+80]
0013dc38mov [rdi], rax
0013dc3bmov [rdi+8], 1
0013dc43lea rax, [rsp+32]
0013dc48mov [rdi+16], rax
0013dc4cxorps x0, x0
0013dc4fmovups [rdi+24], x0
0013dc53lea rsi, [rip+0xb082e]
0013dc5acall core::panicking::panic_fmt
0013dc5fud2
0013d087