Similarity

00139beb
00139beb_<core::ops::range::Range<usize> as core::slice::index::SliceIndex<[T]>>::index_mut:
00139bebpush rax
00139becmov r9, rsi
00139befsub r9, rdi
00139bf2jb 0x139c02
00139bf4cmp rsi, rcx
00139bf7ja 0x139c0c
00139bf9lea rax, [rdx+8*rdi]
00139bfdmov rdx, r9
00139c00pop rcx
00139c01ret
00139c02
00139c02loc_139c02:
00139c02mov rdx, r8
00139c05call core::slice::index::slice_index_order_fail
00139c0aud2
00139c0c
00139c0cloc_139c0c:
00139c0cmov rdi, rsi
00139c0fmov rsi, rcx
00139c12mov rdx, r8
00139c15call core::slice::index::slice_end_index_len_fail
00139c1aud2
00139beb

00139c1c
00139c1cregex_automata::dfa::onepass::Cache::reset:
00139c1cpush r14
00139c1epush rbx
00139c1fpush rax
00139c20mov rbx, rdi
00139c23mov rdi, [rsi+360]
00139c2acall regex_automata::util::captures::GroupInfo::explicit_slot_len
00139c2fmov r14, rax
00139c32mov rdi, rbx
00139c35mov rsi, rax
00139c38call alloc::vec::Vec<T,A>::resize
00139c3dmov [rbx+24], r14
00139c41add rsp, 8
00139c45pop rbx
00139c46pop r14
00139c48ret
00139c1c

00139c49
00139c49regex_automata::hybrid::dfa::Builder::new:
00139c49push rbx
00139c4amov rbx, rdi
00139c4dadd rdi, 128
00139c54call regex_automata::nfa::thompson::compiler::Compiler::new
00139c59and [rbx], 0
00139c5dand [rbx+40], 0
00139c62push 2
00139c64pop rax
00139c65mov [rbx+56], rax
00139c69mov [rbx+72], rax
00139c6dmov [rbx+112], 3
00139c71mov [rbx+120], 0x2020202
00139c78mov [rbx+124], 514
00139c7epop rbx
00139c7fret
00139c49

00139c80
00139c80core::ptr::drop_in_place<regex_automata::hybrid::dfa::Builder>:
00139c80push rbx
00139c81mov rbx, rdi
00139c84add rdi, 88
00139c88call core::ptr::drop_in_place<core::option::Option<core::option::Option<regex_automata::util::prefilter::Prefilter>>>
00139c8dsub rbx, -128
00139c91mov rdi, rbx
00139c94pop rbx
00139c95jmp 0x13873c
00139c80

00139c9a
00139c9aregex_automata::hybrid::dfa::Builder::build_from_nfa:
00139c9apush rbp
00139c9bpush r15
00139c9dpush r14
00139c9fpush r13
00139ca1push r12
00139ca3push rbx
00139ca4sub rsp, 968
00139cabmov r14, rdx
00139caemov r15, rsi
00139cb1mov [rsp+8], rdi
00139cb6mov [rsp+24], rdx
00139cbbcmp [rsi], 0
00139cbfje 0x139cd2
00139cc1movups x0, [r15+8]
00139cc6movups x1, [r15+24]
00139ccbmovaps [rsp+80], x1
00139cd0jmp 0x139cda
00139cd2
00139cd2loc_139cd2:
00139cd2xorps x0, x0
00139cd5movaps [rsp+80], x0
00139cda
00139cdaloc_139cda:
00139cdamovaps [rsp+64], x0
00139cdftest [r14+376], 0x33300
00139ceaje 0x139d7f
00139cf0test [r15+123], 1
00139cf5jne 0x139d19
00139cf7mov cl, 128
00139cf9lea rbx, [rsp+64]
00139cfemov bpl, 128
00139d01
00139d01loc_139d01:
00139d01inc bpl
00139d04je 0x139d48
00139d06movzx esi, cl
00139d09mov rdi, rbx
00139d0ccall core::iter::traits::iterator::Iterator::all::check::_{{closure}}
00139d11mov ecx, ebp
00139d13test al, al
00139d15je 0x139d01
00139d17jmp 0x139d5b
00139d19
00139d19loc_139d19:
00139d19lea rbx, [rsp+712]
00139d21mov [rbx+2], -1
00139d25mov [rbx], -32768
00139d2alea r12, [rsp+64]
00139d2f
00139d2floc_139d2f:
00139d2fmov rdi, rbx
00139d32call core::iter::range::_<impl core::iter::traits::iterator::Iterator for core::ops::range::RangeInclusive<A>>::next
00139d37test al, 1
00139d39je 0x139d7f
00139d3bmovzx esi, dl
00139d3emov rdi, r12
00139d41call aho_corasick::util::alphabet::ByteSet::add
00139d46jmp 0x139d2f
00139d48
00139d48loc_139d48:
00139d48lea rdi, [rsp+64]
00139d4dmov esi, 255
00139d52call core::iter::traits::iterator::Iterator::all::check::_{{closure}}
00139d57test al, al
00139d59je 0x139d7f
00139d5b
00139d5bloc_139d5b:
00139d5blea rax, [rip-0xe41c5]
00139d62mov rcx, [rsp+8]
00139d67mov [rcx+16], rax
00139d6bmov [rcx+24], 177
00139d73mov [rcx+8], 44
00139d7ajmp 0x139f70
00139d7f
00139d7floc_139d7f:
00139d7fmovaps x0, [rsp+64]
00139d84movaps x1, [rsp+80]
00139d89movups [rsp+48], x1
00139d8emovups [rsp+32], x0
00139d93cmp [r15+122], 0
00139d98mov [rsp+16], r15
00139d9dje 0x139ded
00139d9fmovups x0, [r14+272]
00139da7movups x1, [r14+288]
00139dafmovaps [rsp+336], x1
00139db7movaps [rsp+320], x0
00139dbflea rdi, [rsp+32]
00139dc4call _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
00139dc9test al, al
00139dcbje 0x139ee1
00139dd1
00139dd1loc_139dd1:
00139dd1lea rdi, [rsp+712]
00139dd9lea rsi, [rsp+320]
00139de1call regex_automata::util::alphabet::ByteClassSet::byte_classes
00139de6mov r15, [rsp+16]
00139debjmp 0x139dfa
00139ded
00139dedloc_139ded:
00139dedlea rdi, [rsp+712]
00139df5call regex_automata::util::alphabet::ByteClasses::singletons
00139dfa
00139dfaloc_139dfa:
00139dfatest [r15+121], 1
00139dffmovzx eax, [rsp+967]
00139e07mov r13, [r14+328]
00139e0ejne 0x139e15
00139e10push 24
00139e12pop rbp
00139e13jmp 0x139e21
00139e15
00139e15loc_139e15:
00139e15imul rbp, [r14+352], 24
00139e1dadd rbp, 24
00139e21
00139e21loc_139e21:
00139e21inc rax
00139e24bsr rcx, rax
00139e28not ecx
00139e2apush -1
00139e2cpop rax
00139e2dshr rax, cl
00139e30inc rax
00139e33bsf rcx, rax
00139e37push 20
00139e39pop r12
00139e3bmov r15, rcx
00139e3eshl r12, cl
00139e41call regex_automata::util::determinize::state::State::dead
00139e46mov rbx, rdx
00139e49lea rdi, [rsp+320]
00139e51mov [rdi], rax
00139e54mov [rdi+8], rdx
00139e58call core::ptr::drop_in_place<regex_automata::util::determinize::state::State>
00139e5dmov rdi, r14
00139e60mov rax, [r14+352]
00139e67lea rcx, [4*r13]
00139e6fadd rcx, r13
00139e72lea rdx, [rcx+4*rax]
00139e76lea rax, [rcx+4*rax]
00139e7aadd rax, 9
00139e7elea rcx, [rbx+2*rbx]
00139e82imul rsi, r13, 12
00139e86add rsi, rbp
00139e89add rsi, rcx
00139e8cadd rsi, rax
00139e8fadd rsi, r12
00139e92lea rax, [rsi+2*rdx]
00139e96add rax, 198
00139e9cmov rcx, [rsp+16]
00139ea1cmp [rcx+40], 0
00139ea6mov ebp, 0x200000
00139eabje 0x139eb1
00139eadmov rbp, [rcx+48]
00139eb1
00139eb1loc_139eb1:
00139eb1cmp rbp, rax
00139eb4mov r12, r15
00139eb7jae 0x139edc
00139eb9test [rcx+125], 1
00139ebdjne 0x139f49
00139ec3mov rcx, [rsp+8]
00139ec8mov [rcx+8], 42
00139ecfmov [rcx+16], rax
00139ed3mov [rcx+24], rbp
00139ed7jmp 0x139f70
00139edc
00139edcloc_139edc:
00139edcmov r14, rdi
00139edfjmp 0x139f4f
00139ee1
00139ee1loc_139ee1:
00139ee1xor ebp, ebp
00139ee3lea r12, [rsp+32]
00139ee8lea r13, [rsp+320]
00139ef0
00139ef0loc_139ef0:
00139ef0cmp rbp, 255
00139ef7ja 0x139dd1
00139efdmov rbx, rbp
00139f00inc rbp
00139f03mov rdi, r12
00139f06mov esi, ebx
00139f08call aho_corasick::util::alphabet::ByteSet::contains
00139f0dtest al, al
00139f0fje 0x139ef0
00139f11
00139f11loc_139f11:
00139f11cmp rbp, 255
00139f18ja 0x139f2d
00139f1amov rdi, r12
00139f1dmov esi, ebp
00139f1fcall aho_corasick::util::alphabet::ByteSet::contains
00139f24test al, al
00139f26je 0x139f36
00139f28inc rbp
00139f2bjmp 0x139f11
00139f2d
00139f2dloc_139f2d:
00139f2dmov al, 255
00139f2fmov ebp, 256
00139f34jmp 0x139f39
00139f36
00139f36loc_139f36:
00139f36lea eax, [rbp-1]
00139f39
00139f39loc_139f39:
00139f39movzx esi, bl
00139f3cmovzx edx, al
00139f3fmov rdi, r13
00139f42call aho_corasick::util::alphabet::ByteClassSet::set_range
00139f47jmp 0x139ef0
00139f49
00139f49loc_139f49:
00139f49mov r14, rdi
00139f4cmov rbp, rax
00139f4f
00139f4floc_139f4f:
00139f4fpush 4
00139f51pop rax
00139f52mov ecx, r12l
00139f55shl rax, cl
00139f58cmp rax, 0x7ffffff
00139f5ejbe 0x139f86
00139f60mov rcx, [rsp+8]
00139f65mov [rcx+8], 43
00139f6cmov [rcx+16], rax
00139f70
00139f70loc_139f70:
00139f70mov [rcx], 2
00139f77lea rdi, [rsp+24]
00139f7ccall core::ptr::drop_in_place<regex_automata::nfa::thompson::nfa::NFA>
00139f81jmp 0x13a0a1
00139f86
00139f86loc_139f86:
00139f86lea rbx, [rsp+320]
00139f8emov edx, 256
00139f93mov rdi, rbx
00139f96xor esi, esi
00139f98call [rip+0xd7b6a]
00139f9emov [rbx+10], 3
00139fa2mov [rbx+13], 4
00139fa6mov [rbx+95], 1
00139faapush 48
00139facpop rax
00139fad
00139fadloc_139fad:
00139fadcmp rax, 58
00139fb1je 0x139fc0
00139fb3mov [rsp+rax+320], 1
00139fbbinc rax
00139fbejmp 0x139fad
00139fc0
00139fc0loc_139fc0:
00139fc0push 65
00139fc2pop rax
00139fc3
00139fc3loc_139fc3:
00139fc3cmp rax, 91
00139fc7je 0x139fd6
00139fc9mov [rsp+rax+320], 1
00139fd1inc rax
00139fd4jmp 0x139fc3
00139fd6
00139fd6loc_139fd6:
00139fd6push 97
00139fd8pop rax
00139fd9
00139fd9loc_139fd9:
00139fd9cmp rax, 123
00139fddje 0x139fec
00139fdfmov [rsp+rax+320], 1
00139fe7inc rax
00139feajmp 0x139fd9
00139fec
00139fecloc_139fec:
00139fecmovzx eax, [r14+384]
00139ff4cmp eax, 10
00139ff7je 0x13a006
00139ff9cmp eax, 13
00139ffcje 0x13a006
00139ffemov [rsp+rax+320], 5
0013a006
0013a006loc_13a006:
0013a006lea rdi, [rsp+64]
0013a00blea rsi, [rsp+320]
0013a013mov rbx, [rip+0xd7b06]
0013a01amov edx, 256
0013a01fcall rbx
0013a021lea r13, [rsp+320]
0013a029mov rdi, r13
0013a02cmov rsi, [rsp+16]
0013a031call _<regex_automata::hybrid::dfa::Config as core::clone::Clone>::clone
0013a036mov r15, [rsp+8]
0013a03blea rdi, [r15+400]
0013a042lea rsi, [rsp+712]
0013a04amov edx, 256
0013a04fcall rbx
0013a051movups x0, [rsp+32]
0013a056movups x1, [rsp+48]
0013a05bmovups [r15+656], x0
0013a063movups [r15+672], x1
0013a06blea rdi, [rsp+448]
0013a073mov edx, 256
0013a078lea rsi, [rsp+64]
0013a07dcall rbx
0013a07fmov edx, 384
0013a084mov rdi, r15
0013a087mov rsi, r13
0013a08acall rbx
0013a08cmov [r15+384], r14
0013a093mov [r15+392], r12
0013a09amov [r15+688], rbp
0013a0a1
0013a0a1loc_13a0a1:
0013a0a1add rsp, 968
0013a0a8pop rbx
0013a0a9pop r12
0013a0abpop r13
0013a0adpop r14
0013a0afpop r15
0013a0b1pop rbp
0013a0b2ret
00139c9a

