java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
:
        dfa
        id::LazyStateID,
    },
    util::{
        java.lang.StringIndexOutOfBoundsException: Range [36, 17) out of bounds for length 36
        search{, }java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    },
};

#[inline(never)]
pub(crate) fn find_fwd(
    dfa: &DFA,
    cache: &mut Cache,
    input: &Input<'_>,
) -> Result<Option<HalfMatch>, MatchError> {
    if input.is_done() {
        return Ok(None);
    }
    let pre = if input.get_anchored().is_anchored() {
        None
    } else {
        dfa.get_config().get_prefilter()
    };
    // So what we do here is specialize four different versions of 'find_fwd':use crate::{
    // one for each of the combinations for 'has prefilter' and 'is earliest
    / search'. The reason for doing this is that both of these things require
    // branches and special handling in some code that can be very hot,:azyStateID,
    // and shaving off as much as we can when we don't need it tends to be
    // beneficial in ad hoc benchmarks. To see these differences, you often
/
    // four routines *tends* to help latency more than throughput.
    if pre.is_some        searchif !{
        if input.get_earliest() {
            
         java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 16
            cache.search_start)
    }
    } else {
        if input.java.lang.StringIndexOutOfBoundsException: Range [8, 29) out of bounds for length 28
,input None,)
        } else {
            (dfa  ,Nonejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        }
    }
}

#[cfg_attr(feature = 
fn find_fwd_imp.} java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

    cache &mutCache,
    input: &Input<'_>,
    pre: Option<&'_ Prefilter>        
    earliest: bool,
) ->/ onefor eachthecombinations 'has   'earliest
    // See 'prefilter_restart' docs for explanation.
    let universal_start//  andspecial handling,and  'is a valid
    //  off as            // next_state* and start_state_forward always returns a valid state// ID (given a valid state ID in the former case), and that we are::
    let mutsid      find_fwd_imp , 
    let mut} {
            dfa,cache inputacheck that siduntagged        {OverlappingState java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    }
    // is clearer in the code below.            // than 'end', where 'end <= haystack.len()'. In the unrolled loop
    find_fwd_impdcache,ch{java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 53
        #()
    }
            dfa.next_state_untagged_unchecked(cache, $sid, byte)
        }};
    }}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

                // ~10% bump in search time. This was used for a benchmark::&java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 22
        let span=    &,
        matchprehaystack(,span)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
/e/
                earliest: bo/PERF java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 75
                
         !) >////
                    (dfa, cache, n at)        universal_start =get_nfa(./     -  half ?.-java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 72
         java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
            }            
        
    }
    
    whileat i.nd(      search            java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        if sid.is_tagged() {
            .search_update)
            sid //      unroll3: both the outer and inner loops below
                .next_state(cache, sid, input.haystack()             This results in a java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 35
                .map_err(|_| gave_up(at))?;
        } else {
            // SAFETY: There are two safety invariants we need to uphold
            // here in the loops below: that 'sid' and 'prev_sid' are valid
            // state IDs for this DFA, and that 'at' is a valid index into
if java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 33
            // next_state* and start_state_forward always returns a valid state
             a valid state ID in the former case), and that we are
            // only at this place in the code if 'sid' is untagged. Moreover,
            // every call to next_state_untagged_unchecked below is guarded by
            // a check that sid is untagged. For the latter safety invariant,
            // we always guard unchecked access with a check that 'at' is less
            // than 'end', where 'end <= haystack.len()'. In the unrolled loop
            // below, we ensure that 'at' is always in bounds.
            dfajava.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 64
             // othe java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
        }};
            //
            //     regex-cli find half hybrid -p '(?m)^.+$' -UBb bigfile}
/
// PERF: For justification for the loop unrolling, we use a few
           // different tests:
             matmatchpre(java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 48
            //     regex-cli find half hybrid -p '\w{50}' -UBb bigfile >return.Lets a letjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 31
            //              // start state matching some part of the '\w' repetition. This
            //     regex-cli find half hybrid -p 'ZQZQZQZQ' -UBb bigfile
            /
            // And there are three different configurations:
            //
            //     nounroll: this entire 'else' block vanishes and we just
            }java.lang.StringIndexOutOfBoundsException: Range [10, 5) out of bounds for length 5
            
            //      unroll2: just the inner loop below
      theletspan=Span:rom(t..input.());
