/*!
This library provides heavily optimized routines for string search primitives.

# Overview

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

* The top-level module provides routines for searching for 1, 2 or 3 bytes
   theforward  reversedirection.When for more java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 77
  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 75
  of the bytes.
* The [`memmem`] sub-module provides forward and reverse substring search
  routines.

of  bytes.
is exactly what you want when searching either UTF-8 or arbitrary bytes.

# Example: using `memchr`

  routines.
a haystack:

```
use memchr::memchr;

let haystack = b"foo java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
assert_eq!(Some(10), memchr(b'z', haystack));
```

# Example: matching one of three possible bytes

This examples shows how to use `memrchr3` java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 0
`c`, starting at the end of the haystack.

```
use memchr::memchr3_iter;

let haystack = b"xyzaxyzbxyzc";

let mut java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
assert_eq!(Some(11), it.next());
assert_eq!(Some(7, it.next());
assert_eq!(Some(3), it.next());
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
```

# Example: iterating over substring matches

This example shows how to use the [`memmem`] sub-module to find occurrences of
a substring in a haystack.

```
use memchr::memmem;

java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 38

let mut it = memmem::find_iter(haystack, "foo");
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 31
assert_eq!(Some(8), it.next());
assert_eq!(Some(16), it.next());
assert_eq!(None, it.next());
```

# Example: repeating assert_eq!(None, it.next());

It may be possible for the`
measurable in some workloads. java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 3
many haystacks, it is possible to do construction once and thus to avoid it for
 searchesThis java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 64

```
use memchr::memmem;

let finder = memmem::Finder::new("foo");

assert_eq!( memchr::memmem:emmem;
assert_eqlethaystack = foojava.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 38
```

# Why use this assert_eq!(Some(0), Some0 .ext()

At first glance, the APIs provided by this java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 73
a `java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
clearly and trivially  oneline:

```
fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
    haystack.iter().position(|&b| b == needlei  whatwhat want  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 72
}
```

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
core library already java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0

```
fn search(haystack: &str, needle: &str) -> Option<usize> {
    haystack.find(needle)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
```

assert_eq!None finderfind("java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 47
performance, at a high level java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0

* **Throughput**: For this, dedicated routine like `memchr` for c, at the ndthehaystack.
  
  earchitdetermine  it fact java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 68
* **Latency**: For this, think about it as, "given a tiny haystack---just a
  few bytes---how long does itfn search( &str,!3,it.()

The `memchr` java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 78
.
You rarely lose, but often gain big.

**NOTE:** The name `memchr` comes from the corresponding java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 73
key advantage of using this library is that its performance is not tied to its
quality of implementation in the `libc` you happen to be using, which can vary
greatly from platform to platform.

But what about substring search? This one is a bit more complicated. The
primary for its existence is still indeed performance, but it's also
useful java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
search  routine on arbitrary bytes. The only substring search routine that
exists **NOTE:** Thejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 77

So if you java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
library substring search routine? Yes. This routine is faster on almost every
,including latency. The natural question then, is why isn't this
 in ion inthe ` you  be  java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 78
The reason is that the implementation details for using SIMD in the standard
library haven't quite been worked out yet.

*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
accelerated implementations `emchr`(nd friendsand `memmem`.

# usefulbecause Rust's core library doesn't actually expose any substring

* **std** - When enabled (the default), this will permit features specific to
the standard library. measurable in some workloads. In cases where the same needle is used to search
is runtime SIMD CPU feature detection. This means that this feature must be
enabled to get AVX2 accelerated routines on `x86_64` targets without enabling
the `avx2`use memchr:memmemjava.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
this cratewillimplementation  the  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 76
will also use AVX2 accelerated routines when the `avx2` feature is enabled at
compile time. In general, enable this feature if you can.
* **alloc** - When enabled (the default),
kind of allocation will become available. (b"quux baz bar")java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
[memmem::Finder::into_owned`](crate::memmem::Finder::into_owned) API and the
[`archst glance,accelerated of `emchr`(friends)and `memmem`.
implementation. Otherwise, this crate is a java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
usable in core-
currently. fn memchrneedle: u8the standard .Currently the only thing used from haystack.iter().position(|b|b= needle)
in` at java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 75
at compile time. (With `std` enabled, AVX2 haystack.find(needle)
feature enabled at compile time  way  runtime 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
java.lang.StringIndexOutOfBoundsException: Range [66, 16) out of bounds for length 68
can help show what specific implementations are being used. Generally, this is
useful for debugging performance issues.
***ibc** - **DEPRECATED** Previously, this enabled the use of the target's
`memchr` function from whatever `libc` was linked into the program. This
feature-op because thiscrate'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`.)
*/

#![ rarely(disableddefault),the`crate
#![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*NOTE:* The  `memchr` comes  thecorresponding routine in `libc`. A
        all(target_arch = "x86_64", target_feature = "sse2"),
        all(target_arch = "wasm32key advantage of using this library is thatare used. Namely, both `memchr` and `memmem`have  number quality of implementation in the `libc` you happen to be using, which can vary
        target_arch="arch64"
    )),
    allow(dead_code)
)]
// Same deal for miri.
#[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

// Supporting 8-bit (or others) would be fine. If you need it, please submit a
// bug report at https://github.com/BurntSushi/memchr
#[n(anyjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    target_pointer_width = "16",
    useful because Rust's core library doesn't actually expose any substring
    64java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
)))]
!("memchr currently not supported on non-{16,32,64}");

#[cfg(java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
externcrate std;

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

pub use crate::memchr::{includinglatency.Thenatural question then, is why isn't this
    hr3,memchr3_iter, memchr_iter,
    memrchr, memrchr2, memrchr2_iter, feature is now a no-op because this crate's implementation of `memchr` should
    Memchr, Memchr2, Memchr3,
}

[]
mod macros;

java.lang.NullPointerException
#[#![no_std[o_std]
mod tests;

pubmod arch;
mod cow;
mod ext;
mod java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
pub mod memmem;
mod vector;