0013a0b3
0013a0b3_<regex_automata::hybrid::dfa::Config as core::clone::Clone>::clone:
0013a0b3push rbp
0013a0b4push r14
0013a0b6push rbx
0013a0b7sub rsp, 64
0013a0bbmov r14, rsi
0013a0bemov rbx, rdi
0013a0c1mov bpl, [rsi+120]
0013a0c5add rsi, 88
0013a0c9lea rdi, [rsp+32]
0013a0cecall _<core::option::Option<T> as core::clone::Clone>::clone
0013a0d3mov r8b, [r14+121]
0013a0d7mov dil, [r14+122]
0013a0dbmov dl, [r14+123]
0013a0dfcmp [r14], 0
0013a0e3je 0x13a0fd
0013a0e5movups x0, [r14+8]
0013a0eamovups x1, [r14+24]
0013a0efmovaps [rsp+16], x1
0013a0f4movaps [rsp], x0
0013a0f8push 1
0013a0fapop rax
0013a0fbjmp 0x13a0ff
0013a0fd
0013a0fdloc_13a0fd:
0013a0fdxor eax, eax
0013a0ff
0013a0ffloc_13a0ff:
0013a0ffxor ecx, ecx
0013a101test dl, dl
0013a103setne cl
0013a106cmp dl, 2
0013a109push 2
0013a10bpop rsi
0013a10ccmove ecx, esi
0013a10fxor edx, edx
0013a111test dil, dil
0013a114setne dl
0013a117cmp dil, 2
0013a11bcmove edx, esi
0013a11exor edi, edi
0013a120test r8b, r8b
0013a123setne dil
0013a127cmp r8b, 2
0013a12bcmove edi, esi
0013a12exor r9l, r9l
0013a131test bpl, bpl
0013a134setne r9b
0013a138cmp bpl, 2
0013a13ccmove r9l, esi
0013a140mov r10b, [r14+124]
0013a144xor r8l, r8l
0013a147test r10b, r10b
0013a14asetne r8b
0013a14ecmp r10b, 2
0013a152cmove r8l, esi
0013a156mov r10b, [r14+125]
0013a15axor r11l, r11l
0013a15dtest r10b, r10b
0013a160setne r11b
0013a164cmp r10b, 2
0013a168cmove r11l, esi
0013a16cmovups x0, [r14+40]
0013a171movups x1, [r14+56]
0013a176movups x2, [r14+72]
0013a17bmov [rbx+120], r9b
0013a17fmovups x3, [rsp+32]
0013a184movups x4, [rsp+48]
0013a189movups [rbx+88], x3
0013a18dmovups [rbx+104], x4
0013a191mov [rbx+121], dil
0013a195mov [rbx+122], dl
0013a198mov [rbx+123], cl
0013a19bmov [rbx], rax
0013a19emovaps x3, [rsp]
0013a1a2movaps x4, [rsp+16]
0013a1a7movups [rbx+8], x3
0013a1abmovups [rbx+24], x4
0013a1afmov [rbx+124], r8b
0013a1b3movups [rbx+40], x0
0013a1b7mov [rbx+125], r11b
0013a1bbmovups [rbx+56], x1
0013a1bfmovups [rbx+72], x2
0013a1c3add rsp, 64
0013a1c7pop rbx
0013a1c8pop r14
0013a1capop rbp
0013a1cbret
0013a0b3

0013a1cc
0013a1cc_<core::option::Option<T> as core::clone::Clone>::clone:
0013a1ccmov al, [rsi+24]
0013a1cfcmp al, 3
0013a1d1jne 0x13a1d8
0013a1d3mov [rdi+24], 3
0013a1d7ret
0013a1d8
0013a1d8loc_13a1d8:
0013a1d8cmp al, 2
0013a1dajne 0x13a1e1
0013a1dcmov [rdi+24], 2
0013a1e0ret
0013a1e1
0013a1e1loc_13a1e1:
0013a1e1mov rcx, [rsi]
0013a1e4lock inc [rcx]
0013a1e8jle 0x13a1f9
0013a1eamovups x0, [rsi+8]
0013a1eemov [rdi], rcx
0013a1f1movups [rdi+8], x0
0013a1f5mov [rdi+24], al
0013a1f8ret
0013a1f9
0013a1f9loc_13a1f9:
0013a1f9ud2
0013a1fb
0013a1fb 0f 0b ..
0013a1cc