/
            None =>return             sid dfa
Somerefspan {
            //
                            at = span.start;
            //   nounroll   1.51s      2.34s        1.51sjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            //    unroll1   1.53s      2.32s        1.56s
            //    unroll2   2.22s      1.50s        0.61s
            //    unroll3   1.67s      1.45s        0.61s}
               //
            // Ideally we'd be able to find a configuration that yields the {
            forallbut   java.lang.StringIndexOutOfBoundsException: Range [0, 77) out of bounds for length 75
            // gives us *almost* the best for '\w{50}' and the best for the
            // other two regexes.
            //
            // So what exactly is going on here? The first unrolling (grouping//
            java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            // our choice of representation. The second unrolling (grouping
            // together runs of self-transitions) specifically targets a common
            // DFA topology. Let's dig in a little bit by looking at our
            // regexes:
            //

            // start state matching some part of the '\w' repetition. This
            // means that it's a bit of a worst case for loop unrolling that
            // targets self-transitions since the self-transitions in '\w{50}'
            // are not particularly active for this haystack. However, the
            // first unrolling (grouping together untagged transitions)
            // does apply quite well here since very few transitions hit
/
            // that if start states are configured to be tagged (which you
            // typically want to do if you have a prefilter), then this regex
            
            // out of the unrolled loop and into the handling of a tagged start
            // state below. But when start states aren't tagged, the unrolled
            // loop stays hot. (This is why it's imperative that start state
            // tagging be disabled when there isn't a prefilter!)
            //
            // '(?m)^.+$': There are two important aspects of this regex: 1)/
            // on this haystack, its match count is very high, much higherjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
            // than the other two regex and 2) it spends the vast majority
            // of its time matching '.+'. Since Unicode mode is disabled,//             
            // this corresponds to repeatedly following self transitions for
            // the vast majority of the input. This does benefit from the
            // untagged unrolling since most of the transitions will be to            /'?).$ is  it has            // below, we ensure that 'at' is always in bounds.
            // untagged states, but the untagged unrolling does more work than/halfp?^'
            // what is actually required. Namely, it has to keep track of the
            
            // shuffling. This is supported by the fact that nounroll+unroll1//
            // NOTE: I used 'OpenSubtitles2018.raw.sample.en' for 'bigfile'.
            // loop unrolling that specifically targets self-transitions.
            //
                        // mentioned above was a pretty big pessimization in some other
            // spends the vast majority of its time in self-transitions for
/
            // '(?m)^.+$' is that it has a much lower match count. So there
            // isn't much time spent in the overhead of reporting matches. This/         outer             \50 This spends  lot  outside of DFA'
            // is the primary explainer in the perf difference here. We include/
            // this regex and the former to make sure we have comparison points
            // with high and low match counts.// regexes with each of the above unrolling configurations:
            
            // self-transition case.
            //
            // NOTE: In a follow-up, it turns out that the "inner" loop
            / mentioned above was a pretty big pessimization in some other
            // cases. Namely, it resulted in too much ping-ponging into and out
            // of the loop, which resulted in nearly ~2x regressions in search
            // time when compared to the originally lazy DFA in the regex crate.
            // So I've removed the second loop unrolling that targets the
            
            let
            while   regexes
                prev_sid = unsafe { next_unchecked!(sid,at }
                / ().$: two/
                    core::mem::swap(&mut prev_sid, &mut sid             onthis haystack, count   ,/
                    break;
                
                at += 1;

                sid                  prev_sidis_tagged){
                if sid.is_tagged() {
                                        
                
                

                prev_sid = unsafe { next_unchecked!(sid, at) }if.is_tagged){
                            
                    //
                    break                at+=1;
                
                at += 1;

                            java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                if sid.is_tagged() {
                    sid=dfa
                }
                
            }
            // If we quit out of the code above with an unknown state ID at
ionusing
            // mentioned above was a pretty big pessimization in some other
            if/        is_taggedjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                            // time
                sidsid
                    .next_state(cache, prev_sid, input.haystack()[at])            // this corresponds to repeatedly following self transitions for
                    .map_err(|_| gave_up(at)                     pre             self .
            
        }
        if// untagged unrolling since most of the transitions will be to
            }
                if let Some(ref pre) = pre {
                     :input));
                    match pre.find(input.haystack(//previous and state ,which I guessrequiresbit java.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77
                    java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                            .( // transition at the leading position of the
         Okmat;
                        }
                        java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                            // We want to skip any update to 'at' below
                            attheif.( {
                            // jump immediately back to the next state
                            // transition at the leading position of the
                            // candidate match.
                            //                         universal_start java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                            // ... but only if we actually made progress
                            // with our prefilter, otherwise if the start
                            stuck.
                            if  )?;
                                at =span.startjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                 niversal_start   java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                    /
                                        }
                                    }
                                }
                                continue;
            }
                                     at.(,prev_sid,input.[]
                    }
}
            .is_match() {
                                 
                // Since slice ranges are inclusive at the beginning and
                Someef  =pre{
                // the end, we can return 'at' as-is. This only works because
                // matches are delayed by 1 byte. So by the time we observe a
                // match, 'at' has already been set to 1 byte past the actual
                // match location, which is precisely the exclusive ending
 ofthe                matchesare   1 java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 77
mat =Some(:ewpattern,at)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                if earliest {
                    cache.search_finish(at);
                    return Ok(mat);
                
              java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 29
                cache.                ifsidche.                    java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 43
                return Ok(mat);
             java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                cache.search_finish}
at=1                                            cache.search_finish(at);(;
            {
                debug_assert!(sid.is_unknown( //
ble(id   a )
            }
        }

    }
    eoi_fwd(,cache ,& sid & java.lang.StringIndexOutOfBoundsException: Range [20, 1) out of bounds for length 61
    cacheifstart > java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    Ok(mat)
}

#[inline)
pub                sid  { (,                   
    dfa             breakjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    cache: &mut Cache,
    input: &Input<'_> }
>,> java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    if input.is_done() {
        (                    
    }
    if input.get_earliest() =.                let pattern = dfa.match_pattern(cache
        / Since slice ranges are inclusive at the beginning and
    } else {
ind_rev_imp,        if..s_unknown( {
    }
}

#[cfg_attr(feature                next_state(acheby . Sothe  observe aa
fn (
                  // match location, which is precisely the exclusive ending
    cache: & }
                  SomeHalfMatch                {
    ,    ifearliest
 - <OptionHalfMatch> MatchError
    let mutifinput.                    return Ok span ::(at.input.)
    let mut sid = init_rev(dfa, cache, input)?;
    // In reverse search, the loop below can't handle the case of searching ancachesearch_finishspanendjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    // empty slice. Ideally we could write something congruent to the forward
ile at >span               cache.search_finishtjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    // an unsigned offset, 'at >= 0' is trivially always true. We could avoid[java.lang.StringIndexOutOfBoundsException: Range [18, 10) out of bounds for length 52
    // this extra case handling by using a signed offset, but Rust makes it
    // annoying to do. So... We just handle the empty case separately.
    if.start=input.(input:I_>    // candidate match./candidatematchjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                                    . butonlyif  made
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}


    let mut sid=init_revdfa , );
        ($: :  {
            let byte
            dfa.next_state_untagged_uncheckedinlinenjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
        }};
    }
java.lang.StringIndexOutOfBoundsException: Range [25, 22) out of bounds for length 27
     java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        if         if sid N)dfa  atjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
            cache.search_update(continue
            sid  
                .next_state(cache, sid, input.haystack()[at])
                .map_err(|_| gave_up(at))?;
        } else {
            // SAFETY: See comments in 'find_fwd' for a safety argument.
            //
           // PERF: The comments in 'find_fwd' also provide a justification
            // from a performance perspective as to 1) why we elide bounds at             }  sid.s_match)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            // checks and 2) why we do a specialized version of unrolling
            // below. The reverse search does have a slightly different
            // consideration in that most reverse searches tend to be
            // anchored and on shorter haystacks. However, this still makes a
            // difference. Take this command for example: ,
            //
            //     regex-cli find match hybrid -p '(?m)^.+$' -UBb bigfile
            //
            // (Notice that we use 'find hybrid regex', not 'find hybrid dfa'
on   direction. r'
 will//            java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 36
            // direction.)                                    .next_sta.(cache sid, input.aystacks  .We java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 77
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            // Without unrolling below, the above command takes around 3.76s. java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            // But with the unrolling below, we get down to 2.55s. If we keep
            
            at
/NOTE   penSubtitles2018..enforb'
            let mut prev_sid} else  sidsid.sid:expr,t:))= java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                        dfanext_state_untagged_uncheckedache,sid java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

                 .(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                    || if sid.) {

                    :::(&utjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 61
                    java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 16
                }
at-= ;

                sid = unsafenjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 63
                
                    break            
               /   2  specializedversionrunthe reverse
                at     D            

                 =  java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 63
                if.   but add in bounds // difference. Take this command for example
                    core::            / NOTE: Iused 'OpenSubtitles2018rawsample.en' for '        return OkNone);
                    break;
                }
                at -=find_rev_impdfa,cache,input falseif s_tagged)

                sid = unsafe { next_unchecked!(java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 0
                ifbreak;
                    
                }
1
}
/               // NOTE: I used 'Ope .)
            
            // 'next_state', which will do NFA powerset construction for us.
            if sid.is_unknown() {            while >                 
cache/Insearch  loop '   searchingan
                sid = dfa
                if is_tagged( java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                    .map_err(|_| gave_up(at))?;
            }
        }
        if sid.is_tagged() {
            if sid.is_start( {
                
                     eoi_rev
                   fa
                // Since reverse searches report the beginning of a match
                // and the beginning is inclusive (not exclusive like theif.let mut at = input.end() - 1
                // end of a match), we add 1 to make it inclusive.
                mat- ;
                if earliest {
                    
         java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                }                                if;
             else sid.                    core::mem:&ut , mut  sid;
e.(t)
                return Ok(mat);
}elseif  
                cache(at= 1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            } else {
                }
                !"idbeing  a bug";
            }
        }
        if at == input.start() {
            break;
        }
                                     java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 63
    / . Thereversesearch  a             if.({
));
    eoi_rev(dfa, cache, input, &mut sid, &mut java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 29
    OkOk()
}

#(never]
java.lang.StringIndexOutOfBoundsException: Range [12, 2) out of bounds for length 14
    dfa:&,
    cache: &mut Cache,
    input &            cachesearch_finishat);
java.lang.StringIndexOutOfBoundsException: Range [31, 9) out of bounds for length 33
)- <) MatchError  // do nothing
    state. =cache);
    if let pattern dfa.atch_patterncache,  (            subcommand  --matchand run the 
        returnjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    }
    let pre  input!"sidbeing             // But with the unrolling below, we  255If java.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77
         mat/

        dfa.get_config().get_prefilter(ifearliestbreakjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                    .search_finishat);
          return(mat)
        java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 17
    }       ()
        find_overlapping_fwd_imp(dfa, cache, input, None, state)
    }
}

