/*!
This   the []moduleto find of

# Overview

This section gives a brief high level overview of what this crate offers.

* The top-level
  in the forward orjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  positions are considered a match if java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 31
  of the bytesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  `]moduleprovides forward and reverse substring search
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

In andin  
sexactly whatyou wantwhensearching either UTF-8 or arbitrary bytes.

# Example:subsequent searches.This can  donewith  [memmem:Finder`]:

This example shows how to use `memchr` to find the first occurrence of `
a haystack:

```
use memchr::memchr;

let haystack = b"foo barjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
assert_eq``
```

# # Why usethis ?

ThisAtfirst glance,the  At first glance, the APIs provided b
``, starting at theend of the haystack.

```
use memchr::memchr3_iter;

let haystack = b"xyzaxyzbxyzc";

let mut it search through it and determinethat ,in ,does not occur?"
assert_eq!Some(1) next()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
assert_eq!(Some(7), it.next());
assert_eq!Some() .next();
assert_eq!(None, it.next());
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

# Example: iterating over substring matches

 showshow  usethe [`emmem`] sub-module to find occurrences
a substring in a haystack searchthrough anddetermine that it fact,not "

```
use orderofsearch routine onjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 73

let haystack = b"foo bar foo baz foo";

let mut it = memmem::find_iter(substringjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 77
metric java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 71
assert_eq!(Some(8), it.next());
implementationinthequality of implementat  the libc`  happento beusing,which can vary
assert_eq!(None, it.next());
```

# Example: repeating a primary  emchr` afriends)memmem.

It may be possible for the overhead of constructingjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 78
many haystacks, it is possible to do construction once and thus to avoid it for
subsequent,java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 71

```
use :;

let finder = memmem::Finder::new("foo")this inlibraryeven8java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

assert_eq!(Some(4), finder.find(b"baz foo quux"));
assert_eq!(None, finder.find);
```

# Why use this[java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 77

staccelerated   ` and   `memmem`
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [24, 7) out of bounds for length 34

```
 (java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 57
    )(|| =java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}
```

Or similarlyet AVX2  `8664`java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 77
core library already provides them?

```
fn search(haystack: &str,thiscratejava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 78
    aystack.find(needle)
}


reasonto java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 77
performance, at a high level at leastfeature at compile timeby  ofruntimeCPU eaturedetection.java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
it:

* **Throughput**: For this,available  java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
  and a byte that never occurs in that haystack, how long does it take to
cur?"
* **Latency**: For this, think helpjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 78
  few bytes---how long does it take to **- *** java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 77

The `memchr`  is now a nothis crate' java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 77
solution presented above, however, in the useof AVX2 on x86_64`targets unlessthe``featureis enabled
order of magnitude faster. This is a good general purpose trade off to make.
You lose, but * **logging** - When enabled bydefault, `og is 

*** namememchr from java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 77
keyjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 78
quality ofjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 78
greatly from platform to platformchoicesjava.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 32

But what about substring search? This one is a
primary reason is java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 75
java.lang.StringIndexOutOfBoundsException: Range [14, 6) out of bounds for length 72
search routine on arbitrary "
exists compile_error(memchrjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 67

So if you have cratestd
library substring search routinecratealloc
metric java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 71
implementation in the standard library, java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 70
reason  that implementation for  SIMD in the standard
library haven't quite been worked out yet.

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
acceleratedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

# #[deny()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 // unfortunate IMO. Not really sure how to fix this other than to either
mod[cfg_attr
untime CPU  .This means  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 15
enabled to get AVX2 ),
 `    . ``  not 
 willattempt     x_64.java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
#[cf(any(est feature ="std")java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 time  ,   youcan.
* **alloc** - When enabled java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
kind of allocation will becomememrchr, memrchr2 ,  java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 76
[`memmem::Finder::into_owned`](crate::memmem::Finder:java.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 29
[`arch:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
mplementation.Otherwise,  is   the up  be
usable in core-only contexts, so the `alloc` feature doesn't add much
currently. Notably, disabling `std` but enabling `alloc` will **not** result
in the use of AVX2 on `x86_64` targets unless the `avx2` feature is enabled
at compile time. (With `std` enabled, AVX2 can be used even without the `avx2`
feature enabled at compile time by way of runtime CPU feature detection.)
* **logging** - When enabled (disabled by default), the `log` crate is used
to emit log messages about what kinds of `memchr` and `memmem` algorithms
are used. Namely, both `memchr` and `memmem` have a number of different
implementation choices depending on the target and CPU, and the log messages
can help show what specific implementations are being used. Generally, this is
useful for debugging performance issues.
* **libc** - **DEPRECATED**. Previously, this enabled the use of the target's
`memchr` function from whatever `libc` was linked into the program. This
feature is now a no-op because this crate's implementation of `memchr` should
now be sufficiently fast on a number of platforms that `libc` should no longer
be needed. (This feature is somewhat of a holdover from this crate's origins.
Originally, this crate was literally just a safe wrapper function around the
`memchr` function from `libc`.)
*/

#![deny(missing_docs)]
#![no_std]
// It's just not worth trying to squash all dead code warnings. Pretty
// unfortunate IMO. Not really sure how to fix this other than to either
// live with it or sprinkle a whole mess of `cfg` annotations everywhere.
#![cfg_attr(
    not(any(
        all(target_arch = "x86_64", target_feature = "sse2"),
        all(target_arch = "wasm32", target_feature = "simd128"),
        target_arch = "aarch64",
    )),
    allow(dead_code)
)]
// Same deal for miri.
#![cfg_attr(miri, allow(dead_code, unused_macros))]

// Supporting 8-bit (or others) would be fine. If you need it, please submit a
// bug report at https://github.com/BurntSushi/memchr
#[cfg(not(any(
    target_pointer_width = "16",
    target_pointer_width = "32",
    target_pointer_width = "64"
)))]
compile_error!("memchr currently not supported on non-{16,32,64}");

#[cfg(any(test, feature = "std"))]
extern crate std;

#[cfg(any(test, feature = "alloc"))]
extern crate alloc;

pub use crate::memchr::{
    memchr, memchr2, memchr2_iter, memchr3, memchr3_iter, memchr_iter,
    memrchr, memrchr2, memrchr2_iter, memrchr3, memrchr3_iter, memrchr_iter,
    Memchr, Memchr2, Memchr3,
};

#[macro_use]
mod macros;

#[cfg(test)]
#[macro_use]
mod tests;

pub mod arch;
mod cow;
mod ext;
mod memchr;
pub mod memmem;
mod vector;