0013a1fd
0013a1fdregex_automata::util::determinize::state::State::dead:
0013a1fdpush r15
0013a1ffpush r14
0013a201push r12
0013a203push rbx
0013a204sub rsp, 56
0013a208xorps x0, x0
0013a20bmov rsi, rsp
0013a20emovups [rsi+8], x0
0013a212mov [rsi], 1
0013a219lea rbx, [rsp+32]
0013a21emov rdi, rbx
0013a221call regex_automata::util::determinize::state::StateBuilderEmpty::into_matches
0013a226mov r14, rsp
0013a229mov rdi, r14
0013a22cmov rsi, rbx
0013a22fcall regex_automata::util::determinize::state::StateBuilderMatches::into_nfa
0013a234mov rbx, [r14]
0013a237mov rsi, [r14+16]
0013a23bmov rdi, rbx
0013a23ecall regex_automata::util::determinize::state::StateBuilderNFA::to_state
0013a243mov r15, rax
0013a246mov r12, rdx
0013a249mov rsi, [r14+8]
0013a24dmov rdi, rbx
0013a250call core::ptr::drop_in_place<alloc::boxed::Box<str>>
0013a255mov rax, r15
0013a258mov rdx, r12
0013a25badd rsp, 56
0013a25fpop rbx
0013a260pop r12
0013a262pop r14
0013a264pop r15
0013a266ret
0013a1fd

0013a267
0013a267regex_automata::util::determinize::state::StateBuilderEmpty::into_matches:
0013a267push r14
0013a269push rbx
0013a26apush rax
0013a26bmov rbx, rsi
0013a26emov r14, rdi
0013a271lea rsi, [rip-0xe3541]
0013a278lea rdx, [rip-0xe353f]
0013a27fmov rdi, rbx
0013a282call _<alloc::vec::Vec<T,A> as alloc::vec::spec_extend::SpecExtend<&T,core::slice::iter::Iter<T>>>::spec_extend
0013a287mov rax, [rbx+16]
0013a28bmov [r14+16], rax
0013a28fmovups x0, [rbx]
0013a292movups [r14], x0
0013a296add rsp, 8
0013a29apop rbx
0013a29bpop r14
0013a29dret
0013a267

0013a29e
0013a29eregex_automata::util::determinize::state::StateBuilderMatches::into_nfa:
0013a29epush r15
0013a2a0push r14
0013a2a2push r13
0013a2a4push r12
0013a2a6push rbx
0013a2a7sub rsp, 64
0013a2abmov r14, rsi
0013a2aemov rbx, rdi
0013a2b1mov r15, [rsi]
0013a2b4mov r12, [rsi+16]
0013a2b8mov rdi, r15
0013a2bbmov rsi, r12
0013a2becall regex_automata::util::determinize::state::Repr::has_pattern_ids
0013a2c3test al, al
0013a2c5je 0x13a30a
0013a2c7lea r13, [r12-13]
0013a2ccmov rax, r13
0013a2cfand rax, 3
0013a2d3mov [rsp+8], rax
0013a2d8jne 0x13a32b
0013a2damov rax, r13
0013a2ddshr rax, 34
0013a2e1jne 0x13a350
0013a2e3shr r13, 2
0013a2e7lea r8, [rip+0xb6aba]
0013a2eepush 9
0013a2f0pop rdi
0013a2f1push 13
0013a2f3pop rsi
0013a2f4mov rdx, r15
0013a2f7mov rcx, r12
0013a2facall _<core::ops::range::Range<usize> as core::slice::index::SliceIndex<[T]>>::index_mut
0013a2ffmov edi, r13l
0013a302mov rsi, rax
0013a305call _<regex_automata::util::wire::LE as regex_automata::util::wire::Endian>::write_u32
0013a30a
0013a30aloc_13a30a:
0013a30amov rax, [r14+16]
0013a30emov [rbx+16], rax
0013a312movups x0, [r14]
0013a316movups [rbx], x0
0013a319and [rbx+24], 0
0013a31dadd rsp, 64
0013a321pop rbx
0013a322pop r12
0013a324pop r13
0013a326pop r14
0013a328pop r15
0013a32aret
0013a32b
0013a32bloc_13a32b:
0013a32blea rcx, [rsp+16]
0013a330and [rcx], 0
0013a334lea rdx, [rip-0x100ad3]
0013a33blea r8, [rip+0xb6a7e]
0013a342lea rsi, [rsp+8]
0013a347xor edi, edi
0013a349call core::panicking::assert_failed
0013a34eud2
0013a350
0013a350loc_13a350:
0013a350lea rdi, [rip-0xa9169]
0013a357lea rcx, [rip+0xb32aa]
0013a35elea r8, [rip+0xb6a2b]
0013a365push 43
0013a367pop rsi
0013a368lea rdx, [rsp+16]
0013a36dcall core::result::unwrap_failed
0013a372ud2
0013a29e

0013a374
0013a374regex_automata::util::determinize::state::StateBuilderNFA::to_state:
0013a374push r15
0013a376push r14
0013a378push r12
0013a37apush rbx
0013a37bpush rax
0013a37cmov rbx, rsi
0013a37fmov r14, rdi
0013a382mov rdi, rsi
0013a385call alloc::sync::Arc<[T]>::allocate_for_slice
0013a38amov r15, rax
0013a38dmov r12, rdx
0013a390lea rdi, [rax+16]
0013a394mov rsi, r14
0013a397mov rdx, rbx
0013a39acall [rip+0xd7780]
0013a3a0mov rax, r15
0013a3a3mov rdx, r12
0013a3a6add rsp, 8
0013a3aapop rbx
0013a3abpop r12
0013a3adpop r14
0013a3afpop r15
0013a3b1ret
0013a374

0013a3b2
0013a3b2_<regex_automata::util::wire::LE as regex_automata::util::wire::Endian>::write_u32:
0013a3b2push rbx
0013a3b3mov rcx, rdx
0013a3b6mov rdx, rsi
0013a3b9mov ebx, edi
0013a3bblea r8, [rip+0xb6806]
0013a3c2push 4
0013a3c4pop rsi
0013a3c5xor edi, edi
0013a3c7call _<core::ops::range::Range<usize> as core::slice::index::SliceIndex<[T]>>::index_mut
0013a3cccmp rdx, 4
0013a3d0jne 0x13a3d6
0013a3d2mov [rax], ebx
0013a3d4pop rbx
0013a3d5ret
0013a3d6
0013a3d6loc_13a3d6:
0013a3d6lea rax, [rip+0xb6803]
0013a3ddpush 4
0013a3dfpop rsi
0013a3e0mov rdi, rdx
0013a3e3mov rdx, rax
0013a3e6call core::slice::_<impl [T]>::copy_from_slice::len_mismatch_fail
0013a3ebud2
0013a3b2

0013a3ed
0013a3edcore::iter::traits::iterator::Iterator::all::check::_{{closure}}:
0013a3edpush rax
0013a3eecall aho_corasick::util::alphabet::ByteSet::contains
0013a3f3xor al, 1
0013a3f5pop rcx
0013a3f6ret
0013a3ed

0013a3f7
0013a3f7_<regex_automata::nfa::thompson::compiler::Config as core::clone::Clone>::clone:
0013a3f7mov cl, [rsi+18]
0013a3faxor eax, eax
0013a3fctest cl, cl
0013a3fesetne al
0013a401cmp cl, 2
0013a404push 2
0013a406pop rcx
0013a407cmove eax, ecx
0013a40amov dl, [rsi+19]
0013a40dxor r8l, r8l
0013a410test dl, dl
0013a412setne r8b
0013a416cmp dl, 2
0013a419cmove r8l, ecx
0013a41dmovups x0, [rsi]
0013a420mov dl, [rsi+20]
0013a423xor r9l, r9l
0013a426test dl, dl
0013a428setne r9b
0013a42ccmp dl, 2
0013a42fcmove r9l, ecx
0013a433mov cl, [rsi+21]
0013a436movzx edx, [rsi+16]
0013a43amov [rdi+18], al
0013a43dmov [rdi+19], r8b
0013a441movups [rdi], x0
0013a444mov [rdi+20], r9b
0013a448mov [rdi+21], cl
0013a44bmov [rdi+16], dx
0013a44fret
0013a3f7