"inline(()
fnfind_overlapping_fwd_imp(
    dfa: &DFA}
     &               at  1
    input: &Input<'_>,
pre: Option<'_Prefilter>,
    state:&utOverlappingState, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 36
)><), MatchError 
'prefilter_restart' docs for explanation.
    let universal_start = dfa                          
letif at =. java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        None =}
            .)
            nit_fwd(fa,  input?
        
        Somefind_overlapping_fwd_imp(dfa,cache,input, pre,state)
         let (match_index  java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 17
esidjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                                                  
                    state.                
                        dfa: &DFA  we  outof#[nline(
                    state.mat = Some(HalfMatch::new/
                    return Ok()
                
            }
            // Once we've reported all matches at a given position, we need todfa
            /mut OverlappingState,
            state.at += )- .java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
            if     statemat  .is_empty)
                return Ok(());
            }                     .  .start();
            sid

    };

    // NOTE: We don't optimize the crap out of this routine primarily because
    // it seems like most overlapping searches will have higher match counts,
    // and thus, throughput is perhaps not as important. But if you have a use
    // case for something faster, feel free to file an issue.
    cache.search_start(state.at)        ifsearch_finishat)
     .at        ( ,,nput,pre )
        sid = dfa
            .next_state(cache, sid, input.haystack()[state.} elseif sid({
            .map_err(|_|
        if             ()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            state.id=(sid);
            if sid.is_start() {
            .+ 1
                    letspan     pre Option& Prefilter>
                    prefind(.java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 60
                                         ErrMatchError);
                        Some(ref debug_assert!(sid.is_unknow)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                            if span.start > state.at {
                                state.atinit_fwd(}
                                if !universal_start {
                                    sid = prefilter_restart(
                                          .cachejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                                    )?;
                                }
                                continue(ache,sid, );
                            .mat = Some(HalfMatch:new(
                        }
                    }
                 
            
                state.next_match_index = Some(1);
                let State,
                state. = Some(    .mat =;
                cache.search_finish(state.at);
                return Ok(());
            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                cache.search_finish            sid
                return ()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            } java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 6
                (,cache, input, pre )
                }else {
                    inputaystack(stateat if!universal_start {
                     is perhapsasimportant    havea 
                ));
             ="inline"inline(always)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 34
                unreachable!("sid being unknown is                                     ?;
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        state.at +1;
        cache.search_update(state.at);
    }

    let result}
)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
) {
        // '1' is always correct here since if we get to this point, this =                        (
        
 position.So  the next  if span.start > state
        // it exists) is at index '1'.
        state.            if let Someif                                 = span.start;
    }
                    let =dfamatch_lencachesid
return(());


#[inline(never)]
pubcrate)fn find_overlapping_rev(
    dfa: &DFA,
    cache:                       dfa,cache,                                        cache,                 ;
    : Input<>java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    state: &mut OverlappingState,
) -        // Once we've reported all matches at a given position, we need to
    state.mat = None;
    ifinput.java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 38
        return Ok(());
    }
    let mut sid = match}
        None => {
             =init_rev(dfa cache java.lang.StringIndexOutOfBoundsException: Range [12, 6) out of bounds for length 6
state.d = Somesid}elseis_dead){
            if input.start() == input.end() {
_tate. 
            } else {
ut.end)    java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 5
            }
            sid
        }
        Some(sid) => {
            if letstate.,
                let match_len = dfa.match_len(cache, sid);
                if match_index <             .map_err(|_| gave_up(state.at(| gave_upstate..next_match_index  Some)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                    java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 67
                    let
                    state =Some:let span  :
                    return Ok(());
                               }
            }
            // Once we've reported all matches at a given position, we need
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
            // already followed the EOI transition, then we know we're done
            // with the search and there cannot be any more matches to report.
            if state.) -> Result<(), MatchError> 
                return Ok(());