0013a450
0013a450regex_automata::hybrid::dfa::Cache::new:
0013a450push rbp
0013a451push r15
0013a453push r14
0013a455push r13
0013a457push r12
0013a459push rbx
0013a45asub rsp, 472
0013a461mov r15, rsi
0013a464mov [rsp], rdi
0013a468lea r14, [rsp+120]
0013a46dmov rdi, r14
0013a470call std::thread::local::LocalKey<T>::try_with
0013a475mov rdi, r14
0013a478call core::result::Result<T,E>::expect
0013a47dmov rbp, rax
0013a480mov rbx, rdx
0013a483mov rax, [r15+384]
0013a48amov r13, [rax+328]
0013a491lea rdi, [rsp+8]
0013a496mov rsi, r13
0013a499call regex_automata::util::sparse_set::SparseSet::new
0013a49elea r12, [rsp+64]
0013a4a3mov rdi, r12
0013a4a6mov rsi, r13
0013a4a9call regex_automata::util::sparse_set::SparseSet::new
0013a4aexorps x0, x0
0013a4b1movups [r14+288], x0
0013a4b9movups [r14+312], x0
0013a4c1push 4
0013a4c3pop rdx
0013a4c4mov [r14+48], rdx
0013a4c8movups [r14+56], x0
0013a4cdmov [r14+72], rdx
0013a4d1movups [r14+80], x0
0013a4d6mov [r14+96], 8
0013a4demovups [r14+104], x0
0013a4e3lea rax, [rip-0x10163a]
0013a4eamov [r14+120], rax
0013a4eemovups [r14+128], x0
0013a4f6and [r14+144], 0
0013a4femov [r14+152], rbp
0013a505mov [r14+160], rbx
0013a50clea rax, [rsp+288]
0013a514push 14
0013a516pop rcx
0013a517mov rdi, rax
0013a51alea rsi, [rsp+8]
0013a51frep movsq [rdi], [rsi]
0013a522mov [rax+112], rdx
0013a526mov [rax+136], 1
0013a531and [r14+24], 0
0013a536and [r14], 0
0013a53aand [rax+176], 0
0013a542movups [rax+160], x0
0013a549mov [r12-56], r15
0013a54emov [r12-48], r14
0013a553lea rdi, [rsp+8]
0013a558call regex_automata::hybrid::dfa::Lazy::init_cache
0013a55dmov edx, 352
0013a562mov rdi, [rsp]
0013a566mov rsi, r14
0013a569call [rip+0xd75b1]
0013a56fadd rsp, 472
0013a576pop rbx
0013a577pop r12
0013a579pop r13
0013a57bpop r14
0013a57dpop r15
0013a57fpop rbp
0013a580ret
0013a450

0013a581
0013a581regex_automata::hybrid::dfa::Lazy::init_cache:
0013a581push rbp
0013a582push r15
0013a584push r14
0013a586push r13
0013a588push r12
0013a58apush rbx
0013a58bsub rsp, 136
0013a592mov r15, rdi
0013a595mov rax, [rdi]
0013a598test [rax+121], 1
0013a59cmov [rsp+24], rax
0013a5a1jne 0x13a5a8
0013a5a3push 12
0013a5a5pop rbx
0013a5a6jmp 0x13a5bb
0013a5a8
0013a5a8loc_13a5a8:
0013a5a8mov rax, [rax+384]
0013a5afimul rbx, [rax+352], 6
0013a5b7add rbx, 12
0013a5bb
0013a5bbloc_13a5bb:
0013a5bbmov r12, [r15+8]
0013a5bflea r14, [r12+72]
0013a5c4call regex_automata::hybrid::dfa::LazyRef::unknown_id
0013a5c9mov rdi, r14
0013a5ccmov rsi, rbx
0013a5cfmov edx, eax
0013a5d1call alloc::vec::Vec<T,A>::extend_trusted
0013a5d6call regex_automata::util::determinize::state::State::dead
0013a5dblock inc [rax]
0013a5dfjle 0x13aae0
0013a5e5mov r13, rax
0013a5e8mov rbp, rdx
0013a5ebmov [rsp+8], rax
0013a5f0mov [rsp+16], rdx
0013a5f5mov rdi, [rsp+24]
0013a5famov rsi, r12
0013a5fdcall regex_automata::hybrid::dfa::LazyRef::state_fits_in_cache
0013a602test al, al
0013a604mov [rsp+56], rbp
0013a609jne 0x13a617
0013a60bmov rdi, r15
0013a60ecall regex_automata::hybrid::dfa::Lazy::try_clear_cache
0013a613test al, al
0013a615jne 0x13a623
0013a617
0013a617loc_13a617:
0013a617mov rdi, r15
0013a61acall regex_automata::hybrid::dfa::Lazy::next_state_id
0013a61ftest eax, eax
0013a621je 0x13a635
0013a623
0013a623loc_13a623:
0013a623push 1
0013a625pop rbx
0013a626lea rdi, [rsp+8]
0013a62bcall core::ptr::drop_in_place<regex_automata::util::determinize::state::State>
0013a630jmp 0x13a73c
0013a635
0013a635loc_13a635:
0013a635mov ebx, edx
0013a637mov [rsp+40], r13
0013a63cmov rdi, r13
0013a63fmov rsi, rbp
0013a642call regex_automata::util::determinize::state::State::is_match
0013a647movzx r14l, al
0013a64bshl r14l, 27
0013a64for r14l, ebx
0013a652or r14l, 0xffffffff80000000
0013a659lea rbx, [r12+48]
0013a65ecall regex_automata::hybrid::dfa::LazyRef::unknown_id
0013a663mov rdx, [rsp+24]
0013a668mov cl, [rdx+392]
0013a66epush 1
0013a670pop rsi
0013a671shl rsi, cl
0013a674mov rdi, rbx
0013a677mov rbx, rdx
0013a67amov edx, eax
0013a67ccall alloc::vec::Vec<T,A>::extend_trusted
0013a681lea r13, [rbx+656]
0013a688mov rdi, r13
0013a68bcall _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013a690test al, al
0013a692jne 0x13a6fb
0013a694mov rdi, rbx
0013a697mov esi, r14l
0013a69acall regex_automata::hybrid::dfa::LazyRef::is_sentinel
0013a69ftest al, al
0013a6a1jne 0x13a6fb
0013a6a3mov [rsp+32], r12
0013a6a8mov rdi, rbx
0013a6abcall regex_automata::hybrid::dfa::LazyRef::quit_id
0013a6b0lea rbx, [rsp+88]
0013a6b5mov [rbx], r13
0013a6b8and [rbx+8], 0
0013a6bdmov ebp, eax
0013a6bfmov r12, [r15]
0013a6c2mov r13, r15
0013a6c5mov r15, [r15+8]
0013a6c9
0013a6c9loc_13a6c9:
0013a6c9mov rdi, rbx
0013a6cccall _<regex_automata::util::alphabet::ByteSetIter as core::iter::traits::iterator::Iterator>::next
0013a6d1test al, 1
0013a6d3je 0x13a6ee
0013a6d5movzx ecx, dl
0013a6d8shl ecx, 8
0013a6dbmov rdi, r12
0013a6demov rsi, r15
0013a6e1mov edx, r14l
0013a6e4mov r8l, ebp
0013a6e7call regex_automata::hybrid::dfa::Lazy::set_transition
0013a6ecjmp 0x13a6c9
0013a6ee
0013a6eeloc_13a6ee:
0013a6eemov r12, [rsp+32]
0013a6f3mov r15, r13
0013a6f6mov rbp, [rsp+56]
0013a6fb
0013a6fbloc_13a6fb:
0013a6fbadd [r12+328], rbp
0013a703mov r13, [rsp+40]
0013a708lock inc [r13]
0013a70djle 0x13aae0
0013a713lea rdi, [r12+96]
0013a718mov rsi, r13
0013a71bmov rdx, rbp
0013a71ecall alloc::vec::Vec<T,A>::push
0013a723lea rdi, [r12+120]
0013a728mov rsi, [rsp+8]
0013a72dmov rdx, [rsp+16]
0013a732mov ecx, r14l
0013a735call hashbrown::map::HashMap<K,V,S,A>::insert
0013a73axor ebx, ebx
0013a73c
0013a73cloc_13a73c:
0013a73clea rsi, [rip+0xb3a65]
0013a743mov edi, ebx
0013a745call core::result::Result<T,E>::unwrap
0013a74amov [rsp+76], r14l
0013a74flock inc [r13]
0013a754jle 0x13aae0
0013a75amov [rsp+52], r14l
0013a75fmov [rsp+8], r13
0013a764mov [rsp+16], rbp
0013a769mov rdi, [rsp+24]
0013a76emov rsi, r12
0013a771mov rdx, rbp
0013a774call regex_automata::hybrid::dfa::LazyRef::state_fits_in_cache
0013a779test al, al
0013a77bjne 0x13a789
0013a77dmov rdi, r15
0013a780call regex_automata::hybrid::dfa::Lazy::try_clear_cache
0013a785test al, al
0013a787jne 0x13a795
0013a789
0013a789loc_13a789:
0013a789mov rdi, r15
0013a78ccall regex_automata::hybrid::dfa::Lazy::next_state_id
0013a791test eax, eax
0013a793je 0x13a7ac
0013a795
0013a795loc_13a795:
0013a795lea rdi, [rsp+8]
0013a79acall core::ptr::drop_in_place<regex_automata::util::determinize::state::State>
0013a79fpush 1
0013a7a1pop rdi
0013a7a2mov rbx, [rsp+24]
0013a7a7jmp 0x13a8ba
0013a7ac
0013a7acloc_13a7ac:
0013a7acmov ebx, edx
0013a7aemov [rsp+40], r13
0013a7b3mov rdi, r13
0013a7b6mov rsi, rbp
0013a7b9call regex_automata::util::determinize::state::State::is_match
0013a7bemovzx r14l, al
0013a7c2shl r14l, 27
0013a7c6or r14l, ebx
0013a7c9or r14l, 0x40000000
0013a7d0lea rbx, [r12+48]
0013a7d5call regex_automata::hybrid::dfa::LazyRef::unknown_id
0013a7damov rdx, [rsp+24]
0013a7dfmov cl, [rdx+392]
0013a7e5push 1
0013a7e7pop rsi
0013a7e8shl rsi, cl
0013a7ebmov rdi, rbx
0013a7eemov rbx, rdx
0013a7f1mov edx, eax
0013a7f3call alloc::vec::Vec<T,A>::extend_trusted
0013a7f8lea r13, [rbx+656]
0013a7ffmov rdi, r13
0013a802call _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013a807test al, al
0013a809jne 0x13a879
0013a80bmov rdi, rbx
0013a80emov esi, r14l
0013a811call regex_automata::hybrid::dfa::LazyRef::is_sentinel
0013a816test al, al
0013a818jne 0x13a879
0013a81amov [rsp+32], r12
0013a81fmov rdi, rbx
0013a822call regex_automata::hybrid::dfa::LazyRef::quit_id
0013a827lea rbp, [rsp+88]
0013a82cmov [rbp], r13
0013a830and [rbp+8], 0
0013a835mov r13l, eax
0013a838mov r12, [r15]
0013a83bmov rbx, r15
0013a83emov r15, [r15+8]
0013a842
0013a842loc_13a842:
0013a842mov rdi, rbp
0013a845call _<regex_automata::util::alphabet::ByteSetIter as core::iter::traits::iterator::Iterator>::next
0013a84atest al, 1
0013a84cje 0x13a867
0013a84emovzx ecx, dl
0013a851shl ecx, 8
0013a854mov rdi, r12
0013a857mov rsi, r15
0013a85amov edx, r14l
0013a85dmov r8l, r13l
0013a860call regex_automata::hybrid::dfa::Lazy::set_transition
0013a865jmp 0x13a842
0013a867
0013a867loc_13a867:
0013a867mov r12, [rsp+32]
0013a86cmov r15, rbx
0013a86fmov rbp, [rsp+56]
0013a874mov rbx, [rsp+24]
0013a879
0013a879loc_13a879:
0013a879add [r12+328], rbp
0013a881mov r13, [rsp+40]
0013a886lock inc [r13]
0013a88bjle 0x13aae0
0013a891lea rdi, [r12+96]
0013a896mov rsi, r13
0013a899mov rdx, rbp
0013a89ccall alloc::vec::Vec<T,A>::push
0013a8a1lea rdi, [r12+120]
0013a8a6mov rsi, [rsp+8]
0013a8abmov rdx, [rsp+16]
0013a8b0mov ecx, r14l
0013a8b3call hashbrown::map::HashMap<K,V,S,A>::insert
0013a8b8xor edi, edi
0013a8ba
0013a8baloc_13a8ba:
0013a8balea rsi, [rip+0xb38ff]
0013a8c1call core::result::Result<T,E>::unwrap
0013a8c6mov [rsp+80], r14l
0013a8cblock inc [r13]
0013a8d0jle 0x13aae0
0013a8d6mov [rsp+8], r13
0013a8dbmov [rsp+16], rbp
0013a8e0mov rdi, rbx
0013a8e3mov rsi, r12
0013a8e6mov rdx, rbp
0013a8e9call regex_automata::hybrid::dfa::LazyRef::state_fits_in_cache
0013a8eetest al, al
0013a8f0jne 0x13a8fe
0013a8f2mov rdi, r15
0013a8f5call regex_automata::hybrid::dfa::Lazy::try_clear_cache
0013a8fatest al, al
0013a8fcjne 0x13a90a
0013a8fe
0013a8feloc_13a8fe:
0013a8femov rdi, r15
0013a901call regex_automata::hybrid::dfa::Lazy::next_state_id
0013a906test eax, eax
0013a908je 0x13a921
0013a90a
0013a90aloc_13a90a:
0013a90alea rdi, [rsp+8]
0013a90fcall core::ptr::drop_in_place<regex_automata::util::determinize::state::State>
0013a914push 1
0013a916pop rdi
0013a917mov rbx, [rsp+24]
0013a91cjmp 0x13aa33
0013a921
0013a921loc_13a921:
0013a921mov ebx, edx
0013a923mov rdi, r13
0013a926mov rsi, rbp
0013a929call regex_automata::util::determinize::state::State::is_match
0013a92emovzx ebp, al
0013a931shl ebp, 27
0013a934or ebp, ebx
0013a936or ebp, 0x20000000
0013a93clea rbx, [r12+48]
0013a941call regex_automata::hybrid::dfa::LazyRef::unknown_id
0013a946mov rdx, [rsp+24]
0013a94bmov cl, [rdx+392]
0013a951push 1
0013a953pop rsi
0013a954shl rsi, cl
0013a957mov rdi, rbx
0013a95amov rbx, rdx
0013a95dmov edx, eax
0013a95fcall alloc::vec::Vec<T,A>::extend_trusted
0013a964lea rdi, [rbx+656]
0013a96bmov [rsp+64], rdi
0013a970call _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013a975test al, al
0013a977jne 0x13a9f6
0013a979mov rdi, rbx
0013a97cmov esi, ebp
0013a97ecall regex_automata::hybrid::dfa::LazyRef::is_sentinel
0013a983test al, al
0013a985jne 0x13a9f6
0013a987mov [rsp+40], r13
0013a98cmov [rsp+32], r12
0013a991mov rdi, rbx
0013a994call regex_automata::hybrid::dfa::LazyRef::quit_id
0013a999lea r13, [rsp+88]
0013a99emov rcx, [rsp+64]
0013a9a3mov [r13], rcx
0013a9a7and [r13+8], 0
0013a9acmov r12l, eax
0013a9afmov rax, r15
0013a9b2mov r15, [r15]
0013a9b5mov [rsp+64], rax
0013a9bamov rbx, [rax+8]
0013a9be
0013a9beloc_13a9be:
0013a9bemov rdi, r13
0013a9c1call _<regex_automata::util::alphabet::ByteSetIter as core::iter::traits::iterator::Iterator>::next
0013a9c6test al, 1
0013a9c8je 0x13a9e2
0013a9camovzx ecx, dl
0013a9cdshl ecx, 8
0013a9d0mov rdi, r15
0013a9d3mov rsi, rbx
0013a9d6mov edx, ebp
0013a9d8mov r8l, r12l
0013a9dbcall regex_automata::hybrid::dfa::Lazy::set_transition
0013a9e0jmp 0x13a9be
0013a9e2
0013a9e2loc_13a9e2:
0013a9e2mov r12, [rsp+32]
0013a9e7mov r15, [rsp+64]
0013a9ecmov r13, [rsp+40]
0013a9f1mov rbx, [rsp+24]
0013a9f6
0013a9f6loc_13a9f6:
0013a9f6mov rdx, [rsp+56]
0013a9fbadd [r12+328], rdx
0013aa03lock inc [r13]
0013aa08jle 0x13aae0
0013aa0elea rdi, [r12+96]
0013aa13mov rsi, r13
0013aa16call alloc::vec::Vec<T,A>::push
0013aa1blea rdi, [r12+120]
0013aa20mov rsi, [rsp+8]
0013aa25mov rdx, [rsp+16]
0013aa2amov ecx, ebp
0013aa2ccall hashbrown::map::HashMap<K,V,S,A>::insert
0013aa31xor edi, edi
0013aa33
0013aa33loc_13aa33:
0013aa33lea rsi, [rip+0xb379e]
0013aa3acall core::result::Result<T,E>::unwrap
0013aa3fmov [rsp+84], ebp
0013aa43call regex_automata::hybrid::dfa::LazyRef::unknown_id
0013aa48mov [rsp+8], eax
0013aa4ccmp [rsp+52], eax
0013aa50jne 0x13aae4
0013aa56mov rdi, rbx
0013aa59call regex_automata::hybrid::dfa::LazyRef::dead_id
0013aa5emov [rsp+8], eax
0013aa62cmp r14l, eax
0013aa65jne 0x13aafb
0013aa6bmov rdi, rbx
0013aa6ecall regex_automata::hybrid::dfa::LazyRef::quit_id
0013aa73mov [rsp+8], eax
0013aa77cmp ebp, eax
0013aa79jne 0x13ab12
0013aa7fmov rbx, [r15]
0013aa82mov r15, [r15+8]
0013aa86mov rdi, rbx
0013aa89mov rsi, r15
0013aa8cmov ecx, [rsp+52]
0013aa90mov edx, ecx
0013aa92call regex_automata::hybrid::dfa::Lazy::set_all_transitions
0013aa97mov rdi, rbx
0013aa9amov rsi, r15
0013aa9dmov edx, r14l
0013aaa0mov ecx, r14l
0013aaa3call regex_automata::hybrid::dfa::Lazy::set_all_transitions
0013aaa8mov rdi, rbx
0013aaabmov rsi, r15
0013aaaemov edx, ebp
0013aab0mov ecx, ebp
0013aab2call regex_automata::hybrid::dfa::Lazy::set_all_transitions
0013aab7add r12, 120
0013aabbmov rdi, r12
0013aabemov rsi, r13
0013aac1mov rdx, [rsp+56]
0013aac6mov ecx, r14l
0013aac9call hashbrown::map::HashMap<K,V,S,A>::insert
0013aaceadd rsp, 136
0013aad5pop rbx
0013aad6pop r12
0013aad8pop r13
0013aadapop r14
0013aadcpop r15
0013aadepop rbp
0013aadfret
0013aae0
0013aae0loc_13aae0:
0013aae0ud2
0013aae2
0013aae2 0f 0b ..
0013aae4
0013aae4loc_13aae4:
0013aae4lea rdx, [rsp+88]
0013aae9and [rdx], 0
0013aaedlea rcx, [rip+0xb36fc]
0013aaf4lea rdi, [rsp+76]
0013aaf9jmp 0x13ab27
0013aafb
0013aafbloc_13aafb:
0013aafblea rdx, [rsp+88]
0013ab00and [rdx], 0
0013ab04lea rcx, [rip+0xb36fd]
0013ab0blea rdi, [rsp+80]
0013ab10jmp 0x13ab27
0013ab12
0013ab12loc_13ab12:
0013ab12lea rdx, [rsp+88]
0013ab17and [rdx], 0
0013ab1blea rcx, [rip+0xb36fe]
0013ab22lea rdi, [rsp+84]
0013ab27
0013ab27loc_13ab27:
0013ab27lea rsi, [rsp+8]
0013ab2ccall core::panicking::assert_failed
0013ab31ud2
0013a581