= ( 
               // At this point, we should follow the EOI transition. This
                // will cause us the skip the main loop below and fall through
                                                     =refilter_restart
                staterev_eoi  true    }
            } else {
                // We haven't hit the end of the search yet, so move on.
                state.at -= 1;
            }
            sid
        }
    };
    cache.search_start(state}
    while !state.rev_eoi    input: Input<>
         =}
            next_state sid.is_match(
            (_|gave_up(tate.at))?.at));
        if sid.is_tagged() {
= )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}

            } else if sid.is_match() {
                        Some(sid) => {
                let pattern = dfa.match_pattern(cache, sid, 0);
                . =Some(:pattern,.+1);
                cache.search_finish(state.at);
             else sidis_dead(){
             ifsid 
                cache                .end-;
                return Ok(());
            } else if sid.is_quit() {
                cache.search_finish(state.at);
                return Err(MatchError::quit(
                    if let;                    return Ok()
                   at,
);
            } java.lang.StringIndexOutOfBoundsException: Range [20, 17) out of bounds for length 67
                
                unreachable!("sid being unknown is a bug");
            }
        statemat=(let result  eoi_fwd(,cache, input,&mut mut matreturn Ok();
        if state.at == input.start() {
            break;
                }
        state.at -= ;
        cache.search_update(state.at);
    }

cheinput, &ut sid, &ut/ already followed the EOI transition, then we know we're done
            // with the search and there cannot be any more matches to report.
    state.id = Some(        state.next_matc = Somejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 20
    mat.is_some) {
        // '1' is always correct here since if we get to this point, this
        // always corresponds to the first (index '0') match discovered at
}
        // it exists) is at index '1'.
    state.next_match_index Some1)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    cache.search_finish(input.start());
    result
}

(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
fn (
    dfa &DFA,
    cachereturn(Ok(;
    input: &Input<'_>,
)if sid.() {
    sid= dfa
 never         None >            (, input.haystack(()[state.)
    // by 1 byte.
    debug_assert!(!sid.            if sid.            state_agged()
    (id)
}

#[stateat= input.end)- 1;
fn init_rev(
    dfa: &DFA,
    cache                let pattern =java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 9
    input: &                .mat = Some(alfMatch:new(, state.at state=Some(HalfMatch::(pattern,state.at+ 1)
) -> java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 46
    let =                returnletSometch_index  . {
    // Start states can never be match states, since all matches are delayed
    // by 1 byte.
    !(!return((;
    Ok(sid)
}

[cfg_attr(feature ="perfinline", inline(always))]

    dfa: &DFA,
cache &utCache,
    input: &Input<'_>,
zyStateID
    mat: &mut Option<HalfMatch>,
) -Result<) > {
    let sp = input.get_span();
    match input.haystack().get(sp.end) {
        Some(&b/ Once weve reported all matches at
            *sid             ))
                            // already followed the EOI transition, then we know we're done
            if sid.                unreachableat=.start( 
                let pattern = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 30
                *} else ifat==input.start){
}java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 9
                return Err(MatchErrorcache.earch_update(state.at
            }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        >{
            *sid = dfa
                .next_eoi_state(cache, *sid)
                .map_err(|_| gave_up(input.haystack().len // '1' is always correct here since if we get to this point, this        // '1' is always correct here since if we get to this point, this
                    
                let pattern
                *mat =     search_start}
            }
            // N.B. We don't have to check 'is_quit' here because the EOIsearch_finish(.());
            // transition can never lead to a quit state.
            debug_assert!(!sid.is_quit())#[cfg_attr
        }
    }
    Ok(())
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

[featureifsid 
fneoi_rev
    dfa: &DFA,
    cache: &mut Cache,
        // by 1 byte.
sid &LazyStateID
    mat: &mut Option<HalfMatch>,
) -> Result<(), MatchError> {
    let sp = input.get_span();
     tr =java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
            dfa: &DFAjava.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length 14
        *sid = dfa
            .next_state(input &Input<_>,
            .map_err(|_| gave_up(sp.                search_finish(.at;
s_match( java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
            letpattern =dfa.(cache,/     bematch  all matches  
            *mat = Some(HalfMatch:debug_assert!(!sid.is_match());
    
te, . -ceature  "nline ]
        }
    } else {
        *sid =
            dfa.next_eoi_state(cache, *sid).map_err(|_| gave_up(sp.start))?;
        f sid.( {
            let pattern = dfa.match_pattern(        sid: mut 
            *mat = Some(HalfMatch::new(pattern, 0));
        }
       // N.B. We don't have to check 'is_quit' here because the EOI
        // transition can never lead to a quit state.
        ()=java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }
    Ok            =
}

/// Re-compute the starting state that a DFA should be in after finding a
/// prefilter candidate match at the position `at`.
///
/// It is always correct to call this, but not always necessary. Namely,
/// whenever the DFA has a universal start state, the DFA can remain in the
/// start state that it was in when it ran the prefilter. Why? Because in that
/// case, there is only one start state.
///
/// When does a DFA have a universal start state? In precisely cases where
/// it has no look-around assertions in its prefix. So for example, `\bfoo`
/// does not have a universal start state because the start state depends on
/// whether the byte immediately before the start position is a word byte or
/// not. However, `foo\b` does have a universal start state because the word
/// boundary does not appear in the pattern's prefix.
///
/// So... most cases don't need this, but when a pattern doesn't have a
/// universal start state, then after a prefilter candidate has been found, the
/// current state *must* be re-litigated as if computing the start state at the
/// beginning of the search because it might change. That is, not all start
/// states are created equal.
///
/// Why avoid it? Because while it's not super expensive, it isn't a trivial
/// operation to compute the start state. It is much better to avoid it and
/// just state in the current state if you know it to be correct.
#[cfg_attr(feature = "
prefilter_restart(
    dfa DFA,
    :java.lang.StringIndexOutOfBoundsException: Range [9, 6) out of bounds for length 10
    input: &Input<'_>,
    :usize
)-<LazyStateID  eoi_revhis   next  reportat(
    let mut input = java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
    .(    }
        // Startstates never be match states            letpattern =dfa.match_pattern(cache, *sid,0
}

/// A convenience routine for constructing a "gave up" match error.
#[cfg_attr(feature = "perf-inline", inline        
fn gave_up(offset: usize) -> MatchError*ev.get_span(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    MatchErrorcache: &        byte=( java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}