0013ab33
0013ab33regex_automata::hybrid::dfa::LazyRef::unknown_id:
0013ab33sub rsp, 24
0013ab37lea rdi, [rsp+8]
0013ab3cand [rdi], 0
0013ab40lea rsi, [rip+0xb37f9]
0013ab47call core::result::Result<T,E>::unwrap
0013ab4cor eax, 0xffffffff80000000
0013ab51add rsp, 24
0013ab55ret
0013ab33

0013ab56
0013ab56regex_automata::hybrid::dfa::LazyRef::state_fits_in_cache:
0013ab56push r14
0013ab58push rbx
0013ab59push rax
0013ab5amov rbx, rdx
0013ab5dmov r14, rdi
0013ab60mov rdi, rsi
0013ab63call regex_automata::hybrid::dfa::Cache::memory_usage
0013ab68mov cl, [r14+392]
0013ab6fpush 4
0013ab71pop rdx
0013ab72shl rdx, cl
0013ab75add rax, rbx
0013ab78add rax, rdx
0013ab7badd rax, 36
0013ab7fcmp rax, [r14+688]
0013ab86setbe al
0013ab89add rsp, 8
0013ab8dpop rbx
0013ab8epop r14
0013ab90ret
0013ab56

0013ab91
0013ab91regex_automata::hybrid::dfa::Lazy::try_clear_cache:
0013ab91mov rax, [rdi]
0013ab94cmp [rax+56], 1
0013ab98jne 0x13abab
0013ab9amov rdx, [rdi+8]
0013ab9emov rcx, [rdx+336]
0013aba5cmp rcx, [rax+64]
0013aba9jae 0x13abba
0013abab
0013ababloc_13abab:
0013ababpush rax
0013abaccall regex_automata::hybrid::dfa::Lazy::clear_cache
0013abb1xor ecx, ecx
0013abb3add rsp, 8
0013abb7
0013abb7loc_13abb7:
0013abb7mov eax, ecx
0013abb9ret
0013abba
0013abbaloc_13abba:
0013abbamov cl, 1
0013abbccmp [rax+72], 1
0013abc0jne 0x13abb7
0013abc2mov rax, [rax+80]
0013abc6mov r8, [rdx+344]
0013abcdcmp [rdx], 0
0013abd1je 0x13abed
0013abd3mov rsi, [rdx+16]
0013abd7mov r9, [rdx+8]
0013abdbmov r10, rsi
0013abdesub r10, r9
0013abe1neg r10
0013abe4sub rsi, r9
0013abe7cmovb rsi, r10
0013abebjmp 0x13abef
0013abed
0013abedloc_13abed:
0013abedxor esi, esi
0013abef
0013abefloc_13abef:
0013abefadd rsi, r8
0013abf2mul [rdx+112]
0013abf6push -1
0013abf8pop rdx
0013abf9cmovno rdx, rax
0013abfdcmp rsi, rdx
0013ac00jae 0x13abab
0013ac02jmp 0x13abb7
0013ab91

0013ac04
0013ac04regex_automata::hybrid::dfa::Lazy::next_state_id:
0013ac04push rbx
0013ac05sub rsp, 16
0013ac09mov rbx, [rdi+8]
0013ac0dmov rdx, [rbx+64]
0013ac11cmp rdx, 0x7ffffff
0013ac18jbe 0x13ac57
0013ac1acall regex_automata::hybrid::dfa::Lazy::try_clear_cache
0013ac1ftest al, al
0013ac21je 0x13ac28
0013ac23push 1
0013ac25pop rax
0013ac26jmp 0x13ac59
0013ac28
0013ac28loc_13ac28:
0013ac28mov rax, [rbx+64]
0013ac2ccmp rax, 0x7ffffff
0013ac32jbe 0x13ac3e
0013ac34mov [rsp+8], rax
0013ac39push 1
0013ac3bpop rax
0013ac3cjmp 0x13ac44
0013ac3e
0013ac3eloc_13ac3e:
0013ac3emov [rsp+4], eax
0013ac42xor eax, eax
0013ac44
0013ac44loc_13ac44:
0013ac44mov rdi, rsp
0013ac47mov [rdi], eax
0013ac49lea rsi, [rip+0xb3500]
0013ac50call core::result::Result<T,E>::unwrap
0013ac55mov edx, eax
0013ac57
0013ac57loc_13ac57:
0013ac57xor eax, eax
0013ac59
0013ac59loc_13ac59:
0013ac59add rsp, 16
0013ac5dpop rbx
0013ac5eret
0013ac04

0013ac5f
0013ac5fregex_automata::util::determinize::state::State::is_match:
0013ac5fadd rdi, 16
0013ac63jmp 0x12d000
0013ac5f

0013ac68
0013ac68regex_automata::hybrid::dfa::LazyRef::is_sentinel:
0013ac68push rbp
0013ac69push r14
0013ac6bpush rbx
0013ac6cmov ebx, esi
0013ac6emov r14, rdi
0013ac71call regex_automata::hybrid::dfa::LazyRef::unknown_id
0013ac76mov bpl, 1
0013ac79cmp eax, ebx
0013ac7bje 0x13ac97
0013ac7dmov rdi, r14
0013ac80call regex_automata::hybrid::dfa::LazyRef::dead_id
0013ac85cmp eax, ebx
0013ac87je 0x13ac97
0013ac89mov rdi, r14
0013ac8ccall regex_automata::hybrid::dfa::LazyRef::quit_id
0013ac91cmp eax, ebx
0013ac93sete bpl
0013ac97
0013ac97loc_13ac97:
0013ac97mov eax, ebp
0013ac99pop rbx
0013ac9apop r14
0013ac9cpop rbp
0013ac9dret
0013ac68

0013ac9e
0013ac9eregex_automata::hybrid::dfa::LazyRef::quit_id:
0013ac9esub rsp, 24
0013aca2mov cl, [rdi+392]
0013aca8push 2
0013acaapop rax
0013acabshl rax, cl
0013acaecmp rax, 0x7ffffff
0013acb4jbe 0x13acc0
0013acb6mov [rsp+16], rax
0013acbbpush 1
0013acbdpop rax
0013acbejmp 0x13acc6
0013acc0
0013acc0loc_13acc0:
0013acc0mov [rsp+12], eax
0013acc4xor eax, eax
0013acc6
0013acc6loc_13acc6:
0013acc6lea rdi, [rsp+8]
0013accbmov [rdi], eax
0013accdlea rsi, [rip+0xb369c]
0013acd4call core::result::Result<T,E>::unwrap
0013acd9or eax, 0x20000000
0013acdeadd rsp, 24
0013ace2ret
0013ac9e

0013ace3
0013ace3_<regex_automata::util::alphabet::ByteSetIter as core::iter::traits::iterator::Iterator>::next:
0013ace3push r15
0013ace5push r14
0013ace7push r12
0013ace9push rbx
0013aceapush rax
0013acebmov r14, rdi
0013aceemov r15, [rdi]
0013acf1mov rbx, [rdi+8]
0013acf5
0013acf5loc_13acf5:
0013acf5mov r12, rbx
0013acf8cmp r12, 255
0013acffja 0x13ad1c
0013ad01lea rbx, [r12+1]
0013ad06mov [r14+8], rbx
0013ad0amovzx esi, r12b
0013ad0emov rdi, r15
0013ad11call aho_corasick::util::alphabet::ByteSet::contains
0013ad16test al, al
0013ad18je 0x13acf5
0013ad1adec bl
0013ad1c
0013ad1cloc_13ad1c:
0013ad1ccmp r12, 256
0013ad23setb al
0013ad26mov edx, ebx
0013ad28add rsp, 8
0013ad2cpop rbx
0013ad2dpop r12
0013ad2fpop r14
0013ad31pop r15
0013ad33ret
0013ace3

0013ad34
0013ad34regex_automata::hybrid::dfa::Lazy::set_transition:
0013ad34push rbp
0013ad35push r15
0013ad37push r14
0013ad39push r12
0013ad3bpush rbx
0013ad3csub rsp, 80
0013ad40mov ebp, r8l
0013ad43mov ebx, ecx
0013ad45mov r14l, edx
0013ad48mov r15, rsi
0013ad4bmov r12, rdi
0013ad4emov [rsp+8], edx
0013ad52mov [rsp+12], r8l
0013ad57call regex_automata::hybrid::dfa::LazyRef::is_valid
0013ad5ctest al, al
0013ad5eje 0x13adbb
0013ad60mov rdi, r12
0013ad63mov rsi, r15
0013ad66mov edx, ebp
0013ad68call regex_automata::hybrid::dfa::LazyRef::is_valid
0013ad6dtest al, al
0013ad6fje 0x13adff
0013ad75test bl, 1
0013ad78jne 0x13ad88
0013ad7amovzx eax, bh
0013ad7dmovzx ebx, [r12+rax+400]
0013ad86jmp 0x13ad8b
0013ad88
0013ad88loc_13ad88:
0013ad88shr ebx, 16
0013ad8b
0013ad8bloc_13ad8b:
0013ad8band r14l, 0x7ffffff
0013ad92add r14, rbx
0013ad95mov rdi, [r15+48]
0013ad99mov rsi, [r15+64]
0013ad9dlea rcx, [rip+0xb34fc]
0013ada4mov rdx, r14
0013ada7call _<alloc::vec::Vec<T,A> as core::ops::index::Index>::index
0013adacmov [rax], ebp
0013adaeadd rsp, 80
0013adb2pop rbx
0013adb3pop r12
0013adb5pop r14
0013adb7pop r15
0013adb9pop rbp
0013adbaret
0013adbb
0013adbbloc_13adbb:
0013adbblea rax, [rsp+8]
0013adc0lea rcx, [rsp+16]
0013adc5mov [rcx], rax
0013adc8lea rax, [rip+0xb3481]
0013adcflea rdi, [rsp+32]
0013add4mov [rdi], rax
0013add7push 1
0013add9pop rax
0013addamov [rdi+8], rax
0013addeand [rdi+32], 0
0013ade3lea rdx, [rip-56879]
0013adeamov [rcx+8], rdx
0013adeemov [rdi+16], rcx
0013adf2mov [rdi+24], rax
0013adf6lea rsi, [rip+0xb3463]
0013adfdjmp 0x13ae41
0013adff
0013adffloc_13adff:
0013adfflea rax, [rsp+12]
0013ae04lea rcx, [rsp+16]
0013ae09mov [rcx], rax
0013ae0clea rax, [rip+0xb3465]
0013ae13lea rdi, [rsp+32]
0013ae18mov [rdi], rax
0013ae1bpush 1
0013ae1dpop rax
0013ae1emov [rdi+8], rax
0013ae22and [rdi+32], 0
0013ae27lea rdx, [rip-56947]
0013ae2emov [rcx+8], rdx
0013ae32mov [rdi+16], rcx
0013ae36mov [rdi+24], rax
0013ae3alea rsi, [rip+0xb3447]
0013ae41
0013ae41loc_13ae41:
0013ae41call core::panicking::panic_fmt
0013ae46ud2
0013ad34

0013ae48
0013ae48alloc::vec::Vec<T,A>::push:
0013ae48push r15
0013ae4apush r14
0013ae4cpush rbx
0013ae4dmov r14, rdx
0013ae50mov r15, rsi
0013ae53mov rbx, rdi
0013ae56mov rsi, [rdi+16]
0013ae5acmp rsi, [rdi+8]
0013ae5ejne 0x13ae6c
0013ae60mov rdi, rbx
0013ae63call alloc::raw_vec::RawVec<T,A>::reserve_for_push
0013ae68mov rsi, [rbx+16]
0013ae6c
0013ae6cloc_13ae6c:
0013ae6cmov rax, [rbx]
0013ae6fmov rcx, rsi
0013ae72shl rcx, 4
0013ae76mov [rax+rcx], r15
0013ae7amov [rax+rcx+8], r14
0013ae7finc rsi
0013ae82mov [rbx+16], rsi
0013ae86pop rbx
0013ae87pop r14
0013ae89pop r15
0013ae8bret
0013ae48

0013ae8c
0013ae8ccore::result::Result<T,E>::unwrap:
0013ae8ctest edi, edi
0013ae8ejne 0x13ae91
0013ae90ret
0013ae91
0013ae91loc_13ae91:
0013ae91push rax
0013ae92mov r8, rsi
0013ae95lea rdi, [rip-0xa9cae]
0013ae9clea rcx, [rip+0xb26e5]
0013aea3push 43
0013aea5pop rsi
0013aea6lea rdx, [rsp+7]
0013aeabcall core::result::unwrap_failed
0013aeb0ud2
0013ae8c

0013aeb2
0013aeb2regex_automata::hybrid::dfa::LazyRef::dead_id:
0013aeb2sub rsp, 24
0013aeb6mov rcx, [rdi+392]
0013aebdand ecx, 63
0013aec0push 1
0013aec2pop rax
0013aec3shl rax, cl
0013aec6cmp rcx, 26
0013aecajbe 0x13aed6
0013aeccmov [rsp+16], rax
0013aed1push 1
0013aed3pop rax
0013aed4jmp 0x13aedc
0013aed6
0013aed6loc_13aed6:
0013aed6mov [rsp+12], eax
0013aedaxor eax, eax
0013aedc
0013aedcloc_13aedc:
0013aedclea rdi, [rsp+8]
0013aee1mov [rdi], eax
0013aee3lea rsi, [rip+0xb346e]
0013aeeacall core::result::Result<T,E>::unwrap
0013aeefor eax, 0x40000000
0013aef4add rsp, 24
0013aef8ret
0013aeb2

0013aef9
0013aef9regex_automata::hybrid::dfa::Lazy::set_all_transitions:
0013aef9push rbp
0013aefapush r15
0013aefcpush r14
0013aefepush r12
0013af00push rbx
0013af01sub rsp, 48
0013af05mov ebx, ecx
0013af07mov ebp, edx
0013af09mov r14, rsi
0013af0cmov r15, rdi
0013af0flea rax, [rdi+400]
0013af16lea r12, [rsp+8]
0013af1band [r12], 0
0013af20mov [r12+16], rax
0013af25and [r12+24], 0
0013af2bmov [r12+32], 0
0013af31
0013af31loc_13af31:
0013af31mov rdi, r12
0013af34call _<regex_automata::util::alphabet::ByteClassRepresentatives as core::iter::traits::iterator::Iterator>::next
0013af39cmp al, 2
0013af3bje 0x13af51
0013af3dmov rdi, r15
0013af40mov rsi, r14
0013af43mov edx, ebp
0013af45mov ecx, eax
0013af47mov r8l, ebx
0013af4acall regex_automata::hybrid::dfa::Lazy::set_transition
0013af4fjmp 0x13af31
0013af51
0013af51loc_13af51:
0013af51add rsp, 48
0013af55pop rbx
0013af56pop r12
0013af58pop r14
0013af5apop r15
0013af5cpop rbp
0013af5dret
0013aef9

0013af5e
0013af5ecore::result::Result<T,E>::unwrap:
0013af5ecmp [rdi], 0
0013af61jne 0x13af67
0013af63mov eax, [rdi+4]
0013af66ret
0013af67
0013af67loc_13af67:
0013af67push rax
0013af68mov r8, rsi
0013af6bmov rax, [rdi+8]
0013af6fmov rdx, rsp
0013af72mov [rdx], rax
0013af75lea rdi, [rip-0xa9d8e]
0013af7clea rcx, [rip+0xb26a5]
0013af83push 43
0013af85pop rsi
0013af86call core::result::unwrap_failed
0013af8bud2
0013af5e

0013af8d
0013af8dregex_automata::hybrid::dfa::LazyRef::is_valid:
0013af8dand edx, 0x7ffffff
0013af93cmp [rsi+64], rdx
0013af97jbe 0x13afad
0013af99mov cl, [rdi+392]
0013af9fpush -1
0013afa1pop rax
0013afa2shl rax, cl
0013afa5not eax
0013afa7test eax, edx
0013afa9sete al
0013afacret
0013afad
0013afadloc_13afad:
0013afadxor eax, eax
0013afafret
0013af8d

0013afb0
0013afb0regex_automata::hybrid::dfa::Lazy::clear_cache:
0013afb0push rbp
0013afb1push r15
0013afb3push r14
0013afb5push r13
0013afb7push r12
0013afb9push rbx
0013afbasub rsp, 88
0013afbemov rbp, rdi
0013afc1mov rbx, [rdi+8]
0013afc5and [rbx+64], 0
0013afcaand [rbx+88], 0
0013afcfmov rdi, [rbx+96]
0013afd3mov rsi, [rbx+112]
0013afd7and [rbx+112], 0
0013afdccall core::ptr::drop_in_place<[regex_automata::util::determinize::state::State]>
0013afe1lea r15, [rbx+120]
0013afe5xor eax, eax
0013afe7cmp [rbx+144], rax
0013afeeje 0x13b039
0013aff0mov rdi, r15
0013aff3call hashbrown::raw::RawTable<T,A>::drop_elements
0013aff8mov r14, [rbx+128]
0013affftest r14, r14
0013b002je 0x13b016
0013b004mov rdi, [r15]
0013b007lea rdx, [r14+17]
0013b00bmov esi, 255
0013b010call [rip+0xd6af2]
0013b016
0013b016loc_13b016:
0013b016and [rbx+144], 0
0013b01elea rax, [r14+1]
0013b022shr rax, 3
0013b026imul rax, rax, 7
0013b02acmp r14, 8
0013b02ecmovb rax, r14
0013b032mov [rbx+136], rax
0013b039
0013b039loc_13b039:
0013b039and [rbx+328], 0
0013b041inc [rbx+336]
0013b048and [rbx+344], 0
0013b050cmp [rbx], 0
0013b054je 0x13b05e
0013b056mov rax, [rbx+16]
0013b05amov [rbx+8], rax
0013b05e
0013b05eloc_13b05e:
0013b05emov rdi, rbp
0013b061call regex_automata::hybrid::dfa::Lazy::init_cache
0013b066mov eax, [rbx+24]
0013b069mov r14l, [rbx+28]
0013b06dmov rcx, [rbx+32]
0013b071mov r12, [rbx+40]
0013b075and [rbx+24], 0
0013b079cmp eax, 1
0013b07cjne 0x13b19e
0013b082mov [rsp], rcx
0013b086mov [rsp+16], r15
0013b08bmov r13, [rbp]
0013b08fmov rdi, r13
0013b092mov esi, r14l
0013b095call regex_automata::hybrid::dfa::LazyRef::is_sentinel
0013b09atest al, al
0013b09cjne 0x13b21e
0013b0a2mov rax, [rsp]
0013b0a6mov [rsp+24], rax
0013b0abmov [rsp+32], r12
0013b0b0mov rdi, r13
0013b0b3mov rsi, rbx
0013b0b6mov rdx, r12
0013b0b9call regex_automata::hybrid::dfa::LazyRef::state_fits_in_cache
0013b0betest al, al
0013b0c0jne 0x13b0d2
0013b0c2mov rdi, rbp
0013b0c5call regex_automata::hybrid::dfa::Lazy::try_clear_cache
0013b0catest al, al
0013b0ccjne 0x13b1f0
0013b0d2
0013b0d2loc_13b0d2:
0013b0d2mov rdi, rbp
0013b0d5call regex_automata::hybrid::dfa::Lazy::next_state_id
0013b0datest eax, eax
0013b0dcjne 0x13b1f0
0013b0e2mov r15l, edx
0013b0e5lea rax, [rbx+48]
0013b0e9mov [rsp+8], rax
0013b0eeand r14l, 0x10000000
0013b0f5or r15l, r14l
0013b0f8mov rdi, [rsp]
0013b0fcmov rsi, r12
0013b0ffcall regex_automata::util::determinize::state::State::is_match
0013b104mov ebp, r15l
0013b107or ebp, 0x8000000
0013b10dtest al, al
0013b10fcmove ebp, r15l
0013b113call regex_automata::hybrid::dfa::LazyRef::unknown_id
0013b118mov cl, [r13+392]
0013b11fpush 1
0013b121pop rsi
0013b122shl rsi, cl
0013b125mov rdi, [rsp+8]
0013b12amov edx, eax
0013b12ccall alloc::vec::Vec<T,A>::extend_trusted
0013b131lea r14, [r13+656]
0013b138mov rdi, r14
0013b13bcall _<T as core::array::equality::SpecArrayEq<U,_>>::spec_eq
0013b140test al, al
0013b142jne 0x13b152
0013b144mov rdi, r13
0013b147mov esi, ebp
0013b149call regex_automata::hybrid::dfa::LazyRef::is_sentinel
0013b14etest al, al
0013b150je 0x13b1ad
0013b152
0013b152loc_13b152:
0013b152add [rbx+328], r12
0013b159mov r15, [rsp]
0013b15dlock inc [r15]
0013b161jle 0x13b255
0013b167lea rdi, [rbx+96]
0013b16blea r14, [rbx+24]
0013b16fmov rsi, r15
0013b172mov rdx, r12
0013b175call alloc::vec::Vec<T,A>::push
0013b17amov rdi, [rsp+16]
0013b17fmov rsi, r15
0013b182mov rdx, r12
0013b185mov ecx, ebp
0013b187call hashbrown::map::HashMap<K,V,S,A>::insert
0013b18cmov rdi, r14
0013b18fcall core::ptr::drop_in_place<regex_automata::hybrid::dfa::StateSaver>
0013b194mov [rbx+24], 2
0013b19bmov [rbx+28], ebp
0013b19e
0013b19eloc_13b19e:
0013b19eadd rsp, 88
0013b1a2pop rbx
0013b1a3pop r12
0013b1a5pop r13
0013b1a7pop r14
0013b1a9pop r15
0013b1abpop rbp
0013b1acret
0013b1ad
0013b1adloc_13b1ad:
0013b1admov rdi, r13
0013b1b0call regex_automata::hybrid::dfa::LazyRef::quit_id
0013b1b5mov rcx, r14
0013b1b8mov r14l, eax
0013b1bblea r15, [rsp+40]
0013b1c0mov [r15], rcx
0013b1c3and [r15+8], 0
0013b1c8
0013b1c8loc_13b1c8:
0013b1c8mov rdi, r15
0013b1cbcall _<regex_automata::util::alphabet::ByteSetIter as core::iter::traits::iterator::Iterator>::next
0013b1d0test al, 1
0013b1d2je 0x13b152
0013b1d8movzx ecx, dl
0013b1dbshl ecx, 8
0013b1demov rdi, r13
0013b1e1mov rsi, rbx
0013b1e4mov edx, ebp
0013b1e6mov r8l, r14l
0013b1e9call regex_automata::hybrid::dfa::Lazy::set_transition
0013b1eejmp 0x13b1c8
0013b1f0
0013b1f0loc_13b1f0:
0013b1f0lea rdi, [rsp+24]
0013b1f5call core::ptr::drop_in_place<regex_automata::util::determinize::state::State>
0013b1falea rdi, [rip-0xe5775]
0013b201lea rcx, [rip+0xb2380]
0013b208lea r8, [rip+0xb2f59]
0013b20fpush 44
0013b211pop rsi
0013b212lea rdx, [rsp+40]
0013b217call core::result::unwrap_failed
0013b21cud2
0013b21e
0013b21eloc_13b21e:
0013b21elea rax, [rip+0xb2f5b]
0013b225lea rdi, [rsp+40]
0013b22amov [rdi], rax
0013b22dmov [rdi+8], 1
0013b235lea rax, [rip-0xa9f44]
0013b23cmov [rdi+16], rax
0013b240xorps x0, x0
0013b243movups [rdi+24], x0
0013b247lea rsi, [rip+0xb2f42]
0013b24ecall core::panicking::panic_fmt
0013b253ud2
0013b255
0013b255loc_13b255:
0013b255ud2
0013b257
0013b257 0f 0b ..
0013afb0

0013b259
0013b259regex_automata::hybrid::dfa::Cache::memory_usage:
0013b259mov rax, [rdi+88]
0013b25dmov rcx, [rdi+112]
0013b261imul rdx, [rdi+144], 20
0013b269shl rcx, 4
0013b26dadd rdx, rcx
0013b270add rax, [rdi+64]
0013b274add rax, [rdi+184]
0013b27badd rax, [rdi+208]
0013b282add rax, [rdi+240]
0013b289add rax, [rdi+264]
0013b290add rax, [rdi+288]
0013b297add rdx, [rdi+312]
0013b29eadd rdx, [rdi+328]
0013b2a5lea rax, [rdx+4*rax]
0013b2a9ret
0013b259

0013b2aa
0013b2aaregex_automata::hybrid::dfa::Cache::reset:
0013b2aapush r15
0013b2acpush r14
0013b2aepush rbx
0013b2afsub rsp, 16
0013b2b3mov rbx, rsi
0013b2b6mov r14, rdi
0013b2b9mov r15, rsp
0013b2bcmov [r15], rsi
0013b2bfmov [r15+8], rdi
0013b2c3add rdi, 24
0013b2c7call core::ptr::drop_in_place<regex_automata::hybrid::dfa::StateSaver>
0013b2ccand [r14+24], 0
0013b2d1mov rdi, r15
0013b2d4call regex_automata::hybrid::dfa::Lazy::clear_cache
0013b2d9lea rdi, [r14+168]
0013b2e0mov rax, [rbx+384]
0013b2e7mov rbx, [rax+328]
0013b2eemov rsi, rbx
0013b2f1call regex_automata::util::sparse_set::SparseSet::resize
0013b2f6lea rdi, [r14+224]
0013b2fdmov rsi, rbx
0013b300call regex_automata::util::sparse_set::SparseSet::resize
0013b305and [r14+336], 0
0013b30dand [r14], 0
0013b311add rsp, 16
0013b315pop rbx
0013b316pop r14
0013b318pop r15
0013b31aret
0013b2aa

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