Revert "set gitattributes for rust & cargo so hashes dont conflict on Windows"

This reverts commit 032dc5c108195f6bbc2e224f00da5b785df4b7f9.

zeroidc/.gitattributes

@@ -1,7 +0,0 @@
-* text=auto
-* text eol=lf
-*.vcxproj eol=crlf
-*.vcxproj.filters eol=crlf
-*.a binary
-*.lib binary
-

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.both.c

@@ -1,11 +1,11 @@
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-typedef struct Dummy {
-  int32_t x;
-  float y;
-} Dummy;
-
-void root(struct Dummy d);
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct Dummy {
+  int32_t x;
+  float y;
+} Dummy;
+
+void root(struct Dummy d);

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.both.compat.c

@@ -1,19 +1,19 @@
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-typedef struct Dummy {
-  int32_t x;
-  float y;
-} Dummy;
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-void root(struct Dummy d);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct Dummy {
+  int32_t x;
+  float y;
+} Dummy;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct Dummy d);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.c

@@ -1,11 +1,11 @@
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-typedef struct {
-  int32_t x;
-  float y;
-} Dummy;
-
-void root(Dummy d);
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+  int32_t x;
+  float y;
+} Dummy;
+
+void root(Dummy d);

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.compat.c

@@ -1,19 +1,19 @@
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-typedef struct {
-  int32_t x;
-  float y;
-} Dummy;
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-void root(Dummy d);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct {
+  int32_t x;
+  float y;
+} Dummy;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(Dummy d);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.cpp

@@ -1,16 +1,16 @@
-#include <cstdarg>
-#include <cstdint>
-#include <cstdlib>
-#include <ostream>
-#include <new>
-
-struct Dummy {
-  int32_t x;
-  float y;
-};
-
-extern "C" {
-
-void root(Dummy d);
-
-} // extern "C"
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+struct Dummy {
+  int32_t x;
+  float y;
+};
+
+extern "C" {
+
+void root(Dummy d);
+
+} // extern "C"

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.pyx

@@ -1,13 +1,13 @@
-from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
-from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
-cdef extern from *:
-  ctypedef bint bool
-  ctypedef struct va_list
-
-cdef extern from *:
-
-  ctypedef struct Dummy:
-    int32_t x;
-    float y;
-
-  void root(Dummy d);
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef struct Dummy:
+    int32_t x;
+    float y;
+
+  void root(Dummy d);

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.tag.c

@@ -1,11 +1,11 @@
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-struct Dummy {
-  int32_t x;
-  float y;
-};
-
-void root(struct Dummy d);
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct Dummy {
+  int32_t x;
+  float y;
+};
+
+void root(struct Dummy d);

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.tag.compat.c

@@ -1,19 +1,19 @@
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-struct Dummy {
-  int32_t x;
-  float y;
-};
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-void root(struct Dummy d);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+struct Dummy {
+  int32_t x;
+  float y;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct Dummy d);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

zeroidc/vendor/cbindgen/tests/expectations/linestyle_crlf.tag.pyx

@@ -1,13 +1,13 @@
-from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
-from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
-cdef extern from *:
-  ctypedef bint bool
-  ctypedef struct va_list
-
-cdef extern from *:
-
-  cdef struct Dummy:
-    int32_t x;
-    float y;
-
-  void root(Dummy d);
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  cdef struct Dummy:
+    int32_t x;
+    float y;
+
+  void root(Dummy d);

zeroidc/vendor/generic-array/CHANGELOG.md

@@ -1,93 +1,93 @@
-* **`0.14.5`**
-    * Fix unsoundness behavior in `GenericArrayIter::clone` ([#120](https://github.com/fizyk20/generic-array/pull/120))
-
-* **`0.14.4`**
-    * Update `typenum` to `1.12.0`
-    * Make `Drop` a no-op when the inner type does not require `Drop` (using `core::mem::needs_drop`)
-
-* **`0.14.3`**
-    * Improve behavior of `GenericArray::from_exact_iter` to assume `ExactIterator`s can lie.
-    * Fix alignment of zero-length `GenericArray`s
-    * Implement `From<&[T; N]> for &GenericArray<T, N>` and its mutable variant
-
-* **`0.14.2`**
-    * Lower MSRV to `1.36.0` without `From<[T; N]>` implementations.
-
-* **`0.14.1`**
-    * Fix element conversions in `arr!` macro.
-
-* **`0.14.0`**
-    * Replace `Into` implementations with the more general `From`.
-        * Requires minumum Rust version of 1.41.0
-    * Fix unsoundness in `arr!` macro.
-    * Fix meta variable misuse
-    * Fix Undefined Behavior across the crate by switching to `MaybeUninit`
-    * Improve some documentation and doctests
-    * Add `AsRef<[T; N]>` and `AsMut<[T; N]>` impls to `GenericArray<T, N>`
-    * Add `Split` impl for `&GenericArray` and `&mut GenericArray`
-
-* **`0.13.2`**
-    * Add feature `more_lengths`, which adds more `From`/`Into` implementations for arrays of various lengths.
-
-* **`0.13.1`**
-    * Mark `GenericArray` as `#[repr(transparent)]`
-    * Implement `Into<[T; N]>` for `GenericArray<T, N>` up to N=32
-
-* **`0.13.0`**
-    * Allow `arr!` to be imported with use syntax.
-        * Requires minumum Rust version of 1.30.1
-
-* **`0.12.2`**
-    * Implement `FusedIterator` for `GenericArrayIter`
-
-* **`0.12.1`**
-    * Use internal iteration where possible and provide more efficient internal iteration methods.
-
-* **`0.12.0`**
-    * Allow trailing commas in `arr!` macro.
-    * **BREAKING**: Serialize `GenericArray` using `serde` tuples, instead of variable-length sequences. This may not be compatible with old serialized data.
-
-* **`0.11.0`**
-    * **BREAKING** Redesign `GenericSequence` with an emphasis on use in generic type parameters.
-    * Add `MappedGenericSequence` and `FunctionalSequence`
-        * Implements optimized `map`, `zip` and `fold` for `GenericArray`, `&GenericArray` and `&mut GenericArray`
-    * **BREAKING** Remove `map_ref`, `zip_ref` and `map_slice`
-        * `map_slice` is now equivalent to `GenericArray::from_iter(slice.iter().map(...))`
-* **`0.10.0`**
-    * Add `GenericSequence`, `Lengthen`, `Shorten`, `Split` and `Concat` traits.
-    * Redefine `transmute` to avert errors.
-* **`0.9.0`**
-    * Rewrite construction methods to be well-defined in panic situations, correctly dropping elements.
-    * `NoDrop` crate replaced by `ManuallyDrop` as it became stable in Rust core.
-    * Add optimized `map`/`map_ref` and `zip`/`zip_ref` methods to `GenericArray`
-* **`0.8.0`**
-    * Implement `AsRef`, `AsMut`, `Borrow`, `BorrowMut`, `Hash` for `GenericArray`
-    * Update `serde` to `1.0`
-    * Update `typenum`
-    * Make macro `arr!` non-cloning
-    * Implement `From<[T; N]>` up to `N=32`
-    * Fix #45
-* **`0.7.0`**
-    * Upgrade `serde` to `0.9`
-    * Make `serde` with `no_std`
-    * Implement `PartialOrd`/`Ord` for `GenericArray`
-* **`0.6.0`**
-    * Fixed #30
-    * Implement `Default` for `GenericArray`
-    * Implement `LowerHex` and `UpperHex` for `GenericArray<u8, N>`
-    * Use `precision` formatting field in hex representation
-    * Add `as_slice`, `as_mut_slice`
-    * Remove `GenericArray::new` in favor of `Default` trait
-    * Add `from_slice` and `from_mut_slice`
-    * `no_std` and `core` for crate.
-* **`0.5.0`**
-    * Update `serde`
-    * remove `no_std` feature, fixed #19
-* **`0.4.0`**
-    * Re-export `typenum`
-* **`0.3.0`**
-    * Implement `IntoIter` for `GenericArray`
-    * Add `map` method
-    * Add optional `serde` (de)serialization support feature.
-* **`< 0.3.0`**
-    * Initial implementation in late 2015
+* **`0.14.5`**
+    * Fix unsoundness behavior in `GenericArrayIter::clone` ([#120](https://github.com/fizyk20/generic-array/pull/120))
+
+* **`0.14.4`**
+    * Update `typenum` to `1.12.0`
+    * Make `Drop` a no-op when the inner type does not require `Drop` (using `core::mem::needs_drop`)
+
+* **`0.14.3`**
+    * Improve behavior of `GenericArray::from_exact_iter` to assume `ExactIterator`s can lie.
+    * Fix alignment of zero-length `GenericArray`s
+    * Implement `From<&[T; N]> for &GenericArray<T, N>` and its mutable variant
+
+* **`0.14.2`**
+    * Lower MSRV to `1.36.0` without `From<[T; N]>` implementations.
+
+* **`0.14.1`**
+    * Fix element conversions in `arr!` macro.
+
+* **`0.14.0`**
+    * Replace `Into` implementations with the more general `From`.
+        * Requires minumum Rust version of 1.41.0
+    * Fix unsoundness in `arr!` macro.
+    * Fix meta variable misuse
+    * Fix Undefined Behavior across the crate by switching to `MaybeUninit`
+    * Improve some documentation and doctests
+    * Add `AsRef<[T; N]>` and `AsMut<[T; N]>` impls to `GenericArray<T, N>`
+    * Add `Split` impl for `&GenericArray` and `&mut GenericArray`
+
+* **`0.13.2`**
+    * Add feature `more_lengths`, which adds more `From`/`Into` implementations for arrays of various lengths.
+
+* **`0.13.1`**
+    * Mark `GenericArray` as `#[repr(transparent)]`
+    * Implement `Into<[T; N]>` for `GenericArray<T, N>` up to N=32
+
+* **`0.13.0`**
+    * Allow `arr!` to be imported with use syntax.
+        * Requires minumum Rust version of 1.30.1
+
+* **`0.12.2`**
+    * Implement `FusedIterator` for `GenericArrayIter`
+
+* **`0.12.1`**
+    * Use internal iteration where possible and provide more efficient internal iteration methods.
+
+* **`0.12.0`**
+    * Allow trailing commas in `arr!` macro.
+    * **BREAKING**: Serialize `GenericArray` using `serde` tuples, instead of variable-length sequences. This may not be compatible with old serialized data.
+
+* **`0.11.0`**
+    * **BREAKING** Redesign `GenericSequence` with an emphasis on use in generic type parameters.
+    * Add `MappedGenericSequence` and `FunctionalSequence`
+        * Implements optimized `map`, `zip` and `fold` for `GenericArray`, `&GenericArray` and `&mut GenericArray`
+    * **BREAKING** Remove `map_ref`, `zip_ref` and `map_slice`
+        * `map_slice` is now equivalent to `GenericArray::from_iter(slice.iter().map(...))`
+* **`0.10.0`**
+    * Add `GenericSequence`, `Lengthen`, `Shorten`, `Split` and `Concat` traits.
+    * Redefine `transmute` to avert errors.
+* **`0.9.0`**
+    * Rewrite construction methods to be well-defined in panic situations, correctly dropping elements.
+    * `NoDrop` crate replaced by `ManuallyDrop` as it became stable in Rust core.
+    * Add optimized `map`/`map_ref` and `zip`/`zip_ref` methods to `GenericArray`
+* **`0.8.0`**
+    * Implement `AsRef`, `AsMut`, `Borrow`, `BorrowMut`, `Hash` for `GenericArray`
+    * Update `serde` to `1.0`
+    * Update `typenum`
+    * Make macro `arr!` non-cloning
+    * Implement `From<[T; N]>` up to `N=32`
+    * Fix #45
+* **`0.7.0`**
+    * Upgrade `serde` to `0.9`
+    * Make `serde` with `no_std`
+    * Implement `PartialOrd`/`Ord` for `GenericArray`
+* **`0.6.0`**
+    * Fixed #30
+    * Implement `Default` for `GenericArray`
+    * Implement `LowerHex` and `UpperHex` for `GenericArray<u8, N>`
+    * Use `precision` formatting field in hex representation
+    * Add `as_slice`, `as_mut_slice`
+    * Remove `GenericArray::new` in favor of `Default` trait
+    * Add `from_slice` and `from_mut_slice`
+    * `no_std` and `core` for crate.
+* **`0.5.0`**
+    * Update `serde`
+    * remove `no_std` feature, fixed #19
+* **`0.4.0`**
+    * Re-export `typenum`
+* **`0.3.0`**
+    * Implement `IntoIter` for `GenericArray`
+    * Add `map` method
+    * Add optional `serde` (de)serialization support feature.
+* **`< 0.3.0`**
+    * Initial implementation in late 2015

zeroidc/vendor/generic-array/DESIGN.md

@@ -1,585 +1,585 @@
-Design and Usage Notes
-======================
-
-## Sections
-
-1. [How it Works](#how-it-works)
-2. [Initialization](#initialization)
-3. [Functional Programming](#functional-programming)
-4. [Miscellaneous Utilities](#miscellaneous-utilities)
-5. [Safety](#safety)
-6. [Optimization](#optimization)
-7. [The Future](#the-future)
-
-**NOTE**: This document uses `<details>` sections, so look out for collapsible parts with an arrow on the left.
-
-# How it works
-
-`generic-array` is a method of achieving fixed-length fixed-size stack-allocated generic arrays without needing const generics in stable Rust.
-
-That is to say this:
-
-```rust
-struct Foo<const N: usize> {
-    data: [i32; N],
-}
-```
-
-or anything similar is not currently supported.
-
-However, Rust's type system is sufficiently advanced, and a "hack" for solving this was created in the form of the `typenum` crate, which recursively defines integer values in binary as nested types, and operations which can be applied to those type-numbers, such as `Add`, `Sub`, etc.
-
-e.g. `6` would be `UInt<UInt<UInt<UTerm, B1>, B1>, B0>`
-
-Over time, I've come to see `typenum` as less of a hack and more as an elegant solution.
-
-The recursive binary nature of `typenum` is what makes `generic-array` possible, so:
-
-```rust
-struct Foo<N: ArrayLength<i32>> {
-    data: GenericArray<i32, N>,
-}
-```
-
-is supported.
-
-I often see questions about why `ArrayLength` requires the element type `T` in it's signature, even though it's not used in the inner `ArrayType`.
-
-This is because `GenericArray` itself does not define the actual array. Rather, it is defined as:
-
-```rust
-pub struct GenericArray<T, N: ArrayLength<T>> {
-    data: N::ArrayType,
-}
-```
-
-The trait `ArrayLength` does all the real heavy lifting for defining the data, with implementations on `UInt<N, B0>`, `UInt<N, B1>` and `UTerm`, which correspond to even, odd and zero numeric values, respectively.
-
-`ArrayLength`'s implementations use type-level recursion to peel away each least significant bit and form sort of an opaque binary tree of contiguous data the correct physical size to store `N` elements of `T`. The tree, or block of data, is then stored inside of `GenericArray` to be reinterpreted as the array.
-
-For example, `GenericArray<T, U6>` more or less expands to (at compile time):
-
-<details>
-<summary>Expand for code</summary>
-
-```rust
-GenericArray {
-    // UInt<UInt<UInt<UTerm, B1>, B1>, B0>
-    data: EvenData {
-        // UInt<UInt<UTerm, B1>, B1>
-        left: OddData {
-            // UInt<UTerm, B1>
-            left: OddData {
-                left: (),  // UTerm
-                right: (), // UTerm
-                data: T,   // Element 0
-            },
-            // UInt<UTerm, B1>
-            right: OddData {
-                left: (),  // UTerm
-                right: (), // UTerm
-                data: T,   // Element 1
-            },
-            data: T        // Element 2
-        },
-        // UInt<UInt<UTerm, B1>, B1>
-        right: OddData {
-            // UInt<UTerm, B1>
-            left: OddData {
-                left: (),  // UTerm
-                right: (), // UTerm
-                data: T,   // Element 3
-            },
-            // UInt<UTerm, B1>
-            right: OddData {
-                left: (),  // UTerm
-                right: (), // UTerm
-                data: T,   // Element 4
-            },
-            data: T        // Element 5
-        }
-    }
-}
-```
-
-</details>
-
-This has the added benefit of only being `log2(N)` deep, which is important for things like `Drop`, which we'll go into later.
-
-Then, we take `data` and cast it to `*const T` or `*mut T` and use it as a slice like:
-
-```rust
-unsafe {
-    slice::from_raw_parts(
-        self as *const Self as *const T,
-        N::to_usize()
-    )
-}
-```
-
-It is useful to note that because `typenum` is compile-time with nested generics, `to_usize`, even if it isn't a `const fn`, *does* expand to effectively `1 + 2 + 4 + 8 + ...` and so forth, which LLVM is smart enough to reduce to a single compile-time constant. This helps hint to the optimizers about things such as bounds checks.
-
-So, to reiterate, we're working with a raw block of contiguous memory the correct physical size to store `N` elements of `T`. It's really no different from how normal arrays are stored.
-
-## Pointer Safety
-
-Of course, casting pointers around and constructing blocks of data out of thin air is normal for C, but here in Rust we try to be a bit less prone to segfaults. Therefore, great care is taken to minimize casual `unsafe` usage and restrict `unsafe` to specific parts of the API, making heavy use those exposed safe APIs internally.
-
-For example, the above `slice::from_raw_parts` is only used twice in the entire library, once for `&[T]` and `slice::from_raw_parts_mut` once for `&mut [T]`. Everything else goes through those slices.
-
-# Initialization
-
-## Constant
-
-"Constant" initialization, that is to say - without dynamic values, can be done via the `arr![]` macro, which works almost exactly like `vec![]`, but with an additional type parameter.
-
-Example:
-
-```rust
-let my_arr = arr![i32; 1, 2, 3, 4, 5, 6, 7, 8];
-```
-
-## Dynamic
-
-Although some users have opted to use their own initializers, as of version `0.9` and beyond `generic-array` includes safe methods for initializing elements in the array.
-
-The `GenericSequence` trait defines a `generate` method which can be used like so:
-
-```rust
-use generic_array::{GenericArray, sequence::GenericSequence};
-
-let squares: GenericArray<i32, U4> =
-             GenericArray::generate(|i: usize| i as i32 * 2);
-```
-
-and `GenericArray` additionally implements `FromIterator`, although `from_iter` ***will*** panic if the number of elements is not *at least* `N`. It will ignore extra items.
-
-The safety of these operations is described later.
-
-# Functional Programming
-
-In addition to `GenericSequence`, this crate provides a `FunctionalSequence`, which allows extremely efficient `map`, `zip` and `fold` operations on `GenericArray`s.
-
-As described at the end of the [Optimization](#optimization) section, `FunctionalSequence` uses clever specialization tactics to provide optimized methods wherever possible, while remaining perfectly safe.
-
-Some examples, taken from `tests/generic.rs`:
-
-<details>
-<summary>Expand for code</summary>
-
-This is so extensive to show how you can build up to processing totally arbitrary sequences, but for the most part these can be used on `GenericArray` instances without much added complexity.
-
-```rust
-/// Super-simple fixed-length i32 `GenericArray`s
-pub fn generic_array_plain_zip_sum(a: GenericArray<i32, U4>, b: GenericArray<i32, U4>) -> i32 {
-    a.zip(b, |l, r| l + r)
-     .map(|x| x + 1)
-     .fold(0, |a, x| x + a)
-}
-
-pub fn generic_array_variable_length_zip_sum<N>(a: GenericArray<i32, N>, b: GenericArray<i32, N>) -> i32
-where
-    N: ArrayLength<i32>,
-{
-    a.zip(b, |l, r| l + r)
-     .map(|x| x + 1)
-     .fold(0, |a, x| x + a)
-}
-
-pub fn generic_array_same_type_variable_length_zip_sum<T, N>(a: GenericArray<T, N>, b: GenericArray<T, N>) -> i32
-where
-    N: ArrayLength<T> + ArrayLength<<T as Add<T>>::Output>,
-    T: Add<T, Output=i32>,
-{
-    a.zip(b, |l, r| l + r)
-     .map(|x| x + 1)
-     .fold(0, |a, x| x + a)
-}
-
-/// Complex example using fully generic `GenericArray`s with the same length.
-///
-/// It's mostly just the repeated `Add` traits, which would be present in other systems anyway.
-pub fn generic_array_zip_sum<A, B, N: ArrayLength<A> + ArrayLength<B>>(a: GenericArray<A, N>, b: GenericArray<B, N>) -> i32
-where
-    A: Add<B>,
-    N: ArrayLength<<A as Add<B>>::Output> +
-        ArrayLength<<<A as Add<B>>::Output as Add<i32>>::Output>,
-    <A as Add<B>>::Output: Add<i32>,
-    <<A as Add<B>>::Output as Add<i32>>::Output: Add<i32, Output=i32>,
-{
-    a.zip(b, |l, r| l + r)
-     .map(|x| x + 1)
-     .fold(0, |a, x| x + a)
-}
-```
-</details>
-
-and if you really want to go off the deep end and support any arbitrary *`GenericSequence`*:
-
-<details>
-<summary>Expand for code</summary>
-
-```rust
-/// Complex example function using generics to pass N-length sequences, zip them, and then map that result.
-///
-/// If used with `GenericArray` specifically this isn't necessary
-pub fn generic_sequence_zip_sum<A, B>(a: A, b: B) -> i32
-where
-    A: FunctionalSequence<i32>,                                                                 // `.zip`
-    B: FunctionalSequence<i32, Length = A::Length>,                                             // `.zip`
-    A: MappedGenericSequence<i32, i32>,                                                         // `i32` -> `i32`
-    B: MappedGenericSequence<i32, i32, Mapped = MappedSequence<A, i32, i32>>,                   // `i32` -> `i32`, prove A and B can map to the same output
-    A::Item: Add<B::Item, Output = i32>,                                                        // `l + r`
-    MappedSequence<A, i32, i32>: MappedGenericSequence<i32, i32> + FunctionalSequence<i32>,     // `.map`
-    SequenceItem<MappedSequence<A, i32, i32>>: Add<i32, Output=i32>,                            // `x + 1`
-    MappedSequence<MappedSequence<A, i32, i32>, i32, i32>: Debug,                               // `println!`
-    MappedSequence<MappedSequence<A, i32, i32>, i32, i32>: FunctionalSequence<i32>,             // `.fold`
-    SequenceItem<MappedSequence<MappedSequence<A, i32, i32>, i32, i32>>: Add<i32, Output=i32>   // `x + a`, note the order
-{
-    let c = a.zip(b, |l, r| l + r).map(|x| x + 1);
-
-    println!("{:?}", c);
-
-    c.fold(0, |a, x| x + a)
-}
-```
-
-of course, as I stated before, that's almost never necessary, especially when you know the concrete types of all the components.
-
-</details>
-
-The [`numeric-array`](https://crates.io/crates/numeric-array) crate uses these to apply numeric operations across all elements in a `GenericArray`, making full use of all the optimizations described in the last section here.
-
-# Miscellaneous Utilities
-
-Although not usually advertised, `generic-array` contains traits for lengthening, shortening, splitting and concatenating arrays.
-
-For example, these snippets are taken from `tests/mod.rs`:
-
-<details>
-<summary>Expand for code</summary>
-
-Appending and prepending elements:
-
-```rust
-use generic_array::sequence::Lengthen;
-
-#[test]
-fn test_append() {
-    let a = arr![i32; 1, 2, 3];
-
-    let b = a.append(4);
-
-    assert_eq!(b, arr![i32; 1, 2, 3, 4]);
-}
-
-#[test]
-fn test_prepend() {
-    let a = arr![i32; 1, 2, 3];
-
-    let b = a.prepend(4);
-
-    assert_eq!(b, arr![i32; 4, 1, 2, 3]);
-}
-```
-
-Popping elements from the front of back of the array:
-
-```rust
-use generic_array::sequence::Shorten;
-
-let a = arr![i32; 1, 2, 3, 4];
-
-let (init, last) = a.pop_back();
-
-assert_eq!(init, arr![i32; 1, 2, 3]);
-assert_eq!(last, 4);
-
-let (head, tail) = a.pop_front();
-
-assert_eq!(head, 1);
-assert_eq!(tail, arr![i32; 2, 3, 4]);
-```
-
-and of course concatenating and splitting:
-
-```rust
-use generic_array::sequence::{Concat, Split};
-
-let a = arr![i32; 1, 2];
-let b = arr![i32; 3, 4];
-
-let c = a.concat(b);
-
-assert_eq!(c, arr![i32; 1, 2, 3, 4]);
-
-let (d, e) = c.split();
-
-assert_eq!(d, arr![i32; 1]);
-assert_eq!(e, arr![i32; 2, 3, 4]);
-```
-</details>
-
-`Split` and `Concat` in these examples use type-inference to determine the lengths of the resulting arrays.
-
-# Safety
-
-As stated earlier, for raw reinterpretations such as this, safety is a must even while working with unsafe code. Great care is taken to reduce or eliminate undefined behavior.
-
-For most of the above code examples, the biggest potential undefined behavior hasn't even been applicable for one simple reason: they were all primitive values.
-
-The simplest way to lead into this is to post these questions:
-
-1. What if the element type of the array implements `Drop`?
-2. What if `GenericArray::generate` opens a bunch of files?
-3. What if halfway through opening each of the files, one is not found?
-4. What if the resulting error is unwrapped, causing the generation function to panic?
-
-For a fully initialized `GenericArray`, the expanded structure as described in the [How It Works](#how-it-works) can implement `Drop` naturally, recursively dropping elements. As it is only `log2(N)` deep, the recursion is very small overall.
-
-In fact, I tested it while writing this, the size of the array itself overflows the stack before any recursive calls to `drop` can.
-
-However, ***partially*** initialized arrays, such as described in the above hypothetical, pose an issue where `drop` could be called on uninitialized data, which is undefined behavior.
-
-To solve this, `GenericArray` implements two components named `ArrayBuilder` and `ArrayConsumer`, which work very similarly.
-
-`ArrayBuilder` creates a block of wholly uninitialized memory via `mem::unintialized()`, and stores that in a `ManuallyDrop` wrapper. `ManuallyDrop` does exactly what it says on the tin, and simply doesn't drop the value unless manually requested to.
-
-So, as we're initializing our array, `ArrayBuilder` keeps track of the current position through it, and if something happens, `ArrayBuilder` itself will iteratively and manually `drop` all currently initialized elements, ignoring any uninitialized ones, because those are just raw memory and should be ignored.
-
-`ArrayConsumer` does almost the same, "moving" values out of the array and into something else, like user code. It uses `ptr::read` to "move" the value out, and increments a counter saying that value is no longer valid in the array.
-
-If a panic occurs in the user code with that element, it's dropped naturally as it was moved into that scope. `ArrayConsumer` then proceeds to iteratively and manually `drop` all *remaining* elements.
-
-Combined, these two systems provide a safe system for building and consuming `GenericArray`s. In fact, they are used extensively inside the library itself for `FromIterator`, `GenericSequence` and `FunctionalSequence`, among others.
-
-Even `GenericArray`s implementation of `Clone` makes use of this via:
-
-```rust
-impl<T: Clone, N> Clone for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn clone(&self) -> GenericArray<T, N> {
-        self.map(|x| x.clone())
-    }
-}
-```
-
-where `.map` is from the `FunctionalSequence`, and uses those builder and consumer structures to safely move and initialize values. Although, in this particular case, a consumer is not necessary as we're using references. More on how that is automatically deduced is described in the next section.
-
-# Optimization
-
-Rust and LLVM is smart. Crazy smart. However, it's not magic.
-
-In my experience, most of Rust's "zero-cost" abstractions stem more from the type system, rather than explicit optimizations. Most Rust code is very easily optimizable and inlinable by design, so it can be simplified and compacted rather well, as opposed to the spaghetti code of some other languages.
-
-Unfortunately, unless `rustc` or LLVM can "prove" things about code to simplify it, it must still be run, and can prevent further optimization.
-
-A great example of this, and why I created the `GenericSequence` and `FunctionalSequence` traits, are iterators.
-
-Custom iterators are slow. Not terribly slow, but slow enough to prevent some rather important optimizations.
-
-Take `GenericArrayIter` for example:
-
-<details>
-<summary>Expand for code</summary>
-
-```rust
-pub struct GenericArrayIter<T, N: ArrayLength<T>> {
-    array: ManuallyDrop<GenericArray<T, N>>,
-    index: usize,
-    index_back: usize,
-}
-
-impl<T, N> Iterator for GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        if self.index < self.index_back {
-            let p = unsafe {
-                Some(ptr::read(self.array.get_unchecked(self.index)))
-            };
-
-            self.index += 1;
-
-            p
-        } else {
-            None
-        }
-    }
-
-    //and more
-}
-```
-</details>
-
-Seems simple enough, right? Move an element out of the array with `ptr::read` and increment the index. If the iterator is dropped, the remaining elements are dropped exactly as they would with `ArrayConsumer`. `index_back` is provided for `DoubleEndedIterator`.
-
-Unfortunately, that single `if` statement is terrible. In my mind, this is one of the biggest flaws of the iterator design. A conditional jump on a mutable variable unrelated to the data we are accessing on each call foils the optimizer and generates suboptimal code for the above iterator, even when we use `get_unchecked`.
-
-The optimizer is unable to see that we are simply accessing memory sequentially. In fact, almost all iterators are like this. Granted, this is usually fine and, especially if they have to handle errors, it's perfectly acceptable.
-
-However, there is one iterator in the standard library that is optimized perfectly: the slice iterator. So perfectly in fact that it allows the optimizer to do something even more special: **auto-vectorization**! We'll get to that later.
-
-It's a bit frustrating as to *why* slice iterators can be so perfectly optimized, and it basically boils down to that the iterator itself does not own the data the slice refers to, so it uses raw pointers to the array/sequence/etc. rather than having to use an index on a stack allocated and always moving array. It can check for if the iterator is empty by comparing some `front` and `back` pointers for equality, and because those directly correspond to the position in memory of the next element, LLVM can see that and make optimizations.
-
-So, the gist of that is: always use slice iterators where possible.
-
-Here comes the most important part of all of this: `ArrayBuilder` and `ArrayConsumer` don't iterate the arrays themselves. Instead, we use slice iterators (immutable and mutable), with `zip` or `enumerate`, to apply operations to the entire array, incrementing the position in both `ArrayBuilder` or `ArrayConsumer` to keep track.
-
-For example, `GenericSequence::generate` for `GenericArray` is:
-
-<details>
-<summary>Expand for code</summary>
-
-```rust
-fn generate<F>(mut f: F) -> GenericArray<T, N>
-where
-    F: FnMut(usize) -> T,
-{
-    unsafe {
-        let mut destination = ArrayBuilder::new();
-
-        {
-            let (destination_iter, position) = destination.iter_position();
-
-            for (i, dst) in destination_iter.enumerate() {
-                ptr::write(dst, f(i));
-
-                *position += 1;
-            }
-        }
-
-        destination.into_inner()
-    }
-}
-```
-
-where `ArrayBuilder::iter_position` is just an internal convenience function:
-
-```rust
-pub unsafe fn iter_position(&mut self) -> (slice::IterMut<T>, &mut usize) {
-    (self.array.iter_mut(), &mut self.position)
-}
-```
-</details>
-
-Of course, this may appear to be redundant, if we're using an iterator that keeps track of the position itself, and the builder is also keeping track of the position. However, the two are decoupled.
-
-If the generation function doesn't have a chance at panicking, and/or the array element type doesn't implement `Drop`, the optimizer deems the `Drop` implementation on `ArrayBuilder` (and `ArrayConsumer`) dead code, and therefore `position` is never actually read from, so it becomes dead code as well, and is removed.
-
-So for simple non-`Drop`/non-panicking elements and generation functions, `generate` becomes a very simple loop that uses a slice iterator to write values to the array.
-
-Next, let's take a look at a more complex example where this *really* shines: `.zip`
-
-To cut down on excessively verbose code, `.zip` uses `FromIterator` for building the array, which has almost identical code to `generate`, so it will be omitted.
-
-The first implementation of `.zip` is defined as:
-
-<details>
-<summary>Expand for code</summary>
-
-```rust
-fn inverted_zip<B, U, F>(
-    self,
-    lhs: GenericArray<B, Self::Length>,
-    mut f: F,
-) -> MappedSequence<GenericArray<B, Self::Length>, B, U>
-where
-    GenericArray<B, Self::Length>:
-        GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
-    Self: MappedGenericSequence<T, U>,
-    Self::Length: ArrayLength<B> + ArrayLength<U>,
-    F: FnMut(B, Self::Item) -> U,
-{
-    unsafe {
-        let mut left = ArrayConsumer::new(lhs);
-        let mut right = ArrayConsumer::new(self);
-
-        let (left_array_iter, left_position) = left.iter_position();
-        let (right_array_iter, right_position) = right.iter_position();
-
-        FromIterator::from_iter(left_array_iter.zip(right_array_iter).map(|(l, r)| {
-            let left_value = ptr::read(l);
-            let right_value = ptr::read(r);
-
-            *left_position += 1;
-            *right_position += 1;
-
-            f(left_value, right_value)
-        }))
-    }
-}
-```
-</details>
-
-The gist of this is that we have two `GenericArray` instances that need to be zipped together and mapped to a new sequence. This employs two `ArrayConsumer`s, and more or less use the same pattern as the previous example.
-
-Again, the position values can be optimized out, and so can the slice iterator adapters.
-
-We can go a step further with this, however.
-
-Consider this:
-
-```rust
-let a = arr![i32; 1, 3, 5, 7];
-let b = arr![i32; 2, 4, 6, 8];
-
-let c = a.zip(b, |l, r| l + r);
-
-assert_eq!(c, arr![i32; 3, 7, 11, 15]);
-```
-
-when compiled with:
-
-```
-cargo rustc --lib --profile test --release -- -C target-cpu=native -C opt-level=3 --emit asm
-```
-
-will produce assembly with the following relevant instructions taken from the entire program:
-
-```asm
-; Copy constant to register
-vmovaps  __xmm@00000007000000050000000300000001(%rip), %xmm0
-
-; Copy constant to register
-vmovaps  __xmm@00000008000000060000000400000002(%rip), %xmm0
-
-; Add the two values together
-vpaddd   192(%rsp), %xmm0, %xmm1
-
-; Copy constant to register
-vmovaps  __xmm@0000000f0000000b0000000700000003(%rip), %xmm0
-
-; Compare result of the addition with the last constant
-vpcmpeqb 128(%rsp), %xmm0, %xmm0
-```
-
-so, aside from a bunch of obvious hygiene instructions around those selected instructions,
-it seriously boils down that `.zip` call to a ***SINGLE*** SIMD instruction. In fact, it continues to do this for even larger arrays. Although it does fall back to individual additions for fewer than four elements, as it can't fit those into an SSE register evenly.
-
-Using this property of auto-vectorization without sacrificing safety, I created the [`numeric-array`](https://crates.io/crates/numeric-array) crate which makes use of this to wrap `GenericArray` and implement numeric traits so that almost *all* operations can be auto-vectorized, even complex ones like fused multiple-add.
-
-It doesn't end there, though. You may have noticed that the function name for zip above wasn't `zip`, but `inverted_zip`.
-
-This is because `generic-array` employs a clever specialization tactic to ensure `.zip` works corrects with:
-
-1. `a.zip(b, ...)`
-2. `(&a).zip(b, ...)`
-3. `(&a).zip(&b, ...)`
-4. `a.zip(&b, ...)`
-
-wherein `GenericSequence` and `FunctionalSequence` have default implementations of `zip` variants, with concrete implementations for `GenericArray`. As `GenericSequence` is implemented for `&GenericArray`, where calling `into_iter` on produces a slice iterator, it can use "naive" iterator adapters to the same effect, while the specialized implementations use `ArrayConsumer`.
-
-The result is that any combination of move or reference calls to `.zip`, `.map` and `.fold` produce code that can be optimized, none of them falling back to slow non-slice iterators. All perfectly safe with the `ArrayBuilder` and `ArrayConsumer` systems.
-
-Honestly, `GenericArray` is better than standard arrays at this point.
-
-# The Future
-
+Design and Usage Notes
+======================
+
+## Sections
+
+1. [How it Works](#how-it-works)
+2. [Initialization](#initialization)
+3. [Functional Programming](#functional-programming)
+4. [Miscellaneous Utilities](#miscellaneous-utilities)
+5. [Safety](#safety)
+6. [Optimization](#optimization)
+7. [The Future](#the-future)
+
+**NOTE**: This document uses `<details>` sections, so look out for collapsible parts with an arrow on the left.
+
+# How it works
+
+`generic-array` is a method of achieving fixed-length fixed-size stack-allocated generic arrays without needing const generics in stable Rust.
+
+That is to say this:
+
+```rust
+struct Foo<const N: usize> {
+    data: [i32; N],
+}
+```
+
+or anything similar is not currently supported.
+
+However, Rust's type system is sufficiently advanced, and a "hack" for solving this was created in the form of the `typenum` crate, which recursively defines integer values in binary as nested types, and operations which can be applied to those type-numbers, such as `Add`, `Sub`, etc.
+
+e.g. `6` would be `UInt<UInt<UInt<UTerm, B1>, B1>, B0>`
+
+Over time, I've come to see `typenum` as less of a hack and more as an elegant solution.
+
+The recursive binary nature of `typenum` is what makes `generic-array` possible, so:
+
+```rust
+struct Foo<N: ArrayLength<i32>> {
+    data: GenericArray<i32, N>,
+}
+```
+
+is supported.
+
+I often see questions about why `ArrayLength` requires the element type `T` in it's signature, even though it's not used in the inner `ArrayType`.
+
+This is because `GenericArray` itself does not define the actual array. Rather, it is defined as:
+
+```rust
+pub struct GenericArray<T, N: ArrayLength<T>> {
+    data: N::ArrayType,
+}
+```
+
+The trait `ArrayLength` does all the real heavy lifting for defining the data, with implementations on `UInt<N, B0>`, `UInt<N, B1>` and `UTerm`, which correspond to even, odd and zero numeric values, respectively.
+
+`ArrayLength`'s implementations use type-level recursion to peel away each least significant bit and form sort of an opaque binary tree of contiguous data the correct physical size to store `N` elements of `T`. The tree, or block of data, is then stored inside of `GenericArray` to be reinterpreted as the array.
+
+For example, `GenericArray<T, U6>` more or less expands to (at compile time):
+
+<details>
+<summary>Expand for code</summary>
+
+```rust
+GenericArray {
+    // UInt<UInt<UInt<UTerm, B1>, B1>, B0>
+    data: EvenData {
+        // UInt<UInt<UTerm, B1>, B1>
+        left: OddData {
+            // UInt<UTerm, B1>
+            left: OddData {
+                left: (),  // UTerm
+                right: (), // UTerm
+                data: T,   // Element 0
+            },
+            // UInt<UTerm, B1>
+            right: OddData {
+                left: (),  // UTerm
+                right: (), // UTerm
+                data: T,   // Element 1
+            },
+            data: T        // Element 2
+        },
+        // UInt<UInt<UTerm, B1>, B1>
+        right: OddData {
+            // UInt<UTerm, B1>
+            left: OddData {
+                left: (),  // UTerm
+                right: (), // UTerm
+                data: T,   // Element 3
+            },
+            // UInt<UTerm, B1>
+            right: OddData {
+                left: (),  // UTerm
+                right: (), // UTerm
+                data: T,   // Element 4
+            },
+            data: T        // Element 5
+        }
+    }
+}
+```
+
+</details>
+
+This has the added benefit of only being `log2(N)` deep, which is important for things like `Drop`, which we'll go into later.
+
+Then, we take `data` and cast it to `*const T` or `*mut T` and use it as a slice like:
+
+```rust
+unsafe {
+    slice::from_raw_parts(
+        self as *const Self as *const T,
+        N::to_usize()
+    )
+}
+```
+
+It is useful to note that because `typenum` is compile-time with nested generics, `to_usize`, even if it isn't a `const fn`, *does* expand to effectively `1 + 2 + 4 + 8 + ...` and so forth, which LLVM is smart enough to reduce to a single compile-time constant. This helps hint to the optimizers about things such as bounds checks.
+
+So, to reiterate, we're working with a raw block of contiguous memory the correct physical size to store `N` elements of `T`. It's really no different from how normal arrays are stored.
+
+## Pointer Safety
+
+Of course, casting pointers around and constructing blocks of data out of thin air is normal for C, but here in Rust we try to be a bit less prone to segfaults. Therefore, great care is taken to minimize casual `unsafe` usage and restrict `unsafe` to specific parts of the API, making heavy use those exposed safe APIs internally.
+
+For example, the above `slice::from_raw_parts` is only used twice in the entire library, once for `&[T]` and `slice::from_raw_parts_mut` once for `&mut [T]`. Everything else goes through those slices.
+
+# Initialization
+
+## Constant
+
+"Constant" initialization, that is to say - without dynamic values, can be done via the `arr![]` macro, which works almost exactly like `vec![]`, but with an additional type parameter.
+
+Example:
+
+```rust
+let my_arr = arr![i32; 1, 2, 3, 4, 5, 6, 7, 8];
+```
+
+## Dynamic
+
+Although some users have opted to use their own initializers, as of version `0.9` and beyond `generic-array` includes safe methods for initializing elements in the array.
+
+The `GenericSequence` trait defines a `generate` method which can be used like so:
+
+```rust
+use generic_array::{GenericArray, sequence::GenericSequence};
+
+let squares: GenericArray<i32, U4> =
+             GenericArray::generate(|i: usize| i as i32 * 2);
+```
+
+and `GenericArray` additionally implements `FromIterator`, although `from_iter` ***will*** panic if the number of elements is not *at least* `N`. It will ignore extra items.
+
+The safety of these operations is described later.
+
+# Functional Programming
+
+In addition to `GenericSequence`, this crate provides a `FunctionalSequence`, which allows extremely efficient `map`, `zip` and `fold` operations on `GenericArray`s.
+
+As described at the end of the [Optimization](#optimization) section, `FunctionalSequence` uses clever specialization tactics to provide optimized methods wherever possible, while remaining perfectly safe.
+
+Some examples, taken from `tests/generic.rs`:
+
+<details>
+<summary>Expand for code</summary>
+
+This is so extensive to show how you can build up to processing totally arbitrary sequences, but for the most part these can be used on `GenericArray` instances without much added complexity.
+
+```rust
+/// Super-simple fixed-length i32 `GenericArray`s
+pub fn generic_array_plain_zip_sum(a: GenericArray<i32, U4>, b: GenericArray<i32, U4>) -> i32 {
+    a.zip(b, |l, r| l + r)
+     .map(|x| x + 1)
+     .fold(0, |a, x| x + a)
+}
+
+pub fn generic_array_variable_length_zip_sum<N>(a: GenericArray<i32, N>, b: GenericArray<i32, N>) -> i32
+where
+    N: ArrayLength<i32>,
+{
+    a.zip(b, |l, r| l + r)
+     .map(|x| x + 1)
+     .fold(0, |a, x| x + a)
+}
+
+pub fn generic_array_same_type_variable_length_zip_sum<T, N>(a: GenericArray<T, N>, b: GenericArray<T, N>) -> i32
+where
+    N: ArrayLength<T> + ArrayLength<<T as Add<T>>::Output>,
+    T: Add<T, Output=i32>,
+{
+    a.zip(b, |l, r| l + r)
+     .map(|x| x + 1)
+     .fold(0, |a, x| x + a)
+}
+
+/// Complex example using fully generic `GenericArray`s with the same length.
+///
+/// It's mostly just the repeated `Add` traits, which would be present in other systems anyway.
+pub fn generic_array_zip_sum<A, B, N: ArrayLength<A> + ArrayLength<B>>(a: GenericArray<A, N>, b: GenericArray<B, N>) -> i32
+where
+    A: Add<B>,
+    N: ArrayLength<<A as Add<B>>::Output> +
+        ArrayLength<<<A as Add<B>>::Output as Add<i32>>::Output>,
+    <A as Add<B>>::Output: Add<i32>,
+    <<A as Add<B>>::Output as Add<i32>>::Output: Add<i32, Output=i32>,
+{
+    a.zip(b, |l, r| l + r)
+     .map(|x| x + 1)
+     .fold(0, |a, x| x + a)
+}
+```
+</details>
+
+and if you really want to go off the deep end and support any arbitrary *`GenericSequence`*:
+
+<details>
+<summary>Expand for code</summary>
+
+```rust
+/// Complex example function using generics to pass N-length sequences, zip them, and then map that result.
+///
+/// If used with `GenericArray` specifically this isn't necessary
+pub fn generic_sequence_zip_sum<A, B>(a: A, b: B) -> i32
+where
+    A: FunctionalSequence<i32>,                                                                 // `.zip`
+    B: FunctionalSequence<i32, Length = A::Length>,                                             // `.zip`
+    A: MappedGenericSequence<i32, i32>,                                                         // `i32` -> `i32`
+    B: MappedGenericSequence<i32, i32, Mapped = MappedSequence<A, i32, i32>>,                   // `i32` -> `i32`, prove A and B can map to the same output
+    A::Item: Add<B::Item, Output = i32>,                                                        // `l + r`
+    MappedSequence<A, i32, i32>: MappedGenericSequence<i32, i32> + FunctionalSequence<i32>,     // `.map`
+    SequenceItem<MappedSequence<A, i32, i32>>: Add<i32, Output=i32>,                            // `x + 1`
+    MappedSequence<MappedSequence<A, i32, i32>, i32, i32>: Debug,                               // `println!`
+    MappedSequence<MappedSequence<A, i32, i32>, i32, i32>: FunctionalSequence<i32>,             // `.fold`
+    SequenceItem<MappedSequence<MappedSequence<A, i32, i32>, i32, i32>>: Add<i32, Output=i32>   // `x + a`, note the order
+{
+    let c = a.zip(b, |l, r| l + r).map(|x| x + 1);
+
+    println!("{:?}", c);
+
+    c.fold(0, |a, x| x + a)
+}
+```
+
+of course, as I stated before, that's almost never necessary, especially when you know the concrete types of all the components.
+
+</details>
+
+The [`numeric-array`](https://crates.io/crates/numeric-array) crate uses these to apply numeric operations across all elements in a `GenericArray`, making full use of all the optimizations described in the last section here.
+
+# Miscellaneous Utilities
+
+Although not usually advertised, `generic-array` contains traits for lengthening, shortening, splitting and concatenating arrays.
+
+For example, these snippets are taken from `tests/mod.rs`:
+
+<details>
+<summary>Expand for code</summary>
+
+Appending and prepending elements:
+
+```rust
+use generic_array::sequence::Lengthen;
+
+#[test]
+fn test_append() {
+    let a = arr![i32; 1, 2, 3];
+
+    let b = a.append(4);
+
+    assert_eq!(b, arr![i32; 1, 2, 3, 4]);
+}
+
+#[test]
+fn test_prepend() {
+    let a = arr![i32; 1, 2, 3];
+
+    let b = a.prepend(4);
+
+    assert_eq!(b, arr![i32; 4, 1, 2, 3]);
+}
+```
+
+Popping elements from the front of back of the array:
+
+```rust
+use generic_array::sequence::Shorten;
+
+let a = arr![i32; 1, 2, 3, 4];
+
+let (init, last) = a.pop_back();
+
+assert_eq!(init, arr![i32; 1, 2, 3]);
+assert_eq!(last, 4);
+
+let (head, tail) = a.pop_front();
+
+assert_eq!(head, 1);
+assert_eq!(tail, arr![i32; 2, 3, 4]);
+```
+
+and of course concatenating and splitting:
+
+```rust
+use generic_array::sequence::{Concat, Split};
+
+let a = arr![i32; 1, 2];
+let b = arr![i32; 3, 4];
+
+let c = a.concat(b);
+
+assert_eq!(c, arr![i32; 1, 2, 3, 4]);
+
+let (d, e) = c.split();
+
+assert_eq!(d, arr![i32; 1]);
+assert_eq!(e, arr![i32; 2, 3, 4]);
+```
+</details>
+
+`Split` and `Concat` in these examples use type-inference to determine the lengths of the resulting arrays.
+
+# Safety
+
+As stated earlier, for raw reinterpretations such as this, safety is a must even while working with unsafe code. Great care is taken to reduce or eliminate undefined behavior.
+
+For most of the above code examples, the biggest potential undefined behavior hasn't even been applicable for one simple reason: they were all primitive values.
+
+The simplest way to lead into this is to post these questions:
+
+1. What if the element type of the array implements `Drop`?
+2. What if `GenericArray::generate` opens a bunch of files?
+3. What if halfway through opening each of the files, one is not found?
+4. What if the resulting error is unwrapped, causing the generation function to panic?
+
+For a fully initialized `GenericArray`, the expanded structure as described in the [How It Works](#how-it-works) can implement `Drop` naturally, recursively dropping elements. As it is only `log2(N)` deep, the recursion is very small overall.
+
+In fact, I tested it while writing this, the size of the array itself overflows the stack before any recursive calls to `drop` can.
+
+However, ***partially*** initialized arrays, such as described in the above hypothetical, pose an issue where `drop` could be called on uninitialized data, which is undefined behavior.
+
+To solve this, `GenericArray` implements two components named `ArrayBuilder` and `ArrayConsumer`, which work very similarly.
+
+`ArrayBuilder` creates a block of wholly uninitialized memory via `mem::unintialized()`, and stores that in a `ManuallyDrop` wrapper. `ManuallyDrop` does exactly what it says on the tin, and simply doesn't drop the value unless manually requested to.
+
+So, as we're initializing our array, `ArrayBuilder` keeps track of the current position through it, and if something happens, `ArrayBuilder` itself will iteratively and manually `drop` all currently initialized elements, ignoring any uninitialized ones, because those are just raw memory and should be ignored.
+
+`ArrayConsumer` does almost the same, "moving" values out of the array and into something else, like user code. It uses `ptr::read` to "move" the value out, and increments a counter saying that value is no longer valid in the array.
+
+If a panic occurs in the user code with that element, it's dropped naturally as it was moved into that scope. `ArrayConsumer` then proceeds to iteratively and manually `drop` all *remaining* elements.
+
+Combined, these two systems provide a safe system for building and consuming `GenericArray`s. In fact, they are used extensively inside the library itself for `FromIterator`, `GenericSequence` and `FunctionalSequence`, among others.
+
+Even `GenericArray`s implementation of `Clone` makes use of this via:
+
+```rust
+impl<T: Clone, N> Clone for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn clone(&self) -> GenericArray<T, N> {
+        self.map(|x| x.clone())
+    }
+}
+```
+
+where `.map` is from the `FunctionalSequence`, and uses those builder and consumer structures to safely move and initialize values. Although, in this particular case, a consumer is not necessary as we're using references. More on how that is automatically deduced is described in the next section.
+
+# Optimization
+
+Rust and LLVM is smart. Crazy smart. However, it's not magic.
+
+In my experience, most of Rust's "zero-cost" abstractions stem more from the type system, rather than explicit optimizations. Most Rust code is very easily optimizable and inlinable by design, so it can be simplified and compacted rather well, as opposed to the spaghetti code of some other languages.
+
+Unfortunately, unless `rustc` or LLVM can "prove" things about code to simplify it, it must still be run, and can prevent further optimization.
+
+A great example of this, and why I created the `GenericSequence` and `FunctionalSequence` traits, are iterators.
+
+Custom iterators are slow. Not terribly slow, but slow enough to prevent some rather important optimizations.
+
+Take `GenericArrayIter` for example:
+
+<details>
+<summary>Expand for code</summary>
+
+```rust
+pub struct GenericArrayIter<T, N: ArrayLength<T>> {
+    array: ManuallyDrop<GenericArray<T, N>>,
+    index: usize,
+    index_back: usize,
+}
+
+impl<T, N> Iterator for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    type Item = T;
+
+    #[inline]
+    fn next(&mut self) -> Option<T> {
+        if self.index < self.index_back {
+            let p = unsafe {
+                Some(ptr::read(self.array.get_unchecked(self.index)))
+            };
+
+            self.index += 1;
+
+            p
+        } else {
+            None
+        }
+    }
+
+    //and more
+}
+```
+</details>
+
+Seems simple enough, right? Move an element out of the array with `ptr::read` and increment the index. If the iterator is dropped, the remaining elements are dropped exactly as they would with `ArrayConsumer`. `index_back` is provided for `DoubleEndedIterator`.
+
+Unfortunately, that single `if` statement is terrible. In my mind, this is one of the biggest flaws of the iterator design. A conditional jump on a mutable variable unrelated to the data we are accessing on each call foils the optimizer and generates suboptimal code for the above iterator, even when we use `get_unchecked`.
+
+The optimizer is unable to see that we are simply accessing memory sequentially. In fact, almost all iterators are like this. Granted, this is usually fine and, especially if they have to handle errors, it's perfectly acceptable.
+
+However, there is one iterator in the standard library that is optimized perfectly: the slice iterator. So perfectly in fact that it allows the optimizer to do something even more special: **auto-vectorization**! We'll get to that later.
+
+It's a bit frustrating as to *why* slice iterators can be so perfectly optimized, and it basically boils down to that the iterator itself does not own the data the slice refers to, so it uses raw pointers to the array/sequence/etc. rather than having to use an index on a stack allocated and always moving array. It can check for if the iterator is empty by comparing some `front` and `back` pointers for equality, and because those directly correspond to the position in memory of the next element, LLVM can see that and make optimizations.
+
+So, the gist of that is: always use slice iterators where possible.
+
+Here comes the most important part of all of this: `ArrayBuilder` and `ArrayConsumer` don't iterate the arrays themselves. Instead, we use slice iterators (immutable and mutable), with `zip` or `enumerate`, to apply operations to the entire array, incrementing the position in both `ArrayBuilder` or `ArrayConsumer` to keep track.
+
+For example, `GenericSequence::generate` for `GenericArray` is:
+
+<details>
+<summary>Expand for code</summary>
+
+```rust
+fn generate<F>(mut f: F) -> GenericArray<T, N>
+where
+    F: FnMut(usize) -> T,
+{
+    unsafe {
+        let mut destination = ArrayBuilder::new();
+
+        {
+            let (destination_iter, position) = destination.iter_position();
+
+            for (i, dst) in destination_iter.enumerate() {
+                ptr::write(dst, f(i));
+
+                *position += 1;
+            }
+        }
+
+        destination.into_inner()
+    }
+}
+```
+
+where `ArrayBuilder::iter_position` is just an internal convenience function:
+
+```rust
+pub unsafe fn iter_position(&mut self) -> (slice::IterMut<T>, &mut usize) {
+    (self.array.iter_mut(), &mut self.position)
+}
+```
+</details>
+
+Of course, this may appear to be redundant, if we're using an iterator that keeps track of the position itself, and the builder is also keeping track of the position. However, the two are decoupled.
+
+If the generation function doesn't have a chance at panicking, and/or the array element type doesn't implement `Drop`, the optimizer deems the `Drop` implementation on `ArrayBuilder` (and `ArrayConsumer`) dead code, and therefore `position` is never actually read from, so it becomes dead code as well, and is removed.
+
+So for simple non-`Drop`/non-panicking elements and generation functions, `generate` becomes a very simple loop that uses a slice iterator to write values to the array.
+
+Next, let's take a look at a more complex example where this *really* shines: `.zip`
+
+To cut down on excessively verbose code, `.zip` uses `FromIterator` for building the array, which has almost identical code to `generate`, so it will be omitted.
+
+The first implementation of `.zip` is defined as:
+
+<details>
+<summary>Expand for code</summary>
+
+```rust
+fn inverted_zip<B, U, F>(
+    self,
+    lhs: GenericArray<B, Self::Length>,
+    mut f: F,
+) -> MappedSequence<GenericArray<B, Self::Length>, B, U>
+where
+    GenericArray<B, Self::Length>:
+        GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
+    Self: MappedGenericSequence<T, U>,
+    Self::Length: ArrayLength<B> + ArrayLength<U>,
+    F: FnMut(B, Self::Item) -> U,
+{
+    unsafe {
+        let mut left = ArrayConsumer::new(lhs);
+        let mut right = ArrayConsumer::new(self);
+
+        let (left_array_iter, left_position) = left.iter_position();
+        let (right_array_iter, right_position) = right.iter_position();
+
+        FromIterator::from_iter(left_array_iter.zip(right_array_iter).map(|(l, r)| {
+            let left_value = ptr::read(l);
+            let right_value = ptr::read(r);
+
+            *left_position += 1;
+            *right_position += 1;
+
+            f(left_value, right_value)
+        }))
+    }
+}
+```
+</details>
+
+The gist of this is that we have two `GenericArray` instances that need to be zipped together and mapped to a new sequence. This employs two `ArrayConsumer`s, and more or less use the same pattern as the previous example.
+
+Again, the position values can be optimized out, and so can the slice iterator adapters.
+
+We can go a step further with this, however.
+
+Consider this:
+
+```rust
+let a = arr![i32; 1, 3, 5, 7];
+let b = arr![i32; 2, 4, 6, 8];
+
+let c = a.zip(b, |l, r| l + r);
+
+assert_eq!(c, arr![i32; 3, 7, 11, 15]);
+```
+
+when compiled with:
+
+```
+cargo rustc --lib --profile test --release -- -C target-cpu=native -C opt-level=3 --emit asm
+```
+
+will produce assembly with the following relevant instructions taken from the entire program:
+
+```asm
+; Copy constant to register
+vmovaps  __xmm@00000007000000050000000300000001(%rip), %xmm0
+
+; Copy constant to register
+vmovaps  __xmm@00000008000000060000000400000002(%rip), %xmm0
+
+; Add the two values together
+vpaddd   192(%rsp), %xmm0, %xmm1
+
+; Copy constant to register
+vmovaps  __xmm@0000000f0000000b0000000700000003(%rip), %xmm0
+
+; Compare result of the addition with the last constant
+vpcmpeqb 128(%rsp), %xmm0, %xmm0
+```
+
+so, aside from a bunch of obvious hygiene instructions around those selected instructions,
+it seriously boils down that `.zip` call to a ***SINGLE*** SIMD instruction. In fact, it continues to do this for even larger arrays. Although it does fall back to individual additions for fewer than four elements, as it can't fit those into an SSE register evenly.
+
+Using this property of auto-vectorization without sacrificing safety, I created the [`numeric-array`](https://crates.io/crates/numeric-array) crate which makes use of this to wrap `GenericArray` and implement numeric traits so that almost *all* operations can be auto-vectorized, even complex ones like fused multiple-add.
+
+It doesn't end there, though. You may have noticed that the function name for zip above wasn't `zip`, but `inverted_zip`.
+
+This is because `generic-array` employs a clever specialization tactic to ensure `.zip` works corrects with:
+
+1. `a.zip(b, ...)`
+2. `(&a).zip(b, ...)`
+3. `(&a).zip(&b, ...)`
+4. `a.zip(&b, ...)`
+
+wherein `GenericSequence` and `FunctionalSequence` have default implementations of `zip` variants, with concrete implementations for `GenericArray`. As `GenericSequence` is implemented for `&GenericArray`, where calling `into_iter` on produces a slice iterator, it can use "naive" iterator adapters to the same effect, while the specialized implementations use `ArrayConsumer`.
+
+The result is that any combination of move or reference calls to `.zip`, `.map` and `.fold` produce code that can be optimized, none of them falling back to slow non-slice iterators. All perfectly safe with the `ArrayBuilder` and `ArrayConsumer` systems.
+
+Honestly, `GenericArray` is better than standard arrays at this point.
+
+# The Future
+
 If/when const generics land in stable Rust, my intention is to reorient this crate or create a new crate to provide traits and wrappers for standard arrays to provide the same safety and performance discussed above.

zeroidc/vendor/generic-array/LICENSE

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Bartłomiej Kamiński
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+The MIT License (MIT)
+
+Copyright (c) 2015 Bartłomiej Kamiński
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

zeroidc/vendor/generic-array/README.md

@@ -1,62 +1,62 @@
-[![Crates.io](https://img.shields.io/crates/v/generic-array.svg)](https://crates.io/crates/generic-array)
-[![Build Status](https://travis-ci.org/fizyk20/generic-array.svg?branch=master)](https://travis-ci.org/fizyk20/generic-array)
-# generic-array
-
-This crate implements generic array types for Rust.
-
-**Requires minumum Rust version of 1.36.0, or 1.41.0 for `From<[T; N]>` implementations**
-
-[Documentation](http://fizyk20.github.io/generic-array/generic_array/)
-
-## Usage
-
-The Rust arrays `[T; N]` are problematic in that they can't be used generically with respect to `N`, so for example this won't work:
-
-```rust
-struct Foo<N> {
-	data: [i32; N]
-}
-```
-
-**generic-array** defines a new trait `ArrayLength<T>` and a struct `GenericArray<T, N: ArrayLength<T>>`, which let the above be implemented as:
-
-```rust
-struct Foo<N: ArrayLength<i32>> {
-	data: GenericArray<i32, N>
-}
-```
-
-The `ArrayLength<T>` trait is implemented by default for [unsigned integer types](http://fizyk20.github.io/generic-array/typenum/uint/index.html) from [typenum](http://fizyk20.github.io/generic-array/typenum/index.html) crate:
-
-```rust
-use generic_array::typenum::U5;
-
-struct Foo<N: ArrayLength<i32>> {
-    data: GenericArray<i32, N>
-}
-
-fn main() {
-    let foo = Foo::<U5>{data: GenericArray::default()};
-}
-```
-
-For example, `GenericArray<T, U5>` would work almost like `[T; 5]`:
-
-```rust
-use generic_array::typenum::U5;
-
-struct Foo<T, N: ArrayLength<T>> {
-    data: GenericArray<T, N>
-}
-
-fn main() {
-    let foo = Foo::<i32, U5>{data: GenericArray::default()};
-}
-```
-
-In version 0.1.1 an `arr!` macro was introduced, allowing for creation of arrays as shown below:
-
-```rust
-let array = arr![u32; 1, 2, 3];
-assert_eq!(array[2], 3);
-```
+[![Crates.io](https://img.shields.io/crates/v/generic-array.svg)](https://crates.io/crates/generic-array)
+[![Build Status](https://travis-ci.org/fizyk20/generic-array.svg?branch=master)](https://travis-ci.org/fizyk20/generic-array)
+# generic-array
+
+This crate implements generic array types for Rust.
+
+**Requires minumum Rust version of 1.36.0, or 1.41.0 for `From<[T; N]>` implementations**
+
+[Documentation](http://fizyk20.github.io/generic-array/generic_array/)
+
+## Usage
+
+The Rust arrays `[T; N]` are problematic in that they can't be used generically with respect to `N`, so for example this won't work:
+
+```rust
+struct Foo<N> {
+	data: [i32; N]
+}
+```
+
+**generic-array** defines a new trait `ArrayLength<T>` and a struct `GenericArray<T, N: ArrayLength<T>>`, which let the above be implemented as:
+
+```rust
+struct Foo<N: ArrayLength<i32>> {
+	data: GenericArray<i32, N>
+}
+```
+
+The `ArrayLength<T>` trait is implemented by default for [unsigned integer types](http://fizyk20.github.io/generic-array/typenum/uint/index.html) from [typenum](http://fizyk20.github.io/generic-array/typenum/index.html) crate:
+
+```rust
+use generic_array::typenum::U5;
+
+struct Foo<N: ArrayLength<i32>> {
+    data: GenericArray<i32, N>
+}
+
+fn main() {
+    let foo = Foo::<U5>{data: GenericArray::default()};
+}
+```
+
+For example, `GenericArray<T, U5>` would work almost like `[T; 5]`:
+
+```rust
+use generic_array::typenum::U5;
+
+struct Foo<T, N: ArrayLength<T>> {
+    data: GenericArray<T, N>
+}
+
+fn main() {
+    let foo = Foo::<i32, U5>{data: GenericArray::default()};
+}
+```
+
+In version 0.1.1 an `arr!` macro was introduced, allowing for creation of arrays as shown below:
+
+```rust
+let array = arr![u32; 1, 2, 3];
+assert_eq!(array[2], 3);
+```

zeroidc/vendor/generic-array/build.rs

@@ -1,5 +1,5 @@
-fn main() {
-    if version_check::is_min_version("1.41.0").unwrap_or(false) {
-        println!("cargo:rustc-cfg=relaxed_coherence");
-    }
-}
+fn main() {
+    if version_check::is_min_version("1.41.0").unwrap_or(false) {
+        println!("cargo:rustc-cfg=relaxed_coherence");
+    }
+}

zeroidc/vendor/generic-array/rustfmt.toml

@@ -1,3 +1,3 @@
-reorder_imports = true
-reorder_imported_names = true
-use_try_shorthand = true
+reorder_imports = true
+reorder_imported_names = true
+use_try_shorthand = true

zeroidc/vendor/generic-array/src/arr.rs

@@ -1,125 +1,125 @@
-//! Implementation for `arr!` macro.
-
-use super::ArrayLength;
-use core::ops::Add;
-use typenum::U1;
-
-/// Helper trait for `arr!` macro
-pub trait AddLength<T, N: ArrayLength<T>>: ArrayLength<T> {
-    /// Resulting length
-    type Output: ArrayLength<T>;
-}
-
-impl<T, N1, N2> AddLength<T, N2> for N1
-where
-    N1: ArrayLength<T> + Add<N2>,
-    N2: ArrayLength<T>,
-    <N1 as Add<N2>>::Output: ArrayLength<T>,
-{
-    type Output = <N1 as Add<N2>>::Output;
-}
-
-/// Helper type for `arr!` macro
-pub type Inc<T, U> = <U as AddLength<T, U1>>::Output;
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! arr_impl {
-    (@replace_expr $e:expr) => { 1 };
-    ($T:ty; $N:ty, [$($x:expr),*], []) => ({
-        const __ARR_LENGTH: usize = 0 $(+ $crate::arr_impl!(@replace_expr $x) )*;
-
-        #[inline(always)]
-        fn __do_transmute<T, N: $crate::ArrayLength<T>>(arr: [T; __ARR_LENGTH]) -> $crate::GenericArray<T, N> {
-            unsafe { $crate::transmute(arr) }
-        }
-
-        let _: [(); <$N as $crate::typenum::Unsigned>::USIZE] = [(); __ARR_LENGTH];
-
-        __do_transmute::<$T, $N>([$($x as $T),*])
-    });
-    ($T:ty; $N:ty, [], [$x1:expr]) => (
-        $crate::arr_impl!($T; $crate::arr::Inc<$T, $N>, [$x1], [])
-    );
-    ($T:ty; $N:ty, [], [$x1:expr, $($x:expr),+]) => (
-        $crate::arr_impl!($T; $crate::arr::Inc<$T, $N>, [$x1], [$($x),+])
-    );
-    ($T:ty; $N:ty, [$($y:expr),+], [$x1:expr]) => (
-        $crate::arr_impl!($T; $crate::arr::Inc<$T, $N>, [$($y),+, $x1], [])
-    );
-    ($T:ty; $N:ty, [$($y:expr),+], [$x1:expr, $($x:expr),+]) => (
-        $crate::arr_impl!($T; $crate::arr::Inc<$T, $N>, [$($y),+, $x1], [$($x),+])
-    );
-}
-
-/// Macro allowing for easy generation of Generic Arrays.
-/// Example: `let test = arr![u32; 1, 2, 3];`
-#[macro_export]
-macro_rules! arr {
-    ($T:ty; $(,)*) => ({
-        unsafe { $crate::transmute::<[$T; 0], $crate::GenericArray<$T, $crate::typenum::U0>>([]) }
-    });
-    ($T:ty; $($x:expr),* $(,)*) => (
-        $crate::arr_impl!($T; $crate::typenum::U0, [], [$($x),*])
-    );
-    ($($x:expr,)+) => (arr![$($x),+]);
-    () => ("""Macro requires a type, e.g. `let array = arr![u32; 1, 2, 3];`")
-}
-
-mod doctests_only {
-    ///
-    /// # With ellision
-    ///
-    /// Testing that lifetimes aren't transmuted when they're ellided.
-    ///
-    /// ```compile_fail
-    /// #[macro_use] extern crate generic_array;
-    /// fn main() {
-    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'static A {
-    ///        arr![&A; a][0]
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// ```rust
-    /// #[macro_use] extern crate generic_array;
-    /// fn main() {
-    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'a A {
-    ///        arr![&A; a][0]
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// # Without ellision
-    ///
-    /// Testing that lifetimes aren't transmuted when they're specified explicitly.
-    ///
-    /// ```compile_fail
-    /// #[macro_use] extern crate generic_array;
-    /// fn main() {
-    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'static A {
-    ///        arr![&'a A; a][0]
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// ```compile_fail
-    /// #[macro_use] extern crate generic_array;
-    /// fn main() {
-    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'static A {
-    ///        arr![&'static A; a][0]
-    ///    }
-    /// }
-    /// ```
-    ///
-    /// ```rust
-    /// #[macro_use] extern crate generic_array;
-    /// fn main() {
-    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'a A {
-    ///        arr![&'a A; a][0]
-    ///    }
-    /// }
-    /// ```
-    #[allow(dead_code)]
-    pub enum DocTests {}
-}
+//! Implementation for `arr!` macro.
+
+use super::ArrayLength;
+use core::ops::Add;
+use typenum::U1;
+
+/// Helper trait for `arr!` macro
+pub trait AddLength<T, N: ArrayLength<T>>: ArrayLength<T> {
+    /// Resulting length
+    type Output: ArrayLength<T>;
+}
+
+impl<T, N1, N2> AddLength<T, N2> for N1
+where
+    N1: ArrayLength<T> + Add<N2>,
+    N2: ArrayLength<T>,
+    <N1 as Add<N2>>::Output: ArrayLength<T>,
+{
+    type Output = <N1 as Add<N2>>::Output;
+}
+
+/// Helper type for `arr!` macro
+pub type Inc<T, U> = <U as AddLength<T, U1>>::Output;
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! arr_impl {
+    (@replace_expr $e:expr) => { 1 };
+    ($T:ty; $N:ty, [$($x:expr),*], []) => ({
+        const __ARR_LENGTH: usize = 0 $(+ $crate::arr_impl!(@replace_expr $x) )*;
+
+        #[inline(always)]
+        fn __do_transmute<T, N: $crate::ArrayLength<T>>(arr: [T; __ARR_LENGTH]) -> $crate::GenericArray<T, N> {
+            unsafe { $crate::transmute(arr) }
+        }
+
+        let _: [(); <$N as $crate::typenum::Unsigned>::USIZE] = [(); __ARR_LENGTH];
+
+        __do_transmute::<$T, $N>([$($x as $T),*])
+    });
+    ($T:ty; $N:ty, [], [$x1:expr]) => (
+        $crate::arr_impl!($T; $crate::arr::Inc<$T, $N>, [$x1], [])
+    );
+    ($T:ty; $N:ty, [], [$x1:expr, $($x:expr),+]) => (
+        $crate::arr_impl!($T; $crate::arr::Inc<$T, $N>, [$x1], [$($x),+])
+    );
+    ($T:ty; $N:ty, [$($y:expr),+], [$x1:expr]) => (
+        $crate::arr_impl!($T; $crate::arr::Inc<$T, $N>, [$($y),+, $x1], [])
+    );
+    ($T:ty; $N:ty, [$($y:expr),+], [$x1:expr, $($x:expr),+]) => (
+        $crate::arr_impl!($T; $crate::arr::Inc<$T, $N>, [$($y),+, $x1], [$($x),+])
+    );
+}
+
+/// Macro allowing for easy generation of Generic Arrays.
+/// Example: `let test = arr![u32; 1, 2, 3];`
+#[macro_export]
+macro_rules! arr {
+    ($T:ty; $(,)*) => ({
+        unsafe { $crate::transmute::<[$T; 0], $crate::GenericArray<$T, $crate::typenum::U0>>([]) }
+    });
+    ($T:ty; $($x:expr),* $(,)*) => (
+        $crate::arr_impl!($T; $crate::typenum::U0, [], [$($x),*])
+    );
+    ($($x:expr,)+) => (arr![$($x),+]);
+    () => ("""Macro requires a type, e.g. `let array = arr![u32; 1, 2, 3];`")
+}
+
+mod doctests_only {
+    ///
+    /// # With ellision
+    ///
+    /// Testing that lifetimes aren't transmuted when they're ellided.
+    ///
+    /// ```compile_fail
+    /// #[macro_use] extern crate generic_array;
+    /// fn main() {
+    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'static A {
+    ///        arr![&A; a][0]
+    ///    }
+    /// }
+    /// ```
+    ///
+    /// ```rust
+    /// #[macro_use] extern crate generic_array;
+    /// fn main() {
+    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'a A {
+    ///        arr![&A; a][0]
+    ///    }
+    /// }
+    /// ```
+    ///
+    /// # Without ellision
+    ///
+    /// Testing that lifetimes aren't transmuted when they're specified explicitly.
+    ///
+    /// ```compile_fail
+    /// #[macro_use] extern crate generic_array;
+    /// fn main() {
+    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'static A {
+    ///        arr![&'a A; a][0]
+    ///    }
+    /// }
+    /// ```
+    ///
+    /// ```compile_fail
+    /// #[macro_use] extern crate generic_array;
+    /// fn main() {
+    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'static A {
+    ///        arr![&'static A; a][0]
+    ///    }
+    /// }
+    /// ```
+    ///
+    /// ```rust
+    /// #[macro_use] extern crate generic_array;
+    /// fn main() {
+    ///    fn unsound_lifetime_extension<'a, A>(a: &'a A) -> &'a A {
+    ///        arr![&'a A; a][0]
+    ///    }
+    /// }
+    /// ```
+    #[allow(dead_code)]
+    pub enum DocTests {}
+}

zeroidc/vendor/generic-array/src/functional.rs

@@ -1,95 +1,95 @@
-//! Functional programming with generic sequences
-//!
-//! Please see `tests/generics.rs` for examples of how to best use these in your generic functions.
-
-use super::ArrayLength;
-use core::iter::FromIterator;
-
-use crate::sequence::*;
-
-/// Defines the relationship between one generic sequence and another,
-/// for operations such as `map` and `zip`.
-pub unsafe trait MappedGenericSequence<T, U>: GenericSequence<T>
-where
-    Self::Length: ArrayLength<U>,
-{
-    /// Mapped sequence type
-    type Mapped: GenericSequence<U, Length = Self::Length>;
-}
-
-unsafe impl<'a, T, U, S: MappedGenericSequence<T, U>> MappedGenericSequence<T, U> for &'a S
-where
-    &'a S: GenericSequence<T>,
-    S: GenericSequence<T, Length = <&'a S as GenericSequence<T>>::Length>,
-    <S as GenericSequence<T>>::Length: ArrayLength<U>,
-{
-    type Mapped = <S as MappedGenericSequence<T, U>>::Mapped;
-}
-
-unsafe impl<'a, T, U, S: MappedGenericSequence<T, U>> MappedGenericSequence<T, U> for &'a mut S
-where
-    &'a mut S: GenericSequence<T>,
-    S: GenericSequence<T, Length = <&'a mut S as GenericSequence<T>>::Length>,
-    <S as GenericSequence<T>>::Length: ArrayLength<U>,
-{
-    type Mapped = <S as MappedGenericSequence<T, U>>::Mapped;
-}
-
-/// Accessor type for a mapped generic sequence
-pub type MappedSequence<S, T, U> =
-    <<S as MappedGenericSequence<T, U>>::Mapped as GenericSequence<U>>::Sequence;
-
-/// Defines functional programming methods for generic sequences
-pub unsafe trait FunctionalSequence<T>: GenericSequence<T> {
-    /// Maps a `GenericSequence` to another `GenericSequence`.
-    ///
-    /// If the mapping function panics, any already initialized elements in the new sequence
-    /// will be dropped, AND any unused elements in the source sequence will also be dropped.
-    fn map<U, F>(self, f: F) -> MappedSequence<Self, T, U>
-    where
-        Self: MappedGenericSequence<T, U>,
-        Self::Length: ArrayLength<U>,
-        F: FnMut(Self::Item) -> U,
-    {
-        FromIterator::from_iter(self.into_iter().map(f))
-    }
-
-    /// Combines two `GenericSequence` instances and iterates through both of them,
-    /// initializing a new `GenericSequence` with the result of the zipped mapping function.
-    ///
-    /// If the mapping function panics, any already initialized elements in the new sequence
-    /// will be dropped, AND any unused elements in the source sequences will also be dropped.
-    #[inline]
-    fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
-    where
-        Self: MappedGenericSequence<T, U>,
-        Rhs: MappedGenericSequence<B, U, Mapped = MappedSequence<Self, T, U>>,
-        Self::Length: ArrayLength<B> + ArrayLength<U>,
-        Rhs: GenericSequence<B, Length = Self::Length>,
-        F: FnMut(Self::Item, Rhs::Item) -> U,
-    {
-        rhs.inverted_zip2(self, f)
-    }
-
-    /// Folds (or reduces) a sequence of data into a single value.
-    ///
-    /// If the fold function panics, any unused elements will be dropped.
-    fn fold<U, F>(self, init: U, f: F) -> U
-    where
-        F: FnMut(U, Self::Item) -> U,
-    {
-        self.into_iter().fold(init, f)
-    }
-}
-
-unsafe impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a S
-where
-    &'a S: GenericSequence<T>,
-{
-}
-
-unsafe impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a mut S
-where
-    &'a mut S: GenericSequence<T>,
-{
-}
+//! Functional programming with generic sequences
+//!
+//! Please see `tests/generics.rs` for examples of how to best use these in your generic functions.
+
+use super::ArrayLength;
+use core::iter::FromIterator;
+
+use crate::sequence::*;
+
+/// Defines the relationship between one generic sequence and another,
+/// for operations such as `map` and `zip`.
+pub unsafe trait MappedGenericSequence<T, U>: GenericSequence<T>
+where
+    Self::Length: ArrayLength<U>,
+{
+    /// Mapped sequence type
+    type Mapped: GenericSequence<U, Length = Self::Length>;
+}
+
+unsafe impl<'a, T, U, S: MappedGenericSequence<T, U>> MappedGenericSequence<T, U> for &'a S
+where
+    &'a S: GenericSequence<T>,
+    S: GenericSequence<T, Length = <&'a S as GenericSequence<T>>::Length>,
+    <S as GenericSequence<T>>::Length: ArrayLength<U>,
+{
+    type Mapped = <S as MappedGenericSequence<T, U>>::Mapped;
+}
+
+unsafe impl<'a, T, U, S: MappedGenericSequence<T, U>> MappedGenericSequence<T, U> for &'a mut S
+where
+    &'a mut S: GenericSequence<T>,
+    S: GenericSequence<T, Length = <&'a mut S as GenericSequence<T>>::Length>,
+    <S as GenericSequence<T>>::Length: ArrayLength<U>,
+{
+    type Mapped = <S as MappedGenericSequence<T, U>>::Mapped;
+}
+
+/// Accessor type for a mapped generic sequence
+pub type MappedSequence<S, T, U> =
+    <<S as MappedGenericSequence<T, U>>::Mapped as GenericSequence<U>>::Sequence;
+
+/// Defines functional programming methods for generic sequences
+pub unsafe trait FunctionalSequence<T>: GenericSequence<T> {
+    /// Maps a `GenericSequence` to another `GenericSequence`.
+    ///
+    /// If the mapping function panics, any already initialized elements in the new sequence
+    /// will be dropped, AND any unused elements in the source sequence will also be dropped.
+    fn map<U, F>(self, f: F) -> MappedSequence<Self, T, U>
+    where
+        Self: MappedGenericSequence<T, U>,
+        Self::Length: ArrayLength<U>,
+        F: FnMut(Self::Item) -> U,
+    {
+        FromIterator::from_iter(self.into_iter().map(f))
+    }
+
+    /// Combines two `GenericSequence` instances and iterates through both of them,
+    /// initializing a new `GenericSequence` with the result of the zipped mapping function.
+    ///
+    /// If the mapping function panics, any already initialized elements in the new sequence
+    /// will be dropped, AND any unused elements in the source sequences will also be dropped.
+    #[inline]
+    fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
+    where
+        Self: MappedGenericSequence<T, U>,
+        Rhs: MappedGenericSequence<B, U, Mapped = MappedSequence<Self, T, U>>,
+        Self::Length: ArrayLength<B> + ArrayLength<U>,
+        Rhs: GenericSequence<B, Length = Self::Length>,
+        F: FnMut(Self::Item, Rhs::Item) -> U,
+    {
+        rhs.inverted_zip2(self, f)
+    }
+
+    /// Folds (or reduces) a sequence of data into a single value.
+    ///
+    /// If the fold function panics, any unused elements will be dropped.
+    fn fold<U, F>(self, init: U, f: F) -> U
+    where
+        F: FnMut(U, Self::Item) -> U,
+    {
+        self.into_iter().fold(init, f)
+    }
+}
+
+unsafe impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a S
+where
+    &'a S: GenericSequence<T>,
+{
+}
+
+unsafe impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a mut S
+where
+    &'a mut S: GenericSequence<T>,
+{
+}

zeroidc/vendor/generic-array/src/hex.rs

@@ -1,105 +1,105 @@
-//! Generic array are commonly used as a return value for hash digests, so
-//! it's a good idea to allow to hexlify them easily. This module implements
-//! `std::fmt::LowerHex` and `std::fmt::UpperHex` traits.
-//!
-//! Example:
-//!
-//! ```rust
-//! # #[macro_use]
-//! # extern crate generic_array;
-//! # extern crate typenum;
-//! # fn main() {
-//! let array = arr![u8; 10, 20, 30];
-//! assert_eq!(format!("{:x}", array), "0a141e");
-//! # }
-//! ```
-//!
-
-use core::{fmt, str, ops::Add, cmp::min};
-
-use typenum::*;
-
-use crate::{ArrayLength, GenericArray};
-
-static LOWER_CHARS: &'static [u8] = b"0123456789abcdef";
-static UPPER_CHARS: &'static [u8] = b"0123456789ABCDEF";
-
-impl<T: ArrayLength<u8>> fmt::LowerHex for GenericArray<u8, T>
-where
-    T: Add<T>,
-    <T as Add<T>>::Output: ArrayLength<u8>,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);
-        let max_hex = (max_digits >> 1) + (max_digits & 1);
-
-        if T::USIZE < 1024 {
-            // For small arrays use a stack allocated
-            // buffer of 2x number of bytes
-            let mut res = GenericArray::<u8, Sum<T, T>>::default();
-
-            self.iter().take(max_hex).enumerate().for_each(|(i, c)| {
-                res[i * 2] = LOWER_CHARS[(c >> 4) as usize];
-                res[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];
-            });
-
-            f.write_str(unsafe { str::from_utf8_unchecked(&res[..max_digits]) })?;
-        } else {
-            // For large array use chunks of up to 1024 bytes (2048 hex chars)
-            let mut buf = [0u8; 2048];
-            let mut digits_left = max_digits;
-
-            for chunk in self[..max_hex].chunks(1024) {
-                chunk.iter().enumerate().for_each(|(i, c)| {
-                    buf[i * 2] = LOWER_CHARS[(c >> 4) as usize];
-                    buf[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];
-                });
-
-                let n = min(chunk.len() * 2, digits_left);
-                f.write_str(unsafe { str::from_utf8_unchecked(&buf[..n]) })?;
-                digits_left -= n;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl<T: ArrayLength<u8>> fmt::UpperHex for GenericArray<u8, T>
-where
-    T: Add<T>,
-    <T as Add<T>>::Output: ArrayLength<u8>,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);
-        let max_hex = (max_digits >> 1) + (max_digits & 1);
-
-        if T::USIZE < 1024 {
-            // For small arrays use a stack allocated
-            // buffer of 2x number of bytes
-            let mut res = GenericArray::<u8, Sum<T, T>>::default();
-
-            self.iter().take(max_hex).enumerate().for_each(|(i, c)| {
-                res[i * 2] = UPPER_CHARS[(c >> 4) as usize];
-                res[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];
-            });
-
-            f.write_str(unsafe { str::from_utf8_unchecked(&res[..max_digits]) })?;
-        } else {
-            // For large array use chunks of up to 1024 bytes (2048 hex chars)
-            let mut buf = [0u8; 2048];
-            let mut digits_left = max_digits;
-
-            for chunk in self[..max_hex].chunks(1024) {
-                chunk.iter().enumerate().for_each(|(i, c)| {
-                    buf[i * 2] = UPPER_CHARS[(c >> 4) as usize];
-                    buf[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];
-                });
-
-                let n = min(chunk.len() * 2, digits_left);
-                f.write_str(unsafe { str::from_utf8_unchecked(&buf[..n]) })?;
-                digits_left -= n;
-            }
-        }
-        Ok(())
-    }
-}
+//! Generic array are commonly used as a return value for hash digests, so
+//! it's a good idea to allow to hexlify them easily. This module implements
+//! `std::fmt::LowerHex` and `std::fmt::UpperHex` traits.
+//!
+//! Example:
+//!
+//! ```rust
+//! # #[macro_use]
+//! # extern crate generic_array;
+//! # extern crate typenum;
+//! # fn main() {
+//! let array = arr![u8; 10, 20, 30];
+//! assert_eq!(format!("{:x}", array), "0a141e");
+//! # }
+//! ```
+//!
+
+use core::{fmt, str, ops::Add, cmp::min};
+
+use typenum::*;
+
+use crate::{ArrayLength, GenericArray};
+
+static LOWER_CHARS: &'static [u8] = b"0123456789abcdef";
+static UPPER_CHARS: &'static [u8] = b"0123456789ABCDEF";
+
+impl<T: ArrayLength<u8>> fmt::LowerHex for GenericArray<u8, T>
+where
+    T: Add<T>,
+    <T as Add<T>>::Output: ArrayLength<u8>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);
+        let max_hex = (max_digits >> 1) + (max_digits & 1);
+
+        if T::USIZE < 1024 {
+            // For small arrays use a stack allocated
+            // buffer of 2x number of bytes
+            let mut res = GenericArray::<u8, Sum<T, T>>::default();
+
+            self.iter().take(max_hex).enumerate().for_each(|(i, c)| {
+                res[i * 2] = LOWER_CHARS[(c >> 4) as usize];
+                res[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];
+            });
+
+            f.write_str(unsafe { str::from_utf8_unchecked(&res[..max_digits]) })?;
+        } else {
+            // For large array use chunks of up to 1024 bytes (2048 hex chars)
+            let mut buf = [0u8; 2048];
+            let mut digits_left = max_digits;
+
+            for chunk in self[..max_hex].chunks(1024) {
+                chunk.iter().enumerate().for_each(|(i, c)| {
+                    buf[i * 2] = LOWER_CHARS[(c >> 4) as usize];
+                    buf[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];
+                });
+
+                let n = min(chunk.len() * 2, digits_left);
+                f.write_str(unsafe { str::from_utf8_unchecked(&buf[..n]) })?;
+                digits_left -= n;
+            }
+        }
+        Ok(())
+    }
+}
+
+impl<T: ArrayLength<u8>> fmt::UpperHex for GenericArray<u8, T>
+where
+    T: Add<T>,
+    <T as Add<T>>::Output: ArrayLength<u8>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);
+        let max_hex = (max_digits >> 1) + (max_digits & 1);
+
+        if T::USIZE < 1024 {
+            // For small arrays use a stack allocated
+            // buffer of 2x number of bytes
+            let mut res = GenericArray::<u8, Sum<T, T>>::default();
+
+            self.iter().take(max_hex).enumerate().for_each(|(i, c)| {
+                res[i * 2] = UPPER_CHARS[(c >> 4) as usize];
+                res[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];
+            });
+
+            f.write_str(unsafe { str::from_utf8_unchecked(&res[..max_digits]) })?;
+        } else {
+            // For large array use chunks of up to 1024 bytes (2048 hex chars)
+            let mut buf = [0u8; 2048];
+            let mut digits_left = max_digits;
+
+            for chunk in self[..max_hex].chunks(1024) {
+                chunk.iter().enumerate().for_each(|(i, c)| {
+                    buf[i * 2] = UPPER_CHARS[(c >> 4) as usize];
+                    buf[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];
+                });
+
+                let n = min(chunk.len() * 2, digits_left);
+                f.write_str(unsafe { str::from_utf8_unchecked(&buf[..n]) })?;
+                digits_left -= n;
+            }
+        }
+        Ok(())
+    }
+}

zeroidc/vendor/generic-array/src/impl_serde.rs

@@ -1,108 +1,108 @@
-//! Serde serialization/deserialization implementation
-
-use core::fmt;
-use core::marker::PhantomData;
-use serde::de::{self, SeqAccess, Visitor};
-use serde::{ser::SerializeTuple, Deserialize, Deserializer, Serialize, Serializer};
-use {ArrayLength, GenericArray};
-
-impl<T, N> Serialize for GenericArray<T, N>
-where
-    T: Serialize,
-    N: ArrayLength<T>,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut tup = serializer.serialize_tuple(N::USIZE)?;
-        for el in self {
-            tup.serialize_element(el)?;
-        }
-
-        tup.end()
-    }
-}
-
-struct GAVisitor<T, N> {
-    _t: PhantomData<T>,
-    _n: PhantomData<N>,
-}
-
-impl<'de, T, N> Visitor<'de> for GAVisitor<T, N>
-where
-    T: Deserialize<'de> + Default,
-    N: ArrayLength<T>,
-{
-    type Value = GenericArray<T, N>;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("struct GenericArray")
-    }
-
-    fn visit_seq<A>(self, mut seq: A) -> Result<GenericArray<T, N>, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        let mut result = GenericArray::default();
-        for i in 0..N::USIZE {
-            result[i] = seq
-                .next_element()?
-                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
-        }
-        Ok(result)
-    }
-}
-
-impl<'de, T, N> Deserialize<'de> for GenericArray<T, N>
-where
-    T: Deserialize<'de> + Default,
-    N: ArrayLength<T>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<GenericArray<T, N>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let visitor = GAVisitor {
-            _t: PhantomData,
-            _n: PhantomData,
-        };
-        deserializer.deserialize_tuple(N::USIZE, visitor)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use bincode;
-    use typenum;
-
-    #[test]
-    fn test_serialize() {
-        let array = GenericArray::<u8, typenum::U2>::default();
-        let serialized = bincode::serialize(&array);
-        assert!(serialized.is_ok());
-    }
-
-    #[test]
-    fn test_deserialize() {
-        let mut array = GenericArray::<u8, typenum::U2>::default();
-        array[0] = 1;
-        array[1] = 2;
-        let serialized = bincode::serialize(&array).unwrap();
-        let deserialized = bincode::deserialize::<GenericArray<u8, typenum::U2>>(&serialized);
-        assert!(deserialized.is_ok());
-        let array = deserialized.unwrap();
-        assert_eq!(array[0], 1);
-        assert_eq!(array[1], 2);
-    }
-
-    #[test]
-    fn test_serialized_size() {
-        let array = GenericArray::<u8, typenum::U1>::default();
-        let size = bincode::serialized_size(&array).unwrap();
-        assert_eq!(size, 1);
-    }
-
-}
+//! Serde serialization/deserialization implementation
+
+use core::fmt;
+use core::marker::PhantomData;
+use serde::de::{self, SeqAccess, Visitor};
+use serde::{ser::SerializeTuple, Deserialize, Deserializer, Serialize, Serializer};
+use {ArrayLength, GenericArray};
+
+impl<T, N> Serialize for GenericArray<T, N>
+where
+    T: Serialize,
+    N: ArrayLength<T>,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut tup = serializer.serialize_tuple(N::USIZE)?;
+        for el in self {
+            tup.serialize_element(el)?;
+        }
+
+        tup.end()
+    }
+}
+
+struct GAVisitor<T, N> {
+    _t: PhantomData<T>,
+    _n: PhantomData<N>,
+}
+
+impl<'de, T, N> Visitor<'de> for GAVisitor<T, N>
+where
+    T: Deserialize<'de> + Default,
+    N: ArrayLength<T>,
+{
+    type Value = GenericArray<T, N>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("struct GenericArray")
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<GenericArray<T, N>, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let mut result = GenericArray::default();
+        for i in 0..N::USIZE {
+            result[i] = seq
+                .next_element()?
+                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
+        }
+        Ok(result)
+    }
+}
+
+impl<'de, T, N> Deserialize<'de> for GenericArray<T, N>
+where
+    T: Deserialize<'de> + Default,
+    N: ArrayLength<T>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<GenericArray<T, N>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let visitor = GAVisitor {
+            _t: PhantomData,
+            _n: PhantomData,
+        };
+        deserializer.deserialize_tuple(N::USIZE, visitor)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bincode;
+    use typenum;
+
+    #[test]
+    fn test_serialize() {
+        let array = GenericArray::<u8, typenum::U2>::default();
+        let serialized = bincode::serialize(&array);
+        assert!(serialized.is_ok());
+    }
+
+    #[test]
+    fn test_deserialize() {
+        let mut array = GenericArray::<u8, typenum::U2>::default();
+        array[0] = 1;
+        array[1] = 2;
+        let serialized = bincode::serialize(&array).unwrap();
+        let deserialized = bincode::deserialize::<GenericArray<u8, typenum::U2>>(&serialized);
+        assert!(deserialized.is_ok());
+        let array = deserialized.unwrap();
+        assert_eq!(array[0], 1);
+        assert_eq!(array[1], 2);
+    }
+
+    #[test]
+    fn test_serialized_size() {
+        let array = GenericArray::<u8, typenum::U1>::default();
+        let size = bincode::serialized_size(&array).unwrap();
+        assert_eq!(size, 1);
+    }
+
+}

zeroidc/vendor/generic-array/src/impls.rs

@@ -1,269 +1,269 @@
-use core::borrow::{Borrow, BorrowMut};
-use core::cmp::Ordering;
-use core::fmt::{self, Debug};
-use core::hash::{Hash, Hasher};
-
-use super::{ArrayLength, GenericArray};
-
-use crate::functional::*;
-use crate::sequence::*;
-
-impl<T: Default, N> Default for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    #[inline(always)]
-    fn default() -> Self {
-        Self::generate(|_| T::default())
-    }
-}
-
-impl<T: Clone, N> Clone for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn clone(&self) -> GenericArray<T, N> {
-        self.map(Clone::clone)
-    }
-}
-
-impl<T: Copy, N> Copy for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-    N::ArrayType: Copy,
-{
-}
-
-impl<T: PartialEq, N> PartialEq for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn eq(&self, other: &Self) -> bool {
-        **self == **other
-    }
-}
-impl<T: Eq, N> Eq for GenericArray<T, N> where N: ArrayLength<T> {}
-
-impl<T: PartialOrd, N> PartialOrd for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn partial_cmp(&self, other: &GenericArray<T, N>) -> Option<Ordering> {
-        PartialOrd::partial_cmp(self.as_slice(), other.as_slice())
-    }
-}
-
-impl<T: Ord, N> Ord for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn cmp(&self, other: &GenericArray<T, N>) -> Ordering {
-        Ord::cmp(self.as_slice(), other.as_slice())
-    }
-}
-
-impl<T: Debug, N> Debug for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        self[..].fmt(fmt)
-    }
-}
-
-impl<T, N> Borrow<[T]> for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    #[inline(always)]
-    fn borrow(&self) -> &[T] {
-        &self[..]
-    }
-}
-
-impl<T, N> BorrowMut<[T]> for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    #[inline(always)]
-    fn borrow_mut(&mut self) -> &mut [T] {
-        &mut self[..]
-    }
-}
-
-impl<T, N> AsRef<[T]> for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    #[inline(always)]
-    fn as_ref(&self) -> &[T] {
-        &self[..]
-    }
-}
-
-impl<T, N> AsMut<[T]> for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    #[inline(always)]
-    fn as_mut(&mut self) -> &mut [T] {
-        &mut self[..]
-    }
-}
-
-impl<T: Hash, N> Hash for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        Hash::hash(&self[..], state)
-    }
-}
-
-macro_rules! impl_from {
-    ($($n: expr => $ty: ty),*) => {
-        $(
-            impl<T> From<[T; $n]> for GenericArray<T, $ty> {
-                #[inline(always)]
-                fn from(arr: [T; $n]) -> Self {
-                    unsafe { $crate::transmute(arr) }
-                }
-            }
-
-            #[cfg(relaxed_coherence)]
-            impl<T> From<GenericArray<T, $ty>> for [T; $n] {
-                #[inline(always)]
-                fn from(sel: GenericArray<T, $ty>) -> [T; $n] {
-                    unsafe { $crate::transmute(sel) }
-                }
-            }
-
-            impl<'a, T> From<&'a [T; $n]> for &'a GenericArray<T, $ty> {
-                #[inline]
-                fn from(slice: &[T; $n]) -> &GenericArray<T, $ty> {
-                    unsafe { &*(slice.as_ptr() as *const GenericArray<T, $ty>) }
-                }
-            }
-
-            impl<'a, T> From<&'a mut [T; $n]> for &'a mut GenericArray<T, $ty> {
-                #[inline]
-                fn from(slice: &mut [T; $n]) -> &mut GenericArray<T, $ty> {
-                    unsafe { &mut *(slice.as_mut_ptr() as *mut GenericArray<T, $ty>) }
-                }
-            }
-
-            #[cfg(not(relaxed_coherence))]
-            impl<T> Into<[T; $n]> for GenericArray<T, $ty> {
-                #[inline(always)]
-                fn into(self) -> [T; $n] {
-                    unsafe { $crate::transmute(self) }
-                }
-            }
-
-            impl<T> AsRef<[T; $n]> for GenericArray<T, $ty> {
-                #[inline]
-                fn as_ref(&self) -> &[T; $n] {
-                    unsafe { $crate::transmute(self) }
-                }
-            }
-
-            impl<T> AsMut<[T; $n]> for GenericArray<T, $ty> {
-                #[inline]
-                fn as_mut(&mut self) -> &mut [T; $n] {
-                    unsafe { $crate::transmute(self) }
-                }
-            }
-        )*
-    }
-}
-
-impl_from! {
-    1  => ::typenum::U1,
-    2  => ::typenum::U2,
-    3  => ::typenum::U3,
-    4  => ::typenum::U4,
-    5  => ::typenum::U5,
-    6  => ::typenum::U6,
-    7  => ::typenum::U7,
-    8  => ::typenum::U8,
-    9  => ::typenum::U9,
-    10 => ::typenum::U10,
-    11 => ::typenum::U11,
-    12 => ::typenum::U12,
-    13 => ::typenum::U13,
-    14 => ::typenum::U14,
-    15 => ::typenum::U15,
-    16 => ::typenum::U16,
-    17 => ::typenum::U17,
-    18 => ::typenum::U18,
-    19 => ::typenum::U19,
-    20 => ::typenum::U20,
-    21 => ::typenum::U21,
-    22 => ::typenum::U22,
-    23 => ::typenum::U23,
-    24 => ::typenum::U24,
-    25 => ::typenum::U25,
-    26 => ::typenum::U26,
-    27 => ::typenum::U27,
-    28 => ::typenum::U28,
-    29 => ::typenum::U29,
-    30 => ::typenum::U30,
-    31 => ::typenum::U31,
-    32 => ::typenum::U32
-}
-
-#[cfg(feature = "more_lengths")]
-impl_from! {
-    33 => ::typenum::U33,
-    34 => ::typenum::U34,
-    35 => ::typenum::U35,
-    36 => ::typenum::U36,
-    37 => ::typenum::U37,
-    38 => ::typenum::U38,
-    39 => ::typenum::U39,
-    40 => ::typenum::U40,
-    41 => ::typenum::U41,
-    42 => ::typenum::U42,
-    43 => ::typenum::U43,
-    44 => ::typenum::U44,
-    45 => ::typenum::U45,
-    46 => ::typenum::U46,
-    47 => ::typenum::U47,
-    48 => ::typenum::U48,
-    49 => ::typenum::U49,
-    50 => ::typenum::U50,
-    51 => ::typenum::U51,
-    52 => ::typenum::U52,
-    53 => ::typenum::U53,
-    54 => ::typenum::U54,
-    55 => ::typenum::U55,
-    56 => ::typenum::U56,
-    57 => ::typenum::U57,
-    58 => ::typenum::U58,
-    59 => ::typenum::U59,
-    60 => ::typenum::U60,
-    61 => ::typenum::U61,
-    62 => ::typenum::U62,
-    63 => ::typenum::U63,
-    64 => ::typenum::U64,
-
-    70 => ::typenum::U70,
-    80 => ::typenum::U80,
-    90 => ::typenum::U90,
-
-    100 => ::typenum::U100,
-    200 => ::typenum::U200,
-    300 => ::typenum::U300,
-    400 => ::typenum::U400,
-    500 => ::typenum::U500,
-
-    128 => ::typenum::U128,
-    256 => ::typenum::U256,
-    512 => ::typenum::U512,
-
-    1000 => ::typenum::U1000,
-    1024 => ::typenum::U1024
-}
+use core::borrow::{Borrow, BorrowMut};
+use core::cmp::Ordering;
+use core::fmt::{self, Debug};
+use core::hash::{Hash, Hasher};
+
+use super::{ArrayLength, GenericArray};
+
+use crate::functional::*;
+use crate::sequence::*;
+
+impl<T: Default, N> Default for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    #[inline(always)]
+    fn default() -> Self {
+        Self::generate(|_| T::default())
+    }
+}
+
+impl<T: Clone, N> Clone for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn clone(&self) -> GenericArray<T, N> {
+        self.map(Clone::clone)
+    }
+}
+
+impl<T: Copy, N> Copy for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+    N::ArrayType: Copy,
+{
+}
+
+impl<T: PartialEq, N> PartialEq for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn eq(&self, other: &Self) -> bool {
+        **self == **other
+    }
+}
+impl<T: Eq, N> Eq for GenericArray<T, N> where N: ArrayLength<T> {}
+
+impl<T: PartialOrd, N> PartialOrd for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn partial_cmp(&self, other: &GenericArray<T, N>) -> Option<Ordering> {
+        PartialOrd::partial_cmp(self.as_slice(), other.as_slice())
+    }
+}
+
+impl<T: Ord, N> Ord for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn cmp(&self, other: &GenericArray<T, N>) -> Ordering {
+        Ord::cmp(self.as_slice(), other.as_slice())
+    }
+}
+
+impl<T: Debug, N> Debug for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        self[..].fmt(fmt)
+    }
+}
+
+impl<T, N> Borrow<[T]> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    #[inline(always)]
+    fn borrow(&self) -> &[T] {
+        &self[..]
+    }
+}
+
+impl<T, N> BorrowMut<[T]> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    #[inline(always)]
+    fn borrow_mut(&mut self) -> &mut [T] {
+        &mut self[..]
+    }
+}
+
+impl<T, N> AsRef<[T]> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    #[inline(always)]
+    fn as_ref(&self) -> &[T] {
+        &self[..]
+    }
+}
+
+impl<T, N> AsMut<[T]> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    #[inline(always)]
+    fn as_mut(&mut self) -> &mut [T] {
+        &mut self[..]
+    }
+}
+
+impl<T: Hash, N> Hash for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        Hash::hash(&self[..], state)
+    }
+}
+
+macro_rules! impl_from {
+    ($($n: expr => $ty: ty),*) => {
+        $(
+            impl<T> From<[T; $n]> for GenericArray<T, $ty> {
+                #[inline(always)]
+                fn from(arr: [T; $n]) -> Self {
+                    unsafe { $crate::transmute(arr) }
+                }
+            }
+
+            #[cfg(relaxed_coherence)]
+            impl<T> From<GenericArray<T, $ty>> for [T; $n] {
+                #[inline(always)]
+                fn from(sel: GenericArray<T, $ty>) -> [T; $n] {
+                    unsafe { $crate::transmute(sel) }
+                }
+            }
+
+            impl<'a, T> From<&'a [T; $n]> for &'a GenericArray<T, $ty> {
+                #[inline]
+                fn from(slice: &[T; $n]) -> &GenericArray<T, $ty> {
+                    unsafe { &*(slice.as_ptr() as *const GenericArray<T, $ty>) }
+                }
+            }
+
+            impl<'a, T> From<&'a mut [T; $n]> for &'a mut GenericArray<T, $ty> {
+                #[inline]
+                fn from(slice: &mut [T; $n]) -> &mut GenericArray<T, $ty> {
+                    unsafe { &mut *(slice.as_mut_ptr() as *mut GenericArray<T, $ty>) }
+                }
+            }
+
+            #[cfg(not(relaxed_coherence))]
+            impl<T> Into<[T; $n]> for GenericArray<T, $ty> {
+                #[inline(always)]
+                fn into(self) -> [T; $n] {
+                    unsafe { $crate::transmute(self) }
+                }
+            }
+
+            impl<T> AsRef<[T; $n]> for GenericArray<T, $ty> {
+                #[inline]
+                fn as_ref(&self) -> &[T; $n] {
+                    unsafe { $crate::transmute(self) }
+                }
+            }
+
+            impl<T> AsMut<[T; $n]> for GenericArray<T, $ty> {
+                #[inline]
+                fn as_mut(&mut self) -> &mut [T; $n] {
+                    unsafe { $crate::transmute(self) }
+                }
+            }
+        )*
+    }
+}
+
+impl_from! {
+    1  => ::typenum::U1,
+    2  => ::typenum::U2,
+    3  => ::typenum::U3,
+    4  => ::typenum::U4,
+    5  => ::typenum::U5,
+    6  => ::typenum::U6,
+    7  => ::typenum::U7,
+    8  => ::typenum::U8,
+    9  => ::typenum::U9,
+    10 => ::typenum::U10,
+    11 => ::typenum::U11,
+    12 => ::typenum::U12,
+    13 => ::typenum::U13,
+    14 => ::typenum::U14,
+    15 => ::typenum::U15,
+    16 => ::typenum::U16,
+    17 => ::typenum::U17,
+    18 => ::typenum::U18,
+    19 => ::typenum::U19,
+    20 => ::typenum::U20,
+    21 => ::typenum::U21,
+    22 => ::typenum::U22,
+    23 => ::typenum::U23,
+    24 => ::typenum::U24,
+    25 => ::typenum::U25,
+    26 => ::typenum::U26,
+    27 => ::typenum::U27,
+    28 => ::typenum::U28,
+    29 => ::typenum::U29,
+    30 => ::typenum::U30,
+    31 => ::typenum::U31,
+    32 => ::typenum::U32
+}
+
+#[cfg(feature = "more_lengths")]
+impl_from! {
+    33 => ::typenum::U33,
+    34 => ::typenum::U34,
+    35 => ::typenum::U35,
+    36 => ::typenum::U36,
+    37 => ::typenum::U37,
+    38 => ::typenum::U38,
+    39 => ::typenum::U39,
+    40 => ::typenum::U40,
+    41 => ::typenum::U41,
+    42 => ::typenum::U42,
+    43 => ::typenum::U43,
+    44 => ::typenum::U44,
+    45 => ::typenum::U45,
+    46 => ::typenum::U46,
+    47 => ::typenum::U47,
+    48 => ::typenum::U48,
+    49 => ::typenum::U49,
+    50 => ::typenum::U50,
+    51 => ::typenum::U51,
+    52 => ::typenum::U52,
+    53 => ::typenum::U53,
+    54 => ::typenum::U54,
+    55 => ::typenum::U55,
+    56 => ::typenum::U56,
+    57 => ::typenum::U57,
+    58 => ::typenum::U58,
+    59 => ::typenum::U59,
+    60 => ::typenum::U60,
+    61 => ::typenum::U61,
+    62 => ::typenum::U62,
+    63 => ::typenum::U63,
+    64 => ::typenum::U64,
+
+    70 => ::typenum::U70,
+    80 => ::typenum::U80,
+    90 => ::typenum::U90,
+
+    100 => ::typenum::U100,
+    200 => ::typenum::U200,
+    300 => ::typenum::U300,
+    400 => ::typenum::U400,
+    500 => ::typenum::U500,
+
+    128 => ::typenum::U128,
+    256 => ::typenum::U256,
+    512 => ::typenum::U512,
+
+    1000 => ::typenum::U1000,
+    1024 => ::typenum::U1024
+}

zeroidc/vendor/generic-array/src/iter.rs

@@ -1,256 +1,256 @@
-//! `GenericArray` iterator implementation.
-
-use super::{ArrayLength, GenericArray};
-use core::iter::FusedIterator;
-use core::mem::ManuallyDrop;
-use core::{cmp, fmt, ptr, mem};
-
-/// An iterator that moves out of a `GenericArray`
-pub struct GenericArrayIter<T, N: ArrayLength<T>> {
-    // Invariants: index <= index_back <= N
-    // Only values in array[index..index_back] are alive at any given time.
-    // Values from array[..index] and array[index_back..] are already moved/dropped.
-    array: ManuallyDrop<GenericArray<T, N>>,
-    index: usize,
-    index_back: usize,
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    fn send<I: Send>(_iter: I) {}
-
-    #[test]
-    fn test_send_iter() {
-        send(GenericArray::from([1, 2, 3, 4]).into_iter());
-    }
-}
-
-impl<T, N> GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-    /// Returns the remaining items of this iterator as a slice
-    #[inline]
-    pub fn as_slice(&self) -> &[T] {
-        &self.array.as_slice()[self.index..self.index_back]
-    }
-
-    /// Returns the remaining items of this iterator as a mutable slice
-    #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [T] {
-        &mut self.array.as_mut_slice()[self.index..self.index_back]
-    }
-}
-
-impl<T, N> IntoIterator for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    type Item = T;
-    type IntoIter = GenericArrayIter<T, N>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        GenericArrayIter {
-            array: ManuallyDrop::new(self),
-            index: 0,
-            index_back: N::USIZE,
-        }
-    }
-}
-
-// Based on work in rust-lang/rust#49000
-impl<T: fmt::Debug, N> fmt::Debug for GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("GenericArrayIter")
-            .field(&self.as_slice())
-            .finish()
-    }
-}
-
-impl<T, N> Drop for GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-    #[inline]
-    fn drop(&mut self) {
-        if mem::needs_drop::<T>() {
-            // Drop values that are still alive.
-            for p in self.as_mut_slice() {
-                unsafe {
-                    ptr::drop_in_place(p);
-                }
-            }
-        }
-    }
-}
-
-// Based on work in rust-lang/rust#49000
-impl<T: Clone, N> Clone for GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn clone(&self) -> Self {
-        // This places all cloned elements at the start of the new array iterator,
-        // not at their original indices.
-        unsafe {
-            let mut array = ptr::read(&self.array);
-            let mut index_back = 0;
-
-            for (dst, src) in array.as_mut_slice().into_iter().zip(self.as_slice()) {
-                ptr::write(dst, src.clone());
-                index_back += 1;
-            }
-
-            GenericArrayIter {
-                array,
-                index: 0,
-                index_back
-            }
-        }
-    }
-}
-
-impl<T, N> Iterator for GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        if self.index < self.index_back {
-            let p = unsafe { Some(ptr::read(self.array.get_unchecked(self.index))) };
-
-            self.index += 1;
-
-            p
-        } else {
-            None
-        }
-    }
-
-    fn fold<B, F>(mut self, init: B, mut f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        let ret = unsafe {
-            let GenericArrayIter {
-                ref array,
-                ref mut index,
-                index_back,
-            } = self;
-
-            let remaining = &array[*index..index_back];
-
-            remaining.iter().fold(init, |acc, src| {
-                let value = ptr::read(src);
-
-                *index += 1;
-
-                f(acc, value)
-            })
-        };
-
-        // ensure the drop happens here after iteration
-        drop(self);
-
-        ret
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.len();
-        (len, Some(len))
-    }
-
-    #[inline]
-    fn count(self) -> usize {
-        self.len()
-    }
-
-    fn nth(&mut self, n: usize) -> Option<T> {
-        // First consume values prior to the nth.
-        let ndrop = cmp::min(n, self.len());
-
-        for p in &mut self.array[self.index..self.index + ndrop] {
-            self.index += 1;
-
-            unsafe {
-                ptr::drop_in_place(p);
-            }
-        }
-
-        self.next()
-    }
-
-    #[inline]
-    fn last(mut self) -> Option<T> {
-        // Note, everything else will correctly drop first as `self` leaves scope.
-        self.next_back()
-    }
-}
-
-impl<T, N> DoubleEndedIterator for GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn next_back(&mut self) -> Option<T> {
-        if self.index < self.index_back {
-            self.index_back -= 1;
-
-            unsafe { Some(ptr::read(self.array.get_unchecked(self.index_back))) }
-        } else {
-            None
-        }
-    }
-
-    fn rfold<B, F>(mut self, init: B, mut f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        let ret = unsafe {
-            let GenericArrayIter {
-                ref array,
-                index,
-                ref mut index_back,
-            } = self;
-
-            let remaining = &array[index..*index_back];
-
-            remaining.iter().rfold(init, |acc, src| {
-                let value = ptr::read(src);
-
-                *index_back -= 1;
-
-                f(acc, value)
-            })
-        };
-
-        // ensure the drop happens here after iteration
-        drop(self);
-
-        ret
-    }
-}
-
-impl<T, N> ExactSizeIterator for GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn len(&self) -> usize {
-        self.index_back - self.index
-    }
-}
-
-impl<T, N> FusedIterator for GenericArrayIter<T, N>
-where
-    N: ArrayLength<T>,
-{
-}
-
-// TODO: Implement `TrustedLen` when stabilized
+//! `GenericArray` iterator implementation.
+
+use super::{ArrayLength, GenericArray};
+use core::iter::FusedIterator;
+use core::mem::ManuallyDrop;
+use core::{cmp, fmt, ptr, mem};
+
+/// An iterator that moves out of a `GenericArray`
+pub struct GenericArrayIter<T, N: ArrayLength<T>> {
+    // Invariants: index <= index_back <= N
+    // Only values in array[index..index_back] are alive at any given time.
+    // Values from array[..index] and array[index_back..] are already moved/dropped.
+    array: ManuallyDrop<GenericArray<T, N>>,
+    index: usize,
+    index_back: usize,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn send<I: Send>(_iter: I) {}
+
+    #[test]
+    fn test_send_iter() {
+        send(GenericArray::from([1, 2, 3, 4]).into_iter());
+    }
+}
+
+impl<T, N> GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    /// Returns the remaining items of this iterator as a slice
+    #[inline]
+    pub fn as_slice(&self) -> &[T] {
+        &self.array.as_slice()[self.index..self.index_back]
+    }
+
+    /// Returns the remaining items of this iterator as a mutable slice
+    #[inline]
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
+        &mut self.array.as_mut_slice()[self.index..self.index_back]
+    }
+}
+
+impl<T, N> IntoIterator for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    type Item = T;
+    type IntoIter = GenericArrayIter<T, N>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        GenericArrayIter {
+            array: ManuallyDrop::new(self),
+            index: 0,
+            index_back: N::USIZE,
+        }
+    }
+}
+
+// Based on work in rust-lang/rust#49000
+impl<T: fmt::Debug, N> fmt::Debug for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("GenericArrayIter")
+            .field(&self.as_slice())
+            .finish()
+    }
+}
+
+impl<T, N> Drop for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    #[inline]
+    fn drop(&mut self) {
+        if mem::needs_drop::<T>() {
+            // Drop values that are still alive.
+            for p in self.as_mut_slice() {
+                unsafe {
+                    ptr::drop_in_place(p);
+                }
+            }
+        }
+    }
+}
+
+// Based on work in rust-lang/rust#49000
+impl<T: Clone, N> Clone for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn clone(&self) -> Self {
+        // This places all cloned elements at the start of the new array iterator,
+        // not at their original indices.
+        unsafe {
+            let mut array = ptr::read(&self.array);
+            let mut index_back = 0;
+
+            for (dst, src) in array.as_mut_slice().into_iter().zip(self.as_slice()) {
+                ptr::write(dst, src.clone());
+                index_back += 1;
+            }
+
+            GenericArrayIter {
+                array,
+                index: 0,
+                index_back
+            }
+        }
+    }
+}
+
+impl<T, N> Iterator for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    type Item = T;
+
+    #[inline]
+    fn next(&mut self) -> Option<T> {
+        if self.index < self.index_back {
+            let p = unsafe { Some(ptr::read(self.array.get_unchecked(self.index))) };
+
+            self.index += 1;
+
+            p
+        } else {
+            None
+        }
+    }
+
+    fn fold<B, F>(mut self, init: B, mut f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        let ret = unsafe {
+            let GenericArrayIter {
+                ref array,
+                ref mut index,
+                index_back,
+            } = self;
+
+            let remaining = &array[*index..index_back];
+
+            remaining.iter().fold(init, |acc, src| {
+                let value = ptr::read(src);
+
+                *index += 1;
+
+                f(acc, value)
+            })
+        };
+
+        // ensure the drop happens here after iteration
+        drop(self);
+
+        ret
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+
+    #[inline]
+    fn count(self) -> usize {
+        self.len()
+    }
+
+    fn nth(&mut self, n: usize) -> Option<T> {
+        // First consume values prior to the nth.
+        let ndrop = cmp::min(n, self.len());
+
+        for p in &mut self.array[self.index..self.index + ndrop] {
+            self.index += 1;
+
+            unsafe {
+                ptr::drop_in_place(p);
+            }
+        }
+
+        self.next()
+    }
+
+    #[inline]
+    fn last(mut self) -> Option<T> {
+        // Note, everything else will correctly drop first as `self` leaves scope.
+        self.next_back()
+    }
+}
+
+impl<T, N> DoubleEndedIterator for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn next_back(&mut self) -> Option<T> {
+        if self.index < self.index_back {
+            self.index_back -= 1;
+
+            unsafe { Some(ptr::read(self.array.get_unchecked(self.index_back))) }
+        } else {
+            None
+        }
+    }
+
+    fn rfold<B, F>(mut self, init: B, mut f: F) -> B
+    where
+        F: FnMut(B, Self::Item) -> B,
+    {
+        let ret = unsafe {
+            let GenericArrayIter {
+                ref array,
+                index,
+                ref mut index_back,
+            } = self;
+
+            let remaining = &array[index..*index_back];
+
+            remaining.iter().rfold(init, |acc, src| {
+                let value = ptr::read(src);
+
+                *index_back -= 1;
+
+                f(acc, value)
+            })
+        };
+
+        // ensure the drop happens here after iteration
+        drop(self);
+
+        ret
+    }
+}
+
+impl<T, N> ExactSizeIterator for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn len(&self) -> usize {
+        self.index_back - self.index
+    }
+}
+
+impl<T, N> FusedIterator for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+}
+
+// TODO: Implement `TrustedLen` when stabilized

zeroidc/vendor/generic-array/src/lib.rs

@@ -1,673 +1,673 @@
-//! This crate implements a structure that can be used as a generic array type.
-//! Core Rust array types `[T; N]` can't be used generically with
-//! respect to `N`, so for example this:
-//!
-//! ```rust{compile_fail}
-//! struct Foo<T, N> {
-//!     data: [T; N]
-//! }
-//! ```
-//!
-//! won't work.
-//!
-//! **generic-array** exports a `GenericArray<T,N>` type, which lets
-//! the above be implemented as:
-//!
-//! ```rust
-//! use generic_array::{ArrayLength, GenericArray};
-//!
-//! struct Foo<T, N: ArrayLength<T>> {
-//!     data: GenericArray<T,N>
-//! }
-//! ```
-//!
-//! The `ArrayLength<T>` trait is implemented by default for
-//! [unsigned integer types](../typenum/uint/index.html) from
-//! [typenum](../typenum/index.html):
-//!
-//! ```rust
-//! # use generic_array::{ArrayLength, GenericArray};
-//! use generic_array::typenum::U5;
-//!
-//! struct Foo<N: ArrayLength<i32>> {
-//!     data: GenericArray<i32, N>
-//! }
-//!
-//! # fn main() {
-//! let foo = Foo::<U5>{data: GenericArray::default()};
-//! # }
-//! ```
-//!
-//! For example, `GenericArray<T, U5>` would work almost like `[T; 5]`:
-//!
-//! ```rust
-//! # use generic_array::{ArrayLength, GenericArray};
-//! use generic_array::typenum::U5;
-//!
-//! struct Foo<T, N: ArrayLength<T>> {
-//!     data: GenericArray<T, N>
-//! }
-//!
-//! # fn main() {
-//! let foo = Foo::<i32, U5>{data: GenericArray::default()};
-//! # }
-//! ```
-//!
-//! For ease of use, an `arr!` macro is provided - example below:
-//!
-//! ```
-//! # #[macro_use]
-//! # extern crate generic_array;
-//! # extern crate typenum;
-//! # fn main() {
-//! let array = arr![u32; 1, 2, 3];
-//! assert_eq!(array[2], 3);
-//! # }
-//! ```
-
-#![deny(missing_docs)]
-#![deny(meta_variable_misuse)]
-#![no_std]
-
-#[cfg(feature = "serde")]
-extern crate serde;
-
-#[cfg(test)]
-extern crate bincode;
-
-pub extern crate typenum;
-
-mod hex;
-mod impls;
-
-#[cfg(feature = "serde")]
-mod impl_serde;
-
-use core::iter::FromIterator;
-use core::marker::PhantomData;
-use core::mem::{MaybeUninit, ManuallyDrop};
-use core::ops::{Deref, DerefMut};
-use core::{mem, ptr, slice};
-use typenum::bit::{B0, B1};
-use typenum::uint::{UInt, UTerm, Unsigned};
-
-#[cfg_attr(test, macro_use)]
-pub mod arr;
-pub mod functional;
-pub mod iter;
-pub mod sequence;
-
-use self::functional::*;
-pub use self::iter::GenericArrayIter;
-use self::sequence::*;
-
-/// Trait making `GenericArray` work, marking types to be used as length of an array
-pub unsafe trait ArrayLength<T>: Unsigned {
-    /// Associated type representing the array type for the number
-    type ArrayType;
-}
-
-unsafe impl<T> ArrayLength<T> for UTerm {
-    #[doc(hidden)]
-    type ArrayType = [T; 0];
-}
-
-/// Internal type used to generate a struct of appropriate size
-#[allow(dead_code)]
-#[repr(C)]
-#[doc(hidden)]
-pub struct GenericArrayImplEven<T, U> {
-    parent1: U,
-    parent2: U,
-    _marker: PhantomData<T>,
-}
-
-impl<T: Clone, U: Clone> Clone for GenericArrayImplEven<T, U> {
-    fn clone(&self) -> GenericArrayImplEven<T, U> {
-        GenericArrayImplEven {
-            parent1: self.parent1.clone(),
-            parent2: self.parent2.clone(),
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl<T: Copy, U: Copy> Copy for GenericArrayImplEven<T, U> {}
-
-/// Internal type used to generate a struct of appropriate size
-#[allow(dead_code)]
-#[repr(C)]
-#[doc(hidden)]
-pub struct GenericArrayImplOdd<T, U> {
-    parent1: U,
-    parent2: U,
-    data: T,
-}
-
-impl<T: Clone, U: Clone> Clone for GenericArrayImplOdd<T, U> {
-    fn clone(&self) -> GenericArrayImplOdd<T, U> {
-        GenericArrayImplOdd {
-            parent1: self.parent1.clone(),
-            parent2: self.parent2.clone(),
-            data: self.data.clone(),
-        }
-    }
-}
-
-impl<T: Copy, U: Copy> Copy for GenericArrayImplOdd<T, U> {}
-
-unsafe impl<T, N: ArrayLength<T>> ArrayLength<T> for UInt<N, B0> {
-    #[doc(hidden)]
-    type ArrayType = GenericArrayImplEven<T, N::ArrayType>;
-}
-
-unsafe impl<T, N: ArrayLength<T>> ArrayLength<T> for UInt<N, B1> {
-    #[doc(hidden)]
-    type ArrayType = GenericArrayImplOdd<T, N::ArrayType>;
-}
-
-/// Struct representing a generic array - `GenericArray<T, N>` works like [T; N]
-#[allow(dead_code)]
-#[repr(transparent)]
-pub struct GenericArray<T, U: ArrayLength<T>> {
-    data: U::ArrayType,
-}
-
-unsafe impl<T: Send, N: ArrayLength<T>> Send for GenericArray<T, N> {}
-unsafe impl<T: Sync, N: ArrayLength<T>> Sync for GenericArray<T, N> {}
-
-impl<T, N> Deref for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    type Target = [T];
-
-    #[inline(always)]
-    fn deref(&self) -> &[T] {
-        unsafe { slice::from_raw_parts(self as *const Self as *const T, N::USIZE) }
-    }
-}
-
-impl<T, N> DerefMut for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    #[inline(always)]
-    fn deref_mut(&mut self) -> &mut [T] {
-        unsafe { slice::from_raw_parts_mut(self as *mut Self as *mut T, N::USIZE) }
-    }
-}
-
-/// Creates an array one element at a time using a mutable iterator
-/// you can write to with `ptr::write`.
-///
-/// Incremenent the position while iterating to mark off created elements,
-/// which will be dropped if `into_inner` is not called.
-#[doc(hidden)]
-pub struct ArrayBuilder<T, N: ArrayLength<T>> {
-    array: MaybeUninit<GenericArray<T, N>>,
-    position: usize,
-}
-
-impl<T, N: ArrayLength<T>> ArrayBuilder<T, N> {
-    #[doc(hidden)]
-    #[inline]
-    pub unsafe fn new() -> ArrayBuilder<T, N> {
-        ArrayBuilder {
-            array: MaybeUninit::uninit(),
-            position: 0,
-        }
-    }
-
-    /// Creates a mutable iterator for writing to the array using `ptr::write`.
-    ///
-    /// Increment the position value given as a mutable reference as you iterate
-    /// to mark how many elements have been created.
-    #[doc(hidden)]
-    #[inline]
-    pub unsafe fn iter_position(&mut self) -> (slice::IterMut<T>, &mut usize) {
-        ((&mut *self.array.as_mut_ptr()).iter_mut(), &mut self.position)
-    }
-
-    /// When done writing (assuming all elements have been written to),
-    /// get the inner array.
-    #[doc(hidden)]
-    #[inline]
-    pub unsafe fn into_inner(self) -> GenericArray<T, N> {
-        let array = ptr::read(&self.array);
-
-        mem::forget(self);
-
-        array.assume_init()
-    }
-}
-
-impl<T, N: ArrayLength<T>> Drop for ArrayBuilder<T, N> {
-    fn drop(&mut self) {
-        if mem::needs_drop::<T>() {
-            unsafe {
-                for value in &mut (&mut *self.array.as_mut_ptr())[..self.position] {
-                    ptr::drop_in_place(value);
-                }
-            }
-        }
-    }
-}
-
-/// Consumes an array.
-///
-/// Increment the position while iterating and any leftover elements
-/// will be dropped if position does not go to N
-#[doc(hidden)]
-pub struct ArrayConsumer<T, N: ArrayLength<T>> {
-    array: ManuallyDrop<GenericArray<T, N>>,
-    position: usize,
-}
-
-impl<T, N: ArrayLength<T>> ArrayConsumer<T, N> {
-    #[doc(hidden)]
-    #[inline]
-    pub unsafe fn new(array: GenericArray<T, N>) -> ArrayConsumer<T, N> {
-        ArrayConsumer {
-            array: ManuallyDrop::new(array),
-            position: 0,
-        }
-    }
-
-    /// Creates an iterator and mutable reference to the internal position
-    /// to keep track of consumed elements.
-    ///
-    /// Increment the position as you iterate to mark off consumed elements
-    #[doc(hidden)]
-    #[inline]
-    pub unsafe fn iter_position(&mut self) -> (slice::Iter<T>, &mut usize) {
-        (self.array.iter(), &mut self.position)
-    }
-}
-
-impl<T, N: ArrayLength<T>> Drop for ArrayConsumer<T, N> {
-    fn drop(&mut self) {
-        if mem::needs_drop::<T>() {
-            for value in &mut self.array[self.position..N::USIZE] {
-                unsafe {
-                    ptr::drop_in_place(value);
-                }
-            }
-        }
-    }
-}
-
-impl<'a, T: 'a, N> IntoIterator for &'a GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    type IntoIter = slice::Iter<'a, T>;
-    type Item = &'a T;
-
-    fn into_iter(self: &'a GenericArray<T, N>) -> Self::IntoIter {
-        self.as_slice().iter()
-    }
-}
-
-impl<'a, T: 'a, N> IntoIterator for &'a mut GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    type IntoIter = slice::IterMut<'a, T>;
-    type Item = &'a mut T;
-
-    fn into_iter(self: &'a mut GenericArray<T, N>) -> Self::IntoIter {
-        self.as_mut_slice().iter_mut()
-    }
-}
-
-impl<T, N> FromIterator<T> for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    fn from_iter<I>(iter: I) -> GenericArray<T, N>
-    where
-        I: IntoIterator<Item = T>,
-    {
-        unsafe {
-            let mut destination = ArrayBuilder::new();
-
-            {
-                let (destination_iter, position) = destination.iter_position();
-
-                iter.into_iter()
-                    .zip(destination_iter)
-                    .for_each(|(src, dst)| {
-                        ptr::write(dst, src);
-
-                        *position += 1;
-                    });
-            }
-
-            if destination.position < N::USIZE {
-                from_iter_length_fail(destination.position, N::USIZE);
-            }
-
-            destination.into_inner()
-        }
-    }
-}
-
-#[inline(never)]
-#[cold]
-fn from_iter_length_fail(length: usize, expected: usize) -> ! {
-    panic!(
-        "GenericArray::from_iter received {} elements but expected {}",
-        length, expected
-    );
-}
-
-unsafe impl<T, N> GenericSequence<T> for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-    Self: IntoIterator<Item = T>,
-{
-    type Length = N;
-    type Sequence = Self;
-
-    fn generate<F>(mut f: F) -> GenericArray<T, N>
-    where
-        F: FnMut(usize) -> T,
-    {
-        unsafe {
-            let mut destination = ArrayBuilder::new();
-
-            {
-                let (destination_iter, position) = destination.iter_position();
-
-                destination_iter.enumerate().for_each(|(i, dst)| {
-                    ptr::write(dst, f(i));
-
-                    *position += 1;
-                });
-            }
-
-            destination.into_inner()
-        }
-    }
-
-    #[doc(hidden)]
-    fn inverted_zip<B, U, F>(
-        self,
-        lhs: GenericArray<B, Self::Length>,
-        mut f: F,
-    ) -> MappedSequence<GenericArray<B, Self::Length>, B, U>
-    where
-        GenericArray<B, Self::Length>:
-            GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
-        Self: MappedGenericSequence<T, U>,
-        Self::Length: ArrayLength<B> + ArrayLength<U>,
-        F: FnMut(B, Self::Item) -> U,
-    {
-        unsafe {
-            let mut left = ArrayConsumer::new(lhs);
-            let mut right = ArrayConsumer::new(self);
-
-            let (left_array_iter, left_position) = left.iter_position();
-            let (right_array_iter, right_position) = right.iter_position();
-
-            FromIterator::from_iter(left_array_iter.zip(right_array_iter).map(|(l, r)| {
-                let left_value = ptr::read(l);
-                let right_value = ptr::read(r);
-
-                *left_position += 1;
-                *right_position += 1;
-
-                f(left_value, right_value)
-            }))
-        }
-    }
-
-    #[doc(hidden)]
-    fn inverted_zip2<B, Lhs, U, F>(self, lhs: Lhs, mut f: F) -> MappedSequence<Lhs, B, U>
-    where
-        Lhs: GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
-        Self: MappedGenericSequence<T, U>,
-        Self::Length: ArrayLength<B> + ArrayLength<U>,
-        F: FnMut(Lhs::Item, Self::Item) -> U,
-    {
-        unsafe {
-            let mut right = ArrayConsumer::new(self);
-
-            let (right_array_iter, right_position) = right.iter_position();
-
-            FromIterator::from_iter(
-                lhs.into_iter()
-                    .zip(right_array_iter)
-                    .map(|(left_value, r)| {
-                        let right_value = ptr::read(r);
-
-                        *right_position += 1;
-
-                        f(left_value, right_value)
-                    }),
-            )
-        }
-    }
-}
-
-unsafe impl<T, U, N> MappedGenericSequence<T, U> for GenericArray<T, N>
-where
-    N: ArrayLength<T> + ArrayLength<U>,
-    GenericArray<U, N>: GenericSequence<U, Length = N>,
-{
-    type Mapped = GenericArray<U, N>;
-}
-
-unsafe impl<T, N> FunctionalSequence<T> for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-    Self: GenericSequence<T, Item = T, Length = N>,
-{
-    fn map<U, F>(self, mut f: F) -> MappedSequence<Self, T, U>
-    where
-        Self::Length: ArrayLength<U>,
-        Self: MappedGenericSequence<T, U>,
-        F: FnMut(T) -> U,
-    {
-        unsafe {
-            let mut source = ArrayConsumer::new(self);
-
-            let (array_iter, position) = source.iter_position();
-
-            FromIterator::from_iter(array_iter.map(|src| {
-                let value = ptr::read(src);
-
-                *position += 1;
-
-                f(value)
-            }))
-        }
-    }
-
-    #[inline]
-    fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
-    where
-        Self: MappedGenericSequence<T, U>,
-        Rhs: MappedGenericSequence<B, U, Mapped = MappedSequence<Self, T, U>>,
-        Self::Length: ArrayLength<B> + ArrayLength<U>,
-        Rhs: GenericSequence<B, Length = Self::Length>,
-        F: FnMut(T, Rhs::Item) -> U,
-    {
-        rhs.inverted_zip(self, f)
-    }
-
-    fn fold<U, F>(self, init: U, mut f: F) -> U
-    where
-        F: FnMut(U, T) -> U,
-    {
-        unsafe {
-            let mut source = ArrayConsumer::new(self);
-
-            let (array_iter, position) = source.iter_position();
-
-            array_iter.fold(init, |acc, src| {
-                let value = ptr::read(src);
-
-                *position += 1;
-
-                f(acc, value)
-            })
-        }
-    }
-}
-
-impl<T, N> GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    /// Extracts a slice containing the entire array.
-    #[inline]
-    pub fn as_slice(&self) -> &[T] {
-        self.deref()
-    }
-
-    /// Extracts a mutable slice containing the entire array.
-    #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [T] {
-        self.deref_mut()
-    }
-
-    /// Converts slice to a generic array reference with inferred length;
-    ///
-    /// Length of the slice must be equal to the length of the array.
-    #[inline]
-    pub fn from_slice(slice: &[T]) -> &GenericArray<T, N> {
-        slice.into()
-    }
-
-    /// Converts mutable slice to a mutable generic array reference
-    ///
-    /// Length of the slice must be equal to the length of the array.
-    #[inline]
-    pub fn from_mut_slice(slice: &mut [T]) -> &mut GenericArray<T, N> {
-        slice.into()
-    }
-}
-
-impl<'a, T, N: ArrayLength<T>> From<&'a [T]> for &'a GenericArray<T, N> {
-    /// Converts slice to a generic array reference with inferred length;
-    ///
-    /// Length of the slice must be equal to the length of the array.
-    #[inline]
-    fn from(slice: &[T]) -> &GenericArray<T, N> {
-        assert_eq!(slice.len(), N::USIZE);
-
-        unsafe { &*(slice.as_ptr() as *const GenericArray<T, N>) }
-    }
-}
-
-impl<'a, T, N: ArrayLength<T>> From<&'a mut [T]> for &'a mut GenericArray<T, N> {
-    /// Converts mutable slice to a mutable generic array reference
-    ///
-    /// Length of the slice must be equal to the length of the array.
-    #[inline]
-    fn from(slice: &mut [T]) -> &mut GenericArray<T, N> {
-        assert_eq!(slice.len(), N::USIZE);
-
-        unsafe { &mut *(slice.as_mut_ptr() as *mut GenericArray<T, N>) }
-    }
-}
-
-impl<T: Clone, N> GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    /// Construct a `GenericArray` from a slice by cloning its content
-    ///
-    /// Length of the slice must be equal to the length of the array
-    #[inline]
-    pub fn clone_from_slice(list: &[T]) -> GenericArray<T, N> {
-        Self::from_exact_iter(list.iter().cloned())
-            .expect("Slice must be the same length as the array")
-    }
-}
-
-impl<T, N> GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-{
-    /// Creates a new `GenericArray` instance from an iterator with a specific size.
-    ///
-    /// Returns `None` if the size is not equal to the number of elements in the `GenericArray`.
-    pub fn from_exact_iter<I>(iter: I) -> Option<Self>
-    where
-        I: IntoIterator<Item = T>,
-    {
-        let mut iter = iter.into_iter();
-
-        unsafe {
-            let mut destination = ArrayBuilder::new();
-
-            {
-                let (destination_iter, position) = destination.iter_position();
-
-                destination_iter.zip(&mut iter).for_each(|(dst, src)| {
-                    ptr::write(dst, src);
-
-                    *position += 1;
-                });
-
-                // The iterator produced fewer than `N` elements.
-                if *position != N::USIZE {
-                    return None;
-                }
-
-                // The iterator produced more than `N` elements.
-                if iter.next().is_some() {
-                    return None;
-                }
-            }
-
-            Some(destination.into_inner())
-        }
-    }
-}
-
-/// A reimplementation of the `transmute` function, avoiding problems
-/// when the compiler can't prove equal sizes.
-#[inline]
-#[doc(hidden)]
-pub unsafe fn transmute<A, B>(a: A) -> B {
-    let a = ManuallyDrop::new(a);
-    ::core::ptr::read(&*a as *const A as *const B)
-}
-
-#[cfg(test)]
-mod test {
-    // Compile with:
-    // cargo rustc --lib --profile test --release --
-    //      -C target-cpu=native -C opt-level=3 --emit asm
-    // and view the assembly to make sure test_assembly generates
-    // SIMD instructions instead of a niave loop.
-
-    #[inline(never)]
-    pub fn black_box<T>(val: T) -> T {
-        use core::{mem, ptr};
-
-        let ret = unsafe { ptr::read_volatile(&val) };
-        mem::forget(val);
-        ret
-    }
-
-    #[test]
-    fn test_assembly() {
-        use crate::functional::*;
-
-        let a = black_box(arr![i32; 1, 3, 5, 7]);
-        let b = black_box(arr![i32; 2, 4, 6, 8]);
-
-        let c = (&a).zip(b, |l, r| l + r);
-
-        let d = a.fold(0, |a, x| a + x);
-
-        assert_eq!(c, arr![i32; 3, 7, 11, 15]);
-
-        assert_eq!(d, 16);
-    }
-}
+//! This crate implements a structure that can be used as a generic array type.
+//! Core Rust array types `[T; N]` can't be used generically with
+//! respect to `N`, so for example this:
+//!
+//! ```rust{compile_fail}
+//! struct Foo<T, N> {
+//!     data: [T; N]
+//! }
+//! ```
+//!
+//! won't work.
+//!
+//! **generic-array** exports a `GenericArray<T,N>` type, which lets
+//! the above be implemented as:
+//!
+//! ```rust
+//! use generic_array::{ArrayLength, GenericArray};
+//!
+//! struct Foo<T, N: ArrayLength<T>> {
+//!     data: GenericArray<T,N>
+//! }
+//! ```
+//!
+//! The `ArrayLength<T>` trait is implemented by default for
+//! [unsigned integer types](../typenum/uint/index.html) from
+//! [typenum](../typenum/index.html):
+//!
+//! ```rust
+//! # use generic_array::{ArrayLength, GenericArray};
+//! use generic_array::typenum::U5;
+//!
+//! struct Foo<N: ArrayLength<i32>> {
+//!     data: GenericArray<i32, N>
+//! }
+//!
+//! # fn main() {
+//! let foo = Foo::<U5>{data: GenericArray::default()};
+//! # }
+//! ```
+//!
+//! For example, `GenericArray<T, U5>` would work almost like `[T; 5]`:
+//!
+//! ```rust
+//! # use generic_array::{ArrayLength, GenericArray};
+//! use generic_array::typenum::U5;
+//!
+//! struct Foo<T, N: ArrayLength<T>> {
+//!     data: GenericArray<T, N>
+//! }
+//!
+//! # fn main() {
+//! let foo = Foo::<i32, U5>{data: GenericArray::default()};
+//! # }
+//! ```
+//!
+//! For ease of use, an `arr!` macro is provided - example below:
+//!
+//! ```
+//! # #[macro_use]
+//! # extern crate generic_array;
+//! # extern crate typenum;
+//! # fn main() {
+//! let array = arr![u32; 1, 2, 3];
+//! assert_eq!(array[2], 3);
+//! # }
+//! ```
+
+#![deny(missing_docs)]
+#![deny(meta_variable_misuse)]
+#![no_std]
+
+#[cfg(feature = "serde")]
+extern crate serde;
+
+#[cfg(test)]
+extern crate bincode;
+
+pub extern crate typenum;
+
+mod hex;
+mod impls;
+
+#[cfg(feature = "serde")]
+mod impl_serde;
+
+use core::iter::FromIterator;
+use core::marker::PhantomData;
+use core::mem::{MaybeUninit, ManuallyDrop};
+use core::ops::{Deref, DerefMut};
+use core::{mem, ptr, slice};
+use typenum::bit::{B0, B1};
+use typenum::uint::{UInt, UTerm, Unsigned};
+
+#[cfg_attr(test, macro_use)]
+pub mod arr;
+pub mod functional;
+pub mod iter;
+pub mod sequence;
+
+use self::functional::*;
+pub use self::iter::GenericArrayIter;
+use self::sequence::*;
+
+/// Trait making `GenericArray` work, marking types to be used as length of an array
+pub unsafe trait ArrayLength<T>: Unsigned {
+    /// Associated type representing the array type for the number
+    type ArrayType;
+}
+
+unsafe impl<T> ArrayLength<T> for UTerm {
+    #[doc(hidden)]
+    type ArrayType = [T; 0];
+}
+
+/// Internal type used to generate a struct of appropriate size
+#[allow(dead_code)]
+#[repr(C)]
+#[doc(hidden)]
+pub struct GenericArrayImplEven<T, U> {
+    parent1: U,
+    parent2: U,
+    _marker: PhantomData<T>,
+}
+
+impl<T: Clone, U: Clone> Clone for GenericArrayImplEven<T, U> {
+    fn clone(&self) -> GenericArrayImplEven<T, U> {
+        GenericArrayImplEven {
+            parent1: self.parent1.clone(),
+            parent2: self.parent2.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T: Copy, U: Copy> Copy for GenericArrayImplEven<T, U> {}
+
+/// Internal type used to generate a struct of appropriate size
+#[allow(dead_code)]
+#[repr(C)]
+#[doc(hidden)]
+pub struct GenericArrayImplOdd<T, U> {
+    parent1: U,
+    parent2: U,
+    data: T,
+}
+
+impl<T: Clone, U: Clone> Clone for GenericArrayImplOdd<T, U> {
+    fn clone(&self) -> GenericArrayImplOdd<T, U> {
+        GenericArrayImplOdd {
+            parent1: self.parent1.clone(),
+            parent2: self.parent2.clone(),
+            data: self.data.clone(),
+        }
+    }
+}
+
+impl<T: Copy, U: Copy> Copy for GenericArrayImplOdd<T, U> {}
+
+unsafe impl<T, N: ArrayLength<T>> ArrayLength<T> for UInt<N, B0> {
+    #[doc(hidden)]
+    type ArrayType = GenericArrayImplEven<T, N::ArrayType>;
+}
+
+unsafe impl<T, N: ArrayLength<T>> ArrayLength<T> for UInt<N, B1> {
+    #[doc(hidden)]
+    type ArrayType = GenericArrayImplOdd<T, N::ArrayType>;
+}
+
+/// Struct representing a generic array - `GenericArray<T, N>` works like [T; N]
+#[allow(dead_code)]
+#[repr(transparent)]
+pub struct GenericArray<T, U: ArrayLength<T>> {
+    data: U::ArrayType,
+}
+
+unsafe impl<T: Send, N: ArrayLength<T>> Send for GenericArray<T, N> {}
+unsafe impl<T: Sync, N: ArrayLength<T>> Sync for GenericArray<T, N> {}
+
+impl<T, N> Deref for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    type Target = [T];
+
+    #[inline(always)]
+    fn deref(&self) -> &[T] {
+        unsafe { slice::from_raw_parts(self as *const Self as *const T, N::USIZE) }
+    }
+}
+
+impl<T, N> DerefMut for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut [T] {
+        unsafe { slice::from_raw_parts_mut(self as *mut Self as *mut T, N::USIZE) }
+    }
+}
+
+/// Creates an array one element at a time using a mutable iterator
+/// you can write to with `ptr::write`.
+///
+/// Incremenent the position while iterating to mark off created elements,
+/// which will be dropped if `into_inner` is not called.
+#[doc(hidden)]
+pub struct ArrayBuilder<T, N: ArrayLength<T>> {
+    array: MaybeUninit<GenericArray<T, N>>,
+    position: usize,
+}
+
+impl<T, N: ArrayLength<T>> ArrayBuilder<T, N> {
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn new() -> ArrayBuilder<T, N> {
+        ArrayBuilder {
+            array: MaybeUninit::uninit(),
+            position: 0,
+        }
+    }
+
+    /// Creates a mutable iterator for writing to the array using `ptr::write`.
+    ///
+    /// Increment the position value given as a mutable reference as you iterate
+    /// to mark how many elements have been created.
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn iter_position(&mut self) -> (slice::IterMut<T>, &mut usize) {
+        ((&mut *self.array.as_mut_ptr()).iter_mut(), &mut self.position)
+    }
+
+    /// When done writing (assuming all elements have been written to),
+    /// get the inner array.
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn into_inner(self) -> GenericArray<T, N> {
+        let array = ptr::read(&self.array);
+
+        mem::forget(self);
+
+        array.assume_init()
+    }
+}
+
+impl<T, N: ArrayLength<T>> Drop for ArrayBuilder<T, N> {
+    fn drop(&mut self) {
+        if mem::needs_drop::<T>() {
+            unsafe {
+                for value in &mut (&mut *self.array.as_mut_ptr())[..self.position] {
+                    ptr::drop_in_place(value);
+                }
+            }
+        }
+    }
+}
+
+/// Consumes an array.
+///
+/// Increment the position while iterating and any leftover elements
+/// will be dropped if position does not go to N
+#[doc(hidden)]
+pub struct ArrayConsumer<T, N: ArrayLength<T>> {
+    array: ManuallyDrop<GenericArray<T, N>>,
+    position: usize,
+}
+
+impl<T, N: ArrayLength<T>> ArrayConsumer<T, N> {
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn new(array: GenericArray<T, N>) -> ArrayConsumer<T, N> {
+        ArrayConsumer {
+            array: ManuallyDrop::new(array),
+            position: 0,
+        }
+    }
+
+    /// Creates an iterator and mutable reference to the internal position
+    /// to keep track of consumed elements.
+    ///
+    /// Increment the position as you iterate to mark off consumed elements
+    #[doc(hidden)]
+    #[inline]
+    pub unsafe fn iter_position(&mut self) -> (slice::Iter<T>, &mut usize) {
+        (self.array.iter(), &mut self.position)
+    }
+}
+
+impl<T, N: ArrayLength<T>> Drop for ArrayConsumer<T, N> {
+    fn drop(&mut self) {
+        if mem::needs_drop::<T>() {
+            for value in &mut self.array[self.position..N::USIZE] {
+                unsafe {
+                    ptr::drop_in_place(value);
+                }
+            }
+        }
+    }
+}
+
+impl<'a, T: 'a, N> IntoIterator for &'a GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    type IntoIter = slice::Iter<'a, T>;
+    type Item = &'a T;
+
+    fn into_iter(self: &'a GenericArray<T, N>) -> Self::IntoIter {
+        self.as_slice().iter()
+    }
+}
+
+impl<'a, T: 'a, N> IntoIterator for &'a mut GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    type IntoIter = slice::IterMut<'a, T>;
+    type Item = &'a mut T;
+
+    fn into_iter(self: &'a mut GenericArray<T, N>) -> Self::IntoIter {
+        self.as_mut_slice().iter_mut()
+    }
+}
+
+impl<T, N> FromIterator<T> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn from_iter<I>(iter: I) -> GenericArray<T, N>
+    where
+        I: IntoIterator<Item = T>,
+    {
+        unsafe {
+            let mut destination = ArrayBuilder::new();
+
+            {
+                let (destination_iter, position) = destination.iter_position();
+
+                iter.into_iter()
+                    .zip(destination_iter)
+                    .for_each(|(src, dst)| {
+                        ptr::write(dst, src);
+
+                        *position += 1;
+                    });
+            }
+
+            if destination.position < N::USIZE {
+                from_iter_length_fail(destination.position, N::USIZE);
+            }
+
+            destination.into_inner()
+        }
+    }
+}
+
+#[inline(never)]
+#[cold]
+fn from_iter_length_fail(length: usize, expected: usize) -> ! {
+    panic!(
+        "GenericArray::from_iter received {} elements but expected {}",
+        length, expected
+    );
+}
+
+unsafe impl<T, N> GenericSequence<T> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+    Self: IntoIterator<Item = T>,
+{
+    type Length = N;
+    type Sequence = Self;
+
+    fn generate<F>(mut f: F) -> GenericArray<T, N>
+    where
+        F: FnMut(usize) -> T,
+    {
+        unsafe {
+            let mut destination = ArrayBuilder::new();
+
+            {
+                let (destination_iter, position) = destination.iter_position();
+
+                destination_iter.enumerate().for_each(|(i, dst)| {
+                    ptr::write(dst, f(i));
+
+                    *position += 1;
+                });
+            }
+
+            destination.into_inner()
+        }
+    }
+
+    #[doc(hidden)]
+    fn inverted_zip<B, U, F>(
+        self,
+        lhs: GenericArray<B, Self::Length>,
+        mut f: F,
+    ) -> MappedSequence<GenericArray<B, Self::Length>, B, U>
+    where
+        GenericArray<B, Self::Length>:
+            GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
+        Self: MappedGenericSequence<T, U>,
+        Self::Length: ArrayLength<B> + ArrayLength<U>,
+        F: FnMut(B, Self::Item) -> U,
+    {
+        unsafe {
+            let mut left = ArrayConsumer::new(lhs);
+            let mut right = ArrayConsumer::new(self);
+
+            let (left_array_iter, left_position) = left.iter_position();
+            let (right_array_iter, right_position) = right.iter_position();
+
+            FromIterator::from_iter(left_array_iter.zip(right_array_iter).map(|(l, r)| {
+                let left_value = ptr::read(l);
+                let right_value = ptr::read(r);
+
+                *left_position += 1;
+                *right_position += 1;
+
+                f(left_value, right_value)
+            }))
+        }
+    }
+
+    #[doc(hidden)]
+    fn inverted_zip2<B, Lhs, U, F>(self, lhs: Lhs, mut f: F) -> MappedSequence<Lhs, B, U>
+    where
+        Lhs: GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
+        Self: MappedGenericSequence<T, U>,
+        Self::Length: ArrayLength<B> + ArrayLength<U>,
+        F: FnMut(Lhs::Item, Self::Item) -> U,
+    {
+        unsafe {
+            let mut right = ArrayConsumer::new(self);
+
+            let (right_array_iter, right_position) = right.iter_position();
+
+            FromIterator::from_iter(
+                lhs.into_iter()
+                    .zip(right_array_iter)
+                    .map(|(left_value, r)| {
+                        let right_value = ptr::read(r);
+
+                        *right_position += 1;
+
+                        f(left_value, right_value)
+                    }),
+            )
+        }
+    }
+}
+
+unsafe impl<T, U, N> MappedGenericSequence<T, U> for GenericArray<T, N>
+where
+    N: ArrayLength<T> + ArrayLength<U>,
+    GenericArray<U, N>: GenericSequence<U, Length = N>,
+{
+    type Mapped = GenericArray<U, N>;
+}
+
+unsafe impl<T, N> FunctionalSequence<T> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+    Self: GenericSequence<T, Item = T, Length = N>,
+{
+    fn map<U, F>(self, mut f: F) -> MappedSequence<Self, T, U>
+    where
+        Self::Length: ArrayLength<U>,
+        Self: MappedGenericSequence<T, U>,
+        F: FnMut(T) -> U,
+    {
+        unsafe {
+            let mut source = ArrayConsumer::new(self);
+
+            let (array_iter, position) = source.iter_position();
+
+            FromIterator::from_iter(array_iter.map(|src| {
+                let value = ptr::read(src);
+
+                *position += 1;
+
+                f(value)
+            }))
+        }
+    }
+
+    #[inline]
+    fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
+    where
+        Self: MappedGenericSequence<T, U>,
+        Rhs: MappedGenericSequence<B, U, Mapped = MappedSequence<Self, T, U>>,
+        Self::Length: ArrayLength<B> + ArrayLength<U>,
+        Rhs: GenericSequence<B, Length = Self::Length>,
+        F: FnMut(T, Rhs::Item) -> U,
+    {
+        rhs.inverted_zip(self, f)
+    }
+
+    fn fold<U, F>(self, init: U, mut f: F) -> U
+    where
+        F: FnMut(U, T) -> U,
+    {
+        unsafe {
+            let mut source = ArrayConsumer::new(self);
+
+            let (array_iter, position) = source.iter_position();
+
+            array_iter.fold(init, |acc, src| {
+                let value = ptr::read(src);
+
+                *position += 1;
+
+                f(acc, value)
+            })
+        }
+    }
+}
+
+impl<T, N> GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    /// Extracts a slice containing the entire array.
+    #[inline]
+    pub fn as_slice(&self) -> &[T] {
+        self.deref()
+    }
+
+    /// Extracts a mutable slice containing the entire array.
+    #[inline]
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
+        self.deref_mut()
+    }
+
+    /// Converts slice to a generic array reference with inferred length;
+    ///
+    /// Length of the slice must be equal to the length of the array.
+    #[inline]
+    pub fn from_slice(slice: &[T]) -> &GenericArray<T, N> {
+        slice.into()
+    }
+
+    /// Converts mutable slice to a mutable generic array reference
+    ///
+    /// Length of the slice must be equal to the length of the array.
+    #[inline]
+    pub fn from_mut_slice(slice: &mut [T]) -> &mut GenericArray<T, N> {
+        slice.into()
+    }
+}
+
+impl<'a, T, N: ArrayLength<T>> From<&'a [T]> for &'a GenericArray<T, N> {
+    /// Converts slice to a generic array reference with inferred length;
+    ///
+    /// Length of the slice must be equal to the length of the array.
+    #[inline]
+    fn from(slice: &[T]) -> &GenericArray<T, N> {
+        assert_eq!(slice.len(), N::USIZE);
+
+        unsafe { &*(slice.as_ptr() as *const GenericArray<T, N>) }
+    }
+}
+
+impl<'a, T, N: ArrayLength<T>> From<&'a mut [T]> for &'a mut GenericArray<T, N> {
+    /// Converts mutable slice to a mutable generic array reference
+    ///
+    /// Length of the slice must be equal to the length of the array.
+    #[inline]
+    fn from(slice: &mut [T]) -> &mut GenericArray<T, N> {
+        assert_eq!(slice.len(), N::USIZE);
+
+        unsafe { &mut *(slice.as_mut_ptr() as *mut GenericArray<T, N>) }
+    }
+}
+
+impl<T: Clone, N> GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    /// Construct a `GenericArray` from a slice by cloning its content
+    ///
+    /// Length of the slice must be equal to the length of the array
+    #[inline]
+    pub fn clone_from_slice(list: &[T]) -> GenericArray<T, N> {
+        Self::from_exact_iter(list.iter().cloned())
+            .expect("Slice must be the same length as the array")
+    }
+}
+
+impl<T, N> GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    /// Creates a new `GenericArray` instance from an iterator with a specific size.
+    ///
+    /// Returns `None` if the size is not equal to the number of elements in the `GenericArray`.
+    pub fn from_exact_iter<I>(iter: I) -> Option<Self>
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let mut iter = iter.into_iter();
+
+        unsafe {
+            let mut destination = ArrayBuilder::new();
+
+            {
+                let (destination_iter, position) = destination.iter_position();
+
+                destination_iter.zip(&mut iter).for_each(|(dst, src)| {
+                    ptr::write(dst, src);
+
+                    *position += 1;
+                });
+
+                // The iterator produced fewer than `N` elements.
+                if *position != N::USIZE {
+                    return None;
+                }
+
+                // The iterator produced more than `N` elements.
+                if iter.next().is_some() {
+                    return None;
+                }
+            }
+
+            Some(destination.into_inner())
+        }
+    }
+}
+
+/// A reimplementation of the `transmute` function, avoiding problems
+/// when the compiler can't prove equal sizes.
+#[inline]
+#[doc(hidden)]
+pub unsafe fn transmute<A, B>(a: A) -> B {
+    let a = ManuallyDrop::new(a);
+    ::core::ptr::read(&*a as *const A as *const B)
+}
+
+#[cfg(test)]
+mod test {
+    // Compile with:
+    // cargo rustc --lib --profile test --release --
+    //      -C target-cpu=native -C opt-level=3 --emit asm
+    // and view the assembly to make sure test_assembly generates
+    // SIMD instructions instead of a niave loop.
+
+    #[inline(never)]
+    pub fn black_box<T>(val: T) -> T {
+        use core::{mem, ptr};
+
+        let ret = unsafe { ptr::read_volatile(&val) };
+        mem::forget(val);
+        ret
+    }
+
+    #[test]
+    fn test_assembly() {
+        use crate::functional::*;
+
+        let a = black_box(arr![i32; 1, 3, 5, 7]);
+        let b = black_box(arr![i32; 2, 4, 6, 8]);
+
+        let c = (&a).zip(b, |l, r| l + r);
+
+        let d = a.fold(0, |a, x| a + x);
+
+        assert_eq!(c, arr![i32; 3, 7, 11, 15]);
+
+        assert_eq!(d, 16);
+    }
+}

zeroidc/vendor/generic-array/src/sequence.rs

@@ -1,380 +1,380 @@
-//! Useful traits for manipulating sequences of data stored in `GenericArray`s
-
-use super::*;
-use core::ops::{Add, Sub};
-use core::mem::MaybeUninit;
-use core::ptr;
-use typenum::operator_aliases::*;
-
-/// Defines some sequence with an associated length and iteration capabilities.
-///
-/// This is useful for passing N-length generic arrays as generics.
-pub unsafe trait GenericSequence<T>: Sized + IntoIterator {
-    /// `GenericArray` associated length
-    type Length: ArrayLength<T>;
-
-    /// Concrete sequence type used in conjuction with reference implementations of `GenericSequence`
-    type Sequence: GenericSequence<T, Length = Self::Length> + FromIterator<T>;
-
-    /// Initializes a new sequence instance using the given function.
-    ///
-    /// If the generator function panics while initializing the sequence,
-    /// any already initialized elements will be dropped.
-    fn generate<F>(f: F) -> Self::Sequence
-    where
-        F: FnMut(usize) -> T;
-
-    #[doc(hidden)]
-    fn inverted_zip<B, U, F>(
-        self,
-        lhs: GenericArray<B, Self::Length>,
-        mut f: F,
-    ) -> MappedSequence<GenericArray<B, Self::Length>, B, U>
-    where
-        GenericArray<B, Self::Length>: GenericSequence<B, Length = Self::Length>
-            + MappedGenericSequence<B, U>,
-        Self: MappedGenericSequence<T, U>,
-        Self::Length: ArrayLength<B> + ArrayLength<U>,
-        F: FnMut(B, Self::Item) -> U,
-    {
-        unsafe {
-            let mut left = ArrayConsumer::new(lhs);
-
-            let (left_array_iter, left_position) = left.iter_position();
-
-            FromIterator::from_iter(left_array_iter.zip(self.into_iter()).map(
-                |(l, right_value)| {
-                        let left_value = ptr::read(l);
-
-                        *left_position += 1;
-
-                        f(left_value, right_value)
-                },
-            ))
-        }
-    }
-
-    #[doc(hidden)]
-    fn inverted_zip2<B, Lhs, U, F>(self, lhs: Lhs, mut f: F) -> MappedSequence<Lhs, B, U>
-    where
-        Lhs: GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
-        Self: MappedGenericSequence<T, U>,
-        Self::Length: ArrayLength<B> + ArrayLength<U>,
-        F: FnMut(Lhs::Item, Self::Item) -> U,
-    {
-        FromIterator::from_iter(lhs.into_iter().zip(self.into_iter()).map(|(l, r)| f(l, r)))
-    }
-}
-
-/// Accessor for `GenericSequence` item type, which is really `IntoIterator::Item`
-///
-/// For deeply nested generic mapped sequence types, like shown in `tests/generics.rs`,
-/// this can be useful for keeping things organized.
-pub type SequenceItem<T> = <T as IntoIterator>::Item;
-
-unsafe impl<'a, T: 'a, S: GenericSequence<T>> GenericSequence<T> for &'a S
-where
-    &'a S: IntoIterator,
-{
-    type Length = S::Length;
-    type Sequence = S::Sequence;
-
-    #[inline]
-    fn generate<F>(f: F) -> Self::Sequence
-    where
-        F: FnMut(usize) -> T,
-    {
-        S::generate(f)
-    }
-}
-
-unsafe impl<'a, T: 'a, S: GenericSequence<T>> GenericSequence<T> for &'a mut S
-where
-    &'a mut S: IntoIterator,
-{
-    type Length = S::Length;
-    type Sequence = S::Sequence;
-
-    #[inline]
-    fn generate<F>(f: F) -> Self::Sequence
-    where
-        F: FnMut(usize) -> T,
-    {
-        S::generate(f)
-    }
-}
-
-/// Defines any `GenericSequence` which can be lengthened or extended by appending
-/// or prepending an element to it.
-///
-/// Any lengthened sequence can be shortened back to the original using `pop_front` or `pop_back`
-pub unsafe trait Lengthen<T>: Sized + GenericSequence<T> {
-    /// `GenericSequence` that has one more element than `Self`
-    type Longer: Shorten<T, Shorter = Self>;
-
-    /// Returns a new array with the given element appended to the end of it.
-    ///
-    /// Example:
-    ///
-    /// ```rust
-    /// # use generic_array::{arr, sequence::Lengthen};
-    /// # fn main() {
-    /// let a = arr![i32; 1, 2, 3];
-    ///
-    /// let b = a.append(4);
-    ///
-    /// assert_eq!(b, arr![i32; 1, 2, 3, 4]);
-    /// # }
-    /// ```
-    fn append(self, last: T) -> Self::Longer;
-
-    /// Returns a new array with the given element prepended to the front of it.
-    ///
-    /// Example:
-    ///
-    /// ```rust
-    /// # use generic_array::{arr, sequence::Lengthen};
-    /// # fn main() {
-    /// let a = arr![i32; 1, 2, 3];
-    ///
-    /// let b = a.prepend(4);
-    ///
-    /// assert_eq!(b, arr![i32; 4, 1, 2, 3]);
-    /// # }
-    /// ```
-    fn prepend(self, first: T) -> Self::Longer;
-}
-
-/// Defines a `GenericSequence` which can be shortened by removing the first or last element from it.
-///
-/// Additionally, any shortened sequence can be lengthened by
-/// appending or prepending an element to it.
-pub unsafe trait Shorten<T>: Sized + GenericSequence<T> {
-    /// `GenericSequence` that has one less element than `Self`
-    type Shorter: Lengthen<T, Longer = Self>;
-
-    /// Returns a new array without the last element, and the last element.
-    ///
-    /// Example:
-    ///
-    /// ```rust
-    /// # use generic_array::{arr, sequence::Shorten};
-    /// # fn main() {
-    /// let a = arr![i32; 1, 2, 3, 4];
-    ///
-    /// let (init, last) = a.pop_back();
-    ///
-    /// assert_eq!(init, arr![i32; 1, 2, 3]);
-    /// assert_eq!(last, 4);
-    /// # }
-    /// ```
-    fn pop_back(self) -> (Self::Shorter, T);
-
-    /// Returns a new array without the first element, and the first element.
-    /// Example:
-    ///
-    /// ```rust
-    /// # use generic_array::{arr, sequence::Shorten};
-    /// # fn main() {
-    /// let a = arr![i32; 1, 2, 3, 4];
-    ///
-    /// let (head, tail) = a.pop_front();
-    ///
-    /// assert_eq!(head, 1);
-    /// assert_eq!(tail, arr![i32; 2, 3, 4]);
-    /// # }
-    /// ```
-    fn pop_front(self) -> (T, Self::Shorter);
-}
-
-unsafe impl<T, N: ArrayLength<T>> Lengthen<T> for GenericArray<T, N>
-where
-    N: Add<B1>,
-    Add1<N>: ArrayLength<T>,
-    Add1<N>: Sub<B1, Output = N>,
-    Sub1<Add1<N>>: ArrayLength<T>,
-{
-    type Longer = GenericArray<T, Add1<N>>;
-
-    fn append(self, last: T) -> Self::Longer {
-        let mut longer: MaybeUninit<Self::Longer> = MaybeUninit::uninit();
-
-        // Note this is *mut Self, so add(1) increments by the whole array
-        let out_ptr = longer.as_mut_ptr() as *mut Self;
-
-        unsafe {
-            // write self first
-            ptr::write(out_ptr, self);
-            // increment past self, then write the last
-            ptr::write(out_ptr.add(1) as *mut T, last);
-
-            longer.assume_init()
-        }
-    }
-
-    fn prepend(self, first: T) -> Self::Longer {
-        let mut longer: MaybeUninit<Self::Longer> = MaybeUninit::uninit();
-
-        // Note this is *mut T, so add(1) increments by a single T
-        let out_ptr = longer.as_mut_ptr() as *mut T;
-
-        unsafe {
-            // write the first at the start
-            ptr::write(out_ptr, first);
-            // increment past the first, then write self
-            ptr::write(out_ptr.add(1) as *mut Self, self);
-
-            longer.assume_init()
-        }
-    }
-}
-
-unsafe impl<T, N: ArrayLength<T>> Shorten<T> for GenericArray<T, N>
-where
-    N: Sub<B1>,
-    Sub1<N>: ArrayLength<T>,
-    Sub1<N>: Add<B1, Output = N>,
-    Add1<Sub1<N>>: ArrayLength<T>,
-{
-    type Shorter = GenericArray<T, Sub1<N>>;
-
-    fn pop_back(self) -> (Self::Shorter, T) {
-        let whole = ManuallyDrop::new(self);
-
-        unsafe {
-            let init = ptr::read(whole.as_ptr() as _);
-            let last = ptr::read(whole.as_ptr().add(Sub1::<N>::USIZE) as _);
-
-            (init, last)
-        }
-    }
-
-    fn pop_front(self) -> (T, Self::Shorter) {
-        // ensure this doesn't get dropped
-        let whole = ManuallyDrop::new(self);
-
-        unsafe {
-            let head = ptr::read(whole.as_ptr() as _);
-            let tail = ptr::read(whole.as_ptr().offset(1) as _);
-
-            (head, tail)
-        }
-    }
-}
-
-/// Defines a `GenericSequence` that can be split into two parts at a given pivot index.
-pub unsafe trait Split<T, K>: GenericSequence<T>
-where
-    K: ArrayLength<T>,
-{
-    /// First part of the resulting split array
-    type First: GenericSequence<T>;
-    /// Second part of the resulting split array
-    type Second: GenericSequence<T>;
-
-    /// Splits an array at the given index, returning the separate parts of the array.
-    fn split(self) -> (Self::First, Self::Second);
-}
-
-unsafe impl<T, N, K> Split<T, K> for GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-    K: ArrayLength<T>,
-    N: Sub<K>,
-    Diff<N, K>: ArrayLength<T>,
-{
-    type First = GenericArray<T, K>;
-    type Second = GenericArray<T, Diff<N, K>>;
-
-    fn split(self) -> (Self::First, Self::Second) {
-        unsafe {
-            // ensure this doesn't get dropped
-            let whole = ManuallyDrop::new(self);
-
-            let head = ptr::read(whole.as_ptr() as *const _);
-            let tail = ptr::read(whole.as_ptr().add(K::USIZE) as *const _);
-
-            (head, tail)
-        }
-    }
-}
-
-unsafe impl<'a, T, N, K> Split<T, K> for &'a GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-    K: ArrayLength<T> + 'static,
-    N: Sub<K>,
-    Diff<N, K>: ArrayLength<T>,
-{
-    type First = &'a GenericArray<T, K>;
-    type Second = &'a GenericArray<T, Diff<N, K>>;
-
-    fn split(self) -> (Self::First, Self::Second) {
-        unsafe {
-            let ptr_to_first: *const T = self.as_ptr();
-            let head = &*(ptr_to_first as *const _);
-            let tail = &*(ptr_to_first.add(K::USIZE) as *const _);
-            (head, tail)
-        }
-    }
-}
-
-unsafe impl<'a, T, N, K> Split<T, K> for &'a mut GenericArray<T, N>
-where
-    N: ArrayLength<T>,
-    K: ArrayLength<T> + 'static,
-    N: Sub<K>,
-    Diff<N, K>: ArrayLength<T>,
-{
-    type First = &'a mut GenericArray<T, K>;
-    type Second = &'a mut GenericArray<T, Diff<N, K>>;
-
-    fn split(self) -> (Self::First, Self::Second) {
-        unsafe {
-            let ptr_to_first: *mut T = self.as_mut_ptr();
-            let head = &mut *(ptr_to_first as *mut _);
-            let tail = &mut *(ptr_to_first.add(K::USIZE) as *mut _);
-            (head, tail)
-        }
-    }
-}
-
-/// Defines `GenericSequence`s which can be joined together, forming a larger array.
-pub unsafe trait Concat<T, M>: GenericSequence<T>
-where
-    M: ArrayLength<T>,
-{
-    /// Sequence to be concatenated with `self`
-    type Rest: GenericSequence<T, Length = M>;
-
-    /// Resulting sequence formed by the concatenation.
-    type Output: GenericSequence<T>;
-
-    /// Concatenate, or join, two sequences.
-    fn concat(self, rest: Self::Rest) -> Self::Output;
-}
-
-unsafe impl<T, N, M> Concat<T, M> for GenericArray<T, N>
-where
-    N: ArrayLength<T> + Add<M>,
-    M: ArrayLength<T>,
-    Sum<N, M>: ArrayLength<T>,
-{
-    type Rest = GenericArray<T, M>;
-    type Output = GenericArray<T, Sum<N, M>>;
-
-    fn concat(self, rest: Self::Rest) -> Self::Output {
-        let mut output: MaybeUninit<Self::Output> = MaybeUninit::uninit();
-
-        let out_ptr = output.as_mut_ptr() as *mut Self;
-
-        unsafe {
-            // write all of self to the pointer
-            ptr::write(out_ptr, self);
-            // increment past self, then write the rest
-            ptr::write(out_ptr.add(1) as *mut _, rest);
-
-            output.assume_init()
-        }
-    }
-}
+//! Useful traits for manipulating sequences of data stored in `GenericArray`s
+
+use super::*;
+use core::ops::{Add, Sub};
+use core::mem::MaybeUninit;
+use core::ptr;
+use typenum::operator_aliases::*;
+
+/// Defines some sequence with an associated length and iteration capabilities.
+///
+/// This is useful for passing N-length generic arrays as generics.
+pub unsafe trait GenericSequence<T>: Sized + IntoIterator {
+    /// `GenericArray` associated length
+    type Length: ArrayLength<T>;
+
+    /// Concrete sequence type used in conjuction with reference implementations of `GenericSequence`
+    type Sequence: GenericSequence<T, Length = Self::Length> + FromIterator<T>;
+
+    /// Initializes a new sequence instance using the given function.
+    ///
+    /// If the generator function panics while initializing the sequence,
+    /// any already initialized elements will be dropped.
+    fn generate<F>(f: F) -> Self::Sequence
+    where
+        F: FnMut(usize) -> T;
+
+    #[doc(hidden)]
+    fn inverted_zip<B, U, F>(
+        self,
+        lhs: GenericArray<B, Self::Length>,
+        mut f: F,
+    ) -> MappedSequence<GenericArray<B, Self::Length>, B, U>
+    where
+        GenericArray<B, Self::Length>: GenericSequence<B, Length = Self::Length>
+            + MappedGenericSequence<B, U>,
+        Self: MappedGenericSequence<T, U>,
+        Self::Length: ArrayLength<B> + ArrayLength<U>,
+        F: FnMut(B, Self::Item) -> U,
+    {
+        unsafe {
+            let mut left = ArrayConsumer::new(lhs);
+
+            let (left_array_iter, left_position) = left.iter_position();
+
+            FromIterator::from_iter(left_array_iter.zip(self.into_iter()).map(
+                |(l, right_value)| {
+                        let left_value = ptr::read(l);
+
+                        *left_position += 1;
+
+                        f(left_value, right_value)
+                },
+            ))
+        }
+    }
+
+    #[doc(hidden)]
+    fn inverted_zip2<B, Lhs, U, F>(self, lhs: Lhs, mut f: F) -> MappedSequence<Lhs, B, U>
+    where
+        Lhs: GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
+        Self: MappedGenericSequence<T, U>,
+        Self::Length: ArrayLength<B> + ArrayLength<U>,
+        F: FnMut(Lhs::Item, Self::Item) -> U,
+    {
+        FromIterator::from_iter(lhs.into_iter().zip(self.into_iter()).map(|(l, r)| f(l, r)))
+    }
+}
+
+/// Accessor for `GenericSequence` item type, which is really `IntoIterator::Item`
+///
+/// For deeply nested generic mapped sequence types, like shown in `tests/generics.rs`,
+/// this can be useful for keeping things organized.
+pub type SequenceItem<T> = <T as IntoIterator>::Item;
+
+unsafe impl<'a, T: 'a, S: GenericSequence<T>> GenericSequence<T> for &'a S
+where
+    &'a S: IntoIterator,
+{
+    type Length = S::Length;
+    type Sequence = S::Sequence;
+
+    #[inline]
+    fn generate<F>(f: F) -> Self::Sequence
+    where
+        F: FnMut(usize) -> T,
+    {
+        S::generate(f)
+    }
+}
+
+unsafe impl<'a, T: 'a, S: GenericSequence<T>> GenericSequence<T> for &'a mut S
+where
+    &'a mut S: IntoIterator,
+{
+    type Length = S::Length;
+    type Sequence = S::Sequence;
+
+    #[inline]
+    fn generate<F>(f: F) -> Self::Sequence
+    where
+        F: FnMut(usize) -> T,
+    {
+        S::generate(f)
+    }
+}
+
+/// Defines any `GenericSequence` which can be lengthened or extended by appending
+/// or prepending an element to it.
+///
+/// Any lengthened sequence can be shortened back to the original using `pop_front` or `pop_back`
+pub unsafe trait Lengthen<T>: Sized + GenericSequence<T> {
+    /// `GenericSequence` that has one more element than `Self`
+    type Longer: Shorten<T, Shorter = Self>;
+
+    /// Returns a new array with the given element appended to the end of it.
+    ///
+    /// Example:
+    ///
+    /// ```rust
+    /// # use generic_array::{arr, sequence::Lengthen};
+    /// # fn main() {
+    /// let a = arr![i32; 1, 2, 3];
+    ///
+    /// let b = a.append(4);
+    ///
+    /// assert_eq!(b, arr![i32; 1, 2, 3, 4]);
+    /// # }
+    /// ```
+    fn append(self, last: T) -> Self::Longer;
+
+    /// Returns a new array with the given element prepended to the front of it.
+    ///
+    /// Example:
+    ///
+    /// ```rust
+    /// # use generic_array::{arr, sequence::Lengthen};
+    /// # fn main() {
+    /// let a = arr![i32; 1, 2, 3];
+    ///
+    /// let b = a.prepend(4);
+    ///
+    /// assert_eq!(b, arr![i32; 4, 1, 2, 3]);
+    /// # }
+    /// ```
+    fn prepend(self, first: T) -> Self::Longer;
+}
+
+/// Defines a `GenericSequence` which can be shortened by removing the first or last element from it.
+///
+/// Additionally, any shortened sequence can be lengthened by
+/// appending or prepending an element to it.
+pub unsafe trait Shorten<T>: Sized + GenericSequence<T> {
+    /// `GenericSequence` that has one less element than `Self`
+    type Shorter: Lengthen<T, Longer = Self>;
+
+    /// Returns a new array without the last element, and the last element.
+    ///
+    /// Example:
+    ///
+    /// ```rust
+    /// # use generic_array::{arr, sequence::Shorten};
+    /// # fn main() {
+    /// let a = arr![i32; 1, 2, 3, 4];
+    ///
+    /// let (init, last) = a.pop_back();
+    ///
+    /// assert_eq!(init, arr![i32; 1, 2, 3]);
+    /// assert_eq!(last, 4);
+    /// # }
+    /// ```
+    fn pop_back(self) -> (Self::Shorter, T);
+
+    /// Returns a new array without the first element, and the first element.
+    /// Example:
+    ///
+    /// ```rust
+    /// # use generic_array::{arr, sequence::Shorten};
+    /// # fn main() {
+    /// let a = arr![i32; 1, 2, 3, 4];
+    ///
+    /// let (head, tail) = a.pop_front();
+    ///
+    /// assert_eq!(head, 1);
+    /// assert_eq!(tail, arr![i32; 2, 3, 4]);
+    /// # }
+    /// ```
+    fn pop_front(self) -> (T, Self::Shorter);
+}
+
+unsafe impl<T, N: ArrayLength<T>> Lengthen<T> for GenericArray<T, N>
+where
+    N: Add<B1>,
+    Add1<N>: ArrayLength<T>,
+    Add1<N>: Sub<B1, Output = N>,
+    Sub1<Add1<N>>: ArrayLength<T>,
+{
+    type Longer = GenericArray<T, Add1<N>>;
+
+    fn append(self, last: T) -> Self::Longer {
+        let mut longer: MaybeUninit<Self::Longer> = MaybeUninit::uninit();
+
+        // Note this is *mut Self, so add(1) increments by the whole array
+        let out_ptr = longer.as_mut_ptr() as *mut Self;
+
+        unsafe {
+            // write self first
+            ptr::write(out_ptr, self);
+            // increment past self, then write the last
+            ptr::write(out_ptr.add(1) as *mut T, last);
+
+            longer.assume_init()
+        }
+    }
+
+    fn prepend(self, first: T) -> Self::Longer {
+        let mut longer: MaybeUninit<Self::Longer> = MaybeUninit::uninit();
+
+        // Note this is *mut T, so add(1) increments by a single T
+        let out_ptr = longer.as_mut_ptr() as *mut T;
+
+        unsafe {
+            // write the first at the start
+            ptr::write(out_ptr, first);
+            // increment past the first, then write self
+            ptr::write(out_ptr.add(1) as *mut Self, self);
+
+            longer.assume_init()
+        }
+    }
+}
+
+unsafe impl<T, N: ArrayLength<T>> Shorten<T> for GenericArray<T, N>
+where
+    N: Sub<B1>,
+    Sub1<N>: ArrayLength<T>,
+    Sub1<N>: Add<B1, Output = N>,
+    Add1<Sub1<N>>: ArrayLength<T>,
+{
+    type Shorter = GenericArray<T, Sub1<N>>;
+
+    fn pop_back(self) -> (Self::Shorter, T) {
+        let whole = ManuallyDrop::new(self);
+
+        unsafe {
+            let init = ptr::read(whole.as_ptr() as _);
+            let last = ptr::read(whole.as_ptr().add(Sub1::<N>::USIZE) as _);
+
+            (init, last)
+        }
+    }
+
+    fn pop_front(self) -> (T, Self::Shorter) {
+        // ensure this doesn't get dropped
+        let whole = ManuallyDrop::new(self);
+
+        unsafe {
+            let head = ptr::read(whole.as_ptr() as _);
+            let tail = ptr::read(whole.as_ptr().offset(1) as _);
+
+            (head, tail)
+        }
+    }
+}
+
+/// Defines a `GenericSequence` that can be split into two parts at a given pivot index.
+pub unsafe trait Split<T, K>: GenericSequence<T>
+where
+    K: ArrayLength<T>,
+{
+    /// First part of the resulting split array
+    type First: GenericSequence<T>;
+    /// Second part of the resulting split array
+    type Second: GenericSequence<T>;
+
+    /// Splits an array at the given index, returning the separate parts of the array.
+    fn split(self) -> (Self::First, Self::Second);
+}
+
+unsafe impl<T, N, K> Split<T, K> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+    K: ArrayLength<T>,
+    N: Sub<K>,
+    Diff<N, K>: ArrayLength<T>,
+{
+    type First = GenericArray<T, K>;
+    type Second = GenericArray<T, Diff<N, K>>;
+
+    fn split(self) -> (Self::First, Self::Second) {
+        unsafe {
+            // ensure this doesn't get dropped
+            let whole = ManuallyDrop::new(self);
+
+            let head = ptr::read(whole.as_ptr() as *const _);
+            let tail = ptr::read(whole.as_ptr().add(K::USIZE) as *const _);
+
+            (head, tail)
+        }
+    }
+}
+
+unsafe impl<'a, T, N, K> Split<T, K> for &'a GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+    K: ArrayLength<T> + 'static,
+    N: Sub<K>,
+    Diff<N, K>: ArrayLength<T>,
+{
+    type First = &'a GenericArray<T, K>;
+    type Second = &'a GenericArray<T, Diff<N, K>>;
+
+    fn split(self) -> (Self::First, Self::Second) {
+        unsafe {
+            let ptr_to_first: *const T = self.as_ptr();
+            let head = &*(ptr_to_first as *const _);
+            let tail = &*(ptr_to_first.add(K::USIZE) as *const _);
+            (head, tail)
+        }
+    }
+}
+
+unsafe impl<'a, T, N, K> Split<T, K> for &'a mut GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+    K: ArrayLength<T> + 'static,
+    N: Sub<K>,
+    Diff<N, K>: ArrayLength<T>,
+{
+    type First = &'a mut GenericArray<T, K>;
+    type Second = &'a mut GenericArray<T, Diff<N, K>>;
+
+    fn split(self) -> (Self::First, Self::Second) {
+        unsafe {
+            let ptr_to_first: *mut T = self.as_mut_ptr();
+            let head = &mut *(ptr_to_first as *mut _);
+            let tail = &mut *(ptr_to_first.add(K::USIZE) as *mut _);
+            (head, tail)
+        }
+    }
+}
+
+/// Defines `GenericSequence`s which can be joined together, forming a larger array.
+pub unsafe trait Concat<T, M>: GenericSequence<T>
+where
+    M: ArrayLength<T>,
+{
+    /// Sequence to be concatenated with `self`
+    type Rest: GenericSequence<T, Length = M>;
+
+    /// Resulting sequence formed by the concatenation.
+    type Output: GenericSequence<T>;
+
+    /// Concatenate, or join, two sequences.
+    fn concat(self, rest: Self::Rest) -> Self::Output;
+}
+
+unsafe impl<T, N, M> Concat<T, M> for GenericArray<T, N>
+where
+    N: ArrayLength<T> + Add<M>,
+    M: ArrayLength<T>,
+    Sum<N, M>: ArrayLength<T>,
+{
+    type Rest = GenericArray<T, M>;
+    type Output = GenericArray<T, Sum<N, M>>;
+
+    fn concat(self, rest: Self::Rest) -> Self::Output {
+        let mut output: MaybeUninit<Self::Output> = MaybeUninit::uninit();
+
+        let out_ptr = output.as_mut_ptr() as *mut Self;
+
+        unsafe {
+            // write all of self to the pointer
+            ptr::write(out_ptr, self);
+            // increment past self, then write the rest
+            ptr::write(out_ptr.add(1) as *mut _, rest);
+
+            output.assume_init()
+        }
+    }
+}

zeroidc/vendor/generic-array/tests/arr.rs

@@ -1,27 +1,27 @@
-#[macro_use]
-extern crate generic_array;
-extern crate typenum;
-
-#[test]
-fn empty_without_trailing_comma() {
-    let ar = arr![u8; ];
-    assert_eq!(format!("{:x}", ar), "");
-}
-
-#[test]
-fn empty_with_trailing_comma() {
-    let ar = arr![u8; , ];
-    assert_eq!(format!("{:x}", ar), "");
-}
-
-#[test]
-fn without_trailing_comma() {
-    let ar = arr![u8; 10, 20, 30];
-    assert_eq!(format!("{:x}", ar), "0a141e");
-}
-
-#[test]
-fn with_trailing_comma() {
-    let ar = arr![u8; 10, 20, 30, ];
-    assert_eq!(format!("{:x}", ar), "0a141e");
-}
+#[macro_use]
+extern crate generic_array;
+extern crate typenum;
+
+#[test]
+fn empty_without_trailing_comma() {
+    let ar = arr![u8; ];
+    assert_eq!(format!("{:x}", ar), "");
+}
+
+#[test]
+fn empty_with_trailing_comma() {
+    let ar = arr![u8; , ];
+    assert_eq!(format!("{:x}", ar), "");
+}
+
+#[test]
+fn without_trailing_comma() {
+    let ar = arr![u8; 10, 20, 30];
+    assert_eq!(format!("{:x}", ar), "0a141e");
+}
+
+#[test]
+fn with_trailing_comma() {
+    let ar = arr![u8; 10, 20, 30, ];
+    assert_eq!(format!("{:x}", ar), "0a141e");
+}

zeroidc/vendor/generic-array/tests/generics.rs

@@ -1,98 +1,98 @@
-#![recursion_limit = "128"]
-
-#[macro_use]
-extern crate generic_array;
-
-use generic_array::typenum::consts::U4;
-
-use std::fmt::Debug;
-use std::ops::Add;
-
-use generic_array::{GenericArray, ArrayLength};
-use generic_array::sequence::*;
-use generic_array::functional::*;
-
-/// Example function using generics to pass N-length sequences and map them
-pub fn generic_map<S>(s: S)
-where
-    S: FunctionalSequence<i32>,            // `.map`
-    S::Item: Add<i32, Output = i32>,       // `x + 1`
-    S: MappedGenericSequence<i32, i32>,    // `i32` -> `i32`
-    MappedSequence<S, i32, i32>: Debug,    // println!
-{
-    let a = s.map(|x| x + 1);
-
-    println!("{:?}", a);
-}
-
-/// Complex example function using generics to pass N-length sequences, zip them, and then map that result.
-///
-/// If used with `GenericArray` specifically this isn't necessary
-pub fn generic_sequence_zip_sum<A, B>(a: A, b: B) -> i32
-where
-    A: FunctionalSequence<i32>,                                                                 // `.zip`
-    B: FunctionalSequence<i32, Length = A::Length>,                                             // `.zip`
-    A: MappedGenericSequence<i32, i32>,                                                         // `i32` -> `i32`
-    B: MappedGenericSequence<i32, i32, Mapped = MappedSequence<A, i32, i32>>,                   // `i32` -> `i32`, prove A and B can map to the same output
-    A::Item: Add<B::Item, Output = i32>,                                                        // `l + r`
-    MappedSequence<A, i32, i32>: MappedGenericSequence<i32, i32> + FunctionalSequence<i32>,     // `.map`
-    SequenceItem<MappedSequence<A, i32, i32>>: Add<i32, Output=i32>,                            // `x + 1`
-    MappedSequence<MappedSequence<A, i32, i32>, i32, i32>: Debug,                               // `println!`
-    MappedSequence<MappedSequence<A, i32, i32>, i32, i32>: FunctionalSequence<i32>,             // `.fold`
-    SequenceItem<MappedSequence<MappedSequence<A, i32, i32>, i32, i32>>: Add<i32, Output=i32>   // `x + a`, note the order
-{
-    let c = a.zip(b, |l, r| l + r).map(|x| x + 1);
-
-    println!("{:?}", c);
-
-    c.fold(0, |a, x| x + a)
-}
-
-/// Super-simple fixed-length i32 `GenericArray`s
-pub fn generic_array_plain_zip_sum(a: GenericArray<i32, U4>, b: GenericArray<i32, U4>) -> i32 {
-    a.zip(b, |l, r| l + r).map(|x| x + 1).fold(0, |a, x| x + a)
-}
-
-pub fn generic_array_variable_length_zip_sum<N>(a: GenericArray<i32, N>, b: GenericArray<i32, N>) -> i32
-where
-    N: ArrayLength<i32>,
-{
-    a.zip(b, |l, r| l + r).map(|x| x + 1).fold(0, |a, x| x + a)
-}
-
-pub fn generic_array_same_type_variable_length_zip_sum<T, N>(a: GenericArray<T, N>, b: GenericArray<T, N>) -> i32
-where
-    N: ArrayLength<T> + ArrayLength<<T as Add<T>>::Output>,
-    T: Add<T, Output=i32>,
-{
-    a.zip(b, |l, r| l + r).map(|x| x + 1).fold(0, |a, x| x + a)
-}
-
-/// Complex example using fully generic `GenericArray`s with the same length.
-///
-/// It's mostly just the repeated `Add` traits, which would be present in other systems anyway.
-pub fn generic_array_zip_sum<A, B, N: ArrayLength<A> + ArrayLength<B>>(a: GenericArray<A, N>, b: GenericArray<B, N>) -> i32
-where
-    A: Add<B>,
-    N: ArrayLength<<A as Add<B>>::Output> +
-        ArrayLength<<<A as Add<B>>::Output as Add<i32>>::Output>,
-    <A as Add<B>>::Output: Add<i32>,
-    <<A as Add<B>>::Output as Add<i32>>::Output: Add<i32, Output=i32>,
-{
-    a.zip(b, |l, r| l + r).map(|x| x + 1).fold(0, |a, x| x + a)
-}
-
-#[test]
-fn test_generics() {
-    generic_map(arr![i32; 1, 2, 3, 4]);
-
-    assert_eq!(generic_sequence_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
-
-    assert_eq!(generic_array_plain_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
-
-    assert_eq!(generic_array_variable_length_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
-
-    assert_eq!(generic_array_same_type_variable_length_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
-
-    assert_eq!(generic_array_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
+#![recursion_limit = "128"]
+
+#[macro_use]
+extern crate generic_array;
+
+use generic_array::typenum::consts::U4;
+
+use std::fmt::Debug;
+use std::ops::Add;
+
+use generic_array::{GenericArray, ArrayLength};
+use generic_array::sequence::*;
+use generic_array::functional::*;
+
+/// Example function using generics to pass N-length sequences and map them
+pub fn generic_map<S>(s: S)
+where
+    S: FunctionalSequence<i32>,            // `.map`
+    S::Item: Add<i32, Output = i32>,       // `x + 1`
+    S: MappedGenericSequence<i32, i32>,    // `i32` -> `i32`
+    MappedSequence<S, i32, i32>: Debug,    // println!
+{
+    let a = s.map(|x| x + 1);
+
+    println!("{:?}", a);
+}
+
+/// Complex example function using generics to pass N-length sequences, zip them, and then map that result.
+///
+/// If used with `GenericArray` specifically this isn't necessary
+pub fn generic_sequence_zip_sum<A, B>(a: A, b: B) -> i32
+where
+    A: FunctionalSequence<i32>,                                                                 // `.zip`
+    B: FunctionalSequence<i32, Length = A::Length>,                                             // `.zip`
+    A: MappedGenericSequence<i32, i32>,                                                         // `i32` -> `i32`
+    B: MappedGenericSequence<i32, i32, Mapped = MappedSequence<A, i32, i32>>,                   // `i32` -> `i32`, prove A and B can map to the same output
+    A::Item: Add<B::Item, Output = i32>,                                                        // `l + r`
+    MappedSequence<A, i32, i32>: MappedGenericSequence<i32, i32> + FunctionalSequence<i32>,     // `.map`
+    SequenceItem<MappedSequence<A, i32, i32>>: Add<i32, Output=i32>,                            // `x + 1`
+    MappedSequence<MappedSequence<A, i32, i32>, i32, i32>: Debug,                               // `println!`
+    MappedSequence<MappedSequence<A, i32, i32>, i32, i32>: FunctionalSequence<i32>,             // `.fold`
+    SequenceItem<MappedSequence<MappedSequence<A, i32, i32>, i32, i32>>: Add<i32, Output=i32>   // `x + a`, note the order
+{
+    let c = a.zip(b, |l, r| l + r).map(|x| x + 1);
+
+    println!("{:?}", c);
+
+    c.fold(0, |a, x| x + a)
+}
+
+/// Super-simple fixed-length i32 `GenericArray`s
+pub fn generic_array_plain_zip_sum(a: GenericArray<i32, U4>, b: GenericArray<i32, U4>) -> i32 {
+    a.zip(b, |l, r| l + r).map(|x| x + 1).fold(0, |a, x| x + a)
+}
+
+pub fn generic_array_variable_length_zip_sum<N>(a: GenericArray<i32, N>, b: GenericArray<i32, N>) -> i32
+where
+    N: ArrayLength<i32>,
+{
+    a.zip(b, |l, r| l + r).map(|x| x + 1).fold(0, |a, x| x + a)
+}
+
+pub fn generic_array_same_type_variable_length_zip_sum<T, N>(a: GenericArray<T, N>, b: GenericArray<T, N>) -> i32
+where
+    N: ArrayLength<T> + ArrayLength<<T as Add<T>>::Output>,
+    T: Add<T, Output=i32>,
+{
+    a.zip(b, |l, r| l + r).map(|x| x + 1).fold(0, |a, x| x + a)
+}
+
+/// Complex example using fully generic `GenericArray`s with the same length.
+///
+/// It's mostly just the repeated `Add` traits, which would be present in other systems anyway.
+pub fn generic_array_zip_sum<A, B, N: ArrayLength<A> + ArrayLength<B>>(a: GenericArray<A, N>, b: GenericArray<B, N>) -> i32
+where
+    A: Add<B>,
+    N: ArrayLength<<A as Add<B>>::Output> +
+        ArrayLength<<<A as Add<B>>::Output as Add<i32>>::Output>,
+    <A as Add<B>>::Output: Add<i32>,
+    <<A as Add<B>>::Output as Add<i32>>::Output: Add<i32, Output=i32>,
+{
+    a.zip(b, |l, r| l + r).map(|x| x + 1).fold(0, |a, x| x + a)
+}
+
+#[test]
+fn test_generics() {
+    generic_map(arr![i32; 1, 2, 3, 4]);
+
+    assert_eq!(generic_sequence_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
+
+    assert_eq!(generic_array_plain_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
+
+    assert_eq!(generic_array_variable_length_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
+
+    assert_eq!(generic_array_same_type_variable_length_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
+
+    assert_eq!(generic_array_zip_sum(arr![i32; 1, 2, 3, 4], arr![i32; 2, 3, 4, 5]), 28);
 }

zeroidc/vendor/generic-array/tests/hex.rs

@@ -1,61 +1,61 @@
-#[macro_use]
-extern crate generic_array;
-extern crate typenum;
-
-use generic_array::GenericArray;
-use std::str::from_utf8;
-use typenum::U2048;
-
-#[test]
-fn short_lower_hex() {
-    let ar = arr![u8; 10, 20, 30];
-    assert_eq!(format!("{:x}", ar), "0a141e");
-}
-
-#[test]
-fn short_upper_hex() {
-    let ar = arr![u8; 30, 20, 10];
-    assert_eq!(format!("{:X}", ar), "1E140A");
-}
-
-#[test]
-fn long_lower_hex() {
-    let ar = GenericArray::<u8, U2048>::default();
-    assert_eq!(format!("{:x}", ar), from_utf8(&[b'0'; 4096]).unwrap());
-}
-
-#[test]
-fn long_lower_hex_truncated() {
-    let ar = GenericArray::<u8, U2048>::default();
-    assert_eq!(format!("{:.3001x}", ar), from_utf8(&[b'0'; 3001]).unwrap());
-}
-
-#[test]
-fn long_upper_hex() {
-    let ar = GenericArray::<u8, U2048>::default();
-    assert_eq!(format!("{:X}", ar), from_utf8(&[b'0'; 4096]).unwrap());
-}
-
-#[test]
-fn long_upper_hex_truncated() {
-    let ar = GenericArray::<u8, U2048>::default();
-    assert_eq!(format!("{:.2777X}", ar), from_utf8(&[b'0'; 2777]).unwrap());
-}
-
-#[test]
-fn truncated_lower_hex() {
-    let ar = arr![u8; 10, 20, 30, 40, 50];
-    assert_eq!(format!("{:.2x}", ar), "0a");
-    assert_eq!(format!("{:.3x}", ar), "0a1");
-    assert_eq!(format!("{:.4x}", ar), "0a14");
-}
-
-#[test]
-fn truncated_upper_hex() {
-    let ar = arr![u8; 30, 20, 10, 17, 0];
-    assert_eq!(format!("{:.4X}", ar), "1E14");
-    assert_eq!(format!("{:.5X}", ar), "1E140");
-    assert_eq!(format!("{:.6X}", ar), "1E140A");
-    assert_eq!(format!("{:.7X}", ar), "1E140A1");
-    assert_eq!(format!("{:.8X}", ar), "1E140A11");
-}
+#[macro_use]
+extern crate generic_array;
+extern crate typenum;
+
+use generic_array::GenericArray;
+use std::str::from_utf8;
+use typenum::U2048;
+
+#[test]
+fn short_lower_hex() {
+    let ar = arr![u8; 10, 20, 30];
+    assert_eq!(format!("{:x}", ar), "0a141e");
+}
+
+#[test]
+fn short_upper_hex() {
+    let ar = arr![u8; 30, 20, 10];
+    assert_eq!(format!("{:X}", ar), "1E140A");
+}
+
+#[test]
+fn long_lower_hex() {
+    let ar = GenericArray::<u8, U2048>::default();
+    assert_eq!(format!("{:x}", ar), from_utf8(&[b'0'; 4096]).unwrap());
+}
+
+#[test]
+fn long_lower_hex_truncated() {
+    let ar = GenericArray::<u8, U2048>::default();
+    assert_eq!(format!("{:.3001x}", ar), from_utf8(&[b'0'; 3001]).unwrap());
+}
+
+#[test]
+fn long_upper_hex() {
+    let ar = GenericArray::<u8, U2048>::default();
+    assert_eq!(format!("{:X}", ar), from_utf8(&[b'0'; 4096]).unwrap());
+}
+
+#[test]
+fn long_upper_hex_truncated() {
+    let ar = GenericArray::<u8, U2048>::default();
+    assert_eq!(format!("{:.2777X}", ar), from_utf8(&[b'0'; 2777]).unwrap());
+}
+
+#[test]
+fn truncated_lower_hex() {
+    let ar = arr![u8; 10, 20, 30, 40, 50];
+    assert_eq!(format!("{:.2x}", ar), "0a");
+    assert_eq!(format!("{:.3x}", ar), "0a1");
+    assert_eq!(format!("{:.4x}", ar), "0a14");
+}
+
+#[test]
+fn truncated_upper_hex() {
+    let ar = arr![u8; 30, 20, 10, 17, 0];
+    assert_eq!(format!("{:.4X}", ar), "1E14");
+    assert_eq!(format!("{:.5X}", ar), "1E140");
+    assert_eq!(format!("{:.6X}", ar), "1E140A");
+    assert_eq!(format!("{:.7X}", ar), "1E140A1");
+    assert_eq!(format!("{:.8X}", ar), "1E140A11");
+}

zeroidc/vendor/generic-array/tests/import_name.rs

@@ -1,10 +1,10 @@
-#[macro_use]
-extern crate generic_array as gen_arr;
-
-use gen_arr::typenum;
-
-#[test]
-fn test_different_crate_name() {
-    let _: gen_arr::GenericArray<u32, typenum::U4> = arr![u32; 0, 1, 2, 3];
-    let _: gen_arr::GenericArray<u32, typenum::U0> = arr![u32;];
-}
+#[macro_use]
+extern crate generic_array as gen_arr;
+
+use gen_arr::typenum;
+
+#[test]
+fn test_different_crate_name() {
+    let _: gen_arr::GenericArray<u32, typenum::U4> = arr![u32; 0, 1, 2, 3];
+    let _: gen_arr::GenericArray<u32, typenum::U0> = arr![u32;];
+}

zeroidc/vendor/generic-array/tests/iter.rs

@@ -1,199 +1,199 @@
-#[macro_use]
-extern crate generic_array;
-
-use std::cell::Cell;
-use std::ops::Drop;
-
-use generic_array::typenum::consts::U5;
-use generic_array::GenericArray;
-
-#[test]
-fn test_from_iterator() {
-    struct BadExact(usize);
-
-    impl Iterator for BadExact {
-        type Item = usize;
-        fn next(&mut self) -> Option<usize> {
-            if self.0 == 1 {
-                return None;
-            }
-            self.0 -= 1;
-            Some(self.0)
-        }
-    }
-    impl ExactSizeIterator for BadExact {
-        fn len(&self) -> usize { self.0 }
-    }
-    assert!(GenericArray::<usize, U5>::from_exact_iter(BadExact(5)).is_none());
-}
-
-#[test]
-fn test_into_iter_as_slice() {
-    let array = arr![char; 'a', 'b', 'c'];
-    let mut into_iter = array.into_iter();
-    assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
-    let _ = into_iter.next().unwrap();
-    assert_eq!(into_iter.as_slice(), &['b', 'c']);
-    let _ = into_iter.next().unwrap();
-    let _ = into_iter.next().unwrap();
-    assert_eq!(into_iter.as_slice(), &[]);
-}
-
-#[test]
-fn test_into_iter_as_mut_slice() {
-    let array = arr![char; 'a', 'b', 'c'];
-    let mut into_iter = array.into_iter();
-    assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
-    into_iter.as_mut_slice()[0] = 'x';
-    into_iter.as_mut_slice()[1] = 'y';
-    assert_eq!(into_iter.next().unwrap(), 'x');
-    assert_eq!(into_iter.as_slice(), &['y', 'c']);
-}
-
-#[test]
-fn test_into_iter_debug() {
-    let array = arr![char; 'a', 'b', 'c'];
-    let into_iter = array.into_iter();
-    let debug = format!("{:?}", into_iter);
-    assert_eq!(debug, "GenericArrayIter(['a', 'b', 'c'])");
-}
-
-#[test]
-fn test_into_iter_clone() {
-    fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
-        let v: Vec<i32> = it.collect();
-        assert_eq!(&v[..], slice);
-    }
-    let mut it = arr![i32; 1, 2, 3].into_iter();
-    iter_equal(it.clone(), &[1, 2, 3]);
-    assert_eq!(it.next(), Some(1));
-    let mut it = it.rev();
-    iter_equal(it.clone(), &[3, 2]);
-    assert_eq!(it.next(), Some(3));
-    iter_equal(it.clone(), &[2]);
-    assert_eq!(it.next(), Some(2));
-    iter_equal(it.clone(), &[]);
-    assert_eq!(it.next(), None);
-}
-
-#[test]
-fn test_into_iter_nth() {
-    let v = arr![i32; 0, 1, 2, 3, 4];
-    for i in 0..v.len() {
-        assert_eq!(v.clone().into_iter().nth(i).unwrap(), v[i]);
-    }
-    assert_eq!(v.clone().into_iter().nth(v.len()), None);
-
-    let mut iter = v.into_iter();
-    assert_eq!(iter.nth(2).unwrap(), v[2]);
-    assert_eq!(iter.nth(1).unwrap(), v[4]);
-}
-
-#[test]
-fn test_into_iter_last() {
-    let v = arr![i32; 0, 1, 2, 3, 4];
-    assert_eq!(v.into_iter().last().unwrap(), 4);
-    assert_eq!(arr![i32; 0].into_iter().last().unwrap(), 0);
-}
-
-#[test]
-fn test_into_iter_count() {
-    let v = arr![i32; 0, 1, 2, 3, 4];
-    assert_eq!(v.clone().into_iter().count(), 5);
-
-    let mut iter2 = v.into_iter();
-    iter2.next();
-    iter2.next();
-    assert_eq!(iter2.count(), 3);
-}
-
-#[test]
-fn test_into_iter_flat_map() {
-    assert!((0..5).flat_map(|i| arr![i32; 2 * i, 2 * i + 1]).eq(0..10));
-}
-
-#[test]
-fn test_into_iter_fold() {
-    assert_eq!(
-        arr![i32; 1, 2, 3, 4].into_iter().fold(0, |sum, x| sum + x),
-        10
-    );
-
-    let mut iter = arr![i32; 0, 1, 2, 3, 4, 5].into_iter();
-
-    iter.next();
-    iter.next_back();
-
-    assert_eq!(iter.clone().fold(0, |sum, x| sum + x), 10);
-
-    assert_eq!(iter.rfold(0, |sum, x| sum + x), 10);
-}
-
-#[test]
-fn test_into_iter_drops() {
-    struct R<'a> {
-        i: &'a Cell<usize>,
-    }
-
-    impl<'a> Drop for R<'a> {
-        fn drop(&mut self) {
-            self.i.set(self.i.get() + 1);
-        }
-    }
-
-    fn r(i: &Cell<usize>) -> R {
-        R { i: i }
-    }
-
-    fn v(i: &Cell<usize>) -> GenericArray<R, U5> {
-        arr![R; r(i), r(i), r(i), r(i), r(i)]
-    }
-
-    let i = Cell::new(0);
-    {
-        v(&i).into_iter();
-    }
-    assert_eq!(i.get(), 5);
-
-    let i = Cell::new(0);
-    {
-        let mut iter = v(&i).into_iter();
-        let _x = iter.next();
-        assert_eq!(i.get(), 0);
-        assert_eq!(iter.count(), 4);
-        assert_eq!(i.get(), 4);
-    }
-    assert_eq!(i.get(), 5);
-
-    let i = Cell::new(0);
-    {
-        let mut iter = v(&i).into_iter();
-        let _x = iter.nth(2);
-        assert_eq!(i.get(), 2);
-        let _y = iter.last();
-        assert_eq!(i.get(), 3);
-    }
-    assert_eq!(i.get(), 5);
-
-    let i = Cell::new(0);
-    for (index, _x) in v(&i).into_iter().enumerate() {
-        assert_eq!(i.get(), index);
-    }
-    assert_eq!(i.get(), 5);
-
-    let i = Cell::new(0);
-    for (index, _x) in v(&i).into_iter().rev().enumerate() {
-        assert_eq!(i.get(), index);
-    }
-    assert_eq!(i.get(), 5);
-}
-
-/*
-//TODO: Cover this
-#[allow(dead_code)]
-fn assert_covariance() {
-    fn into_iter<'new>(i: GenericArrayIter<&'static str, U10>) -> GenericArrayIter<&'new str, U10> {
-        i
-    }
-}
-*/
+#[macro_use]
+extern crate generic_array;
+
+use std::cell::Cell;
+use std::ops::Drop;
+
+use generic_array::typenum::consts::U5;
+use generic_array::GenericArray;
+
+#[test]
+fn test_from_iterator() {
+    struct BadExact(usize);
+
+    impl Iterator for BadExact {
+        type Item = usize;
+        fn next(&mut self) -> Option<usize> {
+            if self.0 == 1 {
+                return None;
+            }
+            self.0 -= 1;
+            Some(self.0)
+        }
+    }
+    impl ExactSizeIterator for BadExact {
+        fn len(&self) -> usize { self.0 }
+    }
+    assert!(GenericArray::<usize, U5>::from_exact_iter(BadExact(5)).is_none());
+}
+
+#[test]
+fn test_into_iter_as_slice() {
+    let array = arr![char; 'a', 'b', 'c'];
+    let mut into_iter = array.into_iter();
+    assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
+    let _ = into_iter.next().unwrap();
+    assert_eq!(into_iter.as_slice(), &['b', 'c']);
+    let _ = into_iter.next().unwrap();
+    let _ = into_iter.next().unwrap();
+    assert_eq!(into_iter.as_slice(), &[]);
+}
+
+#[test]
+fn test_into_iter_as_mut_slice() {
+    let array = arr![char; 'a', 'b', 'c'];
+    let mut into_iter = array.into_iter();
+    assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
+    into_iter.as_mut_slice()[0] = 'x';
+    into_iter.as_mut_slice()[1] = 'y';
+    assert_eq!(into_iter.next().unwrap(), 'x');
+    assert_eq!(into_iter.as_slice(), &['y', 'c']);
+}
+
+#[test]
+fn test_into_iter_debug() {
+    let array = arr![char; 'a', 'b', 'c'];
+    let into_iter = array.into_iter();
+    let debug = format!("{:?}", into_iter);
+    assert_eq!(debug, "GenericArrayIter(['a', 'b', 'c'])");
+}
+
+#[test]
+fn test_into_iter_clone() {
+    fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
+        let v: Vec<i32> = it.collect();
+        assert_eq!(&v[..], slice);
+    }
+    let mut it = arr![i32; 1, 2, 3].into_iter();
+    iter_equal(it.clone(), &[1, 2, 3]);
+    assert_eq!(it.next(), Some(1));
+    let mut it = it.rev();
+    iter_equal(it.clone(), &[3, 2]);
+    assert_eq!(it.next(), Some(3));
+    iter_equal(it.clone(), &[2]);
+    assert_eq!(it.next(), Some(2));
+    iter_equal(it.clone(), &[]);
+    assert_eq!(it.next(), None);
+}
+
+#[test]
+fn test_into_iter_nth() {
+    let v = arr![i32; 0, 1, 2, 3, 4];
+    for i in 0..v.len() {
+        assert_eq!(v.clone().into_iter().nth(i).unwrap(), v[i]);
+    }
+    assert_eq!(v.clone().into_iter().nth(v.len()), None);
+
+    let mut iter = v.into_iter();
+    assert_eq!(iter.nth(2).unwrap(), v[2]);
+    assert_eq!(iter.nth(1).unwrap(), v[4]);
+}
+
+#[test]
+fn test_into_iter_last() {
+    let v = arr![i32; 0, 1, 2, 3, 4];
+    assert_eq!(v.into_iter().last().unwrap(), 4);
+    assert_eq!(arr![i32; 0].into_iter().last().unwrap(), 0);
+}
+
+#[test]
+fn test_into_iter_count() {
+    let v = arr![i32; 0, 1, 2, 3, 4];
+    assert_eq!(v.clone().into_iter().count(), 5);
+
+    let mut iter2 = v.into_iter();
+    iter2.next();
+    iter2.next();
+    assert_eq!(iter2.count(), 3);
+}
+
+#[test]
+fn test_into_iter_flat_map() {
+    assert!((0..5).flat_map(|i| arr![i32; 2 * i, 2 * i + 1]).eq(0..10));
+}
+
+#[test]
+fn test_into_iter_fold() {
+    assert_eq!(
+        arr![i32; 1, 2, 3, 4].into_iter().fold(0, |sum, x| sum + x),
+        10
+    );
+
+    let mut iter = arr![i32; 0, 1, 2, 3, 4, 5].into_iter();
+
+    iter.next();
+    iter.next_back();
+
+    assert_eq!(iter.clone().fold(0, |sum, x| sum + x), 10);
+
+    assert_eq!(iter.rfold(0, |sum, x| sum + x), 10);
+}
+
+#[test]
+fn test_into_iter_drops() {
+    struct R<'a> {
+        i: &'a Cell<usize>,
+    }
+
+    impl<'a> Drop for R<'a> {
+        fn drop(&mut self) {
+            self.i.set(self.i.get() + 1);
+        }
+    }
+
+    fn r(i: &Cell<usize>) -> R {
+        R { i: i }
+    }
+
+    fn v(i: &Cell<usize>) -> GenericArray<R, U5> {
+        arr![R; r(i), r(i), r(i), r(i), r(i)]
+    }
+
+    let i = Cell::new(0);
+    {
+        v(&i).into_iter();
+    }
+    assert_eq!(i.get(), 5);
+
+    let i = Cell::new(0);
+    {
+        let mut iter = v(&i).into_iter();
+        let _x = iter.next();
+        assert_eq!(i.get(), 0);
+        assert_eq!(iter.count(), 4);
+        assert_eq!(i.get(), 4);
+    }
+    assert_eq!(i.get(), 5);
+
+    let i = Cell::new(0);
+    {
+        let mut iter = v(&i).into_iter();
+        let _x = iter.nth(2);
+        assert_eq!(i.get(), 2);
+        let _y = iter.last();
+        assert_eq!(i.get(), 3);
+    }
+    assert_eq!(i.get(), 5);
+
+    let i = Cell::new(0);
+    for (index, _x) in v(&i).into_iter().enumerate() {
+        assert_eq!(i.get(), index);
+    }
+    assert_eq!(i.get(), 5);
+
+    let i = Cell::new(0);
+    for (index, _x) in v(&i).into_iter().rev().enumerate() {
+        assert_eq!(i.get(), index);
+    }
+    assert_eq!(i.get(), 5);
+}
+
+/*
+//TODO: Cover this
+#[allow(dead_code)]
+fn assert_covariance() {
+    fn into_iter<'new>(i: GenericArrayIter<&'static str, U10>) -> GenericArrayIter<&'new str, U10> {
+        i
+    }
+}
+*/

zeroidc/vendor/generic-array/tests/mod.rs

@@ -1,379 +1,379 @@
-#![recursion_limit = "128"]
-#![no_std]
-#[macro_use]
-extern crate generic_array;
-use core::cell::Cell;
-use core::ops::{Add, Drop};
-use generic_array::functional::*;
-use generic_array::sequence::*;
-use generic_array::typenum::{U0, U3, U4, U97};
-use generic_array::GenericArray;
-
-#[test]
-fn test() {
-    let mut list97 = [0; 97];
-    for i in 0..97 {
-        list97[i] = i as i32;
-    }
-    let l: GenericArray<i32, U97> = GenericArray::clone_from_slice(&list97);
-    assert_eq!(l[0], 0);
-    assert_eq!(l[1], 1);
-    assert_eq!(l[32], 32);
-    assert_eq!(l[56], 56);
-}
-
-#[test]
-fn test_drop() {
-    #[derive(Clone)]
-    struct TestDrop<'a>(&'a Cell<u32>);
-
-    impl<'a> Drop for TestDrop<'a> {
-        fn drop(&mut self) {
-            self.0.set(self.0.get() + 1);
-        }
-    }
-
-    let drop_counter = Cell::new(0);
-    {
-        let _: GenericArray<TestDrop, U3> = arr![TestDrop; TestDrop(&drop_counter),
-                           TestDrop(&drop_counter),
-                           TestDrop(&drop_counter)];
-    }
-    assert_eq!(drop_counter.get(), 3);
-}
-
-#[test]
-fn test_arr() {
-    let test: GenericArray<u32, U3> = arr![u32; 1, 2, 3];
-    assert_eq!(test[1], 2);
-}
-
-#[test]
-fn test_copy() {
-    let test = arr![u32; 1, 2, 3];
-    let test2 = test;
-    // if GenericArray is not copy, this should fail as a use of a moved value
-    assert_eq!(test[1], 2);
-    assert_eq!(test2[0], 1);
-}
-
-#[derive(Debug, PartialEq, Eq)]
-struct NoClone<T>(T);
-
-#[test]
-fn test_from_slice() {
-    let arr = [1, 2, 3, 4];
-    let gen_arr = GenericArray::<_, U3>::from_slice(&arr[..3]);
-    assert_eq!(&arr[..3], gen_arr.as_slice());
-    let arr = [NoClone(1u32), NoClone(2), NoClone(3), NoClone(4)];
-    let gen_arr = GenericArray::<_, U3>::from_slice(&arr[..3]);
-    assert_eq!(&arr[..3], gen_arr.as_slice());
-}
-
-#[test]
-fn test_from_mut_slice() {
-    let mut arr = [1, 2, 3, 4];
-    {
-        let gen_arr = GenericArray::<_, U3>::from_mut_slice(&mut arr[..3]);
-        gen_arr[2] = 10;
-    }
-    assert_eq!(arr, [1, 2, 10, 4]);
-    let mut arr = [NoClone(1u32), NoClone(2), NoClone(3), NoClone(4)];
-    {
-        let gen_arr = GenericArray::<_, U3>::from_mut_slice(&mut arr[..3]);
-        gen_arr[2] = NoClone(10);
-    }
-    assert_eq!(arr, [NoClone(1), NoClone(2), NoClone(10), NoClone(4)]);
-}
-
-#[test]
-fn test_default() {
-    let arr = GenericArray::<u8, U4>::default();
-    assert_eq!(arr.as_slice(), &[0, 0, 0, 0]);
-}
-
-#[test]
-fn test_from() {
-    let data = [(1, 2, 3), (4, 5, 6), (7, 8, 9)];
-    let garray: GenericArray<(usize, usize, usize), U3> = data.into();
-    assert_eq!(&data, garray.as_slice());
-}
-
-#[test]
-fn test_unit_macro() {
-    let arr = arr![f32; 3.14];
-    assert_eq!(arr[0], 3.14);
-}
-
-#[test]
-fn test_empty_macro() {
-    let _arr = arr![f32;];
-}
-
-#[test]
-fn test_cmp() {
-    let _ = arr![u8; 0x00].cmp(&arr![u8; 0x00]);
-}
-
-/// This test should cause a helpful compile error if uncommented.
-// #[test]
-// fn test_empty_macro2(){
-//     let arr = arr![];
-// }
-#[cfg(feature = "serde")]
-mod impl_serde {
-    extern crate serde_json;
-
-    use generic_array::typenum::U6;
-    use generic_array::GenericArray;
-
-    #[test]
-    fn test_serde_implementation() {
-        let array: GenericArray<f64, U6> = arr![f64; 0.0, 5.0, 3.0, 7.07192, 76.0, -9.0];
-        let string = serde_json::to_string(&array).unwrap();
-        assert_eq!(string, "[0.0,5.0,3.0,7.07192,76.0,-9.0]");
-
-        let test_array: GenericArray<f64, U6> = serde_json::from_str(&string).unwrap();
-        assert_eq!(test_array, array);
-    }
-}
-
-#[test]
-fn test_map() {
-    let b: GenericArray<i32, U4> = GenericArray::generate(|i| i as i32 * 4).map(|x| x - 3);
-
-    assert_eq!(b, arr![i32; -3, 1, 5, 9]);
-}
-
-#[test]
-fn test_zip() {
-    let a: GenericArray<_, U4> = GenericArray::generate(|i| i + 1);
-    let b: GenericArray<_, U4> = GenericArray::generate(|i| i as i32 * 4);
-
-    // Uses reference and non-reference arguments
-    let c = (&a).zip(b, |r, l| *r as i32 + l);
-
-    assert_eq!(c, arr![i32; 1, 6, 11, 16]);
-}
-
-#[test]
-#[should_panic]
-fn test_from_iter_short() {
-    use core::iter::repeat;
-
-    let a: GenericArray<_, U4> = repeat(11).take(3).collect();
-
-    assert_eq!(a, arr![i32; 11, 11, 11, 0]);
-}
-
-#[test]
-fn test_from_iter() {
-    use core::iter::{once, repeat};
-
-    let a: GenericArray<_, U4> = repeat(11).take(3).chain(once(0)).collect();
-
-    assert_eq!(a, arr![i32; 11, 11, 11, 0]);
-}
-
-#[allow(unused)]
-#[derive(Debug, Copy, Clone)]
-enum E {
-    V,
-    V2(i32),
-    V3 { h: bool, i: i32 },
-}
-
-#[allow(unused)]
-#[derive(Debug, Copy, Clone)]
-#[repr(C)]
-#[repr(packed)]
-struct Test {
-    t: u16,
-    s: u32,
-    mm: bool,
-    r: u16,
-    f: u16,
-    p: (),
-    o: u32,
-    ff: *const extern "C" fn(*const char) -> *const core::ffi::c_void,
-    l: *const core::ffi::c_void,
-    w: bool,
-    q: bool,
-    v: E,
-}
-
-#[test]
-fn test_sizes() {
-    use core::mem::{size_of, size_of_val};
-
-    assert_eq!(size_of::<E>(), 8);
-
-    assert_eq!(size_of::<Test>(), 25 + size_of::<usize>() * 2);
-
-    assert_eq!(size_of_val(&arr![u8; 1, 2, 3]), size_of::<u8>() * 3);
-    assert_eq!(size_of_val(&arr![u32; 1]), size_of::<u32>() * 1);
-    assert_eq!(size_of_val(&arr![u64; 1, 2, 3, 4]), size_of::<u64>() * 4);
-
-    assert_eq!(size_of::<GenericArray<Test, U97>>(), size_of::<Test>() * 97);
-}
-
-#[test]
-fn test_alignment() {
-    use core::mem::align_of;
-
-    assert_eq!(align_of::<GenericArray::<u32, U0>>(), align_of::<[u32; 0]>());
-    assert_eq!(align_of::<GenericArray::<u32, U3>>(), align_of::<[u32; 3]>());
-    assert_eq!(align_of::<GenericArray::<Test, U3>>(), align_of::<[Test; 3]>());
-}
-
-#[test]
-fn test_append() {
-    let a = arr![i32; 1, 2, 3];
-
-    let b = a.append(4);
-
-    assert_eq!(b, arr![i32; 1, 2, 3, 4]);
-}
-
-#[test]
-fn test_prepend() {
-    let a = arr![i32; 1, 2, 3];
-
-    let b = a.prepend(4);
-
-    assert_eq!(b, arr![i32; 4, 1, 2, 3]);
-}
-
-#[test]
-fn test_pop() {
-    let a = arr![i32; 1, 2, 3, 4];
-
-    let (init, last) = a.pop_back();
-
-    assert_eq!(init, arr![i32; 1, 2, 3]);
-    assert_eq!(last, 4);
-
-    let (head, tail) = a.pop_front();
-
-    assert_eq!(head, 1);
-    assert_eq!(tail, arr![i32; 2, 3, 4]);
-}
-
-#[test]
-fn test_split() {
-    let a = arr![i32; 1, 2, 3, 4];
-
-    let (b, c) = a.split();
-
-    assert_eq!(b, arr![i32; 1]);
-    assert_eq!(c, arr![i32; 2, 3, 4]);
-
-    let (e, f) = a.split();
-
-    assert_eq!(e, arr![i32; 1, 2]);
-    assert_eq!(f, arr![i32; 3, 4]);
-}
-
-#[test]
-fn test_split_ref() {
-    let a = arr![i32; 1, 2, 3, 4];
-    let a_ref = &a;
-
-    let (b_ref, c_ref) = a_ref.split();
-
-    assert_eq!(b_ref, &arr![i32; 1]);
-    assert_eq!(c_ref, &arr![i32; 2, 3, 4]);
-
-    let (e_ref, f_ref) = a_ref.split();
-
-    assert_eq!(e_ref, &arr![i32; 1, 2]);
-    assert_eq!(f_ref, &arr![i32; 3, 4]);
-}
-
-#[test]
-fn test_split_mut() {
-    let mut a = arr![i32; 1, 2, 3, 4];
-    let a_ref = &mut a;
-
-    let (b_ref, c_ref) = a_ref.split();
-
-    assert_eq!(b_ref, &mut arr![i32; 1]);
-    assert_eq!(c_ref, &mut arr![i32; 2, 3, 4]);
-
-    let (e_ref, f_ref) = a_ref.split();
-
-    assert_eq!(e_ref, &mut arr![i32; 1, 2]);
-    assert_eq!(f_ref, &mut arr![i32; 3, 4]);
-}
-
-#[test]
-fn test_concat() {
-    let a = arr![i32; 1, 2];
-    let b = arr![i32; 3, 4, 5];
-
-    let c = a.concat(b);
-
-    assert_eq!(c, arr![i32; 1, 2, 3, 4, 5]);
-
-    let (d, e) = c.split();
-
-    assert_eq!(d, arr![i32; 1, 2]);
-    assert_eq!(e, arr![i32; 3, 4, 5]);
-}
-
-#[test]
-fn test_fold() {
-    let a = arr![i32; 1, 2, 3, 4];
-
-    assert_eq!(10, a.fold(0, |a, x| a + x));
-}
-
-fn sum_generic<S>(s: S) -> i32
-where
-    S: FunctionalSequence<i32>,
-    S::Item: Add<i32, Output = i32>, // `+`
-    i32: Add<S::Item, Output = i32>, // reflexive
-{
-    s.fold(0, |a, x| a + x)
-}
-
-#[test]
-fn test_sum() {
-    let a = sum_generic(arr![i32; 1, 2, 3, 4]);
-
-    assert_eq!(a, 10);
-}
-
-#[test]
-fn test_as_ref() {
-    let a = arr![i32; 1, 2, 3, 4];
-    let a_ref: &[i32; 4] = a.as_ref();
-    assert_eq!(a_ref, &[1, 2, 3, 4]);
-}
-
-#[test]
-fn test_as_mut() {
-    let mut a = arr![i32; 1, 2, 3, 4];
-    let a_mut: &mut [i32; 4] = a.as_mut();
-    assert_eq!(a_mut, &mut [1, 2, 3, 4]);
-    a_mut[2] = 0;
-    assert_eq!(a_mut, &mut [1, 2, 0, 4]);
-    assert_eq!(a, arr![i32; 1, 2, 0, 4]);
-}
-
-#[test]
-fn test_from_array_ref() {
-    let a = arr![i32; 1, 2, 3, 4];
-    let a_ref: &[i32; 4] = a.as_ref();
-    let a_from: &GenericArray<i32, U4> = a_ref.into();
-    assert_eq!(&a, a_from);
-}
-
-#[test]
-fn test_from_array_mut() {
-    let mut a = arr![i32; 1, 2, 3, 4];
-    let mut a_copy = a;
-    let a_mut: &mut [i32; 4] = a.as_mut();
-    let a_from: &mut GenericArray<i32, U4> = a_mut.into();
-    assert_eq!(&mut a_copy, a_from);
-}
+#![recursion_limit = "128"]
+#![no_std]
+#[macro_use]
+extern crate generic_array;
+use core::cell::Cell;
+use core::ops::{Add, Drop};
+use generic_array::functional::*;
+use generic_array::sequence::*;
+use generic_array::typenum::{U0, U3, U4, U97};
+use generic_array::GenericArray;
+
+#[test]
+fn test() {
+    let mut list97 = [0; 97];
+    for i in 0..97 {
+        list97[i] = i as i32;
+    }
+    let l: GenericArray<i32, U97> = GenericArray::clone_from_slice(&list97);
+    assert_eq!(l[0], 0);
+    assert_eq!(l[1], 1);
+    assert_eq!(l[32], 32);
+    assert_eq!(l[56], 56);
+}
+
+#[test]
+fn test_drop() {
+    #[derive(Clone)]
+    struct TestDrop<'a>(&'a Cell<u32>);
+
+    impl<'a> Drop for TestDrop<'a> {
+        fn drop(&mut self) {
+            self.0.set(self.0.get() + 1);
+        }
+    }
+
+    let drop_counter = Cell::new(0);
+    {
+        let _: GenericArray<TestDrop, U3> = arr![TestDrop; TestDrop(&drop_counter),
+                           TestDrop(&drop_counter),
+                           TestDrop(&drop_counter)];
+    }
+    assert_eq!(drop_counter.get(), 3);
+}
+
+#[test]
+fn test_arr() {
+    let test: GenericArray<u32, U3> = arr![u32; 1, 2, 3];
+    assert_eq!(test[1], 2);
+}
+
+#[test]
+fn test_copy() {
+    let test = arr![u32; 1, 2, 3];
+    let test2 = test;
+    // if GenericArray is not copy, this should fail as a use of a moved value
+    assert_eq!(test[1], 2);
+    assert_eq!(test2[0], 1);
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct NoClone<T>(T);
+
+#[test]
+fn test_from_slice() {
+    let arr = [1, 2, 3, 4];
+    let gen_arr = GenericArray::<_, U3>::from_slice(&arr[..3]);
+    assert_eq!(&arr[..3], gen_arr.as_slice());
+    let arr = [NoClone(1u32), NoClone(2), NoClone(3), NoClone(4)];
+    let gen_arr = GenericArray::<_, U3>::from_slice(&arr[..3]);
+    assert_eq!(&arr[..3], gen_arr.as_slice());
+}
+
+#[test]
+fn test_from_mut_slice() {
+    let mut arr = [1, 2, 3, 4];
+    {
+        let gen_arr = GenericArray::<_, U3>::from_mut_slice(&mut arr[..3]);
+        gen_arr[2] = 10;
+    }
+    assert_eq!(arr, [1, 2, 10, 4]);
+    let mut arr = [NoClone(1u32), NoClone(2), NoClone(3), NoClone(4)];
+    {
+        let gen_arr = GenericArray::<_, U3>::from_mut_slice(&mut arr[..3]);
+        gen_arr[2] = NoClone(10);
+    }
+    assert_eq!(arr, [NoClone(1), NoClone(2), NoClone(10), NoClone(4)]);
+}
+
+#[test]
+fn test_default() {
+    let arr = GenericArray::<u8, U4>::default();
+    assert_eq!(arr.as_slice(), &[0, 0, 0, 0]);
+}
+
+#[test]
+fn test_from() {
+    let data = [(1, 2, 3), (4, 5, 6), (7, 8, 9)];
+    let garray: GenericArray<(usize, usize, usize), U3> = data.into();
+    assert_eq!(&data, garray.as_slice());
+}
+
+#[test]
+fn test_unit_macro() {
+    let arr = arr![f32; 3.14];
+    assert_eq!(arr[0], 3.14);
+}
+
+#[test]
+fn test_empty_macro() {
+    let _arr = arr![f32;];
+}
+
+#[test]
+fn test_cmp() {
+    let _ = arr![u8; 0x00].cmp(&arr![u8; 0x00]);
+}
+
+/// This test should cause a helpful compile error if uncommented.
+// #[test]
+// fn test_empty_macro2(){
+//     let arr = arr![];
+// }
+#[cfg(feature = "serde")]
+mod impl_serde {
+    extern crate serde_json;
+
+    use generic_array::typenum::U6;
+    use generic_array::GenericArray;
+
+    #[test]
+    fn test_serde_implementation() {
+        let array: GenericArray<f64, U6> = arr![f64; 0.0, 5.0, 3.0, 7.07192, 76.0, -9.0];
+        let string = serde_json::to_string(&array).unwrap();
+        assert_eq!(string, "[0.0,5.0,3.0,7.07192,76.0,-9.0]");
+
+        let test_array: GenericArray<f64, U6> = serde_json::from_str(&string).unwrap();
+        assert_eq!(test_array, array);
+    }
+}
+
+#[test]
+fn test_map() {
+    let b: GenericArray<i32, U4> = GenericArray::generate(|i| i as i32 * 4).map(|x| x - 3);
+
+    assert_eq!(b, arr![i32; -3, 1, 5, 9]);
+}
+
+#[test]
+fn test_zip() {
+    let a: GenericArray<_, U4> = GenericArray::generate(|i| i + 1);
+    let b: GenericArray<_, U4> = GenericArray::generate(|i| i as i32 * 4);
+
+    // Uses reference and non-reference arguments
+    let c = (&a).zip(b, |r, l| *r as i32 + l);
+
+    assert_eq!(c, arr![i32; 1, 6, 11, 16]);
+}
+
+#[test]
+#[should_panic]
+fn test_from_iter_short() {
+    use core::iter::repeat;
+
+    let a: GenericArray<_, U4> = repeat(11).take(3).collect();
+
+    assert_eq!(a, arr![i32; 11, 11, 11, 0]);
+}
+
+#[test]
+fn test_from_iter() {
+    use core::iter::{once, repeat};
+
+    let a: GenericArray<_, U4> = repeat(11).take(3).chain(once(0)).collect();
+
+    assert_eq!(a, arr![i32; 11, 11, 11, 0]);
+}
+
+#[allow(unused)]
+#[derive(Debug, Copy, Clone)]
+enum E {
+    V,
+    V2(i32),
+    V3 { h: bool, i: i32 },
+}
+
+#[allow(unused)]
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+#[repr(packed)]
+struct Test {
+    t: u16,
+    s: u32,
+    mm: bool,
+    r: u16,
+    f: u16,
+    p: (),
+    o: u32,
+    ff: *const extern "C" fn(*const char) -> *const core::ffi::c_void,
+    l: *const core::ffi::c_void,
+    w: bool,
+    q: bool,
+    v: E,
+}
+
+#[test]
+fn test_sizes() {
+    use core::mem::{size_of, size_of_val};
+
+    assert_eq!(size_of::<E>(), 8);
+
+    assert_eq!(size_of::<Test>(), 25 + size_of::<usize>() * 2);
+
+    assert_eq!(size_of_val(&arr![u8; 1, 2, 3]), size_of::<u8>() * 3);
+    assert_eq!(size_of_val(&arr![u32; 1]), size_of::<u32>() * 1);
+    assert_eq!(size_of_val(&arr![u64; 1, 2, 3, 4]), size_of::<u64>() * 4);
+
+    assert_eq!(size_of::<GenericArray<Test, U97>>(), size_of::<Test>() * 97);
+}
+
+#[test]
+fn test_alignment() {
+    use core::mem::align_of;
+
+    assert_eq!(align_of::<GenericArray::<u32, U0>>(), align_of::<[u32; 0]>());
+    assert_eq!(align_of::<GenericArray::<u32, U3>>(), align_of::<[u32; 3]>());
+    assert_eq!(align_of::<GenericArray::<Test, U3>>(), align_of::<[Test; 3]>());
+}
+
+#[test]
+fn test_append() {
+    let a = arr![i32; 1, 2, 3];
+
+    let b = a.append(4);
+
+    assert_eq!(b, arr![i32; 1, 2, 3, 4]);
+}
+
+#[test]
+fn test_prepend() {
+    let a = arr![i32; 1, 2, 3];
+
+    let b = a.prepend(4);
+
+    assert_eq!(b, arr![i32; 4, 1, 2, 3]);
+}
+
+#[test]
+fn test_pop() {
+    let a = arr![i32; 1, 2, 3, 4];
+
+    let (init, last) = a.pop_back();
+
+    assert_eq!(init, arr![i32; 1, 2, 3]);
+    assert_eq!(last, 4);
+
+    let (head, tail) = a.pop_front();
+
+    assert_eq!(head, 1);
+    assert_eq!(tail, arr![i32; 2, 3, 4]);
+}
+
+#[test]
+fn test_split() {
+    let a = arr![i32; 1, 2, 3, 4];
+
+    let (b, c) = a.split();
+
+    assert_eq!(b, arr![i32; 1]);
+    assert_eq!(c, arr![i32; 2, 3, 4]);
+
+    let (e, f) = a.split();
+
+    assert_eq!(e, arr![i32; 1, 2]);
+    assert_eq!(f, arr![i32; 3, 4]);
+}
+
+#[test]
+fn test_split_ref() {
+    let a = arr![i32; 1, 2, 3, 4];
+    let a_ref = &a;
+
+    let (b_ref, c_ref) = a_ref.split();
+
+    assert_eq!(b_ref, &arr![i32; 1]);
+    assert_eq!(c_ref, &arr![i32; 2, 3, 4]);
+
+    let (e_ref, f_ref) = a_ref.split();
+
+    assert_eq!(e_ref, &arr![i32; 1, 2]);
+    assert_eq!(f_ref, &arr![i32; 3, 4]);
+}
+
+#[test]
+fn test_split_mut() {
+    let mut a = arr![i32; 1, 2, 3, 4];
+    let a_ref = &mut a;
+
+    let (b_ref, c_ref) = a_ref.split();
+
+    assert_eq!(b_ref, &mut arr![i32; 1]);
+    assert_eq!(c_ref, &mut arr![i32; 2, 3, 4]);
+
+    let (e_ref, f_ref) = a_ref.split();
+
+    assert_eq!(e_ref, &mut arr![i32; 1, 2]);
+    assert_eq!(f_ref, &mut arr![i32; 3, 4]);
+}
+
+#[test]
+fn test_concat() {
+    let a = arr![i32; 1, 2];
+    let b = arr![i32; 3, 4, 5];
+
+    let c = a.concat(b);
+
+    assert_eq!(c, arr![i32; 1, 2, 3, 4, 5]);
+
+    let (d, e) = c.split();
+
+    assert_eq!(d, arr![i32; 1, 2]);
+    assert_eq!(e, arr![i32; 3, 4, 5]);
+}
+
+#[test]
+fn test_fold() {
+    let a = arr![i32; 1, 2, 3, 4];
+
+    assert_eq!(10, a.fold(0, |a, x| a + x));
+}
+
+fn sum_generic<S>(s: S) -> i32
+where
+    S: FunctionalSequence<i32>,
+    S::Item: Add<i32, Output = i32>, // `+`
+    i32: Add<S::Item, Output = i32>, // reflexive
+{
+    s.fold(0, |a, x| a + x)
+}
+
+#[test]
+fn test_sum() {
+    let a = sum_generic(arr![i32; 1, 2, 3, 4]);
+
+    assert_eq!(a, 10);
+}
+
+#[test]
+fn test_as_ref() {
+    let a = arr![i32; 1, 2, 3, 4];
+    let a_ref: &[i32; 4] = a.as_ref();
+    assert_eq!(a_ref, &[1, 2, 3, 4]);
+}
+
+#[test]
+fn test_as_mut() {
+    let mut a = arr![i32; 1, 2, 3, 4];
+    let a_mut: &mut [i32; 4] = a.as_mut();
+    assert_eq!(a_mut, &mut [1, 2, 3, 4]);
+    a_mut[2] = 0;
+    assert_eq!(a_mut, &mut [1, 2, 0, 4]);
+    assert_eq!(a, arr![i32; 1, 2, 0, 4]);
+}
+
+#[test]
+fn test_from_array_ref() {
+    let a = arr![i32; 1, 2, 3, 4];
+    let a_ref: &[i32; 4] = a.as_ref();
+    let a_from: &GenericArray<i32, U4> = a_ref.into();
+    assert_eq!(&a, a_from);
+}
+
+#[test]
+fn test_from_array_mut() {
+    let mut a = arr![i32; 1, 2, 3, 4];
+    let mut a_copy = a;
+    let a_mut: &mut [i32; 4] = a.as_mut();
+    let a_from: &mut GenericArray<i32, U4> = a_mut.into();
+    assert_eq!(&mut a_copy, a_from);
+}

zeroidc/vendor/instant/AUTHORS

@@ -1,2 +1,2 @@
-Main developer:
+Main developer:
     * Sébastien Crozet <[email protected]>

zeroidc/vendor/instant/CHANGELOGS.md

@@ -1,7 +1,7 @@
-# v0.1.12
-## Added 
-- Add `SystemTime` which works in both native and WASM environments.
-
-## Modified
-- The `now` function is always available now: there is no need to enable the `now` feature any more. The `now` feature
+# v0.1.12
+## Added 
+- Add `SystemTime` which works in both native and WASM environments.
+
+## Modified
+- The `now` function is always available now: there is no need to enable the `now` feature any more. The `now` feature
   still exists (but doesn’t do anything) for backwards compatibility.

zeroidc/vendor/instant/LICENSE

@@ -1,27 +1,27 @@
-Copyright (c) 2019, Sébastien Crozet
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the author nor the names of its contributors may be used
-   to endorse or promote products derived from this software without specific
-   prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Copyright (c) 2019, Sébastien Crozet
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the author nor the names of its contributors may be used
+   to endorse or promote products derived from this software without specific
+   prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

zeroidc/vendor/instant/README.md

@@ -1,143 +1,143 @@
-# Instant
-
-If you call `std::time::Instant::now()` on a WASM platform, it will panic. This crate provides a partial
-replacement for `std::time::Instant` that works on WASM too. This defines the type `instant::Instant` which is:
-
-* A struct emulating the behavior of **std::time::Instant** if you are targeting `wasm32-unknown-unknown` or `wasm32-unknown-asmjs`
-**and** you enabled either the `stdweb` or the `wasm-bindgen` feature. This emulation is based on the javascript `performance.now()` function.
-* A type alias for `std::time::Instant` otherwise.
-
-
-
-Note that even if the **stdweb** or **wasm-bindgen** feature is enabled, this crate will continue to rely on `std::time::Instant`
-as long as you are not targeting wasm32. This allows for portable code that will work on both native and WASM platforms.
-
-This crate also exports the function `instant::now()` which returns a representation of the current time as an `f64`, expressed in milliseconds, in a platform-agnostic way. `instant::now()` will either:
-
-* Call `performance.now()` when compiling for a WASM platform with the features **stdweb** or **wasm-bindgen** enabled, or using a custom javascript function.
-* Return the time elapsed since the *Unix Epoch* on *native*, *non-WASM* platforms.
-
-*Note*: The old feature, `now`, has been deprecated. `instant::now()` is always exported and the `now` feature flag no longer has any effect. It remains listed in `Cargo.toml` to avoid introducing breaking changes and may be removed in future versions.
-
-## Examples
-### Using `instant` for a native platform.
-_Cargo.toml_:
-```toml
-[dependencies]
-instant = "0.1"
-```
-
-_main.rs_:
-```rust
-fn main() {
-    // Will be the same as `std::time::Instant`.
-    let now = instant::Instant::now();
-}
-```
-
------
-
-### Using `instant` for a WASM platform.
-This example shows the use of the `stdweb` feature. It would be similar with `wasm-bindgen`.
-
-_Cargo.toml_:
-```toml
-[dependencies]
-instant = { version = "0.1", features = [ "stdweb" ] }
-```
-
-_main.rs_:
-```rust
-fn main() {
-    // Will emulate `std::time::Instant` based on `performance.now()`.
-    let now = instant::Instant::now();
-}
-```
-
------
-
-### Using `instant` for a WASM platform where `performance.now()` is not available.
-This example shows the use of the `inaccurate` feature.
-
-_Cargo.toml_:
-```toml
-[dependencies]
-instant = { version = "0.1", features = [ "wasm-bindgen", "inaccurate" ] }
-```
-
-_main.rs_:
-```rust
-fn main() {
-    // Will emulate `std::time::Instant` based on `Date.now()`.
-    let now = instant::Instant::now();
-}
-```
-
-
------
-
-### Using `instant` for any platform enabling a feature transitively.
-_Cargo.toml_:
-```toml
-[features]
-stdweb = [ "instant/stdweb" ]
-wasm-bindgen = [ "instant/wasm-bindgen" ]
-
-[dependencies]
-instant = "0.1"
-```
-
-_lib.rs_:
-```rust
-fn my_function() {
-    // Will select the proper implementation depending on the
-    // feature selected by the user.
-    let now = instant::Instant::now();
-}
-```
-
------
-
-### Using `instant::now()`
-_Cargo.toml_:
-```toml
-[features]
-stdweb = [ "instant/stdweb" ]
-wasm-bindgen = [ "instant/wasm-bindgen" ]
-
-[dependencies]
-instant = "0.1"
-```
-
-_lib.rs_:
-```rust
-fn my_function() {
-    // Will select the proper implementation depending on the
-    // feature selected by the user.
-    let now_instant = instant::Instant::now();
-    let now_milliseconds = instant::now(); // In milliseconds.
-}
-```
-
-### Using the feature `now` without `stdweb` or `wasm-bindgen`.
-_Cargo.toml_:
-```toml
-[dependencies]
-instant = "0.1"
-```
-
-_lib.rs_:
-```rust
-fn my_function() {
-    // Will use the 'now' javascript implementation.
-    let now_instant = instant::Instant::now();
-    let now_milliseconds = instant::now(); // In milliseconds.
-}
-```
-
-_javascript WASM bindings file_:
-```js
-function now() {
-	return Date.now() / 1000.0;
-}
-```
+# Instant
+
+If you call `std::time::Instant::now()` on a WASM platform, it will panic. This crate provides a partial
+replacement for `std::time::Instant` that works on WASM too. This defines the type `instant::Instant` which is:
+
+* A struct emulating the behavior of **std::time::Instant** if you are targeting `wasm32-unknown-unknown` or `wasm32-unknown-asmjs`
+**and** you enabled either the `stdweb` or the `wasm-bindgen` feature. This emulation is based on the javascript `performance.now()` function.
+* A type alias for `std::time::Instant` otherwise.
+
+
+
+Note that even if the **stdweb** or **wasm-bindgen** feature is enabled, this crate will continue to rely on `std::time::Instant`
+as long as you are not targeting wasm32. This allows for portable code that will work on both native and WASM platforms.
+
+This crate also exports the function `instant::now()` which returns a representation of the current time as an `f64`, expressed in milliseconds, in a platform-agnostic way. `instant::now()` will either:
+
+* Call `performance.now()` when compiling for a WASM platform with the features **stdweb** or **wasm-bindgen** enabled, or using a custom javascript function.
+* Return the time elapsed since the *Unix Epoch* on *native*, *non-WASM* platforms.
+
+*Note*: The old feature, `now`, has been deprecated. `instant::now()` is always exported and the `now` feature flag no longer has any effect. It remains listed in `Cargo.toml` to avoid introducing breaking changes and may be removed in future versions.
+
+## Examples
+### Using `instant` for a native platform.
+_Cargo.toml_:
+```toml
+[dependencies]
+instant = "0.1"
+```
+
+_main.rs_:
+```rust
+fn main() {
+    // Will be the same as `std::time::Instant`.
+    let now = instant::Instant::now();
+}
+```
+
+-----
+
+### Using `instant` for a WASM platform.
+This example shows the use of the `stdweb` feature. It would be similar with `wasm-bindgen`.
+
+_Cargo.toml_:
+```toml
+[dependencies]
+instant = { version = "0.1", features = [ "stdweb" ] }
+```
+
+_main.rs_:
+```rust
+fn main() {
+    // Will emulate `std::time::Instant` based on `performance.now()`.
+    let now = instant::Instant::now();
+}
+```
+
+-----
+
+### Using `instant` for a WASM platform where `performance.now()` is not available.
+This example shows the use of the `inaccurate` feature.
+
+_Cargo.toml_:
+```toml
+[dependencies]
+instant = { version = "0.1", features = [ "wasm-bindgen", "inaccurate" ] }
+```
+
+_main.rs_:
+```rust
+fn main() {
+    // Will emulate `std::time::Instant` based on `Date.now()`.
+    let now = instant::Instant::now();
+}
+```
+
+
+-----
+
+### Using `instant` for any platform enabling a feature transitively.
+_Cargo.toml_:
+```toml
+[features]
+stdweb = [ "instant/stdweb" ]
+wasm-bindgen = [ "instant/wasm-bindgen" ]
+
+[dependencies]
+instant = "0.1"
+```
+
+_lib.rs_:
+```rust
+fn my_function() {
+    // Will select the proper implementation depending on the
+    // feature selected by the user.
+    let now = instant::Instant::now();
+}
+```
+
+-----
+
+### Using `instant::now()`
+_Cargo.toml_:
+```toml
+[features]
+stdweb = [ "instant/stdweb" ]
+wasm-bindgen = [ "instant/wasm-bindgen" ]
+
+[dependencies]
+instant = "0.1"
+```
+
+_lib.rs_:
+```rust
+fn my_function() {
+    // Will select the proper implementation depending on the
+    // feature selected by the user.
+    let now_instant = instant::Instant::now();
+    let now_milliseconds = instant::now(); // In milliseconds.
+}
+```
+
+### Using the feature `now` without `stdweb` or `wasm-bindgen`.
+_Cargo.toml_:
+```toml
+[dependencies]
+instant = "0.1"
+```
+
+_lib.rs_:
+```rust
+fn my_function() {
+    // Will use the 'now' javascript implementation.
+    let now_instant = instant::Instant::now();
+    let now_milliseconds = instant::now(); // In milliseconds.
+}
+```
+
+_javascript WASM bindings file_:
+```js
+function now() {
+	return Date.now() / 1000.0;
+}
+```

zeroidc/vendor/instant/src/lib.rs

@@ -1,22 +1,22 @@
-cfg_if::cfg_if! {
-    if #[cfg(any(
-        all(target_arch = "wasm32", not(target_os = "wasi")),
-        target_arch = "asmjs"
-    ))] {
-        #[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))]
-        #[macro_use]
-        extern crate stdweb;
-
-        mod wasm;
-        pub use wasm::Instant;
-        pub use crate::wasm::now;
-        pub use wasm::SystemTime;
-    } else {
-        mod native;
-        pub use native::Instant;
-        pub use native::now;
-        pub use native::SystemTime;
-    }
-}
-
-pub use std::time::Duration;
+cfg_if::cfg_if! {
+    if #[cfg(any(
+        all(target_arch = "wasm32", not(target_os = "wasi")),
+        target_arch = "asmjs"
+    ))] {
+        #[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))]
+        #[macro_use]
+        extern crate stdweb;
+
+        mod wasm;
+        pub use wasm::Instant;
+        pub use crate::wasm::now;
+        pub use wasm::SystemTime;
+    } else {
+        mod native;
+        pub use native::Instant;
+        pub use native::now;
+        pub use native::SystemTime;
+    }
+}
+
+pub use std::time::Duration;

zeroidc/vendor/instant/src/native.rs

@@ -1,9 +1,9 @@
-pub type Instant = std::time::Instant;
-pub type SystemTime = std::time::SystemTime;
-
-/// The current time, expressed in milliseconds since the Unix Epoch.
-pub fn now() -> f64 {
-    std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH)
-                                .expect("System clock was before 1970.")
-                                .as_secs_f64() * 1000.0
-}
+pub type Instant = std::time::Instant;
+pub type SystemTime = std::time::SystemTime;
+
+/// The current time, expressed in milliseconds since the Unix Epoch.
+pub fn now() -> f64 {
+    std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH)
+                                .expect("System clock was before 1970.")
+                                .as_secs_f64() * 1000.0
+}

zeroidc/vendor/instant/src/wasm.rs

@@ -1,240 +1,240 @@
-use std::cmp::Ordering;
-use std::ops::{Add, AddAssign, Sub, SubAssign};
-use std::time::Duration;
-
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Hash)]
-pub struct Instant(Duration);
-
-impl Ord for Instant {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.partial_cmp(other)
-            .expect("an instant should never be NaN or Inf.")
-    }
-}
-impl Eq for Instant {}
-
-impl Instant {
-    #[inline]
-    pub fn now() -> Self {
-        Instant(duration_from_f64(now()))
-    }
-
-    #[inline]
-    pub fn duration_since(&self, earlier: Instant) -> Duration {
-        assert!(
-            earlier.0 <= self.0,
-            "`earlier` cannot be later than `self`."
-        );
-        self.0 - earlier.0
-    }
-
-    #[inline]
-    pub fn elapsed(&self) -> Duration {
-        Self::now().duration_since(*self)
-    }
-
-    /// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as
-    /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
-    /// otherwise.
-    #[inline]
-    pub fn checked_add(&self, duration: Duration) -> Option<Instant> {
-        self.0.checked_add(duration).map(Instant)
-    }
-
-    /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
-    /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
-    /// otherwise.
-    #[inline]
-    pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
-        self.0.checked_sub(duration).map(Instant)
-    }
-
-    /// Returns the amount of time elapsed from another instant to this one, or None if that
-    /// instant is later than this one.
-    #[inline]
-    pub fn checked_duration_since(&self, earlier: Instant) -> Option<Duration> {
-        if earlier.0 > self.0 {
-            None
-        } else {
-            Some(self.0 - earlier.0)
-        }
-    }
-
-    /// Returns the amount of time elapsed from another instant to this one, or zero duration if
-    /// that instant is later than this one.
-    #[inline]
-    pub fn saturating_duration_since(&self, earlier: Instant) -> Duration {
-        self.checked_duration_since(earlier).unwrap_or_default()
-    }
-}
-
-impl Add<Duration> for Instant {
-    type Output = Self;
-
-    #[inline]
-    fn add(self, rhs: Duration) -> Self {
-        Instant(self.0 + rhs)
-    }
-}
-
-impl AddAssign<Duration> for Instant {
-    #[inline]
-    fn add_assign(&mut self, rhs: Duration) {
-        self.0 += rhs
-    }
-}
-
-impl Sub<Duration> for Instant {
-    type Output = Self;
-
-    #[inline]
-    fn sub(self, rhs: Duration) -> Self {
-        Instant(self.0 - rhs)
-    }
-}
-
-impl Sub<Instant> for Instant {
-    type Output = Duration;
-
-    #[inline]
-    fn sub(self, rhs: Instant) -> Duration {
-        self.duration_since(rhs)
-    }
-}
-
-impl SubAssign<Duration> for Instant {
-    #[inline]
-    fn sub_assign(&mut self, rhs: Duration) {
-        self.0 -= rhs
-    }
-}
-
-fn duration_from_f64(millis: f64) -> Duration {
-    Duration::from_millis(millis.trunc() as u64)
-        + Duration::from_nanos((millis.fract() * 1.0e6) as u64)
-}
-
-#[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))]
-#[allow(unused_results)] // Needed because the js macro triggers it.
-pub fn now() -> f64 {
-    use stdweb::unstable::TryInto;
-
-    // https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
-    #[cfg(not(feature = "inaccurate"))]
-    let v = js! { return performance.now(); };
-    #[cfg(feature = "inaccurate")]
-    let v = js! { return Date.now(); };
-    v.try_into().unwrap()
-}
-
-#[cfg(feature = "wasm-bindgen")]
-pub fn now() -> f64 {
-    #[cfg(not(feature = "inaccurate"))]
-    let now = {
-        use wasm_bindgen_rs::prelude::*;
-        use wasm_bindgen_rs::JsCast;
-        js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str("performance"))
-            .expect("failed to get performance from global object")
-            .unchecked_into::<web_sys::Performance>()
-            .now()
-    };
-    #[cfg(feature = "inaccurate")]
-    let now = js_sys::Date::now();
-    now
-}
-
-// The JS now function is in a module so it won't have to be renamed
-#[cfg(not(any(feature = "wasm-bindgen", feature = "stdweb")))]
-mod js {
-    extern "C" {
-        #[cfg(not(target_os = "emscripten"))]
-        pub fn now() -> f64;
-        #[cfg(target_os = "emscripten")]
-        pub fn _emscripten_get_now() -> f64;
-    }
-}
-// Make the unsafe extern function "safe" so it can be called like the other 'now' functions
-#[cfg(not(any(feature = "wasm-bindgen", feature = "stdweb")))]
-pub fn now() -> f64 {
-    #[cfg(not(target_os = "emscripten"))]
-    return unsafe { js::now() };
-    #[cfg(target_os = "emscripten")]
-    return unsafe { js::_emscripten_get_now() };
-}
-
-/// Returns the number of millisecods elapsed since January 1, 1970 00:00:00 UTC.
-#[cfg(any(feature = "wasm-bindgen", feature = "stdweb"))]
-fn get_time() -> f64 {
-    #[cfg(feature = "wasm-bindgen")]
-    return js_sys::Date::now();
-    #[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))]
-    {
-        let v = js! { return Date.now(); };
-        return v.try_into().unwrap();
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
-pub struct SystemTime(f64);
-
-impl SystemTime {
-    pub const UNIX_EPOCH: SystemTime = SystemTime(0.0);
-
-    pub fn now() -> SystemTime {
-        cfg_if::cfg_if! {
-            if #[cfg(any(feature = "wasm-bindgen", feature = "stdweb"))] {
-                SystemTime(get_time())
-            } else {
-                SystemTime(now())
-            }
-        }
-    }
-
-    pub fn duration_since(&self, earlier: SystemTime) -> Result<Duration, ()> {
-        let dur_ms = self.0 - earlier.0;
-        if dur_ms < 0.0 {
-            return Err(());
-        }
-        Ok(Duration::from_millis(dur_ms as u64))
-    }
-
-    pub fn elapsed(&self) -> Result<Duration, ()> {
-        self.duration_since(SystemTime::now())
-    }
-
-    pub fn checked_add(&self, duration: Duration) -> Option<SystemTime> {
-        Some(*self + duration)
-    }
-
-    pub fn checked_sub(&self, duration: Duration) -> Option<SystemTime> {
-        Some(*self - duration)
-    }
-}
-
-impl Add<Duration> for SystemTime {
-    type Output = SystemTime;
-
-    fn add(self, other: Duration) -> SystemTime {
-        SystemTime(self.0 + other.as_millis() as f64)
-    }
-}
-
-impl Sub<Duration> for SystemTime {
-    type Output = SystemTime;
-
-    fn sub(self, other: Duration) -> SystemTime {
-        SystemTime(self.0 - other.as_millis() as f64)
-    }
-}
-
-impl AddAssign<Duration> for SystemTime {
-    fn add_assign(&mut self, rhs: Duration) {
-        *self = *self + rhs;
-    }
-}
-
-impl SubAssign<Duration> for SystemTime {
-    fn sub_assign(&mut self, rhs: Duration) {
-        *self = *self - rhs;
-    }
-}
+use std::cmp::Ordering;
+use std::ops::{Add, AddAssign, Sub, SubAssign};
+use std::time::Duration;
+
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Hash)]
+pub struct Instant(Duration);
+
+impl Ord for Instant {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.partial_cmp(other)
+            .expect("an instant should never be NaN or Inf.")
+    }
+}
+impl Eq for Instant {}
+
+impl Instant {
+    #[inline]
+    pub fn now() -> Self {
+        Instant(duration_from_f64(now()))
+    }
+
+    #[inline]
+    pub fn duration_since(&self, earlier: Instant) -> Duration {
+        assert!(
+            earlier.0 <= self.0,
+            "`earlier` cannot be later than `self`."
+        );
+        self.0 - earlier.0
+    }
+
+    #[inline]
+    pub fn elapsed(&self) -> Duration {
+        Self::now().duration_since(*self)
+    }
+
+    /// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as
+    /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
+    /// otherwise.
+    #[inline]
+    pub fn checked_add(&self, duration: Duration) -> Option<Instant> {
+        self.0.checked_add(duration).map(Instant)
+    }
+
+    /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
+    /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
+    /// otherwise.
+    #[inline]
+    pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
+        self.0.checked_sub(duration).map(Instant)
+    }
+
+    /// Returns the amount of time elapsed from another instant to this one, or None if that
+    /// instant is later than this one.
+    #[inline]
+    pub fn checked_duration_since(&self, earlier: Instant) -> Option<Duration> {
+        if earlier.0 > self.0 {
+            None
+        } else {
+            Some(self.0 - earlier.0)
+        }
+    }
+
+    /// Returns the amount of time elapsed from another instant to this one, or zero duration if
+    /// that instant is later than this one.
+    #[inline]
+    pub fn saturating_duration_since(&self, earlier: Instant) -> Duration {
+        self.checked_duration_since(earlier).unwrap_or_default()
+    }
+}
+
+impl Add<Duration> for Instant {
+    type Output = Self;
+
+    #[inline]
+    fn add(self, rhs: Duration) -> Self {
+        Instant(self.0 + rhs)
+    }
+}
+
+impl AddAssign<Duration> for Instant {
+    #[inline]
+    fn add_assign(&mut self, rhs: Duration) {
+        self.0 += rhs
+    }
+}
+
+impl Sub<Duration> for Instant {
+    type Output = Self;
+
+    #[inline]
+    fn sub(self, rhs: Duration) -> Self {
+        Instant(self.0 - rhs)
+    }
+}
+
+impl Sub<Instant> for Instant {
+    type Output = Duration;
+
+    #[inline]
+    fn sub(self, rhs: Instant) -> Duration {
+        self.duration_since(rhs)
+    }
+}
+
+impl SubAssign<Duration> for Instant {
+    #[inline]
+    fn sub_assign(&mut self, rhs: Duration) {
+        self.0 -= rhs
+    }
+}
+
+fn duration_from_f64(millis: f64) -> Duration {
+    Duration::from_millis(millis.trunc() as u64)
+        + Duration::from_nanos((millis.fract() * 1.0e6) as u64)
+}
+
+#[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))]
+#[allow(unused_results)] // Needed because the js macro triggers it.
+pub fn now() -> f64 {
+    use stdweb::unstable::TryInto;
+
+    // https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
+    #[cfg(not(feature = "inaccurate"))]
+    let v = js! { return performance.now(); };
+    #[cfg(feature = "inaccurate")]
+    let v = js! { return Date.now(); };
+    v.try_into().unwrap()
+}
+
+#[cfg(feature = "wasm-bindgen")]
+pub fn now() -> f64 {
+    #[cfg(not(feature = "inaccurate"))]
+    let now = {
+        use wasm_bindgen_rs::prelude::*;
+        use wasm_bindgen_rs::JsCast;
+        js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str("performance"))
+            .expect("failed to get performance from global object")
+            .unchecked_into::<web_sys::Performance>()
+            .now()
+    };
+    #[cfg(feature = "inaccurate")]
+    let now = js_sys::Date::now();
+    now
+}
+
+// The JS now function is in a module so it won't have to be renamed
+#[cfg(not(any(feature = "wasm-bindgen", feature = "stdweb")))]
+mod js {
+    extern "C" {
+        #[cfg(not(target_os = "emscripten"))]
+        pub fn now() -> f64;
+        #[cfg(target_os = "emscripten")]
+        pub fn _emscripten_get_now() -> f64;
+    }
+}
+// Make the unsafe extern function "safe" so it can be called like the other 'now' functions
+#[cfg(not(any(feature = "wasm-bindgen", feature = "stdweb")))]
+pub fn now() -> f64 {
+    #[cfg(not(target_os = "emscripten"))]
+    return unsafe { js::now() };
+    #[cfg(target_os = "emscripten")]
+    return unsafe { js::_emscripten_get_now() };
+}
+
+/// Returns the number of millisecods elapsed since January 1, 1970 00:00:00 UTC.
+#[cfg(any(feature = "wasm-bindgen", feature = "stdweb"))]
+fn get_time() -> f64 {
+    #[cfg(feature = "wasm-bindgen")]
+    return js_sys::Date::now();
+    #[cfg(all(feature = "stdweb", not(feature = "wasm-bindgen")))]
+    {
+        let v = js! { return Date.now(); };
+        return v.try_into().unwrap();
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
+pub struct SystemTime(f64);
+
+impl SystemTime {
+    pub const UNIX_EPOCH: SystemTime = SystemTime(0.0);
+
+    pub fn now() -> SystemTime {
+        cfg_if::cfg_if! {
+            if #[cfg(any(feature = "wasm-bindgen", feature = "stdweb"))] {
+                SystemTime(get_time())
+            } else {
+                SystemTime(now())
+            }
+        }
+    }
+
+    pub fn duration_since(&self, earlier: SystemTime) -> Result<Duration, ()> {
+        let dur_ms = self.0 - earlier.0;
+        if dur_ms < 0.0 {
+            return Err(());
+        }
+        Ok(Duration::from_millis(dur_ms as u64))
+    }
+
+    pub fn elapsed(&self) -> Result<Duration, ()> {
+        self.duration_since(SystemTime::now())
+    }
+
+    pub fn checked_add(&self, duration: Duration) -> Option<SystemTime> {
+        Some(*self + duration)
+    }
+
+    pub fn checked_sub(&self, duration: Duration) -> Option<SystemTime> {
+        Some(*self - duration)
+    }
+}
+
+impl Add<Duration> for SystemTime {
+    type Output = SystemTime;
+
+    fn add(self, other: Duration) -> SystemTime {
+        SystemTime(self.0 + other.as_millis() as f64)
+    }
+}
+
+impl Sub<Duration> for SystemTime {
+    type Output = SystemTime;
+
+    fn sub(self, other: Duration) -> SystemTime {
+        SystemTime(self.0 - other.as_millis() as f64)
+    }
+}
+
+impl AddAssign<Duration> for SystemTime {
+    fn add_assign(&mut self, rhs: Duration) {
+        *self = *self + rhs;
+    }
+}
+
+impl SubAssign<Duration> for SystemTime {
+    fn sub_assign(&mut self, rhs: Duration) {
+        *self = *self - rhs;
+    }
+}

zeroidc/vendor/instant/tests/wasm.rs

@@ -1,57 +1,57 @@
-extern crate wasm_bindgen_test;
-
-use instant::{Instant, SystemTime};
-use std::time::Duration;
-use wasm_bindgen_test::*;
-
-wasm_bindgen_test_configure!(run_in_browser);
-// run these tests using: wasm-pack test --chrome --headless -- --features wasm-bindgen
-
-#[wasm_bindgen_test]
-fn test_instant_now() {
-    let now = Instant::now();
-    #[cfg(feature = "inaccurate")]
-    while now.elapsed().as_millis() == 0 {}
-    #[cfg(not(feature = "inaccurate"))]
-    assert!(now.elapsed().as_nanos() > 0);
-}
-
-#[wasm_bindgen_test]
-fn test_duration() {
-    let now = Instant::now();
-    let one_sec = Duration::from_secs(1);
-    assert!(now.elapsed() < one_sec);
-}
-
-// Duration::new will overflow when you have u64::MAX seconds and one billion nanoseconds.
-// <https://doc.rust-lang.org/std/time/struct.Duration.html#method.new>
-const ONE_BILLION: u32 = 1_000_000_000;
-
-#[wasm_bindgen_test]
-fn test_checked_add() {
-    let now = Instant::now();
-
-    assert!(now.checked_add(Duration::from_millis(1)).is_some());
-    assert_eq!(
-        None,
-        now.checked_add(Duration::new(u64::MAX, ONE_BILLION - 1))
-    );
-}
-
-#[wasm_bindgen_test]
-fn test_checked_sub() {
-    let now = Instant::now();
-
-    assert!(now.checked_sub(Duration::from_millis(1)).is_some());
-    assert!(now
-        .checked_sub(Duration::new(u64::MAX, ONE_BILLION - 1))
-        .is_none());
-}
-
-#[wasm_bindgen_test]
-fn test_system_time() {
-    assert!(SystemTime::UNIX_EPOCH
-        .duration_since(SystemTime::now())
-        .is_err());
-}
-
+extern crate wasm_bindgen_test;
+
+use instant::{Instant, SystemTime};
+use std::time::Duration;
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
+// run these tests using: wasm-pack test --chrome --headless -- --features wasm-bindgen
+
+#[wasm_bindgen_test]
+fn test_instant_now() {
+    let now = Instant::now();
+    #[cfg(feature = "inaccurate")]
+    while now.elapsed().as_millis() == 0 {}
+    #[cfg(not(feature = "inaccurate"))]
+    assert!(now.elapsed().as_nanos() > 0);
+}
+
+#[wasm_bindgen_test]
+fn test_duration() {
+    let now = Instant::now();
+    let one_sec = Duration::from_secs(1);
+    assert!(now.elapsed() < one_sec);
+}
+
+// Duration::new will overflow when you have u64::MAX seconds and one billion nanoseconds.
+// <https://doc.rust-lang.org/std/time/struct.Duration.html#method.new>
+const ONE_BILLION: u32 = 1_000_000_000;
+
+#[wasm_bindgen_test]
+fn test_checked_add() {
+    let now = Instant::now();
+
+    assert!(now.checked_add(Duration::from_millis(1)).is_some());
+    assert_eq!(
+        None,
+        now.checked_add(Duration::new(u64::MAX, ONE_BILLION - 1))
+    );
+}
+
+#[wasm_bindgen_test]
+fn test_checked_sub() {
+    let now = Instant::now();
+
+    assert!(now.checked_sub(Duration::from_millis(1)).is_some());
+    assert!(now
+        .checked_sub(Duration::new(u64::MAX, ONE_BILLION - 1))
+        .is_none());
+}
+
+#[wasm_bindgen_test]
+fn test_system_time() {
+    assert!(SystemTime::UNIX_EPOCH
+        .duration_since(SystemTime::now())
+        .is_err());
+}
+

zeroidc/vendor/libc/src/unix/linux_like/android/b64/aarch64/int128.rs

@@ -1,7 +1,7 @@
-s! {
-    pub struct user_fpsimd_struct {
-        pub vregs: [::__uint128_t; 32],
-        pub fpsr: u32,
-        pub fpcr: u32,
-    }
-}
+s! {
+    pub struct user_fpsimd_struct {
+        pub vregs: [::__uint128_t; 32],
+        pub fpsr: u32,
+        pub fpcr: u32,
+    }
+}

zeroidc/vendor/libc/src/unix/linux_like/linux/gnu/b64/aarch64/int128.rs

@@ -1,7 +1,7 @@
-s! {
-    pub struct user_fpsimd_struct {
-        pub vregs: [::__uint128_t; 32],
-        pub fpsr: u32,
-        pub fpcr: u32,
-    }
-}
+s! {
+    pub struct user_fpsimd_struct {
+        pub vregs: [::__uint128_t; 32],
+        pub fpsr: u32,
+        pub fpcr: u32,
+    }
+}

zeroidc/vendor/libc/src/unix/linux_like/linux/musl/b64/aarch64/int128.rs

@@ -1,7 +1,7 @@
-s! {
-    pub struct user_fpsimd_struct {
-        pub vregs: [::__uint128_t; 32],
-        pub fpsr: u32,
-        pub fpcr: u32,
-    }
-}
+s! {
+    pub struct user_fpsimd_struct {
+        pub vregs: [::__uint128_t; 32],
+        pub fpsr: u32,
+        pub fpcr: u32,
+    }
+}

zeroidc/vendor/log/CHANGELOG.md

@@ -1,241 +1,241 @@
-# Change Log
-
-## [Unreleased]
-
-## [0.4.17] - 2022-04-29
-
-* Update `kv_unstable` internal dependencies.
-
-## [0.4.16] - 2022-03-22
-
-* Fix a conflict with unqualified `Option` use in macros.
-
-## [0.4.15] - 2022-02-23
-
-* Silence a warning about the deprecated `spin_loop_hint`.
-* Relax ordering in the atomic `set_max_level` call.
-* Add thumbv4t-none-eabi to targets that don't support atomics
-* Allow levels to be iterated over.
-* Implement `Log` on some common wrapper types.
-* Improvements to test coverage.
-* Improvements to documentation.
-* Add key-value support to the `log!` macros.
-* Tighten `kv_unstable` internal dependencies so they don't bump past their current alpha.
-* Add a simple visit API to `kv_unstable`.
-* Support `NonZero*` integers as values in structured logging
-* Support static strings as keys in structured logging
-
-## [0.4.14] - 2021-01-27
-
-* Remove the `__private_api_log_lit` special case.
-* Fixed incorrect combination of `kv_unstable` and `std` features causing compile failures.
-* Remove unstable `Value::to_*` conversions that were incorrectly using `as`.
-* Rename unstable `Value::to_error` to `Value::to_borrowed_error`.
-
-## [0.4.13] - 2021-01-11
-
-* This is the same as `0.4.11`, except with a `kv_unstable_std` feature added to aid migrating current dependents to `0.4.14` (which was originally going to be `0.4.13` until it was decided to create a patch from `0.4.11` to minimize disruption).
-
-## [0.4.12] - 2020-12-24
-
-### New
-
-* Support platforms without atomics by racing instead of failing to compile
-* Implement `Log` for `Box<T: Log>`
-* Update `cfg-if` to `1.0`
-* Internal reworks of the structured logging API. Removed the `Fill` API
-and added `source::as_map` and `source::as_list` to easily serialize a `Source`
-as either a map of `{key: value, ..}` or as a list of `[(key, value), ..]`.
-
-### Fixed
-
-* Fixed deserialization of `LevelFilter` to use their `u64` index variants
-
-## [0.4.11] - 2020-07-09
-
-### New
-
-* Support coercing structured values into concrete types.
-* Reference the `win_dbg_logger` in the readme.
-
-### Fixed
-
-* Updates a few deprecated items used internally.
-* Fixed issues in docs and expands sections.
-* Show the correct build badge in the readme.
-* Fix up a possible inference breakage with structured value errors.
-* Respect formatting flags in structured value formatting.
-
-## [0.4.10] - 2019-12-16 (yanked)
-
-### Fixed
-
-* Fixed the `log!` macros so they work in expression context (this regressed in `0.4.9`, which has been yanked).
-
-## [0.4.9] - 2019-12-12 (yanked)
-
-### Minimum Supported Rust Version
-
-This release bumps the minimum compiler version to `1.31.0`. This was mainly needed for `cfg-if`,
-but between `1.16.0` and `1.31.0` there are a lot of language and library improvements we now
-take advantage of.
-
-### New
-
-* Unstable support for capturing key-value pairs in a record using the `log!` macros
-
-### Improved
-
-* Better documentation for max level filters.
-* Internal updates to line up with bumped MSRV
-
-## [0.4.8] - 2019-07-28
-
-### New
-
-* Support attempting to get `Record` fields as static strings.
-
-## [0.4.7] - 2019-07-06
-
-### New
-
-* Support for embedded environments with thread-unsafe initialization.
-* Initial unstable support for capturing structured data under the `kv_unstable`
-feature gate. This new API doesn't affect existing users and may change in future
-patches (so those changes may not appear in the changelog until it stabilizes).
-
-### Improved
-
-* Docs for using `log` with the 2018 edition.
-* Error messages for macros missing arguments.
-
-## [0.4.6] - 2018-10-27
-
-### Improved
-
-* Support 2018-style macro import for the `log_enabled!` macro.
-
-## [0.4.5] - 2018-09-03
-
-### Improved
-
-* Make `log`'s internal helper macros less likely to conflict with user-defined
-  macros.
-
-## [0.4.4] - 2018-08-17
-
-### Improved
-
-* Support 2018-style imports of the log macros.
-
-## [0.4.3] - 2018-06-29
-
-### Improved
-
-* More code generation improvements.
-
-## [0.4.2] - 2018-06-05
-
-### Improved
-
-* Log invocations now generate less code.
-
-### Fixed
-
-* Example Logger implementations now properly set the max log level.
-
-## [0.4.1] - 2017-12-30
-
-### Fixed
-
-* Some doc links were fixed.
-
-## [0.4.0] - 2017-12-24
-
-The changes in this release include cleanup of some obscure functionality and a more robust public
-API designed to support bridges to other logging systems, and provide more flexibility to new
-features in the future.
-
-### Compatibility
-
-Vast portions of the Rust ecosystem use the 0.3.x release series of log, and we don't want to force
-the community to go through the pain of upgrading every crate to 0.4.x at the exact same time. Along
-with 0.4.0, we've published a new 0.3.9 release which acts as a "shim" over 0.4.0. This will allow
-crates using either version to coexist without losing messages from one side or the other.
-
-There is one caveat - a log message generated by a crate using 0.4.x but consumed by a logging
-implementation using 0.3.x will not have a file name or module path. Applications affected by this
-can upgrade their logging implementations to one using 0.4.x to avoid losing this information. The
-other direction does not lose any information, fortunately!
-
-**TL;DR** Libraries should feel comfortable upgrading to 0.4.0 without treating that as a breaking
-change. Applications may need to update their logging implementation (e.g. env-logger) to a newer
-version using log 0.4.x to avoid losing module and file information.
-
-### New
-
-* The crate is now `no_std` by default.
-* `Level` and `LevelFilter` now implement `Serialize` and `Deserialize` when the `serde` feature is
-    enabled.
-* The `Record` and `Metadata` types can now be constructed by third-party code via a builder API.
-* The `logger` free function returns a reference to the logger implementation. This, along with the
-    ability to construct `Record`s, makes it possible to bridge from another logging framework to
-    this one without digging into the private internals of the crate. The standard `error!` `warn!`,
-    etc, macros now exclusively use the public API of the crate rather than "secret" internal APIs.
-* `Log::flush` has been added to allow crates to tell the logging implementation to ensure that all
-    "in flight" log events have been persisted. This can be used, for example, just before an
-    application exits to ensure that asynchronous log sinks finish their work.
-
-### Removed
-
-* The `shutdown` and `shutdown_raw` functions have been removed. Supporting shutdown significantly
-    complicated the implementation and imposed a performance cost on each logging operation.
-* The `log_panics` function and its associated `nightly` Cargo feature have been removed. Use the
-    [log-panics](https://crates.io/crates/log-panics) instead.
-
-### Changed
-
-* The `Log` prefix has been removed from type names. For example, `LogLevelFilter` is now
-    `LevelFilter`, and `LogRecord` is now `Record`.
-* The `MaxLogLevelFilter` object has been removed in favor of a `set_max_level` free function.
-* The `set_logger` free functions have been restructured. The logger is now directly passed to the
-    functions rather than a closure which returns the logger. `set_logger` now takes a `&'static
-    Log` and is usable in `no_std` contexts in place of the old `set_logger_raw`. `set_boxed_logger`
-    is a convenience function which takes a `Box<Log>` but otherwise acts like `set_logger`. It
-    requires the `std` feature.
-* The `file` and `module_path` values in `Record` no longer have the `'static` lifetime to support
-    integration with other logging frameworks that don't provide a `'static` lifetime for the
-    equivalent values.
-* The `file`, `line`, and `module_path` values in `Record` are now `Option`s to support integration
-    with other logging frameworks that don't provide those values.
-
-### In the Future
-
-* We're looking to add support for *structured* logging - the inclusion of extra key-value pairs of
-    information in a log event in addition to the normal string message. This should be able to be
-    added in a backwards compatible manner to the 0.4.x series when the design is worked out.
-
-## Older
-
-Look at the [release tags] for information about older releases.
-
-[Unreleased]: https://github.com/rust-lang-nursery/log/compare/0.4.17...HEAD
-[0.4.17]: https://github.com/rust-lang-nursery/log/compare/0.4.16...0.4.17
-[0.4.16]: https://github.com/rust-lang-nursery/log/compare/0.4.15...0.4.16
-[0.4.15]: https://github.com/rust-lang-nursery/log/compare/0.4.13...0.4.15
-[0.4.14]: https://github.com/rust-lang-nursery/log/compare/0.4.13...0.4.14
-[0.4.13]: https://github.com/rust-lang-nursery/log/compare/0.4.11...0.4.13
-[0.4.12]: https://github.com/rust-lang-nursery/log/compare/0.4.11...0.4.12
-[0.4.11]: https://github.com/rust-lang-nursery/log/compare/0.4.10...0.4.11
-[0.4.10]: https://github.com/rust-lang-nursery/log/compare/0.4.9...0.4.10
-[0.4.9]: https://github.com/rust-lang-nursery/log/compare/0.4.8...0.4.9
-[0.4.8]: https://github.com/rust-lang-nursery/log/compare/0.4.7...0.4.8
-[0.4.7]: https://github.com/rust-lang-nursery/log/compare/0.4.6...0.4.7
-[0.4.6]: https://github.com/rust-lang-nursery/log/compare/0.4.5...0.4.6
-[0.4.5]: https://github.com/rust-lang-nursery/log/compare/0.4.4...0.4.5
-[0.4.4]: https://github.com/rust-lang-nursery/log/compare/0.4.3...0.4.4
-[0.4.3]: https://github.com/rust-lang-nursery/log/compare/0.4.2...0.4.3
-[0.4.2]: https://github.com/rust-lang-nursery/log/compare/0.4.1...0.4.2
-[0.4.1]: https://github.com/rust-lang-nursery/log/compare/0.4.0...0.4.1
-[0.4.0]: https://github.com/rust-lang-nursery/log/compare/0.3.8...0.4.0
-[release tags]: https://github.com/rust-lang-nursery/log/releases
+# Change Log
+
+## [Unreleased]
+
+## [0.4.17] - 2022-04-29
+
+* Update `kv_unstable` internal dependencies.
+
+## [0.4.16] - 2022-03-22
+
+* Fix a conflict with unqualified `Option` use in macros.
+
+## [0.4.15] - 2022-02-23
+
+* Silence a warning about the deprecated `spin_loop_hint`.
+* Relax ordering in the atomic `set_max_level` call.
+* Add thumbv4t-none-eabi to targets that don't support atomics
+* Allow levels to be iterated over.
+* Implement `Log` on some common wrapper types.
+* Improvements to test coverage.
+* Improvements to documentation.
+* Add key-value support to the `log!` macros.
+* Tighten `kv_unstable` internal dependencies so they don't bump past their current alpha.
+* Add a simple visit API to `kv_unstable`.
+* Support `NonZero*` integers as values in structured logging
+* Support static strings as keys in structured logging
+
+## [0.4.14] - 2021-01-27
+
+* Remove the `__private_api_log_lit` special case.
+* Fixed incorrect combination of `kv_unstable` and `std` features causing compile failures.
+* Remove unstable `Value::to_*` conversions that were incorrectly using `as`.
+* Rename unstable `Value::to_error` to `Value::to_borrowed_error`.
+
+## [0.4.13] - 2021-01-11
+
+* This is the same as `0.4.11`, except with a `kv_unstable_std` feature added to aid migrating current dependents to `0.4.14` (which was originally going to be `0.4.13` until it was decided to create a patch from `0.4.11` to minimize disruption).
+
+## [0.4.12] - 2020-12-24
+
+### New
+
+* Support platforms without atomics by racing instead of failing to compile
+* Implement `Log` for `Box<T: Log>`
+* Update `cfg-if` to `1.0`
+* Internal reworks of the structured logging API. Removed the `Fill` API
+and added `source::as_map` and `source::as_list` to easily serialize a `Source`
+as either a map of `{key: value, ..}` or as a list of `[(key, value), ..]`.
+
+### Fixed
+
+* Fixed deserialization of `LevelFilter` to use their `u64` index variants
+
+## [0.4.11] - 2020-07-09
+
+### New
+
+* Support coercing structured values into concrete types.
+* Reference the `win_dbg_logger` in the readme.
+
+### Fixed
+
+* Updates a few deprecated items used internally.
+* Fixed issues in docs and expands sections.
+* Show the correct build badge in the readme.
+* Fix up a possible inference breakage with structured value errors.
+* Respect formatting flags in structured value formatting.
+
+## [0.4.10] - 2019-12-16 (yanked)
+
+### Fixed
+
+* Fixed the `log!` macros so they work in expression context (this regressed in `0.4.9`, which has been yanked).
+
+## [0.4.9] - 2019-12-12 (yanked)
+
+### Minimum Supported Rust Version
+
+This release bumps the minimum compiler version to `1.31.0`. This was mainly needed for `cfg-if`,
+but between `1.16.0` and `1.31.0` there are a lot of language and library improvements we now
+take advantage of.
+
+### New
+
+* Unstable support for capturing key-value pairs in a record using the `log!` macros
+
+### Improved
+
+* Better documentation for max level filters.
+* Internal updates to line up with bumped MSRV
+
+## [0.4.8] - 2019-07-28
+
+### New
+
+* Support attempting to get `Record` fields as static strings.
+
+## [0.4.7] - 2019-07-06
+
+### New
+
+* Support for embedded environments with thread-unsafe initialization.
+* Initial unstable support for capturing structured data under the `kv_unstable`
+feature gate. This new API doesn't affect existing users and may change in future
+patches (so those changes may not appear in the changelog until it stabilizes).
+
+### Improved
+
+* Docs for using `log` with the 2018 edition.
+* Error messages for macros missing arguments.
+
+## [0.4.6] - 2018-10-27
+
+### Improved
+
+* Support 2018-style macro import for the `log_enabled!` macro.
+
+## [0.4.5] - 2018-09-03
+
+### Improved
+
+* Make `log`'s internal helper macros less likely to conflict with user-defined
+  macros.
+
+## [0.4.4] - 2018-08-17
+
+### Improved
+
+* Support 2018-style imports of the log macros.
+
+## [0.4.3] - 2018-06-29
+
+### Improved
+
+* More code generation improvements.
+
+## [0.4.2] - 2018-06-05
+
+### Improved
+
+* Log invocations now generate less code.
+
+### Fixed
+
+* Example Logger implementations now properly set the max log level.
+
+## [0.4.1] - 2017-12-30
+
+### Fixed
+
+* Some doc links were fixed.
+
+## [0.4.0] - 2017-12-24
+
+The changes in this release include cleanup of some obscure functionality and a more robust public
+API designed to support bridges to other logging systems, and provide more flexibility to new
+features in the future.
+
+### Compatibility
+
+Vast portions of the Rust ecosystem use the 0.3.x release series of log, and we don't want to force
+the community to go through the pain of upgrading every crate to 0.4.x at the exact same time. Along
+with 0.4.0, we've published a new 0.3.9 release which acts as a "shim" over 0.4.0. This will allow
+crates using either version to coexist without losing messages from one side or the other.
+
+There is one caveat - a log message generated by a crate using 0.4.x but consumed by a logging
+implementation using 0.3.x will not have a file name or module path. Applications affected by this
+can upgrade their logging implementations to one using 0.4.x to avoid losing this information. The
+other direction does not lose any information, fortunately!
+
+**TL;DR** Libraries should feel comfortable upgrading to 0.4.0 without treating that as a breaking
+change. Applications may need to update their logging implementation (e.g. env-logger) to a newer
+version using log 0.4.x to avoid losing module and file information.
+
+### New
+
+* The crate is now `no_std` by default.
+* `Level` and `LevelFilter` now implement `Serialize` and `Deserialize` when the `serde` feature is
+    enabled.
+* The `Record` and `Metadata` types can now be constructed by third-party code via a builder API.
+* The `logger` free function returns a reference to the logger implementation. This, along with the
+    ability to construct `Record`s, makes it possible to bridge from another logging framework to
+    this one without digging into the private internals of the crate. The standard `error!` `warn!`,
+    etc, macros now exclusively use the public API of the crate rather than "secret" internal APIs.
+* `Log::flush` has been added to allow crates to tell the logging implementation to ensure that all
+    "in flight" log events have been persisted. This can be used, for example, just before an
+    application exits to ensure that asynchronous log sinks finish their work.
+
+### Removed
+
+* The `shutdown` and `shutdown_raw` functions have been removed. Supporting shutdown significantly
+    complicated the implementation and imposed a performance cost on each logging operation.
+* The `log_panics` function and its associated `nightly` Cargo feature have been removed. Use the
+    [log-panics](https://crates.io/crates/log-panics) instead.
+
+### Changed
+
+* The `Log` prefix has been removed from type names. For example, `LogLevelFilter` is now
+    `LevelFilter`, and `LogRecord` is now `Record`.
+* The `MaxLogLevelFilter` object has been removed in favor of a `set_max_level` free function.
+* The `set_logger` free functions have been restructured. The logger is now directly passed to the
+    functions rather than a closure which returns the logger. `set_logger` now takes a `&'static
+    Log` and is usable in `no_std` contexts in place of the old `set_logger_raw`. `set_boxed_logger`
+    is a convenience function which takes a `Box<Log>` but otherwise acts like `set_logger`. It
+    requires the `std` feature.
+* The `file` and `module_path` values in `Record` no longer have the `'static` lifetime to support
+    integration with other logging frameworks that don't provide a `'static` lifetime for the
+    equivalent values.
+* The `file`, `line`, and `module_path` values in `Record` are now `Option`s to support integration
+    with other logging frameworks that don't provide those values.
+
+### In the Future
+
+* We're looking to add support for *structured* logging - the inclusion of extra key-value pairs of
+    information in a log event in addition to the normal string message. This should be able to be
+    added in a backwards compatible manner to the 0.4.x series when the design is worked out.
+
+## Older
+
+Look at the [release tags] for information about older releases.
+
+[Unreleased]: https://github.com/rust-lang-nursery/log/compare/0.4.17...HEAD
+[0.4.17]: https://github.com/rust-lang-nursery/log/compare/0.4.16...0.4.17
+[0.4.16]: https://github.com/rust-lang-nursery/log/compare/0.4.15...0.4.16
+[0.4.15]: https://github.com/rust-lang-nursery/log/compare/0.4.13...0.4.15
+[0.4.14]: https://github.com/rust-lang-nursery/log/compare/0.4.13...0.4.14
+[0.4.13]: https://github.com/rust-lang-nursery/log/compare/0.4.11...0.4.13
+[0.4.12]: https://github.com/rust-lang-nursery/log/compare/0.4.11...0.4.12
+[0.4.11]: https://github.com/rust-lang-nursery/log/compare/0.4.10...0.4.11
+[0.4.10]: https://github.com/rust-lang-nursery/log/compare/0.4.9...0.4.10
+[0.4.9]: https://github.com/rust-lang-nursery/log/compare/0.4.8...0.4.9
+[0.4.8]: https://github.com/rust-lang-nursery/log/compare/0.4.7...0.4.8
+[0.4.7]: https://github.com/rust-lang-nursery/log/compare/0.4.6...0.4.7
+[0.4.6]: https://github.com/rust-lang-nursery/log/compare/0.4.5...0.4.6
+[0.4.5]: https://github.com/rust-lang-nursery/log/compare/0.4.4...0.4.5
+[0.4.4]: https://github.com/rust-lang-nursery/log/compare/0.4.3...0.4.4
+[0.4.3]: https://github.com/rust-lang-nursery/log/compare/0.4.2...0.4.3
+[0.4.2]: https://github.com/rust-lang-nursery/log/compare/0.4.1...0.4.2
+[0.4.1]: https://github.com/rust-lang-nursery/log/compare/0.4.0...0.4.1
+[0.4.0]: https://github.com/rust-lang-nursery/log/compare/0.3.8...0.4.0
+[release tags]: https://github.com/rust-lang-nursery/log/releases

zeroidc/vendor/log/LICENSE-APACHE

@@ -1,201 +1,201 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

zeroidc/vendor/log/LICENSE-MIT

@@ -1,25 +1,25 @@
-Copyright (c) 2014 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

zeroidc/vendor/log/README.md

@@ -1,117 +1,117 @@
-log
-===
-
-A Rust library providing a lightweight logging *facade*.
-
-[![Build status](https://img.shields.io/github/workflow/status/rust-lang/log/CI/master)](https://github.com/rust-lang/log/actions)
-[![Latest version](https://img.shields.io/crates/v/log.svg)](https://crates.io/crates/log)
-[![Documentation](https://docs.rs/log/badge.svg)](https://docs.rs/log)
-![License](https://img.shields.io/crates/l/log.svg)
-
-* [`log` documentation](https://docs.rs/log)
-
-A logging facade provides a single logging API that abstracts over the actual
-logging implementation. Libraries can use the logging API provided by this
-crate, and the consumer of those libraries can choose the logging
-implementation that is most suitable for its use case.
-
-
-## Minimum supported `rustc`
-
-`1.31.0+`
-
-This version is explicitly tested in CI and may be bumped in any release as needed. Maintaining compatibility with older compilers is a priority though, so the bar for bumping the minimum supported version is set very high. Any changes to the supported minimum version will be called out in the release notes.
-
-## Usage
-
-### In libraries
-
-Libraries should link only to the `log` crate, and use the provided macros to
-log whatever information will be useful to downstream consumers:
-
-```toml
-[dependencies]
-log = "0.4"
-```
-
-```rust
-use log::{info, trace, warn};
-
-pub fn shave_the_yak(yak: &mut Yak) {
-    trace!("Commencing yak shaving");
-
-    loop {
-        match find_a_razor() {
-            Ok(razor) => {
-                info!("Razor located: {}", razor);
-                yak.shave(razor);
-                break;
-            }
-            Err(err) => {
-                warn!("Unable to locate a razor: {}, retrying", err);
-            }
-        }
-    }
-}
-```
-
-### In executables
-
-In order to produce log output, executables have to use a logger implementation compatible with the facade.
-There are many available implementations to choose from, here are some of the most popular ones:
-
-* Simple minimal loggers:
-    * [`env_logger`](https://docs.rs/env_logger/*/env_logger/)
-    * [`simple_logger`](https://docs.rs/simple_logger/*/simple_logger/)
-    * [`simplelog`](https://docs.rs/simplelog/*/simplelog/)
-    * [`pretty_env_logger`](https://docs.rs/pretty_env_logger/*/pretty_env_logger/)
-    * [`stderrlog`](https://docs.rs/stderrlog/*/stderrlog/)
-    * [`flexi_logger`](https://docs.rs/flexi_logger/*/flexi_logger/)
-* Complex configurable frameworks:
-    * [`log4rs`](https://docs.rs/log4rs/*/log4rs/)
-    * [`fern`](https://docs.rs/fern/*/fern/)
-* Adaptors for other facilities:
-    * [`syslog`](https://docs.rs/syslog/*/syslog/)
-    * [`systemd-journal-logger`](https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/)
-    * [`slog-stdlog`](https://docs.rs/slog-stdlog/*/slog_stdlog/)
-    * [`android_log`](https://docs.rs/android_log/*/android_log/)
-    * [`win_dbg_logger`](https://docs.rs/win_dbg_logger/*/win_dbg_logger/)
-    * [`db_logger`](https://docs.rs/db_logger/*/db_logger/)
-* For WebAssembly binaries:
-    * [`console_log`](https://docs.rs/console_log/*/console_log/)
-* For dynamic libraries:
-    * You may need to construct [an FFI-safe wrapper over `log`](https://github.com/rust-lang/log/issues/421) to initialize in your libraries. 
-* Utilities:
-    * [`log_err`](https://docs.rs/log_err/*/log_err/)
-
-Executables should choose a logger implementation and initialize it early in the
-runtime of the program. Logger implementations will typically include a
-function to do this. Any log messages generated before the logger is
-initialized will be ignored.
-
-The executable itself may use the `log` crate to log as well.
-
-## Structured logging
-
-If you enable the `kv_unstable` feature, you can associate structured data with your log records:
-
-```rust
-use log::{info, trace, warn, as_serde, as_error};
-
-pub fn shave_the_yak(yak: &mut Yak) {
-    trace!(target = "yak_events", yak = as_serde!(yak); "Commencing yak shaving");
-
-    loop {
-        match find_a_razor() {
-            Ok(razor) => {
-                info!(razor = razor; "Razor located");
-                yak.shave(razor);
-                break;
-            }
-            Err(err) => {
-                warn!(err = as_error!(err); "Unable to locate a razor, retrying");
-            }
-        }
-    }
-}
-```
+log
+===
+
+A Rust library providing a lightweight logging *facade*.
+
+[![Build status](https://img.shields.io/github/workflow/status/rust-lang/log/CI/master)](https://github.com/rust-lang/log/actions)
+[![Latest version](https://img.shields.io/crates/v/log.svg)](https://crates.io/crates/log)
+[![Documentation](https://docs.rs/log/badge.svg)](https://docs.rs/log)
+![License](https://img.shields.io/crates/l/log.svg)
+
+* [`log` documentation](https://docs.rs/log)
+
+A logging facade provides a single logging API that abstracts over the actual
+logging implementation. Libraries can use the logging API provided by this
+crate, and the consumer of those libraries can choose the logging
+implementation that is most suitable for its use case.
+
+
+## Minimum supported `rustc`
+
+`1.31.0+`
+
+This version is explicitly tested in CI and may be bumped in any release as needed. Maintaining compatibility with older compilers is a priority though, so the bar for bumping the minimum supported version is set very high. Any changes to the supported minimum version will be called out in the release notes.
+
+## Usage
+
+### In libraries
+
+Libraries should link only to the `log` crate, and use the provided macros to
+log whatever information will be useful to downstream consumers:
+
+```toml
+[dependencies]
+log = "0.4"
+```
+
+```rust
+use log::{info, trace, warn};
+
+pub fn shave_the_yak(yak: &mut Yak) {
+    trace!("Commencing yak shaving");
+
+    loop {
+        match find_a_razor() {
+            Ok(razor) => {
+                info!("Razor located: {}", razor);
+                yak.shave(razor);
+                break;
+            }
+            Err(err) => {
+                warn!("Unable to locate a razor: {}, retrying", err);
+            }
+        }
+    }
+}
+```
+
+### In executables
+
+In order to produce log output, executables have to use a logger implementation compatible with the facade.
+There are many available implementations to choose from, here are some of the most popular ones:
+
+* Simple minimal loggers:
+    * [`env_logger`](https://docs.rs/env_logger/*/env_logger/)
+    * [`simple_logger`](https://docs.rs/simple_logger/*/simple_logger/)
+    * [`simplelog`](https://docs.rs/simplelog/*/simplelog/)
+    * [`pretty_env_logger`](https://docs.rs/pretty_env_logger/*/pretty_env_logger/)
+    * [`stderrlog`](https://docs.rs/stderrlog/*/stderrlog/)
+    * [`flexi_logger`](https://docs.rs/flexi_logger/*/flexi_logger/)
+* Complex configurable frameworks:
+    * [`log4rs`](https://docs.rs/log4rs/*/log4rs/)
+    * [`fern`](https://docs.rs/fern/*/fern/)
+* Adaptors for other facilities:
+    * [`syslog`](https://docs.rs/syslog/*/syslog/)
+    * [`systemd-journal-logger`](https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/)
+    * [`slog-stdlog`](https://docs.rs/slog-stdlog/*/slog_stdlog/)
+    * [`android_log`](https://docs.rs/android_log/*/android_log/)
+    * [`win_dbg_logger`](https://docs.rs/win_dbg_logger/*/win_dbg_logger/)
+    * [`db_logger`](https://docs.rs/db_logger/*/db_logger/)
+* For WebAssembly binaries:
+    * [`console_log`](https://docs.rs/console_log/*/console_log/)
+* For dynamic libraries:
+    * You may need to construct [an FFI-safe wrapper over `log`](https://github.com/rust-lang/log/issues/421) to initialize in your libraries. 
+* Utilities:
+    * [`log_err`](https://docs.rs/log_err/*/log_err/)
+
+Executables should choose a logger implementation and initialize it early in the
+runtime of the program. Logger implementations will typically include a
+function to do this. Any log messages generated before the logger is
+initialized will be ignored.
+
+The executable itself may use the `log` crate to log as well.
+
+## Structured logging
+
+If you enable the `kv_unstable` feature, you can associate structured data with your log records:
+
+```rust
+use log::{info, trace, warn, as_serde, as_error};
+
+pub fn shave_the_yak(yak: &mut Yak) {
+    trace!(target = "yak_events", yak = as_serde!(yak); "Commencing yak shaving");
+
+    loop {
+        match find_a_razor() {
+            Ok(razor) => {
+                info!(razor = razor; "Razor located");
+                yak.shave(razor);
+                break;
+            }
+            Err(err) => {
+                warn!(err = as_error!(err); "Unable to locate a razor, retrying");
+            }
+        }
+    }
+}
+```

zeroidc/vendor/log/benches/value.rs

@@ -1,30 +1,30 @@
-#![cfg(feature = "kv_unstable")]
-#![feature(test)]
-
-extern crate log;
-extern crate test;
-
-use log::kv::Value;
-
-#[bench]
-fn u8_to_value(b: &mut test::Bencher) {
-    b.iter(|| Value::from(1u8))
-}
-
-#[bench]
-fn u8_to_value_debug(b: &mut test::Bencher) {
-    b.iter(|| Value::from_debug(&1u8))
-}
-
-#[bench]
-fn str_to_value_debug(b: &mut test::Bencher) {
-    b.iter(|| Value::from_debug(&"a string"))
-}
-
-#[bench]
-fn custom_to_value_debug(b: &mut test::Bencher) {
-    #[derive(Debug)]
-    struct A;
-
-    b.iter(|| Value::from_debug(&A))
-}
+#![cfg(feature = "kv_unstable")]
+#![feature(test)]
+
+extern crate log;
+extern crate test;
+
+use log::kv::Value;
+
+#[bench]
+fn u8_to_value(b: &mut test::Bencher) {
+    b.iter(|| Value::from(1u8))
+}
+
+#[bench]
+fn u8_to_value_debug(b: &mut test::Bencher) {
+    b.iter(|| Value::from_debug(&1u8))
+}
+
+#[bench]
+fn str_to_value_debug(b: &mut test::Bencher) {
+    b.iter(|| Value::from_debug(&"a string"))
+}
+
+#[bench]
+fn custom_to_value_debug(b: &mut test::Bencher) {
+    #[derive(Debug)]
+    struct A;
+
+    b.iter(|| Value::from_debug(&A))
+}

zeroidc/vendor/log/build.rs

@@ -1,46 +1,46 @@
-//! This build script detects target platforms that lack proper support for
-//! atomics and sets `cfg` flags accordingly.
-
-use std::env;
-use std::str;
-
-fn main() {
-    let target = match rustc_target() {
-        Some(target) => target,
-        None => return,
-    };
-
-    if target_has_atomic_cas(&target) {
-        println!("cargo:rustc-cfg=atomic_cas");
-    }
-
-    if target_has_atomics(&target) {
-        println!("cargo:rustc-cfg=has_atomics");
-    }
-
-    println!("cargo:rerun-if-changed=build.rs");
-}
-
-fn target_has_atomic_cas(target: &str) -> bool {
-    match &target[..] {
-        "thumbv6m-none-eabi"
-        | "msp430-none-elf"
-        | "riscv32i-unknown-none-elf"
-        | "riscv32imc-unknown-none-elf" => false,
-        _ => true,
-    }
-}
-
-fn target_has_atomics(target: &str) -> bool {
-    match &target[..] {
-        "thumbv4t-none-eabi"
-        | "msp430-none-elf"
-        | "riscv32i-unknown-none-elf"
-        | "riscv32imc-unknown-none-elf" => false,
-        _ => true,
-    }
-}
-
-fn rustc_target() -> Option<String> {
-    env::var("TARGET").ok()
-}
+//! This build script detects target platforms that lack proper support for
+//! atomics and sets `cfg` flags accordingly.
+
+use std::env;
+use std::str;
+
+fn main() {
+    let target = match rustc_target() {
+        Some(target) => target,
+        None => return,
+    };
+
+    if target_has_atomic_cas(&target) {
+        println!("cargo:rustc-cfg=atomic_cas");
+    }
+
+    if target_has_atomics(&target) {
+        println!("cargo:rustc-cfg=has_atomics");
+    }
+
+    println!("cargo:rerun-if-changed=build.rs");
+}
+
+fn target_has_atomic_cas(target: &str) -> bool {
+    match &target[..] {
+        "thumbv6m-none-eabi"
+        | "msp430-none-elf"
+        | "riscv32i-unknown-none-elf"
+        | "riscv32imc-unknown-none-elf" => false,
+        _ => true,
+    }
+}
+
+fn target_has_atomics(target: &str) -> bool {
+    match &target[..] {
+        "thumbv4t-none-eabi"
+        | "msp430-none-elf"
+        | "riscv32i-unknown-none-elf"
+        | "riscv32imc-unknown-none-elf" => false,
+        _ => true,
+    }
+}
+
+fn rustc_target() -> Option<String> {
+    env::var("TARGET").ok()
+}

zeroidc/vendor/log/src/kv/error.rs

@@ -1,90 +1,90 @@
-use std::fmt;
-
-/// An error encountered while working with structured data.
-#[derive(Debug)]
-pub struct Error {
-    inner: Inner,
-}
-
-#[derive(Debug)]
-enum Inner {
-    #[cfg(feature = "std")]
-    Boxed(std_support::BoxedError),
-    Msg(&'static str),
-    Value(value_bag::Error),
-    Fmt,
-}
-
-impl Error {
-    /// Create an error from a message.
-    pub fn msg(msg: &'static str) -> Self {
-        Error {
-            inner: Inner::Msg(msg),
-        }
-    }
-
-    // Not public so we don't leak the `value_bag` API
-    pub(super) fn from_value(err: value_bag::Error) -> Self {
-        Error {
-            inner: Inner::Value(err),
-        }
-    }
-
-    // Not public so we don't leak the `value_bag` API
-    pub(super) fn into_value(self) -> value_bag::Error {
-        match self.inner {
-            Inner::Value(err) => err,
-            #[cfg(feature = "kv_unstable_std")]
-            _ => value_bag::Error::boxed(self),
-            #[cfg(not(feature = "kv_unstable_std"))]
-            _ => value_bag::Error::msg("error inspecting a value"),
-        }
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::Inner::*;
-        match &self.inner {
-            #[cfg(feature = "std")]
-            &Boxed(ref err) => err.fmt(f),
-            &Value(ref err) => err.fmt(f),
-            &Msg(ref msg) => msg.fmt(f),
-            &Fmt => fmt::Error.fmt(f),
-        }
-    }
-}
-
-impl From<fmt::Error> for Error {
-    fn from(_: fmt::Error) -> Self {
-        Error { inner: Inner::Fmt }
-    }
-}
-
-#[cfg(feature = "std")]
-mod std_support {
-    use super::*;
-    use std::{error, io};
-
-    pub(super) type BoxedError = Box<dyn error::Error + Send + Sync>;
-
-    impl Error {
-        /// Create an error from a standard error type.
-        pub fn boxed<E>(err: E) -> Self
-        where
-            E: Into<BoxedError>,
-        {
-            Error {
-                inner: Inner::Boxed(err.into()),
-            }
-        }
-    }
-
-    impl error::Error for Error {}
-
-    impl From<io::Error> for Error {
-        fn from(err: io::Error) -> Self {
-            Error::boxed(err)
-        }
-    }
-}
+use std::fmt;
+
+/// An error encountered while working with structured data.
+#[derive(Debug)]
+pub struct Error {
+    inner: Inner,
+}
+
+#[derive(Debug)]
+enum Inner {
+    #[cfg(feature = "std")]
+    Boxed(std_support::BoxedError),
+    Msg(&'static str),
+    Value(value_bag::Error),
+    Fmt,
+}
+
+impl Error {
+    /// Create an error from a message.
+    pub fn msg(msg: &'static str) -> Self {
+        Error {
+            inner: Inner::Msg(msg),
+        }
+    }
+
+    // Not public so we don't leak the `value_bag` API
+    pub(super) fn from_value(err: value_bag::Error) -> Self {
+        Error {
+            inner: Inner::Value(err),
+        }
+    }
+
+    // Not public so we don't leak the `value_bag` API
+    pub(super) fn into_value(self) -> value_bag::Error {
+        match self.inner {
+            Inner::Value(err) => err,
+            #[cfg(feature = "kv_unstable_std")]
+            _ => value_bag::Error::boxed(self),
+            #[cfg(not(feature = "kv_unstable_std"))]
+            _ => value_bag::Error::msg("error inspecting a value"),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use self::Inner::*;
+        match &self.inner {
+            #[cfg(feature = "std")]
+            &Boxed(ref err) => err.fmt(f),
+            &Value(ref err) => err.fmt(f),
+            &Msg(ref msg) => msg.fmt(f),
+            &Fmt => fmt::Error.fmt(f),
+        }
+    }
+}
+
+impl From<fmt::Error> for Error {
+    fn from(_: fmt::Error) -> Self {
+        Error { inner: Inner::Fmt }
+    }
+}
+
+#[cfg(feature = "std")]
+mod std_support {
+    use super::*;
+    use std::{error, io};
+
+    pub(super) type BoxedError = Box<dyn error::Error + Send + Sync>;
+
+    impl Error {
+        /// Create an error from a standard error type.
+        pub fn boxed<E>(err: E) -> Self
+        where
+            E: Into<BoxedError>,
+        {
+            Error {
+                inner: Inner::Boxed(err.into()),
+            }
+        }
+    }
+
+    impl error::Error for Error {}
+
+    impl From<io::Error> for Error {
+        fn from(err: io::Error) -> Self {
+            Error::boxed(err)
+        }
+    }
+}

zeroidc/vendor/log/src/kv/key.rs

@@ -1,172 +1,172 @@
-//! Structured keys.
-
-use std::borrow::Borrow;
-use std::cmp;
-use std::fmt;
-use std::hash;
-
-/// A type that can be converted into a [`Key`](struct.Key.html).
-pub trait ToKey {
-    /// Perform the conversion.
-    fn to_key(&self) -> Key;
-}
-
-impl<'a, T> ToKey for &'a T
-where
-    T: ToKey + ?Sized,
-{
-    fn to_key(&self) -> Key {
-        (**self).to_key()
-    }
-}
-
-impl<'k> ToKey for Key<'k> {
-    fn to_key(&self) -> Key {
-        Key { key: self.key }
-    }
-}
-
-impl ToKey for str {
-    fn to_key(&self) -> Key {
-        Key::from_str(self)
-    }
-}
-
-/// A key in a structured key-value pair.
-#[derive(Clone)]
-pub struct Key<'k> {
-    key: &'k str,
-}
-
-impl<'k> Key<'k> {
-    /// Get a key from a borrowed string.
-    pub fn from_str(key: &'k str) -> Self {
-        Key { key: key }
-    }
-
-    /// Get a borrowed string from this key.
-    pub fn as_str(&self) -> &str {
-        self.key
-    }
-}
-
-impl<'k> fmt::Debug for Key<'k> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.key.fmt(f)
-    }
-}
-
-impl<'k> fmt::Display for Key<'k> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.key.fmt(f)
-    }
-}
-
-impl<'k> hash::Hash for Key<'k> {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: hash::Hasher,
-    {
-        self.as_str().hash(state)
-    }
-}
-
-impl<'k, 'ko> PartialEq<Key<'ko>> for Key<'k> {
-    fn eq(&self, other: &Key<'ko>) -> bool {
-        self.as_str().eq(other.as_str())
-    }
-}
-
-impl<'k> Eq for Key<'k> {}
-
-impl<'k, 'ko> PartialOrd<Key<'ko>> for Key<'k> {
-    fn partial_cmp(&self, other: &Key<'ko>) -> Option<cmp::Ordering> {
-        self.as_str().partial_cmp(other.as_str())
-    }
-}
-
-impl<'k> Ord for Key<'k> {
-    fn cmp(&self, other: &Self) -> cmp::Ordering {
-        self.as_str().cmp(other.as_str())
-    }
-}
-
-impl<'k> AsRef<str> for Key<'k> {
-    fn as_ref(&self) -> &str {
-        self.as_str()
-    }
-}
-
-impl<'k> Borrow<str> for Key<'k> {
-    fn borrow(&self) -> &str {
-        self.as_str()
-    }
-}
-
-impl<'k> From<&'k str> for Key<'k> {
-    fn from(s: &'k str) -> Self {
-        Key::from_str(s)
-    }
-}
-
-#[cfg(feature = "std")]
-mod std_support {
-    use super::*;
-
-    use std::borrow::Cow;
-
-    impl ToKey for String {
-        fn to_key(&self) -> Key {
-            Key::from_str(self)
-        }
-    }
-
-    impl<'a> ToKey for Cow<'a, str> {
-        fn to_key(&self) -> Key {
-            Key::from_str(self)
-        }
-    }
-}
-
-#[cfg(feature = "kv_unstable_sval")]
-mod sval_support {
-    use super::*;
-
-    extern crate sval;
-
-    use self::sval::value::{self, Value};
-
-    impl<'a> Value for Key<'a> {
-        fn stream(&self, stream: &mut value::Stream) -> value::Result {
-            self.key.stream(stream)
-        }
-    }
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-mod serde_support {
-    use super::*;
-
-    extern crate serde;
-
-    use self::serde::{Serialize, Serializer};
-
-    impl<'a> Serialize for Key<'a> {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            self.key.serialize(serializer)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn key_from_string() {
-        assert_eq!("a key", Key::from_str("a key").as_str());
-    }
-}
+//! Structured keys.
+
+use std::borrow::Borrow;
+use std::cmp;
+use std::fmt;
+use std::hash;
+
+/// A type that can be converted into a [`Key`](struct.Key.html).
+pub trait ToKey {
+    /// Perform the conversion.
+    fn to_key(&self) -> Key;
+}
+
+impl<'a, T> ToKey for &'a T
+where
+    T: ToKey + ?Sized,
+{
+    fn to_key(&self) -> Key {
+        (**self).to_key()
+    }
+}
+
+impl<'k> ToKey for Key<'k> {
+    fn to_key(&self) -> Key {
+        Key { key: self.key }
+    }
+}
+
+impl ToKey for str {
+    fn to_key(&self) -> Key {
+        Key::from_str(self)
+    }
+}
+
+/// A key in a structured key-value pair.
+#[derive(Clone)]
+pub struct Key<'k> {
+    key: &'k str,
+}
+
+impl<'k> Key<'k> {
+    /// Get a key from a borrowed string.
+    pub fn from_str(key: &'k str) -> Self {
+        Key { key: key }
+    }
+
+    /// Get a borrowed string from this key.
+    pub fn as_str(&self) -> &str {
+        self.key
+    }
+}
+
+impl<'k> fmt::Debug for Key<'k> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.key.fmt(f)
+    }
+}
+
+impl<'k> fmt::Display for Key<'k> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.key.fmt(f)
+    }
+}
+
+impl<'k> hash::Hash for Key<'k> {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: hash::Hasher,
+    {
+        self.as_str().hash(state)
+    }
+}
+
+impl<'k, 'ko> PartialEq<Key<'ko>> for Key<'k> {
+    fn eq(&self, other: &Key<'ko>) -> bool {
+        self.as_str().eq(other.as_str())
+    }
+}
+
+impl<'k> Eq for Key<'k> {}
+
+impl<'k, 'ko> PartialOrd<Key<'ko>> for Key<'k> {
+    fn partial_cmp(&self, other: &Key<'ko>) -> Option<cmp::Ordering> {
+        self.as_str().partial_cmp(other.as_str())
+    }
+}
+
+impl<'k> Ord for Key<'k> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.as_str().cmp(other.as_str())
+    }
+}
+
+impl<'k> AsRef<str> for Key<'k> {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'k> Borrow<str> for Key<'k> {
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl<'k> From<&'k str> for Key<'k> {
+    fn from(s: &'k str) -> Self {
+        Key::from_str(s)
+    }
+}
+
+#[cfg(feature = "std")]
+mod std_support {
+    use super::*;
+
+    use std::borrow::Cow;
+
+    impl ToKey for String {
+        fn to_key(&self) -> Key {
+            Key::from_str(self)
+        }
+    }
+
+    impl<'a> ToKey for Cow<'a, str> {
+        fn to_key(&self) -> Key {
+            Key::from_str(self)
+        }
+    }
+}
+
+#[cfg(feature = "kv_unstable_sval")]
+mod sval_support {
+    use super::*;
+
+    extern crate sval;
+
+    use self::sval::value::{self, Value};
+
+    impl<'a> Value for Key<'a> {
+        fn stream(&self, stream: &mut value::Stream) -> value::Result {
+            self.key.stream(stream)
+        }
+    }
+}
+
+#[cfg(feature = "kv_unstable_serde")]
+mod serde_support {
+    use super::*;
+
+    extern crate serde;
+
+    use self::serde::{Serialize, Serializer};
+
+    impl<'a> Serialize for Key<'a> {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            self.key.serialize(serializer)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn key_from_string() {
+        assert_eq!("a key", Key::from_str("a key").as_str());
+    }
+}

zeroidc/vendor/log/src/kv/mod.rs

@@ -1,26 +1,26 @@
-//! **UNSTABLE:** Structured key-value pairs.
-//!
-//! This module is unstable and breaking changes may be made
-//! at any time. See [the tracking issue](https://github.com/rust-lang-nursery/log/issues/328)
-//! for more details.
-//!
-//! Add the `kv_unstable` feature to your `Cargo.toml` to enable
-//! this module:
-//!
-//! ```toml
-//! [dependencies.log]
-//! features = ["kv_unstable"]
-//! ```
-
-mod error;
-mod key;
-pub mod source;
-
-pub mod value;
-
-pub use self::error::Error;
-pub use self::key::{Key, ToKey};
-pub use self::source::{Source, Visitor};
-
-#[doc(inline)]
-pub use self::value::{ToValue, Value};
+//! **UNSTABLE:** Structured key-value pairs.
+//!
+//! This module is unstable and breaking changes may be made
+//! at any time. See [the tracking issue](https://github.com/rust-lang-nursery/log/issues/328)
+//! for more details.
+//!
+//! Add the `kv_unstable` feature to your `Cargo.toml` to enable
+//! this module:
+//!
+//! ```toml
+//! [dependencies.log]
+//! features = ["kv_unstable"]
+//! ```
+
+mod error;
+mod key;
+pub mod source;
+
+pub mod value;
+
+pub use self::error::Error;
+pub use self::key::{Key, ToKey};
+pub use self::source::{Source, Visitor};
+
+#[doc(inline)]
+pub use self::value::{ToValue, Value};

zeroidc/vendor/log/src/kv/source.rs

@@ -1,754 +1,754 @@
-//! Sources for key-value pairs.
-
-#[cfg(feature = "kv_unstable_sval")]
-extern crate sval;
-
-#[cfg(feature = "kv_unstable_serde")]
-extern crate serde;
-
-use kv::{Error, Key, ToKey, ToValue, Value};
-use std::fmt;
-
-/// A source of key-value pairs.
-///
-/// The source may be a single pair, a set of pairs, or a filter over a set of pairs.
-/// Use the [`Visitor`](trait.Visitor.html) trait to inspect the structured data
-/// in a source.
-pub trait Source {
-    /// Visit key-value pairs.
-    ///
-    /// A source doesn't have to guarantee any ordering or uniqueness of key-value pairs.
-    /// If the given visitor returns an error then the source may early-return with it,
-    /// even if there are more key-value pairs.
-    ///
-    /// # Implementation notes
-    ///
-    /// A source should yield the same key-value pairs to a subsequent visitor unless
-    /// that visitor itself fails.
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error>;
-
-    /// Get the value for a given key.
-    ///
-    /// If the key appears multiple times in the source then which key is returned
-    /// is implementation specific.
-    ///
-    /// # Implementation notes
-    ///
-    /// A source that can provide a more efficient implementation of this method
-    /// should override it.
-    #[cfg(not(test))]
-    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-        get_default(self, key)
-    }
-
-    #[cfg(test)]
-    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>>;
-
-    /// Count the number of key-value pairs that can be visited.
-    ///
-    /// # Implementation notes
-    ///
-    /// A source that knows the number of key-value pairs upfront may provide a more
-    /// efficient implementation.
-    ///
-    /// A subsequent call to `visit` should yield the same number of key-value pairs
-    /// to the visitor, unless that visitor fails part way through.
-    #[cfg(not(test))]
-    fn count(&self) -> usize {
-        count_default(self)
-    }
-
-    #[cfg(test)]
-    fn count(&self) -> usize;
-}
-
-/// The default implemention of `Source::get`
-pub(crate) fn get_default<'v>(source: &'v (impl Source + ?Sized), key: Key) -> Option<Value<'v>> {
-    struct Get<'k, 'v> {
-        key: Key<'k>,
-        found: Option<Value<'v>>,
-    }
-
-    impl<'k, 'kvs> Visitor<'kvs> for Get<'k, 'kvs> {
-        fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-            if self.key == key {
-                self.found = Some(value);
-            }
-
-            Ok(())
-        }
-    }
-
-    let mut get = Get { key, found: None };
-
-    let _ = source.visit(&mut get);
-    get.found
-}
-
-/// The default implementation of `Source::count`.
-pub(crate) fn count_default(source: impl Source) -> usize {
-    struct Count(usize);
-
-    impl<'kvs> Visitor<'kvs> for Count {
-        fn visit_pair(&mut self, _: Key<'kvs>, _: Value<'kvs>) -> Result<(), Error> {
-            self.0 += 1;
-
-            Ok(())
-        }
-    }
-
-    let mut count = Count(0);
-    let _ = source.visit(&mut count);
-    count.0
-}
-
-impl<'a, T> Source for &'a T
-where
-    T: Source + ?Sized,
-{
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-        Source::visit(&**self, visitor)
-    }
-
-    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-        Source::get(&**self, key)
-    }
-
-    fn count(&self) -> usize {
-        Source::count(&**self)
-    }
-}
-
-impl<K, V> Source for (K, V)
-where
-    K: ToKey,
-    V: ToValue,
-{
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-        visitor.visit_pair(self.0.to_key(), self.1.to_value())
-    }
-
-    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-        if self.0.to_key() == key {
-            Some(self.1.to_value())
-        } else {
-            None
-        }
-    }
-
-    fn count(&self) -> usize {
-        1
-    }
-}
-
-impl<S> Source for [S]
-where
-    S: Source,
-{
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-        for source in self {
-            source.visit(visitor)?;
-        }
-
-        Ok(())
-    }
-
-    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-        for source in self {
-            if let Some(found) = source.get(key.clone()) {
-                return Some(found);
-            }
-        }
-
-        None
-    }
-
-    fn count(&self) -> usize {
-        self.len()
-    }
-}
-
-impl<S> Source for Option<S>
-where
-    S: Source,
-{
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-        if let Some(ref source) = *self {
-            source.visit(visitor)?;
-        }
-
-        Ok(())
-    }
-
-    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-        self.as_ref().and_then(|s| s.get(key))
-    }
-
-    fn count(&self) -> usize {
-        self.as_ref().map(Source::count).unwrap_or(0)
-    }
-}
-
-/// A visitor for the key-value pairs in a [`Source`](trait.Source.html).
-pub trait Visitor<'kvs> {
-    /// Visit a key-value pair.
-    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error>;
-}
-
-impl<'a, 'kvs, T> Visitor<'kvs> for &'a mut T
-where
-    T: Visitor<'kvs> + ?Sized,
-{
-    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-        (**self).visit_pair(key, value)
-    }
-}
-
-impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugMap<'a, 'b> {
-    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-        self.entry(&key, &value);
-        Ok(())
-    }
-}
-
-impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugList<'a, 'b> {
-    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-        self.entry(&(key, value));
-        Ok(())
-    }
-}
-
-impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugSet<'a, 'b> {
-    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-        self.entry(&(key, value));
-        Ok(())
-    }
-}
-
-impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugTuple<'a, 'b> {
-    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-        self.field(&key);
-        self.field(&value);
-        Ok(())
-    }
-}
-
-#[cfg(feature = "std")]
-mod std_support {
-    use super::*;
-    use std::borrow::Borrow;
-    use std::collections::{BTreeMap, HashMap};
-    use std::hash::{BuildHasher, Hash};
-
-    impl<S> Source for Box<S>
-    where
-        S: Source + ?Sized,
-    {
-        fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-            Source::visit(&**self, visitor)
-        }
-
-        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-            Source::get(&**self, key)
-        }
-
-        fn count(&self) -> usize {
-            Source::count(&**self)
-        }
-    }
-
-    impl<S> Source for Vec<S>
-    where
-        S: Source,
-    {
-        fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-            Source::visit(&**self, visitor)
-        }
-
-        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-            Source::get(&**self, key)
-        }
-
-        fn count(&self) -> usize {
-            Source::count(&**self)
-        }
-    }
-
-    impl<'kvs, V> Visitor<'kvs> for Box<V>
-    where
-        V: Visitor<'kvs> + ?Sized,
-    {
-        fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-            (**self).visit_pair(key, value)
-        }
-    }
-
-    impl<K, V, S> Source for HashMap<K, V, S>
-    where
-        K: ToKey + Borrow<str> + Eq + Hash,
-        V: ToValue,
-        S: BuildHasher,
-    {
-        fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-            for (key, value) in self {
-                visitor.visit_pair(key.to_key(), value.to_value())?;
-            }
-            Ok(())
-        }
-
-        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-            HashMap::get(self, key.as_str()).map(|v| v.to_value())
-        }
-
-        fn count(&self) -> usize {
-            self.len()
-        }
-    }
-
-    impl<K, V> Source for BTreeMap<K, V>
-    where
-        K: ToKey + Borrow<str> + Ord,
-        V: ToValue,
-    {
-        fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-            for (key, value) in self {
-                visitor.visit_pair(key.to_key(), value.to_value())?;
-            }
-            Ok(())
-        }
-
-        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-            BTreeMap::get(self, key.as_str()).map(|v| v.to_value())
-        }
-
-        fn count(&self) -> usize {
-            self.len()
-        }
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::*;
-        use kv::value::tests::Token;
-        use std::collections::{BTreeMap, HashMap};
-
-        #[test]
-        fn count() {
-            assert_eq!(1, Source::count(&Box::new(("a", 1))));
-            assert_eq!(2, Source::count(&vec![("a", 1), ("b", 2)]));
-        }
-
-        #[test]
-        fn get() {
-            let source = vec![("a", 1), ("b", 2), ("a", 1)];
-            assert_eq!(
-                Token::I64(1),
-                Source::get(&source, Key::from_str("a")).unwrap().to_token()
-            );
-
-            let source = Box::new(Option::None::<(&str, i32)>);
-            assert!(Source::get(&source, Key::from_str("a")).is_none());
-        }
-
-        #[test]
-        fn hash_map() {
-            let mut map = HashMap::new();
-            map.insert("a", 1);
-            map.insert("b", 2);
-
-            assert_eq!(2, Source::count(&map));
-            assert_eq!(
-                Token::I64(1),
-                Source::get(&map, Key::from_str("a")).unwrap().to_token()
-            );
-        }
-
-        #[test]
-        fn btree_map() {
-            let mut map = BTreeMap::new();
-            map.insert("a", 1);
-            map.insert("b", 2);
-
-            assert_eq!(2, Source::count(&map));
-            assert_eq!(
-                Token::I64(1),
-                Source::get(&map, Key::from_str("a")).unwrap().to_token()
-            );
-        }
-    }
-}
-
-/// The result of calling `Source::as_map`.
-pub struct AsMap<S>(S);
-
-/// Visit this source as a map.
-pub fn as_map<S>(source: S) -> AsMap<S>
-where
-    S: Source,
-{
-    AsMap(source)
-}
-
-impl<S> Source for AsMap<S>
-where
-    S: Source,
-{
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-        self.0.visit(visitor)
-    }
-
-    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-        self.0.get(key)
-    }
-
-    fn count(&self) -> usize {
-        self.0.count()
-    }
-}
-
-impl<S> fmt::Debug for AsMap<S>
-where
-    S: Source,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut f = f.debug_map();
-        self.0.visit(&mut f).map_err(|_| fmt::Error)?;
-        f.finish()
-    }
-}
-
-/// The result of calling `Source::as_list`
-pub struct AsList<S>(S);
-
-/// Visit this source as a list.
-pub fn as_list<S>(source: S) -> AsList<S>
-where
-    S: Source,
-{
-    AsList(source)
-}
-
-impl<S> Source for AsList<S>
-where
-    S: Source,
-{
-    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-        self.0.visit(visitor)
-    }
-
-    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-        self.0.get(key)
-    }
-
-    fn count(&self) -> usize {
-        self.0.count()
-    }
-}
-
-impl<S> fmt::Debug for AsList<S>
-where
-    S: Source,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut f = f.debug_list();
-        self.0.visit(&mut f).map_err(|_| fmt::Error)?;
-        f.finish()
-    }
-}
-
-#[cfg(feature = "kv_unstable_sval")]
-mod sval_support {
-    use super::*;
-
-    use self::sval::value;
-
-    impl<S> value::Value for AsMap<S>
-    where
-        S: Source,
-    {
-        fn stream(&self, stream: &mut value::Stream) -> value::Result {
-            struct StreamVisitor<'a, 'b>(&'a mut value::Stream<'b>);
-
-            impl<'a, 'b, 'kvs> Visitor<'kvs> for StreamVisitor<'a, 'b> {
-                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-                    self.0
-                        .map_key(key)
-                        .map_err(|_| Error::msg("failed to stream map key"))?;
-                    self.0
-                        .map_value(value)
-                        .map_err(|_| Error::msg("failed to stream map value"))?;
-                    Ok(())
-                }
-            }
-
-            stream
-                .map_begin(Some(self.count()))
-                .map_err(|_| self::sval::Error::msg("failed to begin map"))?;
-
-            self.visit(&mut StreamVisitor(stream))
-                .map_err(|_| self::sval::Error::msg("failed to visit key-values"))?;
-
-            stream
-                .map_end()
-                .map_err(|_| self::sval::Error::msg("failed to end map"))
-        }
-    }
-
-    impl<S> value::Value for AsList<S>
-    where
-        S: Source,
-    {
-        fn stream(&self, stream: &mut value::Stream) -> value::Result {
-            struct StreamVisitor<'a, 'b>(&'a mut value::Stream<'b>);
-
-            impl<'a, 'b, 'kvs> Visitor<'kvs> for StreamVisitor<'a, 'b> {
-                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-                    self.0
-                        .seq_elem((key, value))
-                        .map_err(|_| Error::msg("failed to stream seq entry"))?;
-                    Ok(())
-                }
-            }
-
-            stream
-                .seq_begin(Some(self.count()))
-                .map_err(|_| self::sval::Error::msg("failed to begin seq"))?;
-
-            self.visit(&mut StreamVisitor(stream))
-                .map_err(|_| self::sval::Error::msg("failed to visit key-values"))?;
-
-            stream
-                .seq_end()
-                .map_err(|_| self::sval::Error::msg("failed to end seq"))
-        }
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::*;
-
-        use self::sval::Value;
-
-        use crate::kv::source;
-
-        #[test]
-        fn derive_stream() {
-            #[derive(Value)]
-            pub struct MyRecordAsMap<'a> {
-                msg: &'a str,
-                kvs: source::AsMap<&'a dyn Source>,
-            }
-
-            #[derive(Value)]
-            pub struct MyRecordAsList<'a> {
-                msg: &'a str,
-                kvs: source::AsList<&'a dyn Source>,
-            }
-        }
-    }
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-pub mod as_map {
-    //! `serde` adapters for serializing a `Source` as a map.
-
-    use super::*;
-
-    use self::serde::{Serialize, Serializer};
-
-    /// Serialize a `Source` as a map.
-    pub fn serialize<T, S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        T: Source,
-        S: Serializer,
-    {
-        as_map(source).serialize(serializer)
-    }
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-pub mod as_list {
-    //! `serde` adapters for serializing a `Source` as a list.
-
-    use super::*;
-
-    use self::serde::{Serialize, Serializer};
-
-    /// Serialize a `Source` as a list.
-    pub fn serialize<T, S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        T: Source,
-        S: Serializer,
-    {
-        as_list(source).serialize(serializer)
-    }
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-mod serde_support {
-    use super::*;
-
-    use self::serde::ser::{Error as SerError, Serialize, SerializeMap, SerializeSeq, Serializer};
-
-    impl<T> Serialize for AsMap<T>
-    where
-        T: Source,
-    {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            struct SerializerVisitor<'a, S>(&'a mut S);
-
-            impl<'a, 'kvs, S> Visitor<'kvs> for SerializerVisitor<'a, S>
-            where
-                S: SerializeMap,
-            {
-                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-                    self.0
-                        .serialize_entry(&key, &value)
-                        .map_err(|_| Error::msg("failed to serialize map entry"))?;
-                    Ok(())
-                }
-            }
-
-            let mut map = serializer.serialize_map(Some(self.count()))?;
-
-            self.visit(&mut SerializerVisitor(&mut map))
-                .map_err(|_| S::Error::custom("failed to visit key-values"))?;
-
-            map.end()
-        }
-    }
-
-    impl<T> Serialize for AsList<T>
-    where
-        T: Source,
-    {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            struct SerializerVisitor<'a, S>(&'a mut S);
-
-            impl<'a, 'kvs, S> Visitor<'kvs> for SerializerVisitor<'a, S>
-            where
-                S: SerializeSeq,
-            {
-                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
-                    self.0
-                        .serialize_element(&(key, value))
-                        .map_err(|_| Error::msg("failed to serialize seq entry"))?;
-                    Ok(())
-                }
-            }
-
-            let mut seq = serializer.serialize_seq(Some(self.count()))?;
-
-            self.visit(&mut SerializerVisitor(&mut seq))
-                .map_err(|_| S::Error::custom("failed to visit seq"))?;
-
-            seq.end()
-        }
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::*;
-
-        use self::serde::Serialize;
-
-        use crate::kv::source;
-
-        #[test]
-        fn derive_serialize() {
-            #[derive(Serialize)]
-            pub struct MyRecordAsMap<'a> {
-                msg: &'a str,
-                #[serde(flatten)]
-                #[serde(with = "source::as_map")]
-                kvs: &'a dyn Source,
-            }
-
-            #[derive(Serialize)]
-            pub struct MyRecordAsList<'a> {
-                msg: &'a str,
-                #[serde(flatten)]
-                #[serde(with = "source::as_list")]
-                kvs: &'a dyn Source,
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use kv::value::tests::Token;
-
-    #[test]
-    fn source_is_object_safe() {
-        fn _check(_: &dyn Source) {}
-    }
-
-    #[test]
-    fn visitor_is_object_safe() {
-        fn _check(_: &dyn Visitor) {}
-    }
-
-    #[test]
-    fn count() {
-        struct OnePair {
-            key: &'static str,
-            value: i32,
-        }
-
-        impl Source for OnePair {
-            fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
-                visitor.visit_pair(self.key.to_key(), self.value.to_value())
-            }
-
-            fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
-                get_default(self, key)
-            }
-
-            fn count(&self) -> usize {
-                count_default(self)
-            }
-        }
-
-        assert_eq!(1, Source::count(&("a", 1)));
-        assert_eq!(2, Source::count(&[("a", 1), ("b", 2)] as &[_]));
-        assert_eq!(0, Source::count(&Option::None::<(&str, i32)>));
-        assert_eq!(1, Source::count(&OnePair { key: "a", value: 1 }));
-    }
-
-    #[test]
-    fn get() {
-        let source = &[("a", 1), ("b", 2), ("a", 1)] as &[_];
-        assert_eq!(
-            Token::I64(1),
-            Source::get(source, Key::from_str("a")).unwrap().to_token()
-        );
-        assert_eq!(
-            Token::I64(2),
-            Source::get(source, Key::from_str("b")).unwrap().to_token()
-        );
-        assert!(Source::get(&source, Key::from_str("c")).is_none());
-
-        let source = Option::None::<(&str, i32)>;
-        assert!(Source::get(&source, Key::from_str("a")).is_none());
-    }
-
-    #[test]
-    fn as_map() {
-        let _ = crate::kv::source::as_map(("a", 1));
-        let _ = crate::kv::source::as_map(&("a", 1) as &dyn Source);
-    }
-
-    #[test]
-    fn as_list() {
-        let _ = crate::kv::source::as_list(("a", 1));
-        let _ = crate::kv::source::as_list(&("a", 1) as &dyn Source);
-    }
-}
+//! Sources for key-value pairs.
+
+#[cfg(feature = "kv_unstable_sval")]
+extern crate sval;
+
+#[cfg(feature = "kv_unstable_serde")]
+extern crate serde;
+
+use kv::{Error, Key, ToKey, ToValue, Value};
+use std::fmt;
+
+/// A source of key-value pairs.
+///
+/// The source may be a single pair, a set of pairs, or a filter over a set of pairs.
+/// Use the [`Visitor`](trait.Visitor.html) trait to inspect the structured data
+/// in a source.
+pub trait Source {
+    /// Visit key-value pairs.
+    ///
+    /// A source doesn't have to guarantee any ordering or uniqueness of key-value pairs.
+    /// If the given visitor returns an error then the source may early-return with it,
+    /// even if there are more key-value pairs.
+    ///
+    /// # Implementation notes
+    ///
+    /// A source should yield the same key-value pairs to a subsequent visitor unless
+    /// that visitor itself fails.
+    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error>;
+
+    /// Get the value for a given key.
+    ///
+    /// If the key appears multiple times in the source then which key is returned
+    /// is implementation specific.
+    ///
+    /// # Implementation notes
+    ///
+    /// A source that can provide a more efficient implementation of this method
+    /// should override it.
+    #[cfg(not(test))]
+    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+        get_default(self, key)
+    }
+
+    #[cfg(test)]
+    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>>;
+
+    /// Count the number of key-value pairs that can be visited.
+    ///
+    /// # Implementation notes
+    ///
+    /// A source that knows the number of key-value pairs upfront may provide a more
+    /// efficient implementation.
+    ///
+    /// A subsequent call to `visit` should yield the same number of key-value pairs
+    /// to the visitor, unless that visitor fails part way through.
+    #[cfg(not(test))]
+    fn count(&self) -> usize {
+        count_default(self)
+    }
+
+    #[cfg(test)]
+    fn count(&self) -> usize;
+}
+
+/// The default implemention of `Source::get`
+pub(crate) fn get_default<'v>(source: &'v (impl Source + ?Sized), key: Key) -> Option<Value<'v>> {
+    struct Get<'k, 'v> {
+        key: Key<'k>,
+        found: Option<Value<'v>>,
+    }
+
+    impl<'k, 'kvs> Visitor<'kvs> for Get<'k, 'kvs> {
+        fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+            if self.key == key {
+                self.found = Some(value);
+            }
+
+            Ok(())
+        }
+    }
+
+    let mut get = Get { key, found: None };
+
+    let _ = source.visit(&mut get);
+    get.found
+}
+
+/// The default implementation of `Source::count`.
+pub(crate) fn count_default(source: impl Source) -> usize {
+    struct Count(usize);
+
+    impl<'kvs> Visitor<'kvs> for Count {
+        fn visit_pair(&mut self, _: Key<'kvs>, _: Value<'kvs>) -> Result<(), Error> {
+            self.0 += 1;
+
+            Ok(())
+        }
+    }
+
+    let mut count = Count(0);
+    let _ = source.visit(&mut count);
+    count.0
+}
+
+impl<'a, T> Source for &'a T
+where
+    T: Source + ?Sized,
+{
+    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+        Source::visit(&**self, visitor)
+    }
+
+    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+        Source::get(&**self, key)
+    }
+
+    fn count(&self) -> usize {
+        Source::count(&**self)
+    }
+}
+
+impl<K, V> Source for (K, V)
+where
+    K: ToKey,
+    V: ToValue,
+{
+    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+        visitor.visit_pair(self.0.to_key(), self.1.to_value())
+    }
+
+    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+        if self.0.to_key() == key {
+            Some(self.1.to_value())
+        } else {
+            None
+        }
+    }
+
+    fn count(&self) -> usize {
+        1
+    }
+}
+
+impl<S> Source for [S]
+where
+    S: Source,
+{
+    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+        for source in self {
+            source.visit(visitor)?;
+        }
+
+        Ok(())
+    }
+
+    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+        for source in self {
+            if let Some(found) = source.get(key.clone()) {
+                return Some(found);
+            }
+        }
+
+        None
+    }
+
+    fn count(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<S> Source for Option<S>
+where
+    S: Source,
+{
+    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+        if let Some(ref source) = *self {
+            source.visit(visitor)?;
+        }
+
+        Ok(())
+    }
+
+    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+        self.as_ref().and_then(|s| s.get(key))
+    }
+
+    fn count(&self) -> usize {
+        self.as_ref().map(Source::count).unwrap_or(0)
+    }
+}
+
+/// A visitor for the key-value pairs in a [`Source`](trait.Source.html).
+pub trait Visitor<'kvs> {
+    /// Visit a key-value pair.
+    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error>;
+}
+
+impl<'a, 'kvs, T> Visitor<'kvs> for &'a mut T
+where
+    T: Visitor<'kvs> + ?Sized,
+{
+    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+        (**self).visit_pair(key, value)
+    }
+}
+
+impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugMap<'a, 'b> {
+    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+        self.entry(&key, &value);
+        Ok(())
+    }
+}
+
+impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugList<'a, 'b> {
+    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+        self.entry(&(key, value));
+        Ok(())
+    }
+}
+
+impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugSet<'a, 'b> {
+    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+        self.entry(&(key, value));
+        Ok(())
+    }
+}
+
+impl<'a, 'b: 'a, 'kvs> Visitor<'kvs> for fmt::DebugTuple<'a, 'b> {
+    fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+        self.field(&key);
+        self.field(&value);
+        Ok(())
+    }
+}
+
+#[cfg(feature = "std")]
+mod std_support {
+    use super::*;
+    use std::borrow::Borrow;
+    use std::collections::{BTreeMap, HashMap};
+    use std::hash::{BuildHasher, Hash};
+
+    impl<S> Source for Box<S>
+    where
+        S: Source + ?Sized,
+    {
+        fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+            Source::visit(&**self, visitor)
+        }
+
+        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+            Source::get(&**self, key)
+        }
+
+        fn count(&self) -> usize {
+            Source::count(&**self)
+        }
+    }
+
+    impl<S> Source for Vec<S>
+    where
+        S: Source,
+    {
+        fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+            Source::visit(&**self, visitor)
+        }
+
+        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+            Source::get(&**self, key)
+        }
+
+        fn count(&self) -> usize {
+            Source::count(&**self)
+        }
+    }
+
+    impl<'kvs, V> Visitor<'kvs> for Box<V>
+    where
+        V: Visitor<'kvs> + ?Sized,
+    {
+        fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+            (**self).visit_pair(key, value)
+        }
+    }
+
+    impl<K, V, S> Source for HashMap<K, V, S>
+    where
+        K: ToKey + Borrow<str> + Eq + Hash,
+        V: ToValue,
+        S: BuildHasher,
+    {
+        fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+            for (key, value) in self {
+                visitor.visit_pair(key.to_key(), value.to_value())?;
+            }
+            Ok(())
+        }
+
+        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+            HashMap::get(self, key.as_str()).map(|v| v.to_value())
+        }
+
+        fn count(&self) -> usize {
+            self.len()
+        }
+    }
+
+    impl<K, V> Source for BTreeMap<K, V>
+    where
+        K: ToKey + Borrow<str> + Ord,
+        V: ToValue,
+    {
+        fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+            for (key, value) in self {
+                visitor.visit_pair(key.to_key(), value.to_value())?;
+            }
+            Ok(())
+        }
+
+        fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+            BTreeMap::get(self, key.as_str()).map(|v| v.to_value())
+        }
+
+        fn count(&self) -> usize {
+            self.len()
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use kv::value::tests::Token;
+        use std::collections::{BTreeMap, HashMap};
+
+        #[test]
+        fn count() {
+            assert_eq!(1, Source::count(&Box::new(("a", 1))));
+            assert_eq!(2, Source::count(&vec![("a", 1), ("b", 2)]));
+        }
+
+        #[test]
+        fn get() {
+            let source = vec![("a", 1), ("b", 2), ("a", 1)];
+            assert_eq!(
+                Token::I64(1),
+                Source::get(&source, Key::from_str("a")).unwrap().to_token()
+            );
+
+            let source = Box::new(Option::None::<(&str, i32)>);
+            assert!(Source::get(&source, Key::from_str("a")).is_none());
+        }
+
+        #[test]
+        fn hash_map() {
+            let mut map = HashMap::new();
+            map.insert("a", 1);
+            map.insert("b", 2);
+
+            assert_eq!(2, Source::count(&map));
+            assert_eq!(
+                Token::I64(1),
+                Source::get(&map, Key::from_str("a")).unwrap().to_token()
+            );
+        }
+
+        #[test]
+        fn btree_map() {
+            let mut map = BTreeMap::new();
+            map.insert("a", 1);
+            map.insert("b", 2);
+
+            assert_eq!(2, Source::count(&map));
+            assert_eq!(
+                Token::I64(1),
+                Source::get(&map, Key::from_str("a")).unwrap().to_token()
+            );
+        }
+    }
+}
+
+/// The result of calling `Source::as_map`.
+pub struct AsMap<S>(S);
+
+/// Visit this source as a map.
+pub fn as_map<S>(source: S) -> AsMap<S>
+where
+    S: Source,
+{
+    AsMap(source)
+}
+
+impl<S> Source for AsMap<S>
+where
+    S: Source,
+{
+    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+        self.0.visit(visitor)
+    }
+
+    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+        self.0.get(key)
+    }
+
+    fn count(&self) -> usize {
+        self.0.count()
+    }
+}
+
+impl<S> fmt::Debug for AsMap<S>
+where
+    S: Source,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut f = f.debug_map();
+        self.0.visit(&mut f).map_err(|_| fmt::Error)?;
+        f.finish()
+    }
+}
+
+/// The result of calling `Source::as_list`
+pub struct AsList<S>(S);
+
+/// Visit this source as a list.
+pub fn as_list<S>(source: S) -> AsList<S>
+where
+    S: Source,
+{
+    AsList(source)
+}
+
+impl<S> Source for AsList<S>
+where
+    S: Source,
+{
+    fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+        self.0.visit(visitor)
+    }
+
+    fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+        self.0.get(key)
+    }
+
+    fn count(&self) -> usize {
+        self.0.count()
+    }
+}
+
+impl<S> fmt::Debug for AsList<S>
+where
+    S: Source,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut f = f.debug_list();
+        self.0.visit(&mut f).map_err(|_| fmt::Error)?;
+        f.finish()
+    }
+}
+
+#[cfg(feature = "kv_unstable_sval")]
+mod sval_support {
+    use super::*;
+
+    use self::sval::value;
+
+    impl<S> value::Value for AsMap<S>
+    where
+        S: Source,
+    {
+        fn stream(&self, stream: &mut value::Stream) -> value::Result {
+            struct StreamVisitor<'a, 'b>(&'a mut value::Stream<'b>);
+
+            impl<'a, 'b, 'kvs> Visitor<'kvs> for StreamVisitor<'a, 'b> {
+                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+                    self.0
+                        .map_key(key)
+                        .map_err(|_| Error::msg("failed to stream map key"))?;
+                    self.0
+                        .map_value(value)
+                        .map_err(|_| Error::msg("failed to stream map value"))?;
+                    Ok(())
+                }
+            }
+
+            stream
+                .map_begin(Some(self.count()))
+                .map_err(|_| self::sval::Error::msg("failed to begin map"))?;
+
+            self.visit(&mut StreamVisitor(stream))
+                .map_err(|_| self::sval::Error::msg("failed to visit key-values"))?;
+
+            stream
+                .map_end()
+                .map_err(|_| self::sval::Error::msg("failed to end map"))
+        }
+    }
+
+    impl<S> value::Value for AsList<S>
+    where
+        S: Source,
+    {
+        fn stream(&self, stream: &mut value::Stream) -> value::Result {
+            struct StreamVisitor<'a, 'b>(&'a mut value::Stream<'b>);
+
+            impl<'a, 'b, 'kvs> Visitor<'kvs> for StreamVisitor<'a, 'b> {
+                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+                    self.0
+                        .seq_elem((key, value))
+                        .map_err(|_| Error::msg("failed to stream seq entry"))?;
+                    Ok(())
+                }
+            }
+
+            stream
+                .seq_begin(Some(self.count()))
+                .map_err(|_| self::sval::Error::msg("failed to begin seq"))?;
+
+            self.visit(&mut StreamVisitor(stream))
+                .map_err(|_| self::sval::Error::msg("failed to visit key-values"))?;
+
+            stream
+                .seq_end()
+                .map_err(|_| self::sval::Error::msg("failed to end seq"))
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        use self::sval::Value;
+
+        use crate::kv::source;
+
+        #[test]
+        fn derive_stream() {
+            #[derive(Value)]
+            pub struct MyRecordAsMap<'a> {
+                msg: &'a str,
+                kvs: source::AsMap<&'a dyn Source>,
+            }
+
+            #[derive(Value)]
+            pub struct MyRecordAsList<'a> {
+                msg: &'a str,
+                kvs: source::AsList<&'a dyn Source>,
+            }
+        }
+    }
+}
+
+#[cfg(feature = "kv_unstable_serde")]
+pub mod as_map {
+    //! `serde` adapters for serializing a `Source` as a map.
+
+    use super::*;
+
+    use self::serde::{Serialize, Serializer};
+
+    /// Serialize a `Source` as a map.
+    pub fn serialize<T, S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        T: Source,
+        S: Serializer,
+    {
+        as_map(source).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "kv_unstable_serde")]
+pub mod as_list {
+    //! `serde` adapters for serializing a `Source` as a list.
+
+    use super::*;
+
+    use self::serde::{Serialize, Serializer};
+
+    /// Serialize a `Source` as a list.
+    pub fn serialize<T, S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        T: Source,
+        S: Serializer,
+    {
+        as_list(source).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "kv_unstable_serde")]
+mod serde_support {
+    use super::*;
+
+    use self::serde::ser::{Error as SerError, Serialize, SerializeMap, SerializeSeq, Serializer};
+
+    impl<T> Serialize for AsMap<T>
+    where
+        T: Source,
+    {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            struct SerializerVisitor<'a, S>(&'a mut S);
+
+            impl<'a, 'kvs, S> Visitor<'kvs> for SerializerVisitor<'a, S>
+            where
+                S: SerializeMap,
+            {
+                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+                    self.0
+                        .serialize_entry(&key, &value)
+                        .map_err(|_| Error::msg("failed to serialize map entry"))?;
+                    Ok(())
+                }
+            }
+
+            let mut map = serializer.serialize_map(Some(self.count()))?;
+
+            self.visit(&mut SerializerVisitor(&mut map))
+                .map_err(|_| S::Error::custom("failed to visit key-values"))?;
+
+            map.end()
+        }
+    }
+
+    impl<T> Serialize for AsList<T>
+    where
+        T: Source,
+    {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            struct SerializerVisitor<'a, S>(&'a mut S);
+
+            impl<'a, 'kvs, S> Visitor<'kvs> for SerializerVisitor<'a, S>
+            where
+                S: SerializeSeq,
+            {
+                fn visit_pair(&mut self, key: Key<'kvs>, value: Value<'kvs>) -> Result<(), Error> {
+                    self.0
+                        .serialize_element(&(key, value))
+                        .map_err(|_| Error::msg("failed to serialize seq entry"))?;
+                    Ok(())
+                }
+            }
+
+            let mut seq = serializer.serialize_seq(Some(self.count()))?;
+
+            self.visit(&mut SerializerVisitor(&mut seq))
+                .map_err(|_| S::Error::custom("failed to visit seq"))?;
+
+            seq.end()
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        use self::serde::Serialize;
+
+        use crate::kv::source;
+
+        #[test]
+        fn derive_serialize() {
+            #[derive(Serialize)]
+            pub struct MyRecordAsMap<'a> {
+                msg: &'a str,
+                #[serde(flatten)]
+                #[serde(with = "source::as_map")]
+                kvs: &'a dyn Source,
+            }
+
+            #[derive(Serialize)]
+            pub struct MyRecordAsList<'a> {
+                msg: &'a str,
+                #[serde(flatten)]
+                #[serde(with = "source::as_list")]
+                kvs: &'a dyn Source,
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use kv::value::tests::Token;
+
+    #[test]
+    fn source_is_object_safe() {
+        fn _check(_: &dyn Source) {}
+    }
+
+    #[test]
+    fn visitor_is_object_safe() {
+        fn _check(_: &dyn Visitor) {}
+    }
+
+    #[test]
+    fn count() {
+        struct OnePair {
+            key: &'static str,
+            value: i32,
+        }
+
+        impl Source for OnePair {
+            fn visit<'kvs>(&'kvs self, visitor: &mut dyn Visitor<'kvs>) -> Result<(), Error> {
+                visitor.visit_pair(self.key.to_key(), self.value.to_value())
+            }
+
+            fn get<'v>(&'v self, key: Key) -> Option<Value<'v>> {
+                get_default(self, key)
+            }
+
+            fn count(&self) -> usize {
+                count_default(self)
+            }
+        }
+
+        assert_eq!(1, Source::count(&("a", 1)));
+        assert_eq!(2, Source::count(&[("a", 1), ("b", 2)] as &[_]));
+        assert_eq!(0, Source::count(&Option::None::<(&str, i32)>));
+        assert_eq!(1, Source::count(&OnePair { key: "a", value: 1 }));
+    }
+
+    #[test]
+    fn get() {
+        let source = &[("a", 1), ("b", 2), ("a", 1)] as &[_];
+        assert_eq!(
+            Token::I64(1),
+            Source::get(source, Key::from_str("a")).unwrap().to_token()
+        );
+        assert_eq!(
+            Token::I64(2),
+            Source::get(source, Key::from_str("b")).unwrap().to_token()
+        );
+        assert!(Source::get(&source, Key::from_str("c")).is_none());
+
+        let source = Option::None::<(&str, i32)>;
+        assert!(Source::get(&source, Key::from_str("a")).is_none());
+    }
+
+    #[test]
+    fn as_map() {
+        let _ = crate::kv::source::as_map(("a", 1));
+        let _ = crate::kv::source::as_map(&("a", 1) as &dyn Source);
+    }
+
+    #[test]
+    fn as_list() {
+        let _ = crate::kv::source::as_list(("a", 1));
+        let _ = crate::kv::source::as_list(&("a", 1) as &dyn Source);
+    }
+}

zeroidc/vendor/log/src/kv/value.rs

@@ -1,1034 +1,1034 @@
-//! Structured values.
-
-use std::fmt;
-
-extern crate value_bag;
-
-#[cfg(feature = "kv_unstable_sval")]
-extern crate sval;
-
-#[cfg(feature = "kv_unstable_serde")]
-extern crate serde;
-
-use self::value_bag::ValueBag;
-
-pub use kv::Error;
-
-/// A type that can be converted into a [`Value`](struct.Value.html).
-pub trait ToValue {
-    /// Perform the conversion.
-    fn to_value(&self) -> Value;
-}
-
-impl<'a, T> ToValue for &'a T
-where
-    T: ToValue + ?Sized,
-{
-    fn to_value(&self) -> Value {
-        (**self).to_value()
-    }
-}
-
-impl<'v> ToValue for Value<'v> {
-    fn to_value(&self) -> Value {
-        Value {
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-/// Get a value from a type implementing `std::fmt::Debug`.
-#[macro_export]
-macro_rules! as_debug {
-    ($capture:expr) => {
-        $crate::kv::Value::from_debug(&$capture)
-    };
-}
-
-/// Get a value from a type implementing `std::fmt::Display`.
-#[macro_export]
-macro_rules! as_display {
-    ($capture:expr) => {
-        $crate::kv::Value::from_display(&$capture)
-    };
-}
-
-/// Get a value from an error.
-#[cfg(feature = "kv_unstable_std")]
-#[macro_export]
-macro_rules! as_error {
-    ($capture:expr) => {
-        $crate::kv::Value::from_dyn_error(&$capture)
-    };
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-/// Get a value from a type implementing `serde::Serialize`.
-#[macro_export]
-macro_rules! as_serde {
-    ($capture:expr) => {
-        $crate::kv::Value::from_serde(&$capture)
-    };
-}
-
-/// Get a value from a type implementing `sval::value::Value`.
-#[cfg(feature = "kv_unstable_sval")]
-#[macro_export]
-macro_rules! as_sval {
-    ($capture:expr) => {
-        $crate::kv::Value::from_sval(&$capture)
-    };
-}
-
-/// A value in a structured key-value pair.
-///
-/// # Capturing values
-///
-/// There are a few ways to capture a value:
-///
-/// - Using the `Value::capture_*` methods.
-/// - Using the `Value::from_*` methods.
-/// - Using the `ToValue` trait.
-/// - Using the standard `From` trait.
-///
-/// ## Using the `Value::capture_*` methods
-///
-/// `Value` offers a few constructor methods that capture values of different kinds.
-/// These methods require a `T: 'static` to support downcasting.
-///
-/// ```
-/// use log::kv::Value;
-///
-/// let value = Value::capture_debug(&42i32);
-///
-/// assert_eq!(Some(42), value.to_i64());
-/// ```
-///
-/// ## Using the `Value::from_*` methods
-///
-/// `Value` offers a few constructor methods that capture values of different kinds.
-/// These methods don't require `T: 'static`, but can't support downcasting.
-///
-/// ```
-/// use log::kv::Value;
-///
-/// let value = Value::from_debug(&42i32);
-///
-/// assert_eq!(None, value.to_i64());
-/// ```
-///
-/// ## Using the `ToValue` trait
-///
-/// The `ToValue` trait can be used to capture values generically.
-/// It's the bound used by `Source`.
-///
-/// ```
-/// # use log::kv::ToValue;
-/// let value = 42i32.to_value();
-///
-/// assert_eq!(Some(42), value.to_i64());
-/// ```
-///
-/// ```
-/// # use std::fmt::Debug;
-/// use log::kv::ToValue;
-///
-/// let value = (&42i32 as &dyn Debug).to_value();
-///
-/// assert_eq!(None, value.to_i64());
-/// ```
-///
-/// ## Using the standard `From` trait
-///
-/// Standard types that implement `ToValue` also implement `From`.
-///
-/// ```
-/// use log::kv::Value;
-///
-/// let value = Value::from(42i32);
-///
-/// assert_eq!(Some(42), value.to_i64());
-/// ```
-pub struct Value<'v> {
-    inner: ValueBag<'v>,
-}
-
-impl<'v> Value<'v> {
-    /// Get a value from a type implementing `ToValue`.
-    pub fn from_any<T>(value: &'v T) -> Self
-    where
-        T: ToValue,
-    {
-        value.to_value()
-    }
-
-    /// Get a value from a type implementing `std::fmt::Debug`.
-    pub fn capture_debug<T>(value: &'v T) -> Self
-    where
-        T: fmt::Debug + 'static,
-    {
-        Value {
-            inner: ValueBag::capture_debug(value),
-        }
-    }
-
-    /// Get a value from a type implementing `std::fmt::Display`.
-    pub fn capture_display<T>(value: &'v T) -> Self
-    where
-        T: fmt::Display + 'static,
-    {
-        Value {
-            inner: ValueBag::capture_display(value),
-        }
-    }
-
-    /// Get a value from an error.
-    #[cfg(feature = "kv_unstable_std")]
-    pub fn capture_error<T>(err: &'v T) -> Self
-    where
-        T: std::error::Error + 'static,
-    {
-        Value {
-            inner: ValueBag::capture_error(err),
-        }
-    }
-
-    #[cfg(feature = "kv_unstable_serde")]
-    /// Get a value from a type implementing `serde::Serialize`.
-    pub fn capture_serde<T>(value: &'v T) -> Self
-    where
-        T: self::serde::Serialize + 'static,
-    {
-        Value {
-            inner: ValueBag::capture_serde1(value),
-        }
-    }
-
-    /// Get a value from a type implementing `sval::value::Value`.
-    #[cfg(feature = "kv_unstable_sval")]
-    pub fn capture_sval<T>(value: &'v T) -> Self
-    where
-        T: self::sval::value::Value + 'static,
-    {
-        Value {
-            inner: ValueBag::capture_sval1(value),
-        }
-    }
-
-    /// Get a value from a type implementing `std::fmt::Debug`.
-    pub fn from_debug<T>(value: &'v T) -> Self
-    where
-        T: fmt::Debug,
-    {
-        Value {
-            inner: ValueBag::from_debug(value),
-        }
-    }
-
-    /// Get a value from a type implementing `std::fmt::Display`.
-    pub fn from_display<T>(value: &'v T) -> Self
-    where
-        T: fmt::Display,
-    {
-        Value {
-            inner: ValueBag::from_display(value),
-        }
-    }
-
-    /// Get a value from a type implementing `serde::Serialize`.
-    #[cfg(feature = "kv_unstable_serde")]
-    pub fn from_serde<T>(value: &'v T) -> Self
-    where
-        T: self::serde::Serialize,
-    {
-        Value {
-            inner: ValueBag::from_serde1(value),
-        }
-    }
-
-    /// Get a value from a type implementing `sval::value::Value`.
-    #[cfg(feature = "kv_unstable_sval")]
-    pub fn from_sval<T>(value: &'v T) -> Self
-    where
-        T: self::sval::value::Value,
-    {
-        Value {
-            inner: ValueBag::from_sval1(value),
-        }
-    }
-
-    /// Get a value from a dynamic `std::fmt::Debug`.
-    pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
-        Value {
-            inner: ValueBag::from_dyn_debug(value),
-        }
-    }
-
-    /// Get a value from a dynamic `std::fmt::Display`.
-    pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
-        Value {
-            inner: ValueBag::from_dyn_display(value),
-        }
-    }
-
-    /// Get a value from a dynamic error.
-    #[cfg(feature = "kv_unstable_std")]
-    pub fn from_dyn_error(err: &'v (dyn std::error::Error + 'static)) -> Self {
-        Value {
-            inner: ValueBag::from_dyn_error(err),
-        }
-    }
-
-    /// Get a value from a type implementing `sval::value::Value`.
-    #[cfg(feature = "kv_unstable_sval")]
-    pub fn from_dyn_sval(value: &'v dyn self::sval::value::Value) -> Self {
-        Value {
-            inner: ValueBag::from_dyn_sval1(value),
-        }
-    }
-
-    /// Get a value from an internal primitive.
-    fn from_value_bag<T>(value: T) -> Self
-    where
-        T: Into<ValueBag<'v>>,
-    {
-        Value {
-            inner: value.into(),
-        }
-    }
-
-    /// Check whether this value can be downcast to `T`.
-    pub fn is<T: 'static>(&self) -> bool {
-        self.inner.is::<T>()
-    }
-
-    /// Try downcast this value to `T`.
-    pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
-        self.inner.downcast_ref::<T>()
-    }
-
-    /// Inspect this value using a simple visitor.
-    pub fn visit(&self, visitor: impl Visit<'v>) -> Result<(), Error> {
-        struct Visitor<V>(V);
-
-        impl<'v, V> value_bag::visit::Visit<'v> for Visitor<V>
-        where
-            V: Visit<'v>,
-        {
-            fn visit_any(&mut self, value: ValueBag) -> Result<(), value_bag::Error> {
-                self.0
-                    .visit_any(Value { inner: value })
-                    .map_err(Error::into_value)
-            }
-
-            fn visit_u64(&mut self, value: u64) -> Result<(), value_bag::Error> {
-                self.0.visit_u64(value).map_err(Error::into_value)
-            }
-
-            fn visit_i64(&mut self, value: i64) -> Result<(), value_bag::Error> {
-                self.0.visit_i64(value).map_err(Error::into_value)
-            }
-
-            fn visit_u128(&mut self, value: u128) -> Result<(), value_bag::Error> {
-                self.0.visit_u128(value).map_err(Error::into_value)
-            }
-
-            fn visit_i128(&mut self, value: i128) -> Result<(), value_bag::Error> {
-                self.0.visit_i128(value).map_err(Error::into_value)
-            }
-
-            fn visit_f64(&mut self, value: f64) -> Result<(), value_bag::Error> {
-                self.0.visit_f64(value).map_err(Error::into_value)
-            }
-
-            fn visit_bool(&mut self, value: bool) -> Result<(), value_bag::Error> {
-                self.0.visit_bool(value).map_err(Error::into_value)
-            }
-
-            fn visit_str(&mut self, value: &str) -> Result<(), value_bag::Error> {
-                self.0.visit_str(value).map_err(Error::into_value)
-            }
-
-            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), value_bag::Error> {
-                self.0.visit_borrowed_str(value).map_err(Error::into_value)
-            }
-
-            fn visit_char(&mut self, value: char) -> Result<(), value_bag::Error> {
-                self.0.visit_char(value).map_err(Error::into_value)
-            }
-
-            #[cfg(feature = "kv_unstable_std")]
-            fn visit_error(
-                &mut self,
-                err: &(dyn std::error::Error + 'static),
-            ) -> Result<(), value_bag::Error> {
-                self.0.visit_error(err).map_err(Error::into_value)
-            }
-
-            #[cfg(feature = "kv_unstable_std")]
-            fn visit_borrowed_error(
-                &mut self,
-                err: &'v (dyn std::error::Error + 'static),
-            ) -> Result<(), value_bag::Error> {
-                self.0.visit_borrowed_error(err).map_err(Error::into_value)
-            }
-        }
-
-        self.inner
-            .visit(&mut Visitor(visitor))
-            .map_err(Error::from_value)
-    }
-}
-
-impl<'v> fmt::Debug for Value<'v> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self.inner, f)
-    }
-}
-
-impl<'v> fmt::Display for Value<'v> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.inner, f)
-    }
-}
-
-impl ToValue for dyn fmt::Debug {
-    fn to_value(&self) -> Value {
-        Value::from_dyn_debug(self)
-    }
-}
-
-impl ToValue for dyn fmt::Display {
-    fn to_value(&self) -> Value {
-        Value::from_dyn_display(self)
-    }
-}
-
-#[cfg(feature = "kv_unstable_std")]
-impl ToValue for dyn std::error::Error + 'static {
-    fn to_value(&self) -> Value {
-        Value::from_dyn_error(self)
-    }
-}
-
-#[cfg(feature = "kv_unstable_serde")]
-impl<'v> self::serde::Serialize for Value<'v> {
-    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: self::serde::Serializer,
-    {
-        self.inner.serialize(s)
-    }
-}
-
-#[cfg(feature = "kv_unstable_sval")]
-impl<'v> self::sval::value::Value for Value<'v> {
-    fn stream(&self, stream: &mut self::sval::value::Stream) -> self::sval::value::Result {
-        self::sval::value::Value::stream(&self.inner, stream)
-    }
-}
-
-#[cfg(feature = "kv_unstable_sval")]
-impl ToValue for dyn self::sval::value::Value {
-    fn to_value(&self) -> Value {
-        Value::from_dyn_sval(self)
-    }
-}
-
-impl ToValue for str {
-    fn to_value(&self) -> Value {
-        Value::from(self)
-    }
-}
-
-impl ToValue for u128 {
-    fn to_value(&self) -> Value {
-        Value::from(self)
-    }
-}
-
-impl ToValue for i128 {
-    fn to_value(&self) -> Value {
-        Value::from(self)
-    }
-}
-
-impl ToValue for std::num::NonZeroU128 {
-    fn to_value(&self) -> Value {
-        Value::from(self)
-    }
-}
-
-impl ToValue for std::num::NonZeroI128 {
-    fn to_value(&self) -> Value {
-        Value::from(self)
-    }
-}
-
-impl<'v> From<&'v str> for Value<'v> {
-    fn from(value: &'v str) -> Self {
-        Value::from_value_bag(value)
-    }
-}
-
-impl<'v> From<&'v u128> for Value<'v> {
-    fn from(value: &'v u128) -> Self {
-        Value::from_value_bag(value)
-    }
-}
-
-impl<'v> From<&'v i128> for Value<'v> {
-    fn from(value: &'v i128) -> Self {
-        Value::from_value_bag(value)
-    }
-}
-
-impl<'v> From<&'v std::num::NonZeroU128> for Value<'v> {
-    fn from(v: &'v std::num::NonZeroU128) -> Value<'v> {
-        // SAFETY: `NonZeroU128` and `u128` have the same ABI
-        Value::from_value_bag(unsafe { std::mem::transmute::<&std::num::NonZeroU128, &u128>(v) })
-    }
-}
-
-impl<'v> From<&'v std::num::NonZeroI128> for Value<'v> {
-    fn from(v: &'v std::num::NonZeroI128) -> Value<'v> {
-        // SAFETY: `NonZeroI128` and `i128` have the same ABI
-        Value::from_value_bag(unsafe { std::mem::transmute::<&std::num::NonZeroI128, &i128>(v) })
-    }
-}
-
-impl ToValue for () {
-    fn to_value(&self) -> Value {
-        Value::from_value_bag(())
-    }
-}
-
-impl<T> ToValue for Option<T>
-where
-    T: ToValue,
-{
-    fn to_value(&self) -> Value {
-        match *self {
-            Some(ref value) => value.to_value(),
-            None => Value::from_value_bag(()),
-        }
-    }
-}
-
-macro_rules! impl_to_value_primitive {
-    ($($into_ty:ty,)*) => {
-        $(
-            impl ToValue for $into_ty {
-                fn to_value(&self) -> Value {
-                    Value::from(*self)
-                }
-            }
-
-            impl<'v> From<$into_ty> for Value<'v> {
-                fn from(value: $into_ty) -> Self {
-                    Value::from_value_bag(value)
-                }
-            }
-        )*
-    };
-}
-
-macro_rules! impl_to_value_nonzero_primitive {
-    ($($into_ty:ident,)*) => {
-        $(
-            impl ToValue for std::num::$into_ty {
-                fn to_value(&self) -> Value {
-                    Value::from(self.get())
-                }
-            }
-
-            impl<'v> From<std::num::$into_ty> for Value<'v> {
-                fn from(value: std::num::$into_ty) -> Self {
-                    Value::from(value.get())
-                }
-            }
-        )*
-    };
-}
-
-macro_rules! impl_value_to_primitive {
-    ($(#[doc = $doc:tt] $into_name:ident -> $into_ty:ty,)*) => {
-        impl<'v> Value<'v> {
-            $(
-                #[doc = $doc]
-                pub fn $into_name(&self) -> Option<$into_ty> {
-                    self.inner.$into_name()
-                }
-            )*
-        }
-    }
-}
-
-impl_to_value_primitive![usize, u8, u16, u32, u64, isize, i8, i16, i32, i64, f32, f64, char, bool,];
-
-#[rustfmt::skip]
-impl_to_value_nonzero_primitive![
-    NonZeroUsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64,
-    NonZeroIsize, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64,
-];
-
-impl_value_to_primitive![
-    #[doc = "Try convert this value into a `u64`."]
-    to_u64 -> u64,
-    #[doc = "Try convert this value into a `i64`."]
-    to_i64 -> i64,
-    #[doc = "Try convert this value into a `u128`."]
-    to_u128 -> u128,
-    #[doc = "Try convert this value into a `i128`."]
-    to_i128 -> i128,
-    #[doc = "Try convert this value into a `f64`."]
-    to_f64 -> f64,
-    #[doc = "Try convert this value into a `char`."]
-    to_char -> char,
-    #[doc = "Try convert this value into a `bool`."]
-    to_bool -> bool,
-];
-
-impl<'v> Value<'v> {
-    /// Try convert this value into an error.
-    #[cfg(feature = "kv_unstable_std")]
-    pub fn to_borrowed_error(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        self.inner.to_borrowed_error()
-    }
-
-    /// Try convert this value into a borrowed string.
-    pub fn to_borrowed_str(&self) -> Option<&str> {
-        self.inner.to_borrowed_str()
-    }
-}
-
-#[cfg(feature = "kv_unstable_std")]
-mod std_support {
-    use super::*;
-
-    use std::borrow::Cow;
-
-    impl<T> ToValue for Box<T>
-    where
-        T: ToValue + ?Sized,
-    {
-        fn to_value(&self) -> Value {
-            (**self).to_value()
-        }
-    }
-
-    impl ToValue for String {
-        fn to_value(&self) -> Value {
-            Value::from(&**self)
-        }
-    }
-
-    impl<'v> ToValue for Cow<'v, str> {
-        fn to_value(&self) -> Value {
-            Value::from(&**self)
-        }
-    }
-
-    impl<'v> Value<'v> {
-        /// Try convert this value into a string.
-        pub fn to_str(&self) -> Option<Cow<str>> {
-            self.inner.to_str()
-        }
-    }
-
-    impl<'v> From<&'v String> for Value<'v> {
-        fn from(v: &'v String) -> Self {
-            Value::from(&**v)
-        }
-    }
-}
-
-/// A visitor for a `Value`.
-pub trait Visit<'v> {
-    /// Visit a `Value`.
-    ///
-    /// This is the only required method on `Visit` and acts as a fallback for any
-    /// more specific methods that aren't overridden.
-    /// The `Value` may be formatted using its `fmt::Debug` or `fmt::Display` implementation,
-    /// or serialized using its `sval::Value` or `serde::Serialize` implementation.
-    fn visit_any(&mut self, value: Value) -> Result<(), Error>;
-
-    /// Visit an unsigned integer.
-    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
-        self.visit_any(value.into())
-    }
-
-    /// Visit a signed integer.
-    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
-        self.visit_any(value.into())
-    }
-
-    /// Visit a big unsigned integer.
-    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
-        self.visit_any((&value).into())
-    }
-
-    /// Visit a big signed integer.
-    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
-        self.visit_any((&value).into())
-    }
-
-    /// Visit a floating point.
-    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
-        self.visit_any(value.into())
-    }
-
-    /// Visit a boolean.
-    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
-        self.visit_any(value.into())
-    }
-
-    /// Visit a string.
-    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
-        self.visit_any(value.into())
-    }
-
-    /// Visit a string.
-    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
-        self.visit_str(value)
-    }
-
-    /// Visit a Unicode character.
-    fn visit_char(&mut self, value: char) -> Result<(), Error> {
-        let mut b = [0; 4];
-        self.visit_str(&*value.encode_utf8(&mut b))
-    }
-
-    /// Visit an error.
-    #[cfg(feature = "kv_unstable_std")]
-    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
-        self.visit_any(Value::from_dyn_error(err))
-    }
-
-    /// Visit an error.
-    #[cfg(feature = "kv_unstable_std")]
-    fn visit_borrowed_error(
-        &mut self,
-        err: &'v (dyn std::error::Error + 'static),
-    ) -> Result<(), Error> {
-        self.visit_any(Value::from_dyn_error(err))
-    }
-}
-
-impl<'a, 'v, T: ?Sized> Visit<'v> for &'a mut T
-where
-    T: Visit<'v>,
-{
-    fn visit_any(&mut self, value: Value) -> Result<(), Error> {
-        (**self).visit_any(value)
-    }
-
-    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
-        (**self).visit_u64(value)
-    }
-
-    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
-        (**self).visit_i64(value)
-    }
-
-    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
-        (**self).visit_u128(value)
-    }
-
-    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
-        (**self).visit_i128(value)
-    }
-
-    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
-        (**self).visit_f64(value)
-    }
-
-    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
-        (**self).visit_bool(value)
-    }
-
-    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
-        (**self).visit_str(value)
-    }
-
-    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
-        (**self).visit_borrowed_str(value)
-    }
-
-    fn visit_char(&mut self, value: char) -> Result<(), Error> {
-        (**self).visit_char(value)
-    }
-
-    #[cfg(feature = "kv_unstable_std")]
-    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
-        (**self).visit_error(err)
-    }
-
-    #[cfg(feature = "kv_unstable_std")]
-    fn visit_borrowed_error(
-        &mut self,
-        err: &'v (dyn std::error::Error + 'static),
-    ) -> Result<(), Error> {
-        (**self).visit_borrowed_error(err)
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::*;
-
-    pub(crate) use super::value_bag::test::Token;
-
-    impl<'v> Value<'v> {
-        pub(crate) fn to_token(&self) -> Token {
-            self.inner.to_token()
-        }
-    }
-
-    fn unsigned() -> impl Iterator<Item = Value<'static>> {
-        vec![
-            Value::from(8u8),
-            Value::from(16u16),
-            Value::from(32u32),
-            Value::from(64u64),
-            Value::from(1usize),
-            Value::from(std::num::NonZeroU8::new(8).unwrap()),
-            Value::from(std::num::NonZeroU16::new(16).unwrap()),
-            Value::from(std::num::NonZeroU32::new(32).unwrap()),
-            Value::from(std::num::NonZeroU64::new(64).unwrap()),
-            Value::from(std::num::NonZeroUsize::new(1).unwrap()),
-        ]
-        .into_iter()
-    }
-
-    fn signed() -> impl Iterator<Item = Value<'static>> {
-        vec![
-            Value::from(-8i8),
-            Value::from(-16i16),
-            Value::from(-32i32),
-            Value::from(-64i64),
-            Value::from(-1isize),
-            Value::from(std::num::NonZeroI8::new(-8).unwrap()),
-            Value::from(std::num::NonZeroI16::new(-16).unwrap()),
-            Value::from(std::num::NonZeroI32::new(-32).unwrap()),
-            Value::from(std::num::NonZeroI64::new(-64).unwrap()),
-            Value::from(std::num::NonZeroIsize::new(-1).unwrap()),
-        ]
-        .into_iter()
-    }
-
-    fn float() -> impl Iterator<Item = Value<'static>> {
-        vec![Value::from(32.32f32), Value::from(64.64f64)].into_iter()
-    }
-
-    fn bool() -> impl Iterator<Item = Value<'static>> {
-        vec![Value::from(true), Value::from(false)].into_iter()
-    }
-
-    fn str() -> impl Iterator<Item = Value<'static>> {
-        vec![Value::from("a string"), Value::from("a loong string")].into_iter()
-    }
-
-    fn char() -> impl Iterator<Item = Value<'static>> {
-        vec![Value::from('a'), Value::from('⛰')].into_iter()
-    }
-
-    #[test]
-    fn test_capture_fmt() {
-        assert_eq!(Some(42u64), Value::capture_display(&42).to_u64());
-        assert_eq!(Some(42u64), Value::capture_debug(&42).to_u64());
-
-        assert!(Value::from_display(&42).to_u64().is_none());
-        assert!(Value::from_debug(&42).to_u64().is_none());
-    }
-
-    #[cfg(feature = "kv_unstable_std")]
-    #[test]
-    fn test_capture_error() {
-        let err = std::io::Error::from(std::io::ErrorKind::Other);
-
-        assert!(Value::capture_error(&err).to_borrowed_error().is_some());
-        assert!(Value::from_dyn_error(&err).to_borrowed_error().is_some());
-    }
-
-    #[cfg(feature = "kv_unstable_serde")]
-    #[test]
-    fn test_capture_serde() {
-        assert_eq!(Some(42u64), Value::capture_serde(&42).to_u64());
-
-        assert_eq!(Some(42u64), Value::from_serde(&42).to_u64());
-    }
-
-    #[cfg(feature = "kv_unstable_sval")]
-    #[test]
-    fn test_capture_sval() {
-        assert_eq!(Some(42u64), Value::capture_sval(&42).to_u64());
-
-        assert_eq!(Some(42u64), Value::from_sval(&42).to_u64());
-    }
-
-    #[test]
-    fn test_to_value_display() {
-        assert_eq!(42u64.to_value().to_string(), "42");
-        assert_eq!(42i64.to_value().to_string(), "42");
-        assert_eq!(42.01f64.to_value().to_string(), "42.01");
-        assert_eq!(true.to_value().to_string(), "true");
-        assert_eq!('a'.to_value().to_string(), "a");
-        assert_eq!("a loong string".to_value().to_string(), "a loong string");
-        assert_eq!(Some(true).to_value().to_string(), "true");
-        assert_eq!(().to_value().to_string(), "None");
-        assert_eq!(Option::None::<bool>.to_value().to_string(), "None");
-    }
-
-    #[test]
-    fn test_to_value_structured() {
-        assert_eq!(42u64.to_value().to_token(), Token::U64(42));
-        assert_eq!(42i64.to_value().to_token(), Token::I64(42));
-        assert_eq!(42.01f64.to_value().to_token(), Token::F64(42.01));
-        assert_eq!(true.to_value().to_token(), Token::Bool(true));
-        assert_eq!('a'.to_value().to_token(), Token::Char('a'));
-        assert_eq!(
-            "a loong string".to_value().to_token(),
-            Token::Str("a loong string".into())
-        );
-        assert_eq!(Some(true).to_value().to_token(), Token::Bool(true));
-        assert_eq!(().to_value().to_token(), Token::None);
-        assert_eq!(Option::None::<bool>.to_value().to_token(), Token::None);
-    }
-
-    #[test]
-    fn test_to_number() {
-        for v in unsigned() {
-            assert!(v.to_u64().is_some());
-            assert!(v.to_i64().is_some());
-        }
-
-        for v in signed() {
-            assert!(v.to_i64().is_some());
-        }
-
-        for v in unsigned().chain(signed()).chain(float()) {
-            assert!(v.to_f64().is_some());
-        }
-
-        for v in bool().chain(str()).chain(char()) {
-            assert!(v.to_u64().is_none());
-            assert!(v.to_i64().is_none());
-            assert!(v.to_f64().is_none());
-        }
-    }
-
-    #[test]
-    fn test_to_str() {
-        for v in str() {
-            assert!(v.to_borrowed_str().is_some());
-
-            #[cfg(feature = "kv_unstable_std")]
-            assert!(v.to_str().is_some());
-        }
-
-        let short_lived = String::from("short lived");
-        let v = Value::from(&*short_lived);
-
-        assert!(v.to_borrowed_str().is_some());
-
-        #[cfg(feature = "kv_unstable_std")]
-        assert!(v.to_str().is_some());
-
-        for v in unsigned().chain(signed()).chain(float()).chain(bool()) {
-            assert!(v.to_borrowed_str().is_none());
-
-            #[cfg(feature = "kv_unstable_std")]
-            assert!(v.to_str().is_none());
-        }
-    }
-
-    #[test]
-    fn test_to_bool() {
-        for v in bool() {
-            assert!(v.to_bool().is_some());
-        }
-
-        for v in unsigned()
-            .chain(signed())
-            .chain(float())
-            .chain(str())
-            .chain(char())
-        {
-            assert!(v.to_bool().is_none());
-        }
-    }
-
-    #[test]
-    fn test_to_char() {
-        for v in char() {
-            assert!(v.to_char().is_some());
-        }
-
-        for v in unsigned()
-            .chain(signed())
-            .chain(float())
-            .chain(str())
-            .chain(bool())
-        {
-            assert!(v.to_char().is_none());
-        }
-    }
-
-    #[test]
-    fn test_downcast_ref() {
-        #[derive(Debug)]
-        struct Foo(u64);
-
-        let v = Value::capture_debug(&Foo(42));
-
-        assert!(v.is::<Foo>());
-        assert_eq!(42u64, v.downcast_ref::<Foo>().expect("invalid downcast").0);
-    }
-
-    #[test]
-    fn test_visit_integer() {
-        struct Extract(Option<u64>);
-
-        impl<'v> Visit<'v> for Extract {
-            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
-                unimplemented!("unexpected value: {:?}", value)
-            }
-
-            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
-                self.0 = Some(value);
-
-                Ok(())
-            }
-        }
-
-        let mut extract = Extract(None);
-        Value::from(42u64).visit(&mut extract).unwrap();
-
-        assert_eq!(Some(42), extract.0);
-    }
-
-    #[test]
-    fn test_visit_borrowed_str() {
-        struct Extract<'v>(Option<&'v str>);
-
-        impl<'v> Visit<'v> for Extract<'v> {
-            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
-                unimplemented!("unexpected value: {:?}", value)
-            }
-
-            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
-                self.0 = Some(value);
-
-                Ok(())
-            }
-        }
-
-        let mut extract = Extract(None);
-
-        let short_lived = String::from("A short-lived string");
-        Value::from(&*short_lived).visit(&mut extract).unwrap();
-
-        assert_eq!(Some("A short-lived string"), extract.0);
-    }
-}
+//! Structured values.
+
+use std::fmt;
+
+extern crate value_bag;
+
+#[cfg(feature = "kv_unstable_sval")]
+extern crate sval;
+
+#[cfg(feature = "kv_unstable_serde")]
+extern crate serde;
+
+use self::value_bag::ValueBag;
+
+pub use kv::Error;
+
+/// A type that can be converted into a [`Value`](struct.Value.html).
+pub trait ToValue {
+    /// Perform the conversion.
+    fn to_value(&self) -> Value;
+}
+
+impl<'a, T> ToValue for &'a T
+where
+    T: ToValue + ?Sized,
+{
+    fn to_value(&self) -> Value {
+        (**self).to_value()
+    }
+}
+
+impl<'v> ToValue for Value<'v> {
+    fn to_value(&self) -> Value {
+        Value {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+/// Get a value from a type implementing `std::fmt::Debug`.
+#[macro_export]
+macro_rules! as_debug {
+    ($capture:expr) => {
+        $crate::kv::Value::from_debug(&$capture)
+    };
+}
+
+/// Get a value from a type implementing `std::fmt::Display`.
+#[macro_export]
+macro_rules! as_display {
+    ($capture:expr) => {
+        $crate::kv::Value::from_display(&$capture)
+    };
+}
+
+/// Get a value from an error.
+#[cfg(feature = "kv_unstable_std")]
+#[macro_export]
+macro_rules! as_error {
+    ($capture:expr) => {
+        $crate::kv::Value::from_dyn_error(&$capture)
+    };
+}
+
+#[cfg(feature = "kv_unstable_serde")]
+/// Get a value from a type implementing `serde::Serialize`.
+#[macro_export]
+macro_rules! as_serde {
+    ($capture:expr) => {
+        $crate::kv::Value::from_serde(&$capture)
+    };
+}
+
+/// Get a value from a type implementing `sval::value::Value`.
+#[cfg(feature = "kv_unstable_sval")]
+#[macro_export]
+macro_rules! as_sval {
+    ($capture:expr) => {
+        $crate::kv::Value::from_sval(&$capture)
+    };
+}
+
+/// A value in a structured key-value pair.
+///
+/// # Capturing values
+///
+/// There are a few ways to capture a value:
+///
+/// - Using the `Value::capture_*` methods.
+/// - Using the `Value::from_*` methods.
+/// - Using the `ToValue` trait.
+/// - Using the standard `From` trait.
+///
+/// ## Using the `Value::capture_*` methods
+///
+/// `Value` offers a few constructor methods that capture values of different kinds.
+/// These methods require a `T: 'static` to support downcasting.
+///
+/// ```
+/// use log::kv::Value;
+///
+/// let value = Value::capture_debug(&42i32);
+///
+/// assert_eq!(Some(42), value.to_i64());
+/// ```
+///
+/// ## Using the `Value::from_*` methods
+///
+/// `Value` offers a few constructor methods that capture values of different kinds.
+/// These methods don't require `T: 'static`, but can't support downcasting.
+///
+/// ```
+/// use log::kv::Value;
+///
+/// let value = Value::from_debug(&42i32);
+///
+/// assert_eq!(None, value.to_i64());
+/// ```
+///
+/// ## Using the `ToValue` trait
+///
+/// The `ToValue` trait can be used to capture values generically.
+/// It's the bound used by `Source`.
+///
+/// ```
+/// # use log::kv::ToValue;
+/// let value = 42i32.to_value();
+///
+/// assert_eq!(Some(42), value.to_i64());
+/// ```
+///
+/// ```
+/// # use std::fmt::Debug;
+/// use log::kv::ToValue;
+///
+/// let value = (&42i32 as &dyn Debug).to_value();
+///
+/// assert_eq!(None, value.to_i64());
+/// ```
+///
+/// ## Using the standard `From` trait
+///
+/// Standard types that implement `ToValue` also implement `From`.
+///
+/// ```
+/// use log::kv::Value;
+///
+/// let value = Value::from(42i32);
+///
+/// assert_eq!(Some(42), value.to_i64());
+/// ```
+pub struct Value<'v> {
+    inner: ValueBag<'v>,
+}
+
+impl<'v> Value<'v> {
+    /// Get a value from a type implementing `ToValue`.
+    pub fn from_any<T>(value: &'v T) -> Self
+    where
+        T: ToValue,
+    {
+        value.to_value()
+    }
+
+    /// Get a value from a type implementing `std::fmt::Debug`.
+    pub fn capture_debug<T>(value: &'v T) -> Self
+    where
+        T: fmt::Debug + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_debug(value),
+        }
+    }
+
+    /// Get a value from a type implementing `std::fmt::Display`.
+    pub fn capture_display<T>(value: &'v T) -> Self
+    where
+        T: fmt::Display + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_display(value),
+        }
+    }
+
+    /// Get a value from an error.
+    #[cfg(feature = "kv_unstable_std")]
+    pub fn capture_error<T>(err: &'v T) -> Self
+    where
+        T: std::error::Error + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_error(err),
+        }
+    }
+
+    #[cfg(feature = "kv_unstable_serde")]
+    /// Get a value from a type implementing `serde::Serialize`.
+    pub fn capture_serde<T>(value: &'v T) -> Self
+    where
+        T: self::serde::Serialize + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_serde1(value),
+        }
+    }
+
+    /// Get a value from a type implementing `sval::value::Value`.
+    #[cfg(feature = "kv_unstable_sval")]
+    pub fn capture_sval<T>(value: &'v T) -> Self
+    where
+        T: self::sval::value::Value + 'static,
+    {
+        Value {
+            inner: ValueBag::capture_sval1(value),
+        }
+    }
+
+    /// Get a value from a type implementing `std::fmt::Debug`.
+    pub fn from_debug<T>(value: &'v T) -> Self
+    where
+        T: fmt::Debug,
+    {
+        Value {
+            inner: ValueBag::from_debug(value),
+        }
+    }
+
+    /// Get a value from a type implementing `std::fmt::Display`.
+    pub fn from_display<T>(value: &'v T) -> Self
+    where
+        T: fmt::Display,
+    {
+        Value {
+            inner: ValueBag::from_display(value),
+        }
+    }
+
+    /// Get a value from a type implementing `serde::Serialize`.
+    #[cfg(feature = "kv_unstable_serde")]
+    pub fn from_serde<T>(value: &'v T) -> Self
+    where
+        T: self::serde::Serialize,
+    {
+        Value {
+            inner: ValueBag::from_serde1(value),
+        }
+    }
+
+    /// Get a value from a type implementing `sval::value::Value`.
+    #[cfg(feature = "kv_unstable_sval")]
+    pub fn from_sval<T>(value: &'v T) -> Self
+    where
+        T: self::sval::value::Value,
+    {
+        Value {
+            inner: ValueBag::from_sval1(value),
+        }
+    }
+
+    /// Get a value from a dynamic `std::fmt::Debug`.
+    pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
+        Value {
+            inner: ValueBag::from_dyn_debug(value),
+        }
+    }
+
+    /// Get a value from a dynamic `std::fmt::Display`.
+    pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
+        Value {
+            inner: ValueBag::from_dyn_display(value),
+        }
+    }
+
+    /// Get a value from a dynamic error.
+    #[cfg(feature = "kv_unstable_std")]
+    pub fn from_dyn_error(err: &'v (dyn std::error::Error + 'static)) -> Self {
+        Value {
+            inner: ValueBag::from_dyn_error(err),
+        }
+    }
+
+    /// Get a value from a type implementing `sval::value::Value`.
+    #[cfg(feature = "kv_unstable_sval")]
+    pub fn from_dyn_sval(value: &'v dyn self::sval::value::Value) -> Self {
+        Value {
+            inner: ValueBag::from_dyn_sval1(value),
+        }
+    }
+
+    /// Get a value from an internal primitive.
+    fn from_value_bag<T>(value: T) -> Self
+    where
+        T: Into<ValueBag<'v>>,
+    {
+        Value {
+            inner: value.into(),
+        }
+    }
+
+    /// Check whether this value can be downcast to `T`.
+    pub fn is<T: 'static>(&self) -> bool {
+        self.inner.is::<T>()
+    }
+
+    /// Try downcast this value to `T`.
+    pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
+        self.inner.downcast_ref::<T>()
+    }
+
+    /// Inspect this value using a simple visitor.
+    pub fn visit(&self, visitor: impl Visit<'v>) -> Result<(), Error> {
+        struct Visitor<V>(V);
+
+        impl<'v, V> value_bag::visit::Visit<'v> for Visitor<V>
+        where
+            V: Visit<'v>,
+        {
+            fn visit_any(&mut self, value: ValueBag) -> Result<(), value_bag::Error> {
+                self.0
+                    .visit_any(Value { inner: value })
+                    .map_err(Error::into_value)
+            }
+
+            fn visit_u64(&mut self, value: u64) -> Result<(), value_bag::Error> {
+                self.0.visit_u64(value).map_err(Error::into_value)
+            }
+
+            fn visit_i64(&mut self, value: i64) -> Result<(), value_bag::Error> {
+                self.0.visit_i64(value).map_err(Error::into_value)
+            }
+
+            fn visit_u128(&mut self, value: u128) -> Result<(), value_bag::Error> {
+                self.0.visit_u128(value).map_err(Error::into_value)
+            }
+
+            fn visit_i128(&mut self, value: i128) -> Result<(), value_bag::Error> {
+                self.0.visit_i128(value).map_err(Error::into_value)
+            }
+
+            fn visit_f64(&mut self, value: f64) -> Result<(), value_bag::Error> {
+                self.0.visit_f64(value).map_err(Error::into_value)
+            }
+
+            fn visit_bool(&mut self, value: bool) -> Result<(), value_bag::Error> {
+                self.0.visit_bool(value).map_err(Error::into_value)
+            }
+
+            fn visit_str(&mut self, value: &str) -> Result<(), value_bag::Error> {
+                self.0.visit_str(value).map_err(Error::into_value)
+            }
+
+            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), value_bag::Error> {
+                self.0.visit_borrowed_str(value).map_err(Error::into_value)
+            }
+
+            fn visit_char(&mut self, value: char) -> Result<(), value_bag::Error> {
+                self.0.visit_char(value).map_err(Error::into_value)
+            }
+
+            #[cfg(feature = "kv_unstable_std")]
+            fn visit_error(
+                &mut self,
+                err: &(dyn std::error::Error + 'static),
+            ) -> Result<(), value_bag::Error> {
+                self.0.visit_error(err).map_err(Error::into_value)
+            }
+
+            #[cfg(feature = "kv_unstable_std")]
+            fn visit_borrowed_error(
+                &mut self,
+                err: &'v (dyn std::error::Error + 'static),
+            ) -> Result<(), value_bag::Error> {
+                self.0.visit_borrowed_error(err).map_err(Error::into_value)
+            }
+        }
+
+        self.inner
+            .visit(&mut Visitor(visitor))
+            .map_err(Error::from_value)
+    }
+}
+
+impl<'v> fmt::Debug for Value<'v> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&self.inner, f)
+    }
+}
+
+impl<'v> fmt::Display for Value<'v> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.inner, f)
+    }
+}
+
+impl ToValue for dyn fmt::Debug {
+    fn to_value(&self) -> Value {
+        Value::from_dyn_debug(self)
+    }
+}
+
+impl ToValue for dyn fmt::Display {
+    fn to_value(&self) -> Value {
+        Value::from_dyn_display(self)
+    }
+}
+
+#[cfg(feature = "kv_unstable_std")]
+impl ToValue for dyn std::error::Error + 'static {
+    fn to_value(&self) -> Value {
+        Value::from_dyn_error(self)
+    }
+}
+
+#[cfg(feature = "kv_unstable_serde")]
+impl<'v> self::serde::Serialize for Value<'v> {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: self::serde::Serializer,
+    {
+        self.inner.serialize(s)
+    }
+}
+
+#[cfg(feature = "kv_unstable_sval")]
+impl<'v> self::sval::value::Value for Value<'v> {
+    fn stream(&self, stream: &mut self::sval::value::Stream) -> self::sval::value::Result {
+        self::sval::value::Value::stream(&self.inner, stream)
+    }
+}
+
+#[cfg(feature = "kv_unstable_sval")]
+impl ToValue for dyn self::sval::value::Value {
+    fn to_value(&self) -> Value {
+        Value::from_dyn_sval(self)
+    }
+}
+
+impl ToValue for str {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl ToValue for u128 {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl ToValue for i128 {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl ToValue for std::num::NonZeroU128 {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl ToValue for std::num::NonZeroI128 {
+    fn to_value(&self) -> Value {
+        Value::from(self)
+    }
+}
+
+impl<'v> From<&'v str> for Value<'v> {
+    fn from(value: &'v str) -> Self {
+        Value::from_value_bag(value)
+    }
+}
+
+impl<'v> From<&'v u128> for Value<'v> {
+    fn from(value: &'v u128) -> Self {
+        Value::from_value_bag(value)
+    }
+}
+
+impl<'v> From<&'v i128> for Value<'v> {
+    fn from(value: &'v i128) -> Self {
+        Value::from_value_bag(value)
+    }
+}
+
+impl<'v> From<&'v std::num::NonZeroU128> for Value<'v> {
+    fn from(v: &'v std::num::NonZeroU128) -> Value<'v> {
+        // SAFETY: `NonZeroU128` and `u128` have the same ABI
+        Value::from_value_bag(unsafe { std::mem::transmute::<&std::num::NonZeroU128, &u128>(v) })
+    }
+}
+
+impl<'v> From<&'v std::num::NonZeroI128> for Value<'v> {
+    fn from(v: &'v std::num::NonZeroI128) -> Value<'v> {
+        // SAFETY: `NonZeroI128` and `i128` have the same ABI
+        Value::from_value_bag(unsafe { std::mem::transmute::<&std::num::NonZeroI128, &i128>(v) })
+    }
+}
+
+impl ToValue for () {
+    fn to_value(&self) -> Value {
+        Value::from_value_bag(())
+    }
+}
+
+impl<T> ToValue for Option<T>
+where
+    T: ToValue,
+{
+    fn to_value(&self) -> Value {
+        match *self {
+            Some(ref value) => value.to_value(),
+            None => Value::from_value_bag(()),
+        }
+    }
+}
+
+macro_rules! impl_to_value_primitive {
+    ($($into_ty:ty,)*) => {
+        $(
+            impl ToValue for $into_ty {
+                fn to_value(&self) -> Value {
+                    Value::from(*self)
+                }
+            }
+
+            impl<'v> From<$into_ty> for Value<'v> {
+                fn from(value: $into_ty) -> Self {
+                    Value::from_value_bag(value)
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! impl_to_value_nonzero_primitive {
+    ($($into_ty:ident,)*) => {
+        $(
+            impl ToValue for std::num::$into_ty {
+                fn to_value(&self) -> Value {
+                    Value::from(self.get())
+                }
+            }
+
+            impl<'v> From<std::num::$into_ty> for Value<'v> {
+                fn from(value: std::num::$into_ty) -> Self {
+                    Value::from(value.get())
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! impl_value_to_primitive {
+    ($(#[doc = $doc:tt] $into_name:ident -> $into_ty:ty,)*) => {
+        impl<'v> Value<'v> {
+            $(
+                #[doc = $doc]
+                pub fn $into_name(&self) -> Option<$into_ty> {
+                    self.inner.$into_name()
+                }
+            )*
+        }
+    }
+}
+
+impl_to_value_primitive![usize, u8, u16, u32, u64, isize, i8, i16, i32, i64, f32, f64, char, bool,];
+
+#[rustfmt::skip]
+impl_to_value_nonzero_primitive![
+    NonZeroUsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64,
+    NonZeroIsize, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64,
+];
+
+impl_value_to_primitive![
+    #[doc = "Try convert this value into a `u64`."]
+    to_u64 -> u64,
+    #[doc = "Try convert this value into a `i64`."]
+    to_i64 -> i64,
+    #[doc = "Try convert this value into a `u128`."]
+    to_u128 -> u128,
+    #[doc = "Try convert this value into a `i128`."]
+    to_i128 -> i128,
+    #[doc = "Try convert this value into a `f64`."]
+    to_f64 -> f64,
+    #[doc = "Try convert this value into a `char`."]
+    to_char -> char,
+    #[doc = "Try convert this value into a `bool`."]
+    to_bool -> bool,
+];
+
+impl<'v> Value<'v> {
+    /// Try convert this value into an error.
+    #[cfg(feature = "kv_unstable_std")]
+    pub fn to_borrowed_error(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        self.inner.to_borrowed_error()
+    }
+
+    /// Try convert this value into a borrowed string.
+    pub fn to_borrowed_str(&self) -> Option<&str> {
+        self.inner.to_borrowed_str()
+    }
+}
+
+#[cfg(feature = "kv_unstable_std")]
+mod std_support {
+    use super::*;
+
+    use std::borrow::Cow;
+
+    impl<T> ToValue for Box<T>
+    where
+        T: ToValue + ?Sized,
+    {
+        fn to_value(&self) -> Value {
+            (**self).to_value()
+        }
+    }
+
+    impl ToValue for String {
+        fn to_value(&self) -> Value {
+            Value::from(&**self)
+        }
+    }
+
+    impl<'v> ToValue for Cow<'v, str> {
+        fn to_value(&self) -> Value {
+            Value::from(&**self)
+        }
+    }
+
+    impl<'v> Value<'v> {
+        /// Try convert this value into a string.
+        pub fn to_str(&self) -> Option<Cow<str>> {
+            self.inner.to_str()
+        }
+    }
+
+    impl<'v> From<&'v String> for Value<'v> {
+        fn from(v: &'v String) -> Self {
+            Value::from(&**v)
+        }
+    }
+}
+
+/// A visitor for a `Value`.
+pub trait Visit<'v> {
+    /// Visit a `Value`.
+    ///
+    /// This is the only required method on `Visit` and acts as a fallback for any
+    /// more specific methods that aren't overridden.
+    /// The `Value` may be formatted using its `fmt::Debug` or `fmt::Display` implementation,
+    /// or serialized using its `sval::Value` or `serde::Serialize` implementation.
+    fn visit_any(&mut self, value: Value) -> Result<(), Error>;
+
+    /// Visit an unsigned integer.
+    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a signed integer.
+    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a big unsigned integer.
+    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
+        self.visit_any((&value).into())
+    }
+
+    /// Visit a big signed integer.
+    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
+        self.visit_any((&value).into())
+    }
+
+    /// Visit a floating point.
+    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a boolean.
+    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a string.
+    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
+        self.visit_any(value.into())
+    }
+
+    /// Visit a string.
+    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
+        self.visit_str(value)
+    }
+
+    /// Visit a Unicode character.
+    fn visit_char(&mut self, value: char) -> Result<(), Error> {
+        let mut b = [0; 4];
+        self.visit_str(&*value.encode_utf8(&mut b))
+    }
+
+    /// Visit an error.
+    #[cfg(feature = "kv_unstable_std")]
+    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
+        self.visit_any(Value::from_dyn_error(err))
+    }
+
+    /// Visit an error.
+    #[cfg(feature = "kv_unstable_std")]
+    fn visit_borrowed_error(
+        &mut self,
+        err: &'v (dyn std::error::Error + 'static),
+    ) -> Result<(), Error> {
+        self.visit_any(Value::from_dyn_error(err))
+    }
+}
+
+impl<'a, 'v, T: ?Sized> Visit<'v> for &'a mut T
+where
+    T: Visit<'v>,
+{
+    fn visit_any(&mut self, value: Value) -> Result<(), Error> {
+        (**self).visit_any(value)
+    }
+
+    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
+        (**self).visit_u64(value)
+    }
+
+    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
+        (**self).visit_i64(value)
+    }
+
+    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
+        (**self).visit_u128(value)
+    }
+
+    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
+        (**self).visit_i128(value)
+    }
+
+    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
+        (**self).visit_f64(value)
+    }
+
+    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
+        (**self).visit_bool(value)
+    }
+
+    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
+        (**self).visit_str(value)
+    }
+
+    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
+        (**self).visit_borrowed_str(value)
+    }
+
+    fn visit_char(&mut self, value: char) -> Result<(), Error> {
+        (**self).visit_char(value)
+    }
+
+    #[cfg(feature = "kv_unstable_std")]
+    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
+        (**self).visit_error(err)
+    }
+
+    #[cfg(feature = "kv_unstable_std")]
+    fn visit_borrowed_error(
+        &mut self,
+        err: &'v (dyn std::error::Error + 'static),
+    ) -> Result<(), Error> {
+        (**self).visit_borrowed_error(err)
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    pub(crate) use super::value_bag::test::Token;
+
+    impl<'v> Value<'v> {
+        pub(crate) fn to_token(&self) -> Token {
+            self.inner.to_token()
+        }
+    }
+
+    fn unsigned() -> impl Iterator<Item = Value<'static>> {
+        vec![
+            Value::from(8u8),
+            Value::from(16u16),
+            Value::from(32u32),
+            Value::from(64u64),
+            Value::from(1usize),
+            Value::from(std::num::NonZeroU8::new(8).unwrap()),
+            Value::from(std::num::NonZeroU16::new(16).unwrap()),
+            Value::from(std::num::NonZeroU32::new(32).unwrap()),
+            Value::from(std::num::NonZeroU64::new(64).unwrap()),
+            Value::from(std::num::NonZeroUsize::new(1).unwrap()),
+        ]
+        .into_iter()
+    }
+
+    fn signed() -> impl Iterator<Item = Value<'static>> {
+        vec![
+            Value::from(-8i8),
+            Value::from(-16i16),
+            Value::from(-32i32),
+            Value::from(-64i64),
+            Value::from(-1isize),
+            Value::from(std::num::NonZeroI8::new(-8).unwrap()),
+            Value::from(std::num::NonZeroI16::new(-16).unwrap()),
+            Value::from(std::num::NonZeroI32::new(-32).unwrap()),
+            Value::from(std::num::NonZeroI64::new(-64).unwrap()),
+            Value::from(std::num::NonZeroIsize::new(-1).unwrap()),
+        ]
+        .into_iter()
+    }
+
+    fn float() -> impl Iterator<Item = Value<'static>> {
+        vec![Value::from(32.32f32), Value::from(64.64f64)].into_iter()
+    }
+
+    fn bool() -> impl Iterator<Item = Value<'static>> {
+        vec![Value::from(true), Value::from(false)].into_iter()
+    }
+
+    fn str() -> impl Iterator<Item = Value<'static>> {
+        vec![Value::from("a string"), Value::from("a loong string")].into_iter()
+    }
+
+    fn char() -> impl Iterator<Item = Value<'static>> {
+        vec![Value::from('a'), Value::from('⛰')].into_iter()
+    }
+
+    #[test]
+    fn test_capture_fmt() {
+        assert_eq!(Some(42u64), Value::capture_display(&42).to_u64());
+        assert_eq!(Some(42u64), Value::capture_debug(&42).to_u64());
+
+        assert!(Value::from_display(&42).to_u64().is_none());
+        assert!(Value::from_debug(&42).to_u64().is_none());
+    }
+
+    #[cfg(feature = "kv_unstable_std")]
+    #[test]
+    fn test_capture_error() {
+        let err = std::io::Error::from(std::io::ErrorKind::Other);
+
+        assert!(Value::capture_error(&err).to_borrowed_error().is_some());
+        assert!(Value::from_dyn_error(&err).to_borrowed_error().is_some());
+    }
+
+    #[cfg(feature = "kv_unstable_serde")]
+    #[test]
+    fn test_capture_serde() {
+        assert_eq!(Some(42u64), Value::capture_serde(&42).to_u64());
+
+        assert_eq!(Some(42u64), Value::from_serde(&42).to_u64());
+    }
+
+    #[cfg(feature = "kv_unstable_sval")]
+    #[test]
+    fn test_capture_sval() {
+        assert_eq!(Some(42u64), Value::capture_sval(&42).to_u64());
+
+        assert_eq!(Some(42u64), Value::from_sval(&42).to_u64());
+    }
+
+    #[test]
+    fn test_to_value_display() {
+        assert_eq!(42u64.to_value().to_string(), "42");
+        assert_eq!(42i64.to_value().to_string(), "42");
+        assert_eq!(42.01f64.to_value().to_string(), "42.01");
+        assert_eq!(true.to_value().to_string(), "true");
+        assert_eq!('a'.to_value().to_string(), "a");
+        assert_eq!("a loong string".to_value().to_string(), "a loong string");
+        assert_eq!(Some(true).to_value().to_string(), "true");
+        assert_eq!(().to_value().to_string(), "None");
+        assert_eq!(Option::None::<bool>.to_value().to_string(), "None");
+    }
+
+    #[test]
+    fn test_to_value_structured() {
+        assert_eq!(42u64.to_value().to_token(), Token::U64(42));
+        assert_eq!(42i64.to_value().to_token(), Token::I64(42));
+        assert_eq!(42.01f64.to_value().to_token(), Token::F64(42.01));
+        assert_eq!(true.to_value().to_token(), Token::Bool(true));
+        assert_eq!('a'.to_value().to_token(), Token::Char('a'));
+        assert_eq!(
+            "a loong string".to_value().to_token(),
+            Token::Str("a loong string".into())
+        );
+        assert_eq!(Some(true).to_value().to_token(), Token::Bool(true));
+        assert_eq!(().to_value().to_token(), Token::None);
+        assert_eq!(Option::None::<bool>.to_value().to_token(), Token::None);
+    }
+
+    #[test]
+    fn test_to_number() {
+        for v in unsigned() {
+            assert!(v.to_u64().is_some());
+            assert!(v.to_i64().is_some());
+        }
+
+        for v in signed() {
+            assert!(v.to_i64().is_some());
+        }
+
+        for v in unsigned().chain(signed()).chain(float()) {
+            assert!(v.to_f64().is_some());
+        }
+
+        for v in bool().chain(str()).chain(char()) {
+            assert!(v.to_u64().is_none());
+            assert!(v.to_i64().is_none());
+            assert!(v.to_f64().is_none());
+        }
+    }
+
+    #[test]
+    fn test_to_str() {
+        for v in str() {
+            assert!(v.to_borrowed_str().is_some());
+
+            #[cfg(feature = "kv_unstable_std")]
+            assert!(v.to_str().is_some());
+        }
+
+        let short_lived = String::from("short lived");
+        let v = Value::from(&*short_lived);
+
+        assert!(v.to_borrowed_str().is_some());
+
+        #[cfg(feature = "kv_unstable_std")]
+        assert!(v.to_str().is_some());
+
+        for v in unsigned().chain(signed()).chain(float()).chain(bool()) {
+            assert!(v.to_borrowed_str().is_none());
+
+            #[cfg(feature = "kv_unstable_std")]
+            assert!(v.to_str().is_none());
+        }
+    }
+
+    #[test]
+    fn test_to_bool() {
+        for v in bool() {
+            assert!(v.to_bool().is_some());
+        }
+
+        for v in unsigned()
+            .chain(signed())
+            .chain(float())
+            .chain(str())
+            .chain(char())
+        {
+            assert!(v.to_bool().is_none());
+        }
+    }
+
+    #[test]
+    fn test_to_char() {
+        for v in char() {
+            assert!(v.to_char().is_some());
+        }
+
+        for v in unsigned()
+            .chain(signed())
+            .chain(float())
+            .chain(str())
+            .chain(bool())
+        {
+            assert!(v.to_char().is_none());
+        }
+    }
+
+    #[test]
+    fn test_downcast_ref() {
+        #[derive(Debug)]
+        struct Foo(u64);
+
+        let v = Value::capture_debug(&Foo(42));
+
+        assert!(v.is::<Foo>());
+        assert_eq!(42u64, v.downcast_ref::<Foo>().expect("invalid downcast").0);
+    }
+
+    #[test]
+    fn test_visit_integer() {
+        struct Extract(Option<u64>);
+
+        impl<'v> Visit<'v> for Extract {
+            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
+                unimplemented!("unexpected value: {:?}", value)
+            }
+
+            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
+                self.0 = Some(value);
+
+                Ok(())
+            }
+        }
+
+        let mut extract = Extract(None);
+        Value::from(42u64).visit(&mut extract).unwrap();
+
+        assert_eq!(Some(42), extract.0);
+    }
+
+    #[test]
+    fn test_visit_borrowed_str() {
+        struct Extract<'v>(Option<&'v str>);
+
+        impl<'v> Visit<'v> for Extract<'v> {
+            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
+                unimplemented!("unexpected value: {:?}", value)
+            }
+
+            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
+                self.0 = Some(value);
+
+                Ok(())
+            }
+        }
+
+        let mut extract = Extract(None);
+
+        let short_lived = String::from("A short-lived string");
+        Value::from(&*short_lived).visit(&mut extract).unwrap();
+
+        assert_eq!(Some("A short-lived string"), extract.0);
+    }
+}

zeroidc/vendor/log/src/lib.rs

@@ -1,1971 +1,1971 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A lightweight logging facade.
-//!
-//! The `log` crate provides a single logging API that abstracts over the
-//! actual logging implementation. Libraries can use the logging API provided
-//! by this crate, and the consumer of those libraries can choose the logging
-//! implementation that is most suitable for its use case.
-//!
-//! If no logging implementation is selected, the facade falls back to a "noop"
-//! implementation that ignores all log messages. The overhead in this case
-//! is very small - just an integer load, comparison and jump.
-//!
-//! A log request consists of a _target_, a _level_, and a _body_. A target is a
-//! string which defaults to the module path of the location of the log request,
-//! though that default may be overridden. Logger implementations typically use
-//! the target to filter requests based on some user configuration.
-//!
-//! # Usage
-//!
-//! The basic use of the log crate is through the five logging macros: [`error!`],
-//! [`warn!`], [`info!`], [`debug!`] and [`trace!`]
-//! where `error!` represents the highest-priority log messages
-//! and `trace!` the lowest. The log messages are filtered by configuring
-//! the log level to exclude messages with a lower priority.
-//! Each of these macros accept format strings similarly to [`println!`].
-//!
-//!
-//! [`error!`]: ./macro.error.html
-//! [`warn!`]: ./macro.warn.html
-//! [`info!`]: ./macro.info.html
-//! [`debug!`]: ./macro.debug.html
-//! [`trace!`]: ./macro.trace.html
-//! [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.html
-//!
-//! ## In libraries
-//!
-//! Libraries should link only to the `log` crate, and use the provided
-//! macros to log whatever information will be useful to downstream consumers.
-//!
-//! ### Examples
-//!
-//! ```edition2018
-//! # #[derive(Debug)] pub struct Yak(String);
-//! # impl Yak { fn shave(&mut self, _: u32) {} }
-//! # fn find_a_razor() -> Result<u32, u32> { Ok(1) }
-//! use log::{info, warn};
-//!
-//! pub fn shave_the_yak(yak: &mut Yak) {
-//!     info!(target: "yak_events", "Commencing yak shaving for {:?}", yak);
-//!
-//!     loop {
-//!         match find_a_razor() {
-//!             Ok(razor) => {
-//!                 info!("Razor located: {}", razor);
-//!                 yak.shave(razor);
-//!                 break;
-//!             }
-//!             Err(err) => {
-//!                 warn!("Unable to locate a razor: {}, retrying", err);
-//!             }
-//!         }
-//!     }
-//! }
-//! # fn main() {}
-//! ```
-//!
-//! ## In executables
-//!
-//! Executables should choose a logging implementation and initialize it early in the
-//! runtime of the program. Logging implementations will typically include a
-//! function to do this. Any log messages generated before
-//! the implementation is initialized will be ignored.
-//!
-//! The executable itself may use the `log` crate to log as well.
-//!
-//! ### Warning
-//!
-//! The logging system may only be initialized once.
-//!
-//! ## Structured logging
-//!
-//! If you enable the `kv_unstable` feature you can associate structured values
-//! with your log records. If we take the example from before, we can include
-//! some additional context besides what's in the formatted message:
-//!
-//! ```edition2018
-//! # #[macro_use] extern crate serde;
-//! # #[derive(Debug, Serialize)] pub struct Yak(String);
-//! # impl Yak { fn shave(&mut self, _: u32) {} }
-//! # fn find_a_razor() -> Result<u32, std::io::Error> { Ok(1) }
-//! # #[cfg(feature = "kv_unstable_serde")]
-//! # fn main() {
-//! use log::{info, warn, as_serde, as_error};
-//!
-//! pub fn shave_the_yak(yak: &mut Yak) {
-//!     info!(target: "yak_events", yak = as_serde!(yak); "Commencing yak shaving");
-//!
-//!     loop {
-//!         match find_a_razor() {
-//!             Ok(razor) => {
-//!                 info!(razor = razor; "Razor located");
-//!                 yak.shave(razor);
-//!                 break;
-//!             }
-//!             Err(err) => {
-//!                 warn!(err = as_error!(err); "Unable to locate a razor, retrying");
-//!             }
-//!         }
-//!     }
-//! }
-//! # }
-//! # #[cfg(not(feature = "kv_unstable_serde"))]
-//! # fn main() {}
-//! ```
-//!
-//! # Available logging implementations
-//!
-//! In order to produce log output executables have to use
-//! a logger implementation compatible with the facade.
-//! There are many available implementations to choose from,
-//! here are some of the most popular ones:
-//!
-//! * Simple minimal loggers:
-//!     * [env_logger]
-//!     * [simple_logger]
-//!     * [simplelog]
-//!     * [pretty_env_logger]
-//!     * [stderrlog]
-//!     * [flexi_logger]
-//! * Complex configurable frameworks:
-//!     * [log4rs]
-//!     * [fern]
-//! * Adaptors for other facilities:
-//!     * [syslog]
-//!     * [slog-stdlog]
-//!     * [systemd-journal-logger]
-//!     * [android_log]
-//!     * [win_dbg_logger]
-//!     * [db_logger]
-//! * For WebAssembly binaries:
-//!     * [console_log]
-//! * For dynamic libraries:
-//!     * You may need to construct an FFI-safe wrapper over `log` to initialize in your libraries
-//!
-//! # Implementing a Logger
-//!
-//! Loggers implement the [`Log`] trait. Here's a very basic example that simply
-//! logs all messages at the [`Error`][level_link], [`Warn`][level_link] or
-//! [`Info`][level_link] levels to stdout:
-//!
-//! ```edition2018
-//! use log::{Record, Level, Metadata};
-//!
-//! struct SimpleLogger;
-//!
-//! impl log::Log for SimpleLogger {
-//!     fn enabled(&self, metadata: &Metadata) -> bool {
-//!         metadata.level() <= Level::Info
-//!     }
-//!
-//!     fn log(&self, record: &Record) {
-//!         if self.enabled(record.metadata()) {
-//!             println!("{} - {}", record.level(), record.args());
-//!         }
-//!     }
-//!
-//!     fn flush(&self) {}
-//! }
-//!
-//! # fn main() {}
-//! ```
-//!
-//! Loggers are installed by calling the [`set_logger`] function. The maximum
-//! log level also needs to be adjusted via the [`set_max_level`] function. The
-//! logging facade uses this as an optimization to improve performance of log
-//! messages at levels that are disabled. It's important to set it, as it
-//! defaults to [`Off`][filter_link], so no log messages will ever be captured!
-//! In the case of our example logger, we'll want to set the maximum log level
-//! to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or
-//! [`Trace`][level_link] level log messages. A logging implementation should
-//! provide a function that wraps a call to [`set_logger`] and
-//! [`set_max_level`], handling initialization of the logger:
-//!
-//! ```edition2018
-//! # use log::{Level, Metadata};
-//! # struct SimpleLogger;
-//! # impl log::Log for SimpleLogger {
-//! #   fn enabled(&self, _: &Metadata) -> bool { false }
-//! #   fn log(&self, _: &log::Record) {}
-//! #   fn flush(&self) {}
-//! # }
-//! # fn main() {}
-//! use log::{SetLoggerError, LevelFilter};
-//!
-//! static LOGGER: SimpleLogger = SimpleLogger;
-//!
-//! pub fn init() -> Result<(), SetLoggerError> {
-//!     log::set_logger(&LOGGER)
-//!         .map(|()| log::set_max_level(LevelFilter::Info))
-//! }
-//! ```
-//!
-//! Implementations that adjust their configurations at runtime should take care
-//! to adjust the maximum log level as well.
-//!
-//! # Use with `std`
-//!
-//! `set_logger` requires you to provide a `&'static Log`, which can be hard to
-//! obtain if your logger depends on some runtime configuration. The
-//! `set_boxed_logger` function is available with the `std` Cargo feature. It is
-//! identical to `set_logger` except that it takes a `Box<Log>` rather than a
-//! `&'static Log`:
-//!
-//! ```edition2018
-//! # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};
-//! # struct SimpleLogger;
-//! # impl log::Log for SimpleLogger {
-//! #   fn enabled(&self, _: &Metadata) -> bool { false }
-//! #   fn log(&self, _: &log::Record) {}
-//! #   fn flush(&self) {}
-//! # }
-//! # fn main() {}
-//! # #[cfg(feature = "std")]
-//! pub fn init() -> Result<(), SetLoggerError> {
-//!     log::set_boxed_logger(Box::new(SimpleLogger))
-//!         .map(|()| log::set_max_level(LevelFilter::Info))
-//! }
-//! ```
-//!
-//! # Compile time filters
-//!
-//! Log levels can be statically disabled at compile time via Cargo features. Log invocations at
-//! disabled levels will be skipped and will not even be present in the resulting binary.
-//! This level is configured separately for release and debug builds. The features are:
-//!
-//! * `max_level_off`
-//! * `max_level_error`
-//! * `max_level_warn`
-//! * `max_level_info`
-//! * `max_level_debug`
-//! * `max_level_trace`
-//! * `release_max_level_off`
-//! * `release_max_level_error`
-//! * `release_max_level_warn`
-//! * `release_max_level_info`
-//! * `release_max_level_debug`
-//! * `release_max_level_trace`
-//!
-//! These features control the value of the `STATIC_MAX_LEVEL` constant. The logging macros check
-//! this value before logging a message. By default, no levels are disabled.
-//!
-//! Libraries should avoid using the max level features because they're global and can't be changed
-//! once they're set.
-//!
-//! For example, a crate can disable trace level logs in debug builds and trace, debug, and info
-//! level logs in release builds with the following configuration:
-//!
-//! ```toml
-//! [dependencies]
-//! log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }
-//! ```
-//! # Crate Feature Flags
-//!
-//! The following crate feature flags are available in addition to the filters. They are
-//! configured in your `Cargo.toml`.
-//!
-//! * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and
-//! `set_boxed_logger` functionality.
-//! * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.
-//!
-//! ```toml
-//! [dependencies]
-//! log = { version = "0.4", features = ["std", "serde"] }
-//! ```
-//!
-//! # Version compatibility
-//!
-//! The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messages
-//! made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. Log
-//! messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but the
-//! module path and file name information associated with the message will unfortunately be lost.
-//!
-//! [`Log`]: trait.Log.html
-//! [level_link]: enum.Level.html
-//! [filter_link]: enum.LevelFilter.html
-//! [`set_logger`]: fn.set_logger.html
-//! [`set_max_level`]: fn.set_max_level.html
-//! [`try_set_logger_raw`]: fn.try_set_logger_raw.html
-//! [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html
-//! [env_logger]: https://docs.rs/env_logger/*/env_logger/
-//! [simple_logger]: https://github.com/borntyping/rust-simple_logger
-//! [simplelog]: https://github.com/drakulix/simplelog.rs
-//! [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger/
-//! [stderrlog]: https://docs.rs/stderrlog/*/stderrlog/
-//! [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger/
-//! [syslog]: https://docs.rs/syslog/*/syslog/
-//! [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog/
-//! [log4rs]: https://docs.rs/log4rs/*/log4rs/
-//! [fern]: https://docs.rs/fern/*/fern/
-//! [systemd-journal-logger]: https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/
-//! [android_log]: https://docs.rs/android_log/*/android_log/
-//! [win_dbg_logger]: https://docs.rs/win_dbg_logger/*/win_dbg_logger/
-//! [console_log]: https://docs.rs/console_log/*/console_log/
-
-#![doc(
-    html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
-    html_favicon_url = "https://www.rust-lang.org/favicon.ico",
-    html_root_url = "https://docs.rs/log/0.4.17"
-)]
-#![warn(missing_docs)]
-#![deny(missing_debug_implementations, unconditional_recursion)]
-#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
-// When compiled for the rustc compiler itself we want to make sure that this is
-// an unstable crate
-#![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
-#![cfg_attr(rustbuild, unstable(feature = "rustc_private", issue = "27812"))]
-
-#[cfg(all(not(feature = "std"), not(test)))]
-extern crate core as std;
-
-#[macro_use]
-extern crate cfg_if;
-
-use std::cmp;
-#[cfg(feature = "std")]
-use std::error;
-use std::fmt;
-use std::mem;
-use std::str::FromStr;
-
-#[macro_use]
-mod macros;
-mod serde;
-
-#[cfg(feature = "kv_unstable")]
-pub mod kv;
-
-#[cfg(has_atomics)]
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-#[cfg(not(has_atomics))]
-use std::cell::Cell;
-#[cfg(not(has_atomics))]
-use std::sync::atomic::Ordering;
-
-#[cfg(not(has_atomics))]
-struct AtomicUsize {
-    v: Cell<usize>,
-}
-
-#[cfg(not(has_atomics))]
-impl AtomicUsize {
-    const fn new(v: usize) -> AtomicUsize {
-        AtomicUsize { v: Cell::new(v) }
-    }
-
-    fn load(&self, _order: Ordering) -> usize {
-        self.v.get()
-    }
-
-    fn store(&self, val: usize, _order: Ordering) {
-        self.v.set(val)
-    }
-
-    #[cfg(atomic_cas)]
-    fn compare_exchange(
-        &self,
-        current: usize,
-        new: usize,
-        _success: Ordering,
-        _failure: Ordering,
-    ) -> Result<usize, usize> {
-        let prev = self.v.get();
-        if current == prev {
-            self.v.set(new);
-        }
-        Ok(prev)
-    }
-}
-
-// Any platform without atomics is unlikely to have multiple cores, so
-// writing via Cell will not be a race condition.
-#[cfg(not(has_atomics))]
-unsafe impl Sync for AtomicUsize {}
-
-// The LOGGER static holds a pointer to the global logger. It is protected by
-// the STATE static which determines whether LOGGER has been initialized yet.
-static mut LOGGER: &dyn Log = &NopLogger;
-
-static STATE: AtomicUsize = AtomicUsize::new(0);
-
-// There are three different states that we care about: the logger's
-// uninitialized, the logger's initializing (set_logger's been called but
-// LOGGER hasn't actually been set yet), or the logger's active.
-const UNINITIALIZED: usize = 0;
-const INITIALIZING: usize = 1;
-const INITIALIZED: usize = 2;
-
-static MAX_LOG_LEVEL_FILTER: AtomicUsize = AtomicUsize::new(0);
-
-static LOG_LEVEL_NAMES: [&str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"];
-
-static SET_LOGGER_ERROR: &str = "attempted to set a logger after the logging system \
-                                 was already initialized";
-static LEVEL_PARSE_ERROR: &str =
-    "attempted to convert a string that doesn't match an existing log level";
-
-/// An enum representing the available verbosity levels of the logger.
-///
-/// Typical usage includes: checking if a certain `Level` is enabled with
-/// [`log_enabled!`](macro.log_enabled.html), specifying the `Level` of
-/// [`log!`](macro.log.html), and comparing a `Level` directly to a
-/// [`LevelFilter`](enum.LevelFilter.html).
-#[repr(usize)]
-#[derive(Copy, Eq, Debug, Hash)]
-pub enum Level {
-    /// The "error" level.
-    ///
-    /// Designates very serious errors.
-    // This way these line up with the discriminants for LevelFilter below
-    // This works because Rust treats field-less enums the same way as C does:
-    // https://doc.rust-lang.org/reference/items/enumerations.html#custom-discriminant-values-for-field-less-enumerations
-    Error = 1,
-    /// The "warn" level.
-    ///
-    /// Designates hazardous situations.
-    Warn,
-    /// The "info" level.
-    ///
-    /// Designates useful information.
-    Info,
-    /// The "debug" level.
-    ///
-    /// Designates lower priority information.
-    Debug,
-    /// The "trace" level.
-    ///
-    /// Designates very low priority, often extremely verbose, information.
-    Trace,
-}
-
-impl Clone for Level {
-    #[inline]
-    fn clone(&self) -> Level {
-        *self
-    }
-}
-
-impl PartialEq for Level {
-    #[inline]
-    fn eq(&self, other: &Level) -> bool {
-        *self as usize == *other as usize
-    }
-}
-
-impl PartialEq<LevelFilter> for Level {
-    #[inline]
-    fn eq(&self, other: &LevelFilter) -> bool {
-        *self as usize == *other as usize
-    }
-}
-
-impl PartialOrd for Level {
-    #[inline]
-    fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-
-    #[inline]
-    fn lt(&self, other: &Level) -> bool {
-        (*self as usize) < *other as usize
-    }
-
-    #[inline]
-    fn le(&self, other: &Level) -> bool {
-        *self as usize <= *other as usize
-    }
-
-    #[inline]
-    fn gt(&self, other: &Level) -> bool {
-        *self as usize > *other as usize
-    }
-
-    #[inline]
-    fn ge(&self, other: &Level) -> bool {
-        *self as usize >= *other as usize
-    }
-}
-
-impl PartialOrd<LevelFilter> for Level {
-    #[inline]
-    fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
-        Some((*self as usize).cmp(&(*other as usize)))
-    }
-
-    #[inline]
-    fn lt(&self, other: &LevelFilter) -> bool {
-        (*self as usize) < *other as usize
-    }
-
-    #[inline]
-    fn le(&self, other: &LevelFilter) -> bool {
-        *self as usize <= *other as usize
-    }
-
-    #[inline]
-    fn gt(&self, other: &LevelFilter) -> bool {
-        *self as usize > *other as usize
-    }
-
-    #[inline]
-    fn ge(&self, other: &LevelFilter) -> bool {
-        *self as usize >= *other as usize
-    }
-}
-
-impl Ord for Level {
-    #[inline]
-    fn cmp(&self, other: &Level) -> cmp::Ordering {
-        (*self as usize).cmp(&(*other as usize))
-    }
-}
-
-fn ok_or<T, E>(t: Option<T>, e: E) -> Result<T, E> {
-    match t {
-        Some(t) => Ok(t),
-        None => Err(e),
-    }
-}
-
-// Reimplemented here because std::ascii is not available in libcore
-fn eq_ignore_ascii_case(a: &str, b: &str) -> bool {
-    fn to_ascii_uppercase(c: u8) -> u8 {
-        if c >= b'a' && c <= b'z' {
-            c - b'a' + b'A'
-        } else {
-            c
-        }
-    }
-
-    if a.len() == b.len() {
-        a.bytes()
-            .zip(b.bytes())
-            .all(|(a, b)| to_ascii_uppercase(a) == to_ascii_uppercase(b))
-    } else {
-        false
-    }
-}
-
-impl FromStr for Level {
-    type Err = ParseLevelError;
-    fn from_str(level: &str) -> Result<Level, Self::Err> {
-        ok_or(
-            LOG_LEVEL_NAMES
-                .iter()
-                .position(|&name| eq_ignore_ascii_case(name, level))
-                .into_iter()
-                .filter(|&idx| idx != 0)
-                .map(|idx| Level::from_usize(idx).unwrap())
-                .next(),
-            ParseLevelError(()),
-        )
-    }
-}
-
-impl fmt::Display for Level {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.pad(self.as_str())
-    }
-}
-
-impl Level {
-    fn from_usize(u: usize) -> Option<Level> {
-        match u {
-            1 => Some(Level::Error),
-            2 => Some(Level::Warn),
-            3 => Some(Level::Info),
-            4 => Some(Level::Debug),
-            5 => Some(Level::Trace),
-            _ => None,
-        }
-    }
-
-    /// Returns the most verbose logging level.
-    #[inline]
-    pub fn max() -> Level {
-        Level::Trace
-    }
-
-    /// Converts the `Level` to the equivalent `LevelFilter`.
-    #[inline]
-    pub fn to_level_filter(&self) -> LevelFilter {
-        LevelFilter::from_usize(*self as usize).unwrap()
-    }
-
-    /// Returns the string representation of the `Level`.
-    ///
-    /// This returns the same string as the `fmt::Display` implementation.
-    pub fn as_str(&self) -> &'static str {
-        LOG_LEVEL_NAMES[*self as usize]
-    }
-
-    /// Iterate through all supported logging levels.
-    ///
-    /// The order of iteration is from more severe to less severe log messages.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use log::Level;
-    ///
-    /// let mut levels = Level::iter();
-    ///
-    /// assert_eq!(Some(Level::Error), levels.next());
-    /// assert_eq!(Some(Level::Trace), levels.last());
-    /// ```
-    pub fn iter() -> impl Iterator<Item = Self> {
-        (1..6).map(|i| Self::from_usize(i).unwrap())
-    }
-}
-
-/// An enum representing the available verbosity level filters of the logger.
-///
-/// A `LevelFilter` may be compared directly to a [`Level`]. Use this type
-/// to get and set the maximum log level with [`max_level()`] and [`set_max_level`].
-///
-/// [`Level`]: enum.Level.html
-/// [`max_level()`]: fn.max_level.html
-/// [`set_max_level`]: fn.set_max_level.html
-#[repr(usize)]
-#[derive(Copy, Eq, Debug, Hash)]
-pub enum LevelFilter {
-    /// A level lower than all log levels.
-    Off,
-    /// Corresponds to the `Error` log level.
-    Error,
-    /// Corresponds to the `Warn` log level.
-    Warn,
-    /// Corresponds to the `Info` log level.
-    Info,
-    /// Corresponds to the `Debug` log level.
-    Debug,
-    /// Corresponds to the `Trace` log level.
-    Trace,
-}
-
-// Deriving generates terrible impls of these traits
-
-impl Clone for LevelFilter {
-    #[inline]
-    fn clone(&self) -> LevelFilter {
-        *self
-    }
-}
-
-impl PartialEq for LevelFilter {
-    #[inline]
-    fn eq(&self, other: &LevelFilter) -> bool {
-        *self as usize == *other as usize
-    }
-}
-
-impl PartialEq<Level> for LevelFilter {
-    #[inline]
-    fn eq(&self, other: &Level) -> bool {
-        other.eq(self)
-    }
-}
-
-impl PartialOrd for LevelFilter {
-    #[inline]
-    fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-
-    #[inline]
-    fn lt(&self, other: &LevelFilter) -> bool {
-        (*self as usize) < *other as usize
-    }
-
-    #[inline]
-    fn le(&self, other: &LevelFilter) -> bool {
-        *self as usize <= *other as usize
-    }
-
-    #[inline]
-    fn gt(&self, other: &LevelFilter) -> bool {
-        *self as usize > *other as usize
-    }
-
-    #[inline]
-    fn ge(&self, other: &LevelFilter) -> bool {
-        *self as usize >= *other as usize
-    }
-}
-
-impl PartialOrd<Level> for LevelFilter {
-    #[inline]
-    fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
-        Some((*self as usize).cmp(&(*other as usize)))
-    }
-
-    #[inline]
-    fn lt(&self, other: &Level) -> bool {
-        (*self as usize) < *other as usize
-    }
-
-    #[inline]
-    fn le(&self, other: &Level) -> bool {
-        *self as usize <= *other as usize
-    }
-
-    #[inline]
-    fn gt(&self, other: &Level) -> bool {
-        *self as usize > *other as usize
-    }
-
-    #[inline]
-    fn ge(&self, other: &Level) -> bool {
-        *self as usize >= *other as usize
-    }
-}
-
-impl Ord for LevelFilter {
-    #[inline]
-    fn cmp(&self, other: &LevelFilter) -> cmp::Ordering {
-        (*self as usize).cmp(&(*other as usize))
-    }
-}
-
-impl FromStr for LevelFilter {
-    type Err = ParseLevelError;
-    fn from_str(level: &str) -> Result<LevelFilter, Self::Err> {
-        ok_or(
-            LOG_LEVEL_NAMES
-                .iter()
-                .position(|&name| eq_ignore_ascii_case(name, level))
-                .map(|p| LevelFilter::from_usize(p).unwrap()),
-            ParseLevelError(()),
-        )
-    }
-}
-
-impl fmt::Display for LevelFilter {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.pad(self.as_str())
-    }
-}
-
-impl LevelFilter {
-    fn from_usize(u: usize) -> Option<LevelFilter> {
-        match u {
-            0 => Some(LevelFilter::Off),
-            1 => Some(LevelFilter::Error),
-            2 => Some(LevelFilter::Warn),
-            3 => Some(LevelFilter::Info),
-            4 => Some(LevelFilter::Debug),
-            5 => Some(LevelFilter::Trace),
-            _ => None,
-        }
-    }
-
-    /// Returns the most verbose logging level filter.
-    #[inline]
-    pub fn max() -> LevelFilter {
-        LevelFilter::Trace
-    }
-
-    /// Converts `self` to the equivalent `Level`.
-    ///
-    /// Returns `None` if `self` is `LevelFilter::Off`.
-    #[inline]
-    pub fn to_level(&self) -> Option<Level> {
-        Level::from_usize(*self as usize)
-    }
-
-    /// Returns the string representation of the `LevelFilter`.
-    ///
-    /// This returns the same string as the `fmt::Display` implementation.
-    pub fn as_str(&self) -> &'static str {
-        LOG_LEVEL_NAMES[*self as usize]
-    }
-
-    /// Iterate through all supported filtering levels.
-    ///
-    /// The order of iteration is from less to more verbose filtering.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use log::LevelFilter;
-    ///
-    /// let mut levels = LevelFilter::iter();
-    ///
-    /// assert_eq!(Some(LevelFilter::Off), levels.next());
-    /// assert_eq!(Some(LevelFilter::Trace), levels.last());
-    /// ```
-    pub fn iter() -> impl Iterator<Item = Self> {
-        (0..6).map(|i| Self::from_usize(i).unwrap())
-    }
-}
-
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
-enum MaybeStaticStr<'a> {
-    Static(&'static str),
-    Borrowed(&'a str),
-}
-
-impl<'a> MaybeStaticStr<'a> {
-    #[inline]
-    fn get(&self) -> &'a str {
-        match *self {
-            MaybeStaticStr::Static(s) => s,
-            MaybeStaticStr::Borrowed(s) => s,
-        }
-    }
-}
-
-/// The "payload" of a log message.
-///
-/// # Use
-///
-/// `Record` structures are passed as parameters to the [`log`][method.log]
-/// method of the [`Log`] trait. Logger implementors manipulate these
-/// structures in order to display log messages. `Record`s are automatically
-/// created by the [`log!`] macro and so are not seen by log users.
-///
-/// Note that the [`level()`] and [`target()`] accessors are equivalent to
-/// `self.metadata().level()` and `self.metadata().target()` respectively.
-/// These methods are provided as a convenience for users of this structure.
-///
-/// # Example
-///
-/// The following example shows a simple logger that displays the level,
-/// module path, and message of any `Record` that is passed to it.
-///
-/// ```edition2018
-/// struct SimpleLogger;
-///
-/// impl log::Log for SimpleLogger {
-///    fn enabled(&self, metadata: &log::Metadata) -> bool {
-///        true
-///    }
-///
-///    fn log(&self, record: &log::Record) {
-///        if !self.enabled(record.metadata()) {
-///            return;
-///        }
-///
-///        println!("{}:{} -- {}",
-///                 record.level(),
-///                 record.target(),
-///                 record.args());
-///    }
-///    fn flush(&self) {}
-/// }
-/// ```
-///
-/// [method.log]: trait.Log.html#tymethod.log
-/// [`Log`]: trait.Log.html
-/// [`log!`]: macro.log.html
-/// [`level()`]: struct.Record.html#method.level
-/// [`target()`]: struct.Record.html#method.target
-#[derive(Clone, Debug)]
-pub struct Record<'a> {
-    metadata: Metadata<'a>,
-    args: fmt::Arguments<'a>,
-    module_path: Option<MaybeStaticStr<'a>>,
-    file: Option<MaybeStaticStr<'a>>,
-    line: Option<u32>,
-    #[cfg(feature = "kv_unstable")]
-    key_values: KeyValues<'a>,
-}
-
-// This wrapper type is only needed so we can
-// `#[derive(Debug)]` on `Record`. It also
-// provides a useful `Debug` implementation for
-// the underlying `Source`.
-#[cfg(feature = "kv_unstable")]
-#[derive(Clone)]
-struct KeyValues<'a>(&'a dyn kv::Source);
-
-#[cfg(feature = "kv_unstable")]
-impl<'a> fmt::Debug for KeyValues<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut visitor = f.debug_map();
-        self.0.visit(&mut visitor).map_err(|_| fmt::Error)?;
-        visitor.finish()
-    }
-}
-
-impl<'a> Record<'a> {
-    /// Returns a new builder.
-    #[inline]
-    pub fn builder() -> RecordBuilder<'a> {
-        RecordBuilder::new()
-    }
-
-    /// The message body.
-    #[inline]
-    pub fn args(&self) -> &fmt::Arguments<'a> {
-        &self.args
-    }
-
-    /// Metadata about the log directive.
-    #[inline]
-    pub fn metadata(&self) -> &Metadata<'a> {
-        &self.metadata
-    }
-
-    /// The verbosity level of the message.
-    #[inline]
-    pub fn level(&self) -> Level {
-        self.metadata.level()
-    }
-
-    /// The name of the target of the directive.
-    #[inline]
-    pub fn target(&self) -> &'a str {
-        self.metadata.target()
-    }
-
-    /// The module path of the message.
-    #[inline]
-    pub fn module_path(&self) -> Option<&'a str> {
-        self.module_path.map(|s| s.get())
-    }
-
-    /// The module path of the message, if it is a `'static` string.
-    #[inline]
-    pub fn module_path_static(&self) -> Option<&'static str> {
-        match self.module_path {
-            Some(MaybeStaticStr::Static(s)) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// The source file containing the message.
-    #[inline]
-    pub fn file(&self) -> Option<&'a str> {
-        self.file.map(|s| s.get())
-    }
-
-    /// The module path of the message, if it is a `'static` string.
-    #[inline]
-    pub fn file_static(&self) -> Option<&'static str> {
-        match self.file {
-            Some(MaybeStaticStr::Static(s)) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// The line containing the message.
-    #[inline]
-    pub fn line(&self) -> Option<u32> {
-        self.line
-    }
-
-    /// The structured key-value pairs associated with the message.
-    #[cfg(feature = "kv_unstable")]
-    #[inline]
-    pub fn key_values(&self) -> &dyn kv::Source {
-        self.key_values.0
-    }
-
-    /// Create a new [`RecordBuilder`](struct.RecordBuilder.html) based on this record.
-    #[cfg(feature = "kv_unstable")]
-    #[inline]
-    pub fn to_builder(&self) -> RecordBuilder {
-        RecordBuilder {
-            record: Record {
-                metadata: Metadata {
-                    level: self.metadata.level,
-                    target: self.metadata.target,
-                },
-                args: self.args,
-                module_path: self.module_path,
-                file: self.file,
-                line: self.line,
-                key_values: self.key_values.clone(),
-            },
-        }
-    }
-}
-
-/// Builder for [`Record`](struct.Record.html).
-///
-/// Typically should only be used by log library creators or for testing and "shim loggers".
-/// The `RecordBuilder` can set the different parameters of `Record` object, and returns
-/// the created object when `build` is called.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::{Level, Record};
-///
-/// let record = Record::builder()
-///                 .args(format_args!("Error!"))
-///                 .level(Level::Error)
-///                 .target("myApp")
-///                 .file(Some("server.rs"))
-///                 .line(Some(144))
-///                 .module_path(Some("server"))
-///                 .build();
-/// ```
-///
-/// Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):
-///
-/// ```edition2018
-/// use log::{Record, Level, MetadataBuilder};
-///
-/// let error_metadata = MetadataBuilder::new()
-///                         .target("myApp")
-///                         .level(Level::Error)
-///                         .build();
-///
-/// let record = Record::builder()
-///                 .metadata(error_metadata)
-///                 .args(format_args!("Error!"))
-///                 .line(Some(433))
-///                 .file(Some("app.rs"))
-///                 .module_path(Some("server"))
-///                 .build();
-/// ```
-#[derive(Debug)]
-pub struct RecordBuilder<'a> {
-    record: Record<'a>,
-}
-
-impl<'a> RecordBuilder<'a> {
-    /// Construct new `RecordBuilder`.
-    ///
-    /// The default options are:
-    ///
-    /// - `args`: [`format_args!("")`]
-    /// - `metadata`: [`Metadata::builder().build()`]
-    /// - `module_path`: `None`
-    /// - `file`: `None`
-    /// - `line`: `None`
-    ///
-    /// [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.html
-    /// [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.build
-    #[inline]
-    pub fn new() -> RecordBuilder<'a> {
-        RecordBuilder {
-            record: Record {
-                args: format_args!(""),
-                metadata: Metadata::builder().build(),
-                module_path: None,
-                file: None,
-                line: None,
-                #[cfg(feature = "kv_unstable")]
-                key_values: KeyValues(&Option::None::<(kv::Key, kv::Value)>),
-            },
-        }
-    }
-
-    /// Set [`args`](struct.Record.html#method.args).
-    #[inline]
-    pub fn args(&mut self, args: fmt::Arguments<'a>) -> &mut RecordBuilder<'a> {
-        self.record.args = args;
-        self
-    }
-
-    /// Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).
-    #[inline]
-    pub fn metadata(&mut self, metadata: Metadata<'a>) -> &mut RecordBuilder<'a> {
-        self.record.metadata = metadata;
-        self
-    }
-
-    /// Set [`Metadata::level`](struct.Metadata.html#method.level).
-    #[inline]
-    pub fn level(&mut self, level: Level) -> &mut RecordBuilder<'a> {
-        self.record.metadata.level = level;
-        self
-    }
-
-    /// Set [`Metadata::target`](struct.Metadata.html#method.target)
-    #[inline]
-    pub fn target(&mut self, target: &'a str) -> &mut RecordBuilder<'a> {
-        self.record.metadata.target = target;
-        self
-    }
-
-    /// Set [`module_path`](struct.Record.html#method.module_path)
-    #[inline]
-    pub fn module_path(&mut self, path: Option<&'a str>) -> &mut RecordBuilder<'a> {
-        self.record.module_path = path.map(MaybeStaticStr::Borrowed);
-        self
-    }
-
-    /// Set [`module_path`](struct.Record.html#method.module_path) to a `'static` string
-    #[inline]
-    pub fn module_path_static(&mut self, path: Option<&'static str>) -> &mut RecordBuilder<'a> {
-        self.record.module_path = path.map(MaybeStaticStr::Static);
-        self
-    }
-
-    /// Set [`file`](struct.Record.html#method.file)
-    #[inline]
-    pub fn file(&mut self, file: Option<&'a str>) -> &mut RecordBuilder<'a> {
-        self.record.file = file.map(MaybeStaticStr::Borrowed);
-        self
-    }
-
-    /// Set [`file`](struct.Record.html#method.file) to a `'static` string.
-    #[inline]
-    pub fn file_static(&mut self, file: Option<&'static str>) -> &mut RecordBuilder<'a> {
-        self.record.file = file.map(MaybeStaticStr::Static);
-        self
-    }
-
-    /// Set [`line`](struct.Record.html#method.line)
-    #[inline]
-    pub fn line(&mut self, line: Option<u32>) -> &mut RecordBuilder<'a> {
-        self.record.line = line;
-        self
-    }
-
-    /// Set [`key_values`](struct.Record.html#method.key_values)
-    #[cfg(feature = "kv_unstable")]
-    #[inline]
-    pub fn key_values(&mut self, kvs: &'a dyn kv::Source) -> &mut RecordBuilder<'a> {
-        self.record.key_values = KeyValues(kvs);
-        self
-    }
-
-    /// Invoke the builder and return a `Record`
-    #[inline]
-    pub fn build(&self) -> Record<'a> {
-        self.record.clone()
-    }
-}
-
-/// Metadata about a log message.
-///
-/// # Use
-///
-/// `Metadata` structs are created when users of the library use
-/// logging macros.
-///
-/// They are consumed by implementations of the `Log` trait in the
-/// `enabled` method.
-///
-/// `Record`s use `Metadata` to determine the log message's severity
-/// and target.
-///
-/// Users should use the `log_enabled!` macro in their code to avoid
-/// constructing expensive log messages.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::{Record, Level, Metadata};
-///
-/// struct MyLogger;
-///
-/// impl log::Log for MyLogger {
-///     fn enabled(&self, metadata: &Metadata) -> bool {
-///         metadata.level() <= Level::Info
-///     }
-///
-///     fn log(&self, record: &Record) {
-///         if self.enabled(record.metadata()) {
-///             println!("{} - {}", record.level(), record.args());
-///         }
-///     }
-///     fn flush(&self) {}
-/// }
-///
-/// # fn main(){}
-/// ```
-#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
-pub struct Metadata<'a> {
-    level: Level,
-    target: &'a str,
-}
-
-impl<'a> Metadata<'a> {
-    /// Returns a new builder.
-    #[inline]
-    pub fn builder() -> MetadataBuilder<'a> {
-        MetadataBuilder::new()
-    }
-
-    /// The verbosity level of the message.
-    #[inline]
-    pub fn level(&self) -> Level {
-        self.level
-    }
-
-    /// The name of the target of the directive.
-    #[inline]
-    pub fn target(&self) -> &'a str {
-        self.target
-    }
-}
-
-/// Builder for [`Metadata`](struct.Metadata.html).
-///
-/// Typically should only be used by log library creators or for testing and "shim loggers".
-/// The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns
-/// the created object when `build` is called.
-///
-/// # Example
-///
-/// ```edition2018
-/// let target = "myApp";
-/// use log::{Level, MetadataBuilder};
-/// let metadata = MetadataBuilder::new()
-///                     .level(Level::Debug)
-///                     .target(target)
-///                     .build();
-/// ```
-#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
-pub struct MetadataBuilder<'a> {
-    metadata: Metadata<'a>,
-}
-
-impl<'a> MetadataBuilder<'a> {
-    /// Construct a new `MetadataBuilder`.
-    ///
-    /// The default options are:
-    ///
-    /// - `level`: `Level::Info`
-    /// - `target`: `""`
-    #[inline]
-    pub fn new() -> MetadataBuilder<'a> {
-        MetadataBuilder {
-            metadata: Metadata {
-                level: Level::Info,
-                target: "",
-            },
-        }
-    }
-
-    /// Setter for [`level`](struct.Metadata.html#method.level).
-    #[inline]
-    pub fn level(&mut self, arg: Level) -> &mut MetadataBuilder<'a> {
-        self.metadata.level = arg;
-        self
-    }
-
-    /// Setter for [`target`](struct.Metadata.html#method.target).
-    #[inline]
-    pub fn target(&mut self, target: &'a str) -> &mut MetadataBuilder<'a> {
-        self.metadata.target = target;
-        self
-    }
-
-    /// Returns a `Metadata` object.
-    #[inline]
-    pub fn build(&self) -> Metadata<'a> {
-        self.metadata.clone()
-    }
-}
-
-/// A trait encapsulating the operations required of a logger.
-pub trait Log: Sync + Send {
-    /// Determines if a log message with the specified metadata would be
-    /// logged.
-    ///
-    /// This is used by the `log_enabled!` macro to allow callers to avoid
-    /// expensive computation of log message arguments if the message would be
-    /// discarded anyway.
-    ///
-    /// # For implementors
-    ///
-    /// This method isn't called automatically by the `log!` macros.
-    /// It's up to an implementation of the `Log` trait to call `enabled` in its own
-    /// `log` method implementation to guarantee that filtering is applied.
-    fn enabled(&self, metadata: &Metadata) -> bool;
-
-    /// Logs the `Record`.
-    ///
-    /// # For implementors
-    ///
-    /// Note that `enabled` is *not* necessarily called before this method.
-    /// Implementations of `log` should perform all necessary filtering
-    /// internally.
-    fn log(&self, record: &Record);
-
-    /// Flushes any buffered records.
-    fn flush(&self);
-}
-
-// Just used as a dummy initial value for LOGGER
-struct NopLogger;
-
-impl Log for NopLogger {
-    fn enabled(&self, _: &Metadata) -> bool {
-        false
-    }
-
-    fn log(&self, _: &Record) {}
-    fn flush(&self) {}
-}
-
-impl<T> Log for &'_ T
-where
-    T: ?Sized + Log,
-{
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        (**self).enabled(metadata)
-    }
-
-    fn log(&self, record: &Record) {
-        (**self).log(record)
-    }
-    fn flush(&self) {
-        (**self).flush()
-    }
-}
-
-#[cfg(feature = "std")]
-impl<T> Log for std::boxed::Box<T>
-where
-    T: ?Sized + Log,
-{
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        self.as_ref().enabled(metadata)
-    }
-
-    fn log(&self, record: &Record) {
-        self.as_ref().log(record)
-    }
-    fn flush(&self) {
-        self.as_ref().flush()
-    }
-}
-
-#[cfg(feature = "std")]
-impl<T> Log for std::sync::Arc<T>
-where
-    T: ?Sized + Log,
-{
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        self.as_ref().enabled(metadata)
-    }
-
-    fn log(&self, record: &Record) {
-        self.as_ref().log(record)
-    }
-    fn flush(&self) {
-        self.as_ref().flush()
-    }
-}
-
-/// Sets the global maximum log level.
-///
-/// Generally, this should only be called by the active logging implementation.
-///
-/// Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.
-#[inline]
-pub fn set_max_level(level: LevelFilter) {
-    MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::Relaxed)
-}
-
-/// Returns the current maximum log level.
-///
-/// The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros check
-/// this value and discard any message logged at a higher level. The maximum
-/// log level is set by the [`set_max_level`] function.
-///
-/// [`log!`]: macro.log.html
-/// [`error!`]: macro.error.html
-/// [`warn!`]: macro.warn.html
-/// [`info!`]: macro.info.html
-/// [`debug!`]: macro.debug.html
-/// [`trace!`]: macro.trace.html
-/// [`set_max_level`]: fn.set_max_level.html
-#[inline(always)]
-pub fn max_level() -> LevelFilter {
-    // Since `LevelFilter` is `repr(usize)`,
-    // this transmute is sound if and only if `MAX_LOG_LEVEL_FILTER`
-    // is set to a usize that is a valid discriminant for `LevelFilter`.
-    // Since `MAX_LOG_LEVEL_FILTER` is private, the only time it's set
-    // is by `set_max_level` above, i.e. by casting a `LevelFilter` to `usize`.
-    // So any usize stored in `MAX_LOG_LEVEL_FILTER` is a valid discriminant.
-    unsafe { mem::transmute(MAX_LOG_LEVEL_FILTER.load(Ordering::Relaxed)) }
-}
-
-/// Sets the global logger to a `Box<Log>`.
-///
-/// This is a simple convenience wrapper over `set_logger`, which takes a
-/// `Box<Log>` rather than a `&'static Log`. See the documentation for
-/// [`set_logger`] for more details.
-///
-/// Requires the `std` feature.
-///
-/// # Errors
-///
-/// An error is returned if a logger has already been set.
-///
-/// [`set_logger`]: fn.set_logger.html
-#[cfg(all(feature = "std", atomic_cas))]
-pub fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), SetLoggerError> {
-    set_logger_inner(|| Box::leak(logger))
-}
-
-/// Sets the global logger to a `&'static Log`.
-///
-/// This function may only be called once in the lifetime of a program. Any log
-/// events that occur before the call to `set_logger` completes will be ignored.
-///
-/// This function does not typically need to be called manually. Logger
-/// implementations should provide an initialization method that installs the
-/// logger internally.
-///
-/// # Availability
-///
-/// This method is available even when the `std` feature is disabled. However,
-/// it is currently unavailable on `thumbv6` targets, which lack support for
-/// some atomic operations which are used by this function. Even on those
-/// targets, [`set_logger_racy`] will be available.
-///
-/// # Errors
-///
-/// An error is returned if a logger has already been set.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::{error, info, warn, Record, Level, Metadata, LevelFilter};
-///
-/// static MY_LOGGER: MyLogger = MyLogger;
-///
-/// struct MyLogger;
-///
-/// impl log::Log for MyLogger {
-///     fn enabled(&self, metadata: &Metadata) -> bool {
-///         metadata.level() <= Level::Info
-///     }
-///
-///     fn log(&self, record: &Record) {
-///         if self.enabled(record.metadata()) {
-///             println!("{} - {}", record.level(), record.args());
-///         }
-///     }
-///     fn flush(&self) {}
-/// }
-///
-/// # fn main(){
-/// log::set_logger(&MY_LOGGER).unwrap();
-/// log::set_max_level(LevelFilter::Info);
-///
-/// info!("hello log");
-/// warn!("warning");
-/// error!("oops");
-/// # }
-/// ```
-///
-/// [`set_logger_racy`]: fn.set_logger_racy.html
-#[cfg(atomic_cas)]
-pub fn set_logger(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
-    set_logger_inner(|| logger)
-}
-
-#[cfg(atomic_cas)]
-fn set_logger_inner<F>(make_logger: F) -> Result<(), SetLoggerError>
-where
-    F: FnOnce() -> &'static dyn Log,
-{
-    let old_state = match STATE.compare_exchange(
-        UNINITIALIZED,
-        INITIALIZING,
-        Ordering::SeqCst,
-        Ordering::SeqCst,
-    ) {
-        Ok(s) | Err(s) => s,
-    };
-    match old_state {
-        UNINITIALIZED => {
-            unsafe {
-                LOGGER = make_logger();
-            }
-            STATE.store(INITIALIZED, Ordering::SeqCst);
-            Ok(())
-        }
-        INITIALIZING => {
-            while STATE.load(Ordering::SeqCst) == INITIALIZING {
-                // TODO: replace with `hint::spin_loop` once MSRV is 1.49.0.
-                #[allow(deprecated)]
-                std::sync::atomic::spin_loop_hint();
-            }
-            Err(SetLoggerError(()))
-        }
-        _ => Err(SetLoggerError(())),
-    }
-}
-
-/// A thread-unsafe version of [`set_logger`].
-///
-/// This function is available on all platforms, even those that do not have
-/// support for atomics that is needed by [`set_logger`].
-///
-/// In almost all cases, [`set_logger`] should be preferred.
-///
-/// # Safety
-///
-/// This function is only safe to call when no other logger initialization
-/// function is called while this function still executes.
-///
-/// This can be upheld by (for example) making sure that **there are no other
-/// threads**, and (on embedded) that **interrupts are disabled**.
-///
-/// It is safe to use other logging functions while this function runs
-/// (including all logging macros).
-///
-/// [`set_logger`]: fn.set_logger.html
-pub unsafe fn set_logger_racy(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
-    match STATE.load(Ordering::SeqCst) {
-        UNINITIALIZED => {
-            LOGGER = logger;
-            STATE.store(INITIALIZED, Ordering::SeqCst);
-            Ok(())
-        }
-        INITIALIZING => {
-            // This is just plain UB, since we were racing another initialization function
-            unreachable!("set_logger_racy must not be used with other initialization functions")
-        }
-        _ => Err(SetLoggerError(())),
-    }
-}
-
-/// The type returned by [`set_logger`] if [`set_logger`] has already been called.
-///
-/// [`set_logger`]: fn.set_logger.html
-#[allow(missing_copy_implementations)]
-#[derive(Debug)]
-pub struct SetLoggerError(());
-
-impl fmt::Display for SetLoggerError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.write_str(SET_LOGGER_ERROR)
-    }
-}
-
-// The Error trait is not available in libcore
-#[cfg(feature = "std")]
-impl error::Error for SetLoggerError {}
-
-/// The type returned by [`from_str`] when the string doesn't match any of the log levels.
-///
-/// [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_str
-#[allow(missing_copy_implementations)]
-#[derive(Debug, PartialEq)]
-pub struct ParseLevelError(());
-
-impl fmt::Display for ParseLevelError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.write_str(LEVEL_PARSE_ERROR)
-    }
-}
-
-// The Error trait is not available in libcore
-#[cfg(feature = "std")]
-impl error::Error for ParseLevelError {}
-
-/// Returns a reference to the logger.
-///
-/// If a logger has not been set, a no-op implementation is returned.
-pub fn logger() -> &'static dyn Log {
-    if STATE.load(Ordering::SeqCst) != INITIALIZED {
-        static NOP: NopLogger = NopLogger;
-        &NOP
-    } else {
-        unsafe { LOGGER }
-    }
-}
-
-// WARNING: this is not part of the crate's public API and is subject to change at any time
-#[doc(hidden)]
-#[cfg(not(feature = "kv_unstable"))]
-pub fn __private_api_log(
-    args: fmt::Arguments,
-    level: Level,
-    &(target, module_path, file, line): &(&str, &'static str, &'static str, u32),
-    kvs: Option<&[(&str, &str)]>,
-) {
-    if kvs.is_some() {
-        panic!(
-            "key-value support is experimental and must be enabled using the `kv_unstable` feature"
-        )
-    }
-
-    logger().log(
-        &Record::builder()
-            .args(args)
-            .level(level)
-            .target(target)
-            .module_path_static(Some(module_path))
-            .file_static(Some(file))
-            .line(Some(line))
-            .build(),
-    );
-}
-
-// WARNING: this is not part of the crate's public API and is subject to change at any time
-#[doc(hidden)]
-#[cfg(feature = "kv_unstable")]
-pub fn __private_api_log(
-    args: fmt::Arguments,
-    level: Level,
-    &(target, module_path, file, line): &(&str, &'static str, &'static str, u32),
-    kvs: Option<&[(&str, &dyn kv::ToValue)]>,
-) {
-    logger().log(
-        &Record::builder()
-            .args(args)
-            .level(level)
-            .target(target)
-            .module_path_static(Some(module_path))
-            .file_static(Some(file))
-            .line(Some(line))
-            .key_values(&kvs)
-            .build(),
-    );
-}
-
-// WARNING: this is not part of the crate's public API and is subject to change at any time
-#[doc(hidden)]
-pub fn __private_api_enabled(level: Level, target: &str) -> bool {
-    logger().enabled(&Metadata::builder().level(level).target(target).build())
-}
-
-// WARNING: this is not part of the crate's public API and is subject to change at any time
-#[doc(hidden)]
-pub mod __private_api {
-    pub use std::option::Option;
-}
-
-/// The statically resolved maximum log level.
-///
-/// See the crate level documentation for information on how to configure this.
-///
-/// This value is checked by the log macros, but not by the `Log`ger returned by
-/// the [`logger`] function. Code that manually calls functions on that value
-/// should compare the level against this value.
-///
-/// [`logger`]: fn.logger.html
-pub const STATIC_MAX_LEVEL: LevelFilter = MAX_LEVEL_INNER;
-
-cfg_if! {
-    if #[cfg(all(not(debug_assertions), feature = "release_max_level_off"))] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Off;
-    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_error"))] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Error;
-    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_warn"))] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Warn;
-    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_info"))] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Info;
-    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_debug"))] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Debug;
-    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_trace"))] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Trace;
-    } else if #[cfg(feature = "max_level_off")] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Off;
-    } else if #[cfg(feature = "max_level_error")] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Error;
-    } else if #[cfg(feature = "max_level_warn")] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Warn;
-    } else if #[cfg(feature = "max_level_info")] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Info;
-    } else if #[cfg(feature = "max_level_debug")] {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Debug;
-    } else {
-        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Trace;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    extern crate std;
-    use super::{Level, LevelFilter, ParseLevelError};
-    use tests::std::string::ToString;
-
-    #[test]
-    fn test_levelfilter_from_str() {
-        let tests = [
-            ("off", Ok(LevelFilter::Off)),
-            ("error", Ok(LevelFilter::Error)),
-            ("warn", Ok(LevelFilter::Warn)),
-            ("info", Ok(LevelFilter::Info)),
-            ("debug", Ok(LevelFilter::Debug)),
-            ("trace", Ok(LevelFilter::Trace)),
-            ("OFF", Ok(LevelFilter::Off)),
-            ("ERROR", Ok(LevelFilter::Error)),
-            ("WARN", Ok(LevelFilter::Warn)),
-            ("INFO", Ok(LevelFilter::Info)),
-            ("DEBUG", Ok(LevelFilter::Debug)),
-            ("TRACE", Ok(LevelFilter::Trace)),
-            ("asdf", Err(ParseLevelError(()))),
-        ];
-        for &(s, ref expected) in &tests {
-            assert_eq!(expected, &s.parse());
-        }
-    }
-
-    #[test]
-    fn test_level_from_str() {
-        let tests = [
-            ("OFF", Err(ParseLevelError(()))),
-            ("error", Ok(Level::Error)),
-            ("warn", Ok(Level::Warn)),
-            ("info", Ok(Level::Info)),
-            ("debug", Ok(Level::Debug)),
-            ("trace", Ok(Level::Trace)),
-            ("ERROR", Ok(Level::Error)),
-            ("WARN", Ok(Level::Warn)),
-            ("INFO", Ok(Level::Info)),
-            ("DEBUG", Ok(Level::Debug)),
-            ("TRACE", Ok(Level::Trace)),
-            ("asdf", Err(ParseLevelError(()))),
-        ];
-        for &(s, ref expected) in &tests {
-            assert_eq!(expected, &s.parse());
-        }
-    }
-
-    #[test]
-    fn test_level_as_str() {
-        let tests = &[
-            (Level::Error, "ERROR"),
-            (Level::Warn, "WARN"),
-            (Level::Info, "INFO"),
-            (Level::Debug, "DEBUG"),
-            (Level::Trace, "TRACE"),
-        ];
-        for (input, expected) in tests {
-            assert_eq!(*expected, input.as_str());
-        }
-    }
-
-    #[test]
-    fn test_level_show() {
-        assert_eq!("INFO", Level::Info.to_string());
-        assert_eq!("ERROR", Level::Error.to_string());
-    }
-
-    #[test]
-    fn test_levelfilter_show() {
-        assert_eq!("OFF", LevelFilter::Off.to_string());
-        assert_eq!("ERROR", LevelFilter::Error.to_string());
-    }
-
-    #[test]
-    fn test_cross_cmp() {
-        assert!(Level::Debug > LevelFilter::Error);
-        assert!(LevelFilter::Warn < Level::Trace);
-        assert!(LevelFilter::Off < Level::Error);
-    }
-
-    #[test]
-    fn test_cross_eq() {
-        assert!(Level::Error == LevelFilter::Error);
-        assert!(LevelFilter::Off != Level::Error);
-        assert!(Level::Trace == LevelFilter::Trace);
-    }
-
-    #[test]
-    fn test_to_level() {
-        assert_eq!(Some(Level::Error), LevelFilter::Error.to_level());
-        assert_eq!(None, LevelFilter::Off.to_level());
-        assert_eq!(Some(Level::Debug), LevelFilter::Debug.to_level());
-    }
-
-    #[test]
-    fn test_to_level_filter() {
-        assert_eq!(LevelFilter::Error, Level::Error.to_level_filter());
-        assert_eq!(LevelFilter::Trace, Level::Trace.to_level_filter());
-    }
-
-    #[test]
-    fn test_level_filter_as_str() {
-        let tests = &[
-            (LevelFilter::Off, "OFF"),
-            (LevelFilter::Error, "ERROR"),
-            (LevelFilter::Warn, "WARN"),
-            (LevelFilter::Info, "INFO"),
-            (LevelFilter::Debug, "DEBUG"),
-            (LevelFilter::Trace, "TRACE"),
-        ];
-        for (input, expected) in tests {
-            assert_eq!(*expected, input.as_str());
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "std")]
-    fn test_error_trait() {
-        use super::SetLoggerError;
-        let e = SetLoggerError(());
-        assert_eq!(
-            &e.to_string(),
-            "attempted to set a logger after the logging system \
-             was already initialized"
-        );
-    }
-
-    #[test]
-    fn test_metadata_builder() {
-        use super::MetadataBuilder;
-        let target = "myApp";
-        let metadata_test = MetadataBuilder::new()
-            .level(Level::Debug)
-            .target(target)
-            .build();
-        assert_eq!(metadata_test.level(), Level::Debug);
-        assert_eq!(metadata_test.target(), "myApp");
-    }
-
-    #[test]
-    fn test_metadata_convenience_builder() {
-        use super::Metadata;
-        let target = "myApp";
-        let metadata_test = Metadata::builder()
-            .level(Level::Debug)
-            .target(target)
-            .build();
-        assert_eq!(metadata_test.level(), Level::Debug);
-        assert_eq!(metadata_test.target(), "myApp");
-    }
-
-    #[test]
-    fn test_record_builder() {
-        use super::{MetadataBuilder, RecordBuilder};
-        let target = "myApp";
-        let metadata = MetadataBuilder::new().target(target).build();
-        let fmt_args = format_args!("hello");
-        let record_test = RecordBuilder::new()
-            .args(fmt_args)
-            .metadata(metadata)
-            .module_path(Some("foo"))
-            .file(Some("bar"))
-            .line(Some(30))
-            .build();
-        assert_eq!(record_test.metadata().target(), "myApp");
-        assert_eq!(record_test.module_path(), Some("foo"));
-        assert_eq!(record_test.file(), Some("bar"));
-        assert_eq!(record_test.line(), Some(30));
-    }
-
-    #[test]
-    fn test_record_convenience_builder() {
-        use super::{Metadata, Record};
-        let target = "myApp";
-        let metadata = Metadata::builder().target(target).build();
-        let fmt_args = format_args!("hello");
-        let record_test = Record::builder()
-            .args(fmt_args)
-            .metadata(metadata)
-            .module_path(Some("foo"))
-            .file(Some("bar"))
-            .line(Some(30))
-            .build();
-        assert_eq!(record_test.target(), "myApp");
-        assert_eq!(record_test.module_path(), Some("foo"));
-        assert_eq!(record_test.file(), Some("bar"));
-        assert_eq!(record_test.line(), Some(30));
-    }
-
-    #[test]
-    fn test_record_complete_builder() {
-        use super::{Level, Record};
-        let target = "myApp";
-        let record_test = Record::builder()
-            .module_path(Some("foo"))
-            .file(Some("bar"))
-            .line(Some(30))
-            .target(target)
-            .level(Level::Error)
-            .build();
-        assert_eq!(record_test.target(), "myApp");
-        assert_eq!(record_test.level(), Level::Error);
-        assert_eq!(record_test.module_path(), Some("foo"));
-        assert_eq!(record_test.file(), Some("bar"));
-        assert_eq!(record_test.line(), Some(30));
-    }
-
-    #[test]
-    #[cfg(feature = "kv_unstable")]
-    fn test_record_key_values_builder() {
-        use super::Record;
-        use kv::{self, Visitor};
-
-        struct TestVisitor {
-            seen_pairs: usize,
-        }
-
-        impl<'kvs> Visitor<'kvs> for TestVisitor {
-            fn visit_pair(
-                &mut self,
-                _: kv::Key<'kvs>,
-                _: kv::Value<'kvs>,
-            ) -> Result<(), kv::Error> {
-                self.seen_pairs += 1;
-                Ok(())
-            }
-        }
-
-        let kvs: &[(&str, i32)] = &[("a", 1), ("b", 2)];
-        let record_test = Record::builder().key_values(&kvs).build();
-
-        let mut visitor = TestVisitor { seen_pairs: 0 };
-
-        record_test.key_values().visit(&mut visitor).unwrap();
-
-        assert_eq!(2, visitor.seen_pairs);
-    }
-
-    #[test]
-    #[cfg(feature = "kv_unstable")]
-    fn test_record_key_values_get_coerce() {
-        use super::Record;
-
-        let kvs: &[(&str, &str)] = &[("a", "1"), ("b", "2")];
-        let record = Record::builder().key_values(&kvs).build();
-
-        assert_eq!(
-            "2",
-            record
-                .key_values()
-                .get("b".into())
-                .expect("missing key")
-                .to_borrowed_str()
-                .expect("invalid value")
-        );
-    }
-
-    // Test that the `impl Log for Foo` blocks work
-    // This test mostly operates on a type level, so failures will be compile errors
-    #[test]
-    fn test_foreign_impl() {
-        use super::Log;
-        #[cfg(feature = "std")]
-        use std::sync::Arc;
-
-        fn assert_is_log<T: Log + ?Sized>() {}
-
-        assert_is_log::<&dyn Log>();
-
-        #[cfg(feature = "std")]
-        assert_is_log::<Box<dyn Log>>();
-
-        #[cfg(feature = "std")]
-        assert_is_log::<Arc<dyn Log>>();
-
-        // Assert these statements for all T: Log + ?Sized
-        #[allow(unused)]
-        fn forall<T: Log + ?Sized>() {
-            #[cfg(feature = "std")]
-            assert_is_log::<Box<T>>();
-
-            assert_is_log::<&T>();
-
-            #[cfg(feature = "std")]
-            assert_is_log::<Arc<T>>();
-        }
-    }
-}
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A lightweight logging facade.
+//!
+//! The `log` crate provides a single logging API that abstracts over the
+//! actual logging implementation. Libraries can use the logging API provided
+//! by this crate, and the consumer of those libraries can choose the logging
+//! implementation that is most suitable for its use case.
+//!
+//! If no logging implementation is selected, the facade falls back to a "noop"
+//! implementation that ignores all log messages. The overhead in this case
+//! is very small - just an integer load, comparison and jump.
+//!
+//! A log request consists of a _target_, a _level_, and a _body_. A target is a
+//! string which defaults to the module path of the location of the log request,
+//! though that default may be overridden. Logger implementations typically use
+//! the target to filter requests based on some user configuration.
+//!
+//! # Usage
+//!
+//! The basic use of the log crate is through the five logging macros: [`error!`],
+//! [`warn!`], [`info!`], [`debug!`] and [`trace!`]
+//! where `error!` represents the highest-priority log messages
+//! and `trace!` the lowest. The log messages are filtered by configuring
+//! the log level to exclude messages with a lower priority.
+//! Each of these macros accept format strings similarly to [`println!`].
+//!
+//!
+//! [`error!`]: ./macro.error.html
+//! [`warn!`]: ./macro.warn.html
+//! [`info!`]: ./macro.info.html
+//! [`debug!`]: ./macro.debug.html
+//! [`trace!`]: ./macro.trace.html
+//! [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.html
+//!
+//! ## In libraries
+//!
+//! Libraries should link only to the `log` crate, and use the provided
+//! macros to log whatever information will be useful to downstream consumers.
+//!
+//! ### Examples
+//!
+//! ```edition2018
+//! # #[derive(Debug)] pub struct Yak(String);
+//! # impl Yak { fn shave(&mut self, _: u32) {} }
+//! # fn find_a_razor() -> Result<u32, u32> { Ok(1) }
+//! use log::{info, warn};
+//!
+//! pub fn shave_the_yak(yak: &mut Yak) {
+//!     info!(target: "yak_events", "Commencing yak shaving for {:?}", yak);
+//!
+//!     loop {
+//!         match find_a_razor() {
+//!             Ok(razor) => {
+//!                 info!("Razor located: {}", razor);
+//!                 yak.shave(razor);
+//!                 break;
+//!             }
+//!             Err(err) => {
+//!                 warn!("Unable to locate a razor: {}, retrying", err);
+//!             }
+//!         }
+//!     }
+//! }
+//! # fn main() {}
+//! ```
+//!
+//! ## In executables
+//!
+//! Executables should choose a logging implementation and initialize it early in the
+//! runtime of the program. Logging implementations will typically include a
+//! function to do this. Any log messages generated before
+//! the implementation is initialized will be ignored.
+//!
+//! The executable itself may use the `log` crate to log as well.
+//!
+//! ### Warning
+//!
+//! The logging system may only be initialized once.
+//!
+//! ## Structured logging
+//!
+//! If you enable the `kv_unstable` feature you can associate structured values
+//! with your log records. If we take the example from before, we can include
+//! some additional context besides what's in the formatted message:
+//!
+//! ```edition2018
+//! # #[macro_use] extern crate serde;
+//! # #[derive(Debug, Serialize)] pub struct Yak(String);
+//! # impl Yak { fn shave(&mut self, _: u32) {} }
+//! # fn find_a_razor() -> Result<u32, std::io::Error> { Ok(1) }
+//! # #[cfg(feature = "kv_unstable_serde")]
+//! # fn main() {
+//! use log::{info, warn, as_serde, as_error};
+//!
+//! pub fn shave_the_yak(yak: &mut Yak) {
+//!     info!(target: "yak_events", yak = as_serde!(yak); "Commencing yak shaving");
+//!
+//!     loop {
+//!         match find_a_razor() {
+//!             Ok(razor) => {
+//!                 info!(razor = razor; "Razor located");
+//!                 yak.shave(razor);
+//!                 break;
+//!             }
+//!             Err(err) => {
+//!                 warn!(err = as_error!(err); "Unable to locate a razor, retrying");
+//!             }
+//!         }
+//!     }
+//! }
+//! # }
+//! # #[cfg(not(feature = "kv_unstable_serde"))]
+//! # fn main() {}
+//! ```
+//!
+//! # Available logging implementations
+//!
+//! In order to produce log output executables have to use
+//! a logger implementation compatible with the facade.
+//! There are many available implementations to choose from,
+//! here are some of the most popular ones:
+//!
+//! * Simple minimal loggers:
+//!     * [env_logger]
+//!     * [simple_logger]
+//!     * [simplelog]
+//!     * [pretty_env_logger]
+//!     * [stderrlog]
+//!     * [flexi_logger]
+//! * Complex configurable frameworks:
+//!     * [log4rs]
+//!     * [fern]
+//! * Adaptors for other facilities:
+//!     * [syslog]
+//!     * [slog-stdlog]
+//!     * [systemd-journal-logger]
+//!     * [android_log]
+//!     * [win_dbg_logger]
+//!     * [db_logger]
+//! * For WebAssembly binaries:
+//!     * [console_log]
+//! * For dynamic libraries:
+//!     * You may need to construct an FFI-safe wrapper over `log` to initialize in your libraries
+//!
+//! # Implementing a Logger
+//!
+//! Loggers implement the [`Log`] trait. Here's a very basic example that simply
+//! logs all messages at the [`Error`][level_link], [`Warn`][level_link] or
+//! [`Info`][level_link] levels to stdout:
+//!
+//! ```edition2018
+//! use log::{Record, Level, Metadata};
+//!
+//! struct SimpleLogger;
+//!
+//! impl log::Log for SimpleLogger {
+//!     fn enabled(&self, metadata: &Metadata) -> bool {
+//!         metadata.level() <= Level::Info
+//!     }
+//!
+//!     fn log(&self, record: &Record) {
+//!         if self.enabled(record.metadata()) {
+//!             println!("{} - {}", record.level(), record.args());
+//!         }
+//!     }
+//!
+//!     fn flush(&self) {}
+//! }
+//!
+//! # fn main() {}
+//! ```
+//!
+//! Loggers are installed by calling the [`set_logger`] function. The maximum
+//! log level also needs to be adjusted via the [`set_max_level`] function. The
+//! logging facade uses this as an optimization to improve performance of log
+//! messages at levels that are disabled. It's important to set it, as it
+//! defaults to [`Off`][filter_link], so no log messages will ever be captured!
+//! In the case of our example logger, we'll want to set the maximum log level
+//! to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or
+//! [`Trace`][level_link] level log messages. A logging implementation should
+//! provide a function that wraps a call to [`set_logger`] and
+//! [`set_max_level`], handling initialization of the logger:
+//!
+//! ```edition2018
+//! # use log::{Level, Metadata};
+//! # struct SimpleLogger;
+//! # impl log::Log for SimpleLogger {
+//! #   fn enabled(&self, _: &Metadata) -> bool { false }
+//! #   fn log(&self, _: &log::Record) {}
+//! #   fn flush(&self) {}
+//! # }
+//! # fn main() {}
+//! use log::{SetLoggerError, LevelFilter};
+//!
+//! static LOGGER: SimpleLogger = SimpleLogger;
+//!
+//! pub fn init() -> Result<(), SetLoggerError> {
+//!     log::set_logger(&LOGGER)
+//!         .map(|()| log::set_max_level(LevelFilter::Info))
+//! }
+//! ```
+//!
+//! Implementations that adjust their configurations at runtime should take care
+//! to adjust the maximum log level as well.
+//!
+//! # Use with `std`
+//!
+//! `set_logger` requires you to provide a `&'static Log`, which can be hard to
+//! obtain if your logger depends on some runtime configuration. The
+//! `set_boxed_logger` function is available with the `std` Cargo feature. It is
+//! identical to `set_logger` except that it takes a `Box<Log>` rather than a
+//! `&'static Log`:
+//!
+//! ```edition2018
+//! # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};
+//! # struct SimpleLogger;
+//! # impl log::Log for SimpleLogger {
+//! #   fn enabled(&self, _: &Metadata) -> bool { false }
+//! #   fn log(&self, _: &log::Record) {}
+//! #   fn flush(&self) {}
+//! # }
+//! # fn main() {}
+//! # #[cfg(feature = "std")]
+//! pub fn init() -> Result<(), SetLoggerError> {
+//!     log::set_boxed_logger(Box::new(SimpleLogger))
+//!         .map(|()| log::set_max_level(LevelFilter::Info))
+//! }
+//! ```
+//!
+//! # Compile time filters
+//!
+//! Log levels can be statically disabled at compile time via Cargo features. Log invocations at
+//! disabled levels will be skipped and will not even be present in the resulting binary.
+//! This level is configured separately for release and debug builds. The features are:
+//!
+//! * `max_level_off`
+//! * `max_level_error`
+//! * `max_level_warn`
+//! * `max_level_info`
+//! * `max_level_debug`
+//! * `max_level_trace`
+//! * `release_max_level_off`
+//! * `release_max_level_error`
+//! * `release_max_level_warn`
+//! * `release_max_level_info`
+//! * `release_max_level_debug`
+//! * `release_max_level_trace`
+//!
+//! These features control the value of the `STATIC_MAX_LEVEL` constant. The logging macros check
+//! this value before logging a message. By default, no levels are disabled.
+//!
+//! Libraries should avoid using the max level features because they're global and can't be changed
+//! once they're set.
+//!
+//! For example, a crate can disable trace level logs in debug builds and trace, debug, and info
+//! level logs in release builds with the following configuration:
+//!
+//! ```toml
+//! [dependencies]
+//! log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }
+//! ```
+//! # Crate Feature Flags
+//!
+//! The following crate feature flags are available in addition to the filters. They are
+//! configured in your `Cargo.toml`.
+//!
+//! * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and
+//! `set_boxed_logger` functionality.
+//! * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.
+//!
+//! ```toml
+//! [dependencies]
+//! log = { version = "0.4", features = ["std", "serde"] }
+//! ```
+//!
+//! # Version compatibility
+//!
+//! The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messages
+//! made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. Log
+//! messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but the
+//! module path and file name information associated with the message will unfortunately be lost.
+//!
+//! [`Log`]: trait.Log.html
+//! [level_link]: enum.Level.html
+//! [filter_link]: enum.LevelFilter.html
+//! [`set_logger`]: fn.set_logger.html
+//! [`set_max_level`]: fn.set_max_level.html
+//! [`try_set_logger_raw`]: fn.try_set_logger_raw.html
+//! [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html
+//! [env_logger]: https://docs.rs/env_logger/*/env_logger/
+//! [simple_logger]: https://github.com/borntyping/rust-simple_logger
+//! [simplelog]: https://github.com/drakulix/simplelog.rs
+//! [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger/
+//! [stderrlog]: https://docs.rs/stderrlog/*/stderrlog/
+//! [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger/
+//! [syslog]: https://docs.rs/syslog/*/syslog/
+//! [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog/
+//! [log4rs]: https://docs.rs/log4rs/*/log4rs/
+//! [fern]: https://docs.rs/fern/*/fern/
+//! [systemd-journal-logger]: https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/
+//! [android_log]: https://docs.rs/android_log/*/android_log/
+//! [win_dbg_logger]: https://docs.rs/win_dbg_logger/*/win_dbg_logger/
+//! [console_log]: https://docs.rs/console_log/*/console_log/
+
+#![doc(
+    html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+    html_favicon_url = "https://www.rust-lang.org/favicon.ico",
+    html_root_url = "https://docs.rs/log/0.4.17"
+)]
+#![warn(missing_docs)]
+#![deny(missing_debug_implementations, unconditional_recursion)]
+#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
+// When compiled for the rustc compiler itself we want to make sure that this is
+// an unstable crate
+#![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
+#![cfg_attr(rustbuild, unstable(feature = "rustc_private", issue = "27812"))]
+
+#[cfg(all(not(feature = "std"), not(test)))]
+extern crate core as std;
+
+#[macro_use]
+extern crate cfg_if;
+
+use std::cmp;
+#[cfg(feature = "std")]
+use std::error;
+use std::fmt;
+use std::mem;
+use std::str::FromStr;
+
+#[macro_use]
+mod macros;
+mod serde;
+
+#[cfg(feature = "kv_unstable")]
+pub mod kv;
+
+#[cfg(has_atomics)]
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+#[cfg(not(has_atomics))]
+use std::cell::Cell;
+#[cfg(not(has_atomics))]
+use std::sync::atomic::Ordering;
+
+#[cfg(not(has_atomics))]
+struct AtomicUsize {
+    v: Cell<usize>,
+}
+
+#[cfg(not(has_atomics))]
+impl AtomicUsize {
+    const fn new(v: usize) -> AtomicUsize {
+        AtomicUsize { v: Cell::new(v) }
+    }
+
+    fn load(&self, _order: Ordering) -> usize {
+        self.v.get()
+    }
+
+    fn store(&self, val: usize, _order: Ordering) {
+        self.v.set(val)
+    }
+
+    #[cfg(atomic_cas)]
+    fn compare_exchange(
+        &self,
+        current: usize,
+        new: usize,
+        _success: Ordering,
+        _failure: Ordering,
+    ) -> Result<usize, usize> {
+        let prev = self.v.get();
+        if current == prev {
+            self.v.set(new);
+        }
+        Ok(prev)
+    }
+}
+
+// Any platform without atomics is unlikely to have multiple cores, so
+// writing via Cell will not be a race condition.
+#[cfg(not(has_atomics))]
+unsafe impl Sync for AtomicUsize {}
+
+// The LOGGER static holds a pointer to the global logger. It is protected by
+// the STATE static which determines whether LOGGER has been initialized yet.
+static mut LOGGER: &dyn Log = &NopLogger;
+
+static STATE: AtomicUsize = AtomicUsize::new(0);
+
+// There are three different states that we care about: the logger's
+// uninitialized, the logger's initializing (set_logger's been called but
+// LOGGER hasn't actually been set yet), or the logger's active.
+const UNINITIALIZED: usize = 0;
+const INITIALIZING: usize = 1;
+const INITIALIZED: usize = 2;
+
+static MAX_LOG_LEVEL_FILTER: AtomicUsize = AtomicUsize::new(0);
+
+static LOG_LEVEL_NAMES: [&str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"];
+
+static SET_LOGGER_ERROR: &str = "attempted to set a logger after the logging system \
+                                 was already initialized";
+static LEVEL_PARSE_ERROR: &str =
+    "attempted to convert a string that doesn't match an existing log level";
+
+/// An enum representing the available verbosity levels of the logger.
+///
+/// Typical usage includes: checking if a certain `Level` is enabled with
+/// [`log_enabled!`](macro.log_enabled.html), specifying the `Level` of
+/// [`log!`](macro.log.html), and comparing a `Level` directly to a
+/// [`LevelFilter`](enum.LevelFilter.html).
+#[repr(usize)]
+#[derive(Copy, Eq, Debug, Hash)]
+pub enum Level {
+    /// The "error" level.
+    ///
+    /// Designates very serious errors.
+    // This way these line up with the discriminants for LevelFilter below
+    // This works because Rust treats field-less enums the same way as C does:
+    // https://doc.rust-lang.org/reference/items/enumerations.html#custom-discriminant-values-for-field-less-enumerations
+    Error = 1,
+    /// The "warn" level.
+    ///
+    /// Designates hazardous situations.
+    Warn,
+    /// The "info" level.
+    ///
+    /// Designates useful information.
+    Info,
+    /// The "debug" level.
+    ///
+    /// Designates lower priority information.
+    Debug,
+    /// The "trace" level.
+    ///
+    /// Designates very low priority, often extremely verbose, information.
+    Trace,
+}
+
+impl Clone for Level {
+    #[inline]
+    fn clone(&self) -> Level {
+        *self
+    }
+}
+
+impl PartialEq for Level {
+    #[inline]
+    fn eq(&self, other: &Level) -> bool {
+        *self as usize == *other as usize
+    }
+}
+
+impl PartialEq<LevelFilter> for Level {
+    #[inline]
+    fn eq(&self, other: &LevelFilter) -> bool {
+        *self as usize == *other as usize
+    }
+}
+
+impl PartialOrd for Level {
+    #[inline]
+    fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+
+    #[inline]
+    fn lt(&self, other: &Level) -> bool {
+        (*self as usize) < *other as usize
+    }
+
+    #[inline]
+    fn le(&self, other: &Level) -> bool {
+        *self as usize <= *other as usize
+    }
+
+    #[inline]
+    fn gt(&self, other: &Level) -> bool {
+        *self as usize > *other as usize
+    }
+
+    #[inline]
+    fn ge(&self, other: &Level) -> bool {
+        *self as usize >= *other as usize
+    }
+}
+
+impl PartialOrd<LevelFilter> for Level {
+    #[inline]
+    fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
+        Some((*self as usize).cmp(&(*other as usize)))
+    }
+
+    #[inline]
+    fn lt(&self, other: &LevelFilter) -> bool {
+        (*self as usize) < *other as usize
+    }
+
+    #[inline]
+    fn le(&self, other: &LevelFilter) -> bool {
+        *self as usize <= *other as usize
+    }
+
+    #[inline]
+    fn gt(&self, other: &LevelFilter) -> bool {
+        *self as usize > *other as usize
+    }
+
+    #[inline]
+    fn ge(&self, other: &LevelFilter) -> bool {
+        *self as usize >= *other as usize
+    }
+}
+
+impl Ord for Level {
+    #[inline]
+    fn cmp(&self, other: &Level) -> cmp::Ordering {
+        (*self as usize).cmp(&(*other as usize))
+    }
+}
+
+fn ok_or<T, E>(t: Option<T>, e: E) -> Result<T, E> {
+    match t {
+        Some(t) => Ok(t),
+        None => Err(e),
+    }
+}
+
+// Reimplemented here because std::ascii is not available in libcore
+fn eq_ignore_ascii_case(a: &str, b: &str) -> bool {
+    fn to_ascii_uppercase(c: u8) -> u8 {
+        if c >= b'a' && c <= b'z' {
+            c - b'a' + b'A'
+        } else {
+            c
+        }
+    }
+
+    if a.len() == b.len() {
+        a.bytes()
+            .zip(b.bytes())
+            .all(|(a, b)| to_ascii_uppercase(a) == to_ascii_uppercase(b))
+    } else {
+        false
+    }
+}
+
+impl FromStr for Level {
+    type Err = ParseLevelError;
+    fn from_str(level: &str) -> Result<Level, Self::Err> {
+        ok_or(
+            LOG_LEVEL_NAMES
+                .iter()
+                .position(|&name| eq_ignore_ascii_case(name, level))
+                .into_iter()
+                .filter(|&idx| idx != 0)
+                .map(|idx| Level::from_usize(idx).unwrap())
+                .next(),
+            ParseLevelError(()),
+        )
+    }
+}
+
+impl fmt::Display for Level {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.pad(self.as_str())
+    }
+}
+
+impl Level {
+    fn from_usize(u: usize) -> Option<Level> {
+        match u {
+            1 => Some(Level::Error),
+            2 => Some(Level::Warn),
+            3 => Some(Level::Info),
+            4 => Some(Level::Debug),
+            5 => Some(Level::Trace),
+            _ => None,
+        }
+    }
+
+    /// Returns the most verbose logging level.
+    #[inline]
+    pub fn max() -> Level {
+        Level::Trace
+    }
+
+    /// Converts the `Level` to the equivalent `LevelFilter`.
+    #[inline]
+    pub fn to_level_filter(&self) -> LevelFilter {
+        LevelFilter::from_usize(*self as usize).unwrap()
+    }
+
+    /// Returns the string representation of the `Level`.
+    ///
+    /// This returns the same string as the `fmt::Display` implementation.
+    pub fn as_str(&self) -> &'static str {
+        LOG_LEVEL_NAMES[*self as usize]
+    }
+
+    /// Iterate through all supported logging levels.
+    ///
+    /// The order of iteration is from more severe to less severe log messages.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use log::Level;
+    ///
+    /// let mut levels = Level::iter();
+    ///
+    /// assert_eq!(Some(Level::Error), levels.next());
+    /// assert_eq!(Some(Level::Trace), levels.last());
+    /// ```
+    pub fn iter() -> impl Iterator<Item = Self> {
+        (1..6).map(|i| Self::from_usize(i).unwrap())
+    }
+}
+
+/// An enum representing the available verbosity level filters of the logger.
+///
+/// A `LevelFilter` may be compared directly to a [`Level`]. Use this type
+/// to get and set the maximum log level with [`max_level()`] and [`set_max_level`].
+///
+/// [`Level`]: enum.Level.html
+/// [`max_level()`]: fn.max_level.html
+/// [`set_max_level`]: fn.set_max_level.html
+#[repr(usize)]
+#[derive(Copy, Eq, Debug, Hash)]
+pub enum LevelFilter {
+    /// A level lower than all log levels.
+    Off,
+    /// Corresponds to the `Error` log level.
+    Error,
+    /// Corresponds to the `Warn` log level.
+    Warn,
+    /// Corresponds to the `Info` log level.
+    Info,
+    /// Corresponds to the `Debug` log level.
+    Debug,
+    /// Corresponds to the `Trace` log level.
+    Trace,
+}
+
+// Deriving generates terrible impls of these traits
+
+impl Clone for LevelFilter {
+    #[inline]
+    fn clone(&self) -> LevelFilter {
+        *self
+    }
+}
+
+impl PartialEq for LevelFilter {
+    #[inline]
+    fn eq(&self, other: &LevelFilter) -> bool {
+        *self as usize == *other as usize
+    }
+}
+
+impl PartialEq<Level> for LevelFilter {
+    #[inline]
+    fn eq(&self, other: &Level) -> bool {
+        other.eq(self)
+    }
+}
+
+impl PartialOrd for LevelFilter {
+    #[inline]
+    fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+
+    #[inline]
+    fn lt(&self, other: &LevelFilter) -> bool {
+        (*self as usize) < *other as usize
+    }
+
+    #[inline]
+    fn le(&self, other: &LevelFilter) -> bool {
+        *self as usize <= *other as usize
+    }
+
+    #[inline]
+    fn gt(&self, other: &LevelFilter) -> bool {
+        *self as usize > *other as usize
+    }
+
+    #[inline]
+    fn ge(&self, other: &LevelFilter) -> bool {
+        *self as usize >= *other as usize
+    }
+}
+
+impl PartialOrd<Level> for LevelFilter {
+    #[inline]
+    fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
+        Some((*self as usize).cmp(&(*other as usize)))
+    }
+
+    #[inline]
+    fn lt(&self, other: &Level) -> bool {
+        (*self as usize) < *other as usize
+    }
+
+    #[inline]
+    fn le(&self, other: &Level) -> bool {
+        *self as usize <= *other as usize
+    }
+
+    #[inline]
+    fn gt(&self, other: &Level) -> bool {
+        *self as usize > *other as usize
+    }
+
+    #[inline]
+    fn ge(&self, other: &Level) -> bool {
+        *self as usize >= *other as usize
+    }
+}
+
+impl Ord for LevelFilter {
+    #[inline]
+    fn cmp(&self, other: &LevelFilter) -> cmp::Ordering {
+        (*self as usize).cmp(&(*other as usize))
+    }
+}
+
+impl FromStr for LevelFilter {
+    type Err = ParseLevelError;
+    fn from_str(level: &str) -> Result<LevelFilter, Self::Err> {
+        ok_or(
+            LOG_LEVEL_NAMES
+                .iter()
+                .position(|&name| eq_ignore_ascii_case(name, level))
+                .map(|p| LevelFilter::from_usize(p).unwrap()),
+            ParseLevelError(()),
+        )
+    }
+}
+
+impl fmt::Display for LevelFilter {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.pad(self.as_str())
+    }
+}
+
+impl LevelFilter {
+    fn from_usize(u: usize) -> Option<LevelFilter> {
+        match u {
+            0 => Some(LevelFilter::Off),
+            1 => Some(LevelFilter::Error),
+            2 => Some(LevelFilter::Warn),
+            3 => Some(LevelFilter::Info),
+            4 => Some(LevelFilter::Debug),
+            5 => Some(LevelFilter::Trace),
+            _ => None,
+        }
+    }
+
+    /// Returns the most verbose logging level filter.
+    #[inline]
+    pub fn max() -> LevelFilter {
+        LevelFilter::Trace
+    }
+
+    /// Converts `self` to the equivalent `Level`.
+    ///
+    /// Returns `None` if `self` is `LevelFilter::Off`.
+    #[inline]
+    pub fn to_level(&self) -> Option<Level> {
+        Level::from_usize(*self as usize)
+    }
+
+    /// Returns the string representation of the `LevelFilter`.
+    ///
+    /// This returns the same string as the `fmt::Display` implementation.
+    pub fn as_str(&self) -> &'static str {
+        LOG_LEVEL_NAMES[*self as usize]
+    }
+
+    /// Iterate through all supported filtering levels.
+    ///
+    /// The order of iteration is from less to more verbose filtering.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use log::LevelFilter;
+    ///
+    /// let mut levels = LevelFilter::iter();
+    ///
+    /// assert_eq!(Some(LevelFilter::Off), levels.next());
+    /// assert_eq!(Some(LevelFilter::Trace), levels.last());
+    /// ```
+    pub fn iter() -> impl Iterator<Item = Self> {
+        (0..6).map(|i| Self::from_usize(i).unwrap())
+    }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+enum MaybeStaticStr<'a> {
+    Static(&'static str),
+    Borrowed(&'a str),
+}
+
+impl<'a> MaybeStaticStr<'a> {
+    #[inline]
+    fn get(&self) -> &'a str {
+        match *self {
+            MaybeStaticStr::Static(s) => s,
+            MaybeStaticStr::Borrowed(s) => s,
+        }
+    }
+}
+
+/// The "payload" of a log message.
+///
+/// # Use
+///
+/// `Record` structures are passed as parameters to the [`log`][method.log]
+/// method of the [`Log`] trait. Logger implementors manipulate these
+/// structures in order to display log messages. `Record`s are automatically
+/// created by the [`log!`] macro and so are not seen by log users.
+///
+/// Note that the [`level()`] and [`target()`] accessors are equivalent to
+/// `self.metadata().level()` and `self.metadata().target()` respectively.
+/// These methods are provided as a convenience for users of this structure.
+///
+/// # Example
+///
+/// The following example shows a simple logger that displays the level,
+/// module path, and message of any `Record` that is passed to it.
+///
+/// ```edition2018
+/// struct SimpleLogger;
+///
+/// impl log::Log for SimpleLogger {
+///    fn enabled(&self, metadata: &log::Metadata) -> bool {
+///        true
+///    }
+///
+///    fn log(&self, record: &log::Record) {
+///        if !self.enabled(record.metadata()) {
+///            return;
+///        }
+///
+///        println!("{}:{} -- {}",
+///                 record.level(),
+///                 record.target(),
+///                 record.args());
+///    }
+///    fn flush(&self) {}
+/// }
+/// ```
+///
+/// [method.log]: trait.Log.html#tymethod.log
+/// [`Log`]: trait.Log.html
+/// [`log!`]: macro.log.html
+/// [`level()`]: struct.Record.html#method.level
+/// [`target()`]: struct.Record.html#method.target
+#[derive(Clone, Debug)]
+pub struct Record<'a> {
+    metadata: Metadata<'a>,
+    args: fmt::Arguments<'a>,
+    module_path: Option<MaybeStaticStr<'a>>,
+    file: Option<MaybeStaticStr<'a>>,
+    line: Option<u32>,
+    #[cfg(feature = "kv_unstable")]
+    key_values: KeyValues<'a>,
+}
+
+// This wrapper type is only needed so we can
+// `#[derive(Debug)]` on `Record`. It also
+// provides a useful `Debug` implementation for
+// the underlying `Source`.
+#[cfg(feature = "kv_unstable")]
+#[derive(Clone)]
+struct KeyValues<'a>(&'a dyn kv::Source);
+
+#[cfg(feature = "kv_unstable")]
+impl<'a> fmt::Debug for KeyValues<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut visitor = f.debug_map();
+        self.0.visit(&mut visitor).map_err(|_| fmt::Error)?;
+        visitor.finish()
+    }
+}
+
+impl<'a> Record<'a> {
+    /// Returns a new builder.
+    #[inline]
+    pub fn builder() -> RecordBuilder<'a> {
+        RecordBuilder::new()
+    }
+
+    /// The message body.
+    #[inline]
+    pub fn args(&self) -> &fmt::Arguments<'a> {
+        &self.args
+    }
+
+    /// Metadata about the log directive.
+    #[inline]
+    pub fn metadata(&self) -> &Metadata<'a> {
+        &self.metadata
+    }
+
+    /// The verbosity level of the message.
+    #[inline]
+    pub fn level(&self) -> Level {
+        self.metadata.level()
+    }
+
+    /// The name of the target of the directive.
+    #[inline]
+    pub fn target(&self) -> &'a str {
+        self.metadata.target()
+    }
+
+    /// The module path of the message.
+    #[inline]
+    pub fn module_path(&self) -> Option<&'a str> {
+        self.module_path.map(|s| s.get())
+    }
+
+    /// The module path of the message, if it is a `'static` string.
+    #[inline]
+    pub fn module_path_static(&self) -> Option<&'static str> {
+        match self.module_path {
+            Some(MaybeStaticStr::Static(s)) => Some(s),
+            _ => None,
+        }
+    }
+
+    /// The source file containing the message.
+    #[inline]
+    pub fn file(&self) -> Option<&'a str> {
+        self.file.map(|s| s.get())
+    }
+
+    /// The module path of the message, if it is a `'static` string.
+    #[inline]
+    pub fn file_static(&self) -> Option<&'static str> {
+        match self.file {
+            Some(MaybeStaticStr::Static(s)) => Some(s),
+            _ => None,
+        }
+    }
+
+    /// The line containing the message.
+    #[inline]
+    pub fn line(&self) -> Option<u32> {
+        self.line
+    }
+
+    /// The structured key-value pairs associated with the message.
+    #[cfg(feature = "kv_unstable")]
+    #[inline]
+    pub fn key_values(&self) -> &dyn kv::Source {
+        self.key_values.0
+    }
+
+    /// Create a new [`RecordBuilder`](struct.RecordBuilder.html) based on this record.
+    #[cfg(feature = "kv_unstable")]
+    #[inline]
+    pub fn to_builder(&self) -> RecordBuilder {
+        RecordBuilder {
+            record: Record {
+                metadata: Metadata {
+                    level: self.metadata.level,
+                    target: self.metadata.target,
+                },
+                args: self.args,
+                module_path: self.module_path,
+                file: self.file,
+                line: self.line,
+                key_values: self.key_values.clone(),
+            },
+        }
+    }
+}
+
+/// Builder for [`Record`](struct.Record.html).
+///
+/// Typically should only be used by log library creators or for testing and "shim loggers".
+/// The `RecordBuilder` can set the different parameters of `Record` object, and returns
+/// the created object when `build` is called.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::{Level, Record};
+///
+/// let record = Record::builder()
+///                 .args(format_args!("Error!"))
+///                 .level(Level::Error)
+///                 .target("myApp")
+///                 .file(Some("server.rs"))
+///                 .line(Some(144))
+///                 .module_path(Some("server"))
+///                 .build();
+/// ```
+///
+/// Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):
+///
+/// ```edition2018
+/// use log::{Record, Level, MetadataBuilder};
+///
+/// let error_metadata = MetadataBuilder::new()
+///                         .target("myApp")
+///                         .level(Level::Error)
+///                         .build();
+///
+/// let record = Record::builder()
+///                 .metadata(error_metadata)
+///                 .args(format_args!("Error!"))
+///                 .line(Some(433))
+///                 .file(Some("app.rs"))
+///                 .module_path(Some("server"))
+///                 .build();
+/// ```
+#[derive(Debug)]
+pub struct RecordBuilder<'a> {
+    record: Record<'a>,
+}
+
+impl<'a> RecordBuilder<'a> {
+    /// Construct new `RecordBuilder`.
+    ///
+    /// The default options are:
+    ///
+    /// - `args`: [`format_args!("")`]
+    /// - `metadata`: [`Metadata::builder().build()`]
+    /// - `module_path`: `None`
+    /// - `file`: `None`
+    /// - `line`: `None`
+    ///
+    /// [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.html
+    /// [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.build
+    #[inline]
+    pub fn new() -> RecordBuilder<'a> {
+        RecordBuilder {
+            record: Record {
+                args: format_args!(""),
+                metadata: Metadata::builder().build(),
+                module_path: None,
+                file: None,
+                line: None,
+                #[cfg(feature = "kv_unstable")]
+                key_values: KeyValues(&Option::None::<(kv::Key, kv::Value)>),
+            },
+        }
+    }
+
+    /// Set [`args`](struct.Record.html#method.args).
+    #[inline]
+    pub fn args(&mut self, args: fmt::Arguments<'a>) -> &mut RecordBuilder<'a> {
+        self.record.args = args;
+        self
+    }
+
+    /// Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).
+    #[inline]
+    pub fn metadata(&mut self, metadata: Metadata<'a>) -> &mut RecordBuilder<'a> {
+        self.record.metadata = metadata;
+        self
+    }
+
+    /// Set [`Metadata::level`](struct.Metadata.html#method.level).
+    #[inline]
+    pub fn level(&mut self, level: Level) -> &mut RecordBuilder<'a> {
+        self.record.metadata.level = level;
+        self
+    }
+
+    /// Set [`Metadata::target`](struct.Metadata.html#method.target)
+    #[inline]
+    pub fn target(&mut self, target: &'a str) -> &mut RecordBuilder<'a> {
+        self.record.metadata.target = target;
+        self
+    }
+
+    /// Set [`module_path`](struct.Record.html#method.module_path)
+    #[inline]
+    pub fn module_path(&mut self, path: Option<&'a str>) -> &mut RecordBuilder<'a> {
+        self.record.module_path = path.map(MaybeStaticStr::Borrowed);
+        self
+    }
+
+    /// Set [`module_path`](struct.Record.html#method.module_path) to a `'static` string
+    #[inline]
+    pub fn module_path_static(&mut self, path: Option<&'static str>) -> &mut RecordBuilder<'a> {
+        self.record.module_path = path.map(MaybeStaticStr::Static);
+        self
+    }
+
+    /// Set [`file`](struct.Record.html#method.file)
+    #[inline]
+    pub fn file(&mut self, file: Option<&'a str>) -> &mut RecordBuilder<'a> {
+        self.record.file = file.map(MaybeStaticStr::Borrowed);
+        self
+    }
+
+    /// Set [`file`](struct.Record.html#method.file) to a `'static` string.
+    #[inline]
+    pub fn file_static(&mut self, file: Option<&'static str>) -> &mut RecordBuilder<'a> {
+        self.record.file = file.map(MaybeStaticStr::Static);
+        self
+    }
+
+    /// Set [`line`](struct.Record.html#method.line)
+    #[inline]
+    pub fn line(&mut self, line: Option<u32>) -> &mut RecordBuilder<'a> {
+        self.record.line = line;
+        self
+    }
+
+    /// Set [`key_values`](struct.Record.html#method.key_values)
+    #[cfg(feature = "kv_unstable")]
+    #[inline]
+    pub fn key_values(&mut self, kvs: &'a dyn kv::Source) -> &mut RecordBuilder<'a> {
+        self.record.key_values = KeyValues(kvs);
+        self
+    }
+
+    /// Invoke the builder and return a `Record`
+    #[inline]
+    pub fn build(&self) -> Record<'a> {
+        self.record.clone()
+    }
+}
+
+/// Metadata about a log message.
+///
+/// # Use
+///
+/// `Metadata` structs are created when users of the library use
+/// logging macros.
+///
+/// They are consumed by implementations of the `Log` trait in the
+/// `enabled` method.
+///
+/// `Record`s use `Metadata` to determine the log message's severity
+/// and target.
+///
+/// Users should use the `log_enabled!` macro in their code to avoid
+/// constructing expensive log messages.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::{Record, Level, Metadata};
+///
+/// struct MyLogger;
+///
+/// impl log::Log for MyLogger {
+///     fn enabled(&self, metadata: &Metadata) -> bool {
+///         metadata.level() <= Level::Info
+///     }
+///
+///     fn log(&self, record: &Record) {
+///         if self.enabled(record.metadata()) {
+///             println!("{} - {}", record.level(), record.args());
+///         }
+///     }
+///     fn flush(&self) {}
+/// }
+///
+/// # fn main(){}
+/// ```
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+pub struct Metadata<'a> {
+    level: Level,
+    target: &'a str,
+}
+
+impl<'a> Metadata<'a> {
+    /// Returns a new builder.
+    #[inline]
+    pub fn builder() -> MetadataBuilder<'a> {
+        MetadataBuilder::new()
+    }
+
+    /// The verbosity level of the message.
+    #[inline]
+    pub fn level(&self) -> Level {
+        self.level
+    }
+
+    /// The name of the target of the directive.
+    #[inline]
+    pub fn target(&self) -> &'a str {
+        self.target
+    }
+}
+
+/// Builder for [`Metadata`](struct.Metadata.html).
+///
+/// Typically should only be used by log library creators or for testing and "shim loggers".
+/// The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns
+/// the created object when `build` is called.
+///
+/// # Example
+///
+/// ```edition2018
+/// let target = "myApp";
+/// use log::{Level, MetadataBuilder};
+/// let metadata = MetadataBuilder::new()
+///                     .level(Level::Debug)
+///                     .target(target)
+///                     .build();
+/// ```
+#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+pub struct MetadataBuilder<'a> {
+    metadata: Metadata<'a>,
+}
+
+impl<'a> MetadataBuilder<'a> {
+    /// Construct a new `MetadataBuilder`.
+    ///
+    /// The default options are:
+    ///
+    /// - `level`: `Level::Info`
+    /// - `target`: `""`
+    #[inline]
+    pub fn new() -> MetadataBuilder<'a> {
+        MetadataBuilder {
+            metadata: Metadata {
+                level: Level::Info,
+                target: "",
+            },
+        }
+    }
+
+    /// Setter for [`level`](struct.Metadata.html#method.level).
+    #[inline]
+    pub fn level(&mut self, arg: Level) -> &mut MetadataBuilder<'a> {
+        self.metadata.level = arg;
+        self
+    }
+
+    /// Setter for [`target`](struct.Metadata.html#method.target).
+    #[inline]
+    pub fn target(&mut self, target: &'a str) -> &mut MetadataBuilder<'a> {
+        self.metadata.target = target;
+        self
+    }
+
+    /// Returns a `Metadata` object.
+    #[inline]
+    pub fn build(&self) -> Metadata<'a> {
+        self.metadata.clone()
+    }
+}
+
+/// A trait encapsulating the operations required of a logger.
+pub trait Log: Sync + Send {
+    /// Determines if a log message with the specified metadata would be
+    /// logged.
+    ///
+    /// This is used by the `log_enabled!` macro to allow callers to avoid
+    /// expensive computation of log message arguments if the message would be
+    /// discarded anyway.
+    ///
+    /// # For implementors
+    ///
+    /// This method isn't called automatically by the `log!` macros.
+    /// It's up to an implementation of the `Log` trait to call `enabled` in its own
+    /// `log` method implementation to guarantee that filtering is applied.
+    fn enabled(&self, metadata: &Metadata) -> bool;
+
+    /// Logs the `Record`.
+    ///
+    /// # For implementors
+    ///
+    /// Note that `enabled` is *not* necessarily called before this method.
+    /// Implementations of `log` should perform all necessary filtering
+    /// internally.
+    fn log(&self, record: &Record);
+
+    /// Flushes any buffered records.
+    fn flush(&self);
+}
+
+// Just used as a dummy initial value for LOGGER
+struct NopLogger;
+
+impl Log for NopLogger {
+    fn enabled(&self, _: &Metadata) -> bool {
+        false
+    }
+
+    fn log(&self, _: &Record) {}
+    fn flush(&self) {}
+}
+
+impl<T> Log for &'_ T
+where
+    T: ?Sized + Log,
+{
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        (**self).enabled(metadata)
+    }
+
+    fn log(&self, record: &Record) {
+        (**self).log(record)
+    }
+    fn flush(&self) {
+        (**self).flush()
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> Log for std::boxed::Box<T>
+where
+    T: ?Sized + Log,
+{
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        self.as_ref().enabled(metadata)
+    }
+
+    fn log(&self, record: &Record) {
+        self.as_ref().log(record)
+    }
+    fn flush(&self) {
+        self.as_ref().flush()
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> Log for std::sync::Arc<T>
+where
+    T: ?Sized + Log,
+{
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        self.as_ref().enabled(metadata)
+    }
+
+    fn log(&self, record: &Record) {
+        self.as_ref().log(record)
+    }
+    fn flush(&self) {
+        self.as_ref().flush()
+    }
+}
+
+/// Sets the global maximum log level.
+///
+/// Generally, this should only be called by the active logging implementation.
+///
+/// Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.
+#[inline]
+pub fn set_max_level(level: LevelFilter) {
+    MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::Relaxed)
+}
+
+/// Returns the current maximum log level.
+///
+/// The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros check
+/// this value and discard any message logged at a higher level. The maximum
+/// log level is set by the [`set_max_level`] function.
+///
+/// [`log!`]: macro.log.html
+/// [`error!`]: macro.error.html
+/// [`warn!`]: macro.warn.html
+/// [`info!`]: macro.info.html
+/// [`debug!`]: macro.debug.html
+/// [`trace!`]: macro.trace.html
+/// [`set_max_level`]: fn.set_max_level.html
+#[inline(always)]
+pub fn max_level() -> LevelFilter {
+    // Since `LevelFilter` is `repr(usize)`,
+    // this transmute is sound if and only if `MAX_LOG_LEVEL_FILTER`
+    // is set to a usize that is a valid discriminant for `LevelFilter`.
+    // Since `MAX_LOG_LEVEL_FILTER` is private, the only time it's set
+    // is by `set_max_level` above, i.e. by casting a `LevelFilter` to `usize`.
+    // So any usize stored in `MAX_LOG_LEVEL_FILTER` is a valid discriminant.
+    unsafe { mem::transmute(MAX_LOG_LEVEL_FILTER.load(Ordering::Relaxed)) }
+}
+
+/// Sets the global logger to a `Box<Log>`.
+///
+/// This is a simple convenience wrapper over `set_logger`, which takes a
+/// `Box<Log>` rather than a `&'static Log`. See the documentation for
+/// [`set_logger`] for more details.
+///
+/// Requires the `std` feature.
+///
+/// # Errors
+///
+/// An error is returned if a logger has already been set.
+///
+/// [`set_logger`]: fn.set_logger.html
+#[cfg(all(feature = "std", atomic_cas))]
+pub fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), SetLoggerError> {
+    set_logger_inner(|| Box::leak(logger))
+}
+
+/// Sets the global logger to a `&'static Log`.
+///
+/// This function may only be called once in the lifetime of a program. Any log
+/// events that occur before the call to `set_logger` completes will be ignored.
+///
+/// This function does not typically need to be called manually. Logger
+/// implementations should provide an initialization method that installs the
+/// logger internally.
+///
+/// # Availability
+///
+/// This method is available even when the `std` feature is disabled. However,
+/// it is currently unavailable on `thumbv6` targets, which lack support for
+/// some atomic operations which are used by this function. Even on those
+/// targets, [`set_logger_racy`] will be available.
+///
+/// # Errors
+///
+/// An error is returned if a logger has already been set.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::{error, info, warn, Record, Level, Metadata, LevelFilter};
+///
+/// static MY_LOGGER: MyLogger = MyLogger;
+///
+/// struct MyLogger;
+///
+/// impl log::Log for MyLogger {
+///     fn enabled(&self, metadata: &Metadata) -> bool {
+///         metadata.level() <= Level::Info
+///     }
+///
+///     fn log(&self, record: &Record) {
+///         if self.enabled(record.metadata()) {
+///             println!("{} - {}", record.level(), record.args());
+///         }
+///     }
+///     fn flush(&self) {}
+/// }
+///
+/// # fn main(){
+/// log::set_logger(&MY_LOGGER).unwrap();
+/// log::set_max_level(LevelFilter::Info);
+///
+/// info!("hello log");
+/// warn!("warning");
+/// error!("oops");
+/// # }
+/// ```
+///
+/// [`set_logger_racy`]: fn.set_logger_racy.html
+#[cfg(atomic_cas)]
+pub fn set_logger(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
+    set_logger_inner(|| logger)
+}
+
+#[cfg(atomic_cas)]
+fn set_logger_inner<F>(make_logger: F) -> Result<(), SetLoggerError>
+where
+    F: FnOnce() -> &'static dyn Log,
+{
+    let old_state = match STATE.compare_exchange(
+        UNINITIALIZED,
+        INITIALIZING,
+        Ordering::SeqCst,
+        Ordering::SeqCst,
+    ) {
+        Ok(s) | Err(s) => s,
+    };
+    match old_state {
+        UNINITIALIZED => {
+            unsafe {
+                LOGGER = make_logger();
+            }
+            STATE.store(INITIALIZED, Ordering::SeqCst);
+            Ok(())
+        }
+        INITIALIZING => {
+            while STATE.load(Ordering::SeqCst) == INITIALIZING {
+                // TODO: replace with `hint::spin_loop` once MSRV is 1.49.0.
+                #[allow(deprecated)]
+                std::sync::atomic::spin_loop_hint();
+            }
+            Err(SetLoggerError(()))
+        }
+        _ => Err(SetLoggerError(())),
+    }
+}
+
+/// A thread-unsafe version of [`set_logger`].
+///
+/// This function is available on all platforms, even those that do not have
+/// support for atomics that is needed by [`set_logger`].
+///
+/// In almost all cases, [`set_logger`] should be preferred.
+///
+/// # Safety
+///
+/// This function is only safe to call when no other logger initialization
+/// function is called while this function still executes.
+///
+/// This can be upheld by (for example) making sure that **there are no other
+/// threads**, and (on embedded) that **interrupts are disabled**.
+///
+/// It is safe to use other logging functions while this function runs
+/// (including all logging macros).
+///
+/// [`set_logger`]: fn.set_logger.html
+pub unsafe fn set_logger_racy(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
+    match STATE.load(Ordering::SeqCst) {
+        UNINITIALIZED => {
+            LOGGER = logger;
+            STATE.store(INITIALIZED, Ordering::SeqCst);
+            Ok(())
+        }
+        INITIALIZING => {
+            // This is just plain UB, since we were racing another initialization function
+            unreachable!("set_logger_racy must not be used with other initialization functions")
+        }
+        _ => Err(SetLoggerError(())),
+    }
+}
+
+/// The type returned by [`set_logger`] if [`set_logger`] has already been called.
+///
+/// [`set_logger`]: fn.set_logger.html
+#[allow(missing_copy_implementations)]
+#[derive(Debug)]
+pub struct SetLoggerError(());
+
+impl fmt::Display for SetLoggerError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.write_str(SET_LOGGER_ERROR)
+    }
+}
+
+// The Error trait is not available in libcore
+#[cfg(feature = "std")]
+impl error::Error for SetLoggerError {}
+
+/// The type returned by [`from_str`] when the string doesn't match any of the log levels.
+///
+/// [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_str
+#[allow(missing_copy_implementations)]
+#[derive(Debug, PartialEq)]
+pub struct ParseLevelError(());
+
+impl fmt::Display for ParseLevelError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.write_str(LEVEL_PARSE_ERROR)
+    }
+}
+
+// The Error trait is not available in libcore
+#[cfg(feature = "std")]
+impl error::Error for ParseLevelError {}
+
+/// Returns a reference to the logger.
+///
+/// If a logger has not been set, a no-op implementation is returned.
+pub fn logger() -> &'static dyn Log {
+    if STATE.load(Ordering::SeqCst) != INITIALIZED {
+        static NOP: NopLogger = NopLogger;
+        &NOP
+    } else {
+        unsafe { LOGGER }
+    }
+}
+
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+#[cfg(not(feature = "kv_unstable"))]
+pub fn __private_api_log(
+    args: fmt::Arguments,
+    level: Level,
+    &(target, module_path, file, line): &(&str, &'static str, &'static str, u32),
+    kvs: Option<&[(&str, &str)]>,
+) {
+    if kvs.is_some() {
+        panic!(
+            "key-value support is experimental and must be enabled using the `kv_unstable` feature"
+        )
+    }
+
+    logger().log(
+        &Record::builder()
+            .args(args)
+            .level(level)
+            .target(target)
+            .module_path_static(Some(module_path))
+            .file_static(Some(file))
+            .line(Some(line))
+            .build(),
+    );
+}
+
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+#[cfg(feature = "kv_unstable")]
+pub fn __private_api_log(
+    args: fmt::Arguments,
+    level: Level,
+    &(target, module_path, file, line): &(&str, &'static str, &'static str, u32),
+    kvs: Option<&[(&str, &dyn kv::ToValue)]>,
+) {
+    logger().log(
+        &Record::builder()
+            .args(args)
+            .level(level)
+            .target(target)
+            .module_path_static(Some(module_path))
+            .file_static(Some(file))
+            .line(Some(line))
+            .key_values(&kvs)
+            .build(),
+    );
+}
+
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+pub fn __private_api_enabled(level: Level, target: &str) -> bool {
+    logger().enabled(&Metadata::builder().level(level).target(target).build())
+}
+
+// WARNING: this is not part of the crate's public API and is subject to change at any time
+#[doc(hidden)]
+pub mod __private_api {
+    pub use std::option::Option;
+}
+
+/// The statically resolved maximum log level.
+///
+/// See the crate level documentation for information on how to configure this.
+///
+/// This value is checked by the log macros, but not by the `Log`ger returned by
+/// the [`logger`] function. Code that manually calls functions on that value
+/// should compare the level against this value.
+///
+/// [`logger`]: fn.logger.html
+pub const STATIC_MAX_LEVEL: LevelFilter = MAX_LEVEL_INNER;
+
+cfg_if! {
+    if #[cfg(all(not(debug_assertions), feature = "release_max_level_off"))] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Off;
+    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_error"))] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Error;
+    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_warn"))] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Warn;
+    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_info"))] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Info;
+    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_debug"))] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Debug;
+    } else if #[cfg(all(not(debug_assertions), feature = "release_max_level_trace"))] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Trace;
+    } else if #[cfg(feature = "max_level_off")] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Off;
+    } else if #[cfg(feature = "max_level_error")] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Error;
+    } else if #[cfg(feature = "max_level_warn")] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Warn;
+    } else if #[cfg(feature = "max_level_info")] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Info;
+    } else if #[cfg(feature = "max_level_debug")] {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Debug;
+    } else {
+        const MAX_LEVEL_INNER: LevelFilter = LevelFilter::Trace;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate std;
+    use super::{Level, LevelFilter, ParseLevelError};
+    use tests::std::string::ToString;
+
+    #[test]
+    fn test_levelfilter_from_str() {
+        let tests = [
+            ("off", Ok(LevelFilter::Off)),
+            ("error", Ok(LevelFilter::Error)),
+            ("warn", Ok(LevelFilter::Warn)),
+            ("info", Ok(LevelFilter::Info)),
+            ("debug", Ok(LevelFilter::Debug)),
+            ("trace", Ok(LevelFilter::Trace)),
+            ("OFF", Ok(LevelFilter::Off)),
+            ("ERROR", Ok(LevelFilter::Error)),
+            ("WARN", Ok(LevelFilter::Warn)),
+            ("INFO", Ok(LevelFilter::Info)),
+            ("DEBUG", Ok(LevelFilter::Debug)),
+            ("TRACE", Ok(LevelFilter::Trace)),
+            ("asdf", Err(ParseLevelError(()))),
+        ];
+        for &(s, ref expected) in &tests {
+            assert_eq!(expected, &s.parse());
+        }
+    }
+
+    #[test]
+    fn test_level_from_str() {
+        let tests = [
+            ("OFF", Err(ParseLevelError(()))),
+            ("error", Ok(Level::Error)),
+            ("warn", Ok(Level::Warn)),
+            ("info", Ok(Level::Info)),
+            ("debug", Ok(Level::Debug)),
+            ("trace", Ok(Level::Trace)),
+            ("ERROR", Ok(Level::Error)),
+            ("WARN", Ok(Level::Warn)),
+            ("INFO", Ok(Level::Info)),
+            ("DEBUG", Ok(Level::Debug)),
+            ("TRACE", Ok(Level::Trace)),
+            ("asdf", Err(ParseLevelError(()))),
+        ];
+        for &(s, ref expected) in &tests {
+            assert_eq!(expected, &s.parse());
+        }
+    }
+
+    #[test]
+    fn test_level_as_str() {
+        let tests = &[
+            (Level::Error, "ERROR"),
+            (Level::Warn, "WARN"),
+            (Level::Info, "INFO"),
+            (Level::Debug, "DEBUG"),
+            (Level::Trace, "TRACE"),
+        ];
+        for (input, expected) in tests {
+            assert_eq!(*expected, input.as_str());
+        }
+    }
+
+    #[test]
+    fn test_level_show() {
+        assert_eq!("INFO", Level::Info.to_string());
+        assert_eq!("ERROR", Level::Error.to_string());
+    }
+
+    #[test]
+    fn test_levelfilter_show() {
+        assert_eq!("OFF", LevelFilter::Off.to_string());
+        assert_eq!("ERROR", LevelFilter::Error.to_string());
+    }
+
+    #[test]
+    fn test_cross_cmp() {
+        assert!(Level::Debug > LevelFilter::Error);
+        assert!(LevelFilter::Warn < Level::Trace);
+        assert!(LevelFilter::Off < Level::Error);
+    }
+
+    #[test]
+    fn test_cross_eq() {
+        assert!(Level::Error == LevelFilter::Error);
+        assert!(LevelFilter::Off != Level::Error);
+        assert!(Level::Trace == LevelFilter::Trace);
+    }
+
+    #[test]
+    fn test_to_level() {
+        assert_eq!(Some(Level::Error), LevelFilter::Error.to_level());
+        assert_eq!(None, LevelFilter::Off.to_level());
+        assert_eq!(Some(Level::Debug), LevelFilter::Debug.to_level());
+    }
+
+    #[test]
+    fn test_to_level_filter() {
+        assert_eq!(LevelFilter::Error, Level::Error.to_level_filter());
+        assert_eq!(LevelFilter::Trace, Level::Trace.to_level_filter());
+    }
+
+    #[test]
+    fn test_level_filter_as_str() {
+        let tests = &[
+            (LevelFilter::Off, "OFF"),
+            (LevelFilter::Error, "ERROR"),
+            (LevelFilter::Warn, "WARN"),
+            (LevelFilter::Info, "INFO"),
+            (LevelFilter::Debug, "DEBUG"),
+            (LevelFilter::Trace, "TRACE"),
+        ];
+        for (input, expected) in tests {
+            assert_eq!(*expected, input.as_str());
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn test_error_trait() {
+        use super::SetLoggerError;
+        let e = SetLoggerError(());
+        assert_eq!(
+            &e.to_string(),
+            "attempted to set a logger after the logging system \
+             was already initialized"
+        );
+    }
+
+    #[test]
+    fn test_metadata_builder() {
+        use super::MetadataBuilder;
+        let target = "myApp";
+        let metadata_test = MetadataBuilder::new()
+            .level(Level::Debug)
+            .target(target)
+            .build();
+        assert_eq!(metadata_test.level(), Level::Debug);
+        assert_eq!(metadata_test.target(), "myApp");
+    }
+
+    #[test]
+    fn test_metadata_convenience_builder() {
+        use super::Metadata;
+        let target = "myApp";
+        let metadata_test = Metadata::builder()
+            .level(Level::Debug)
+            .target(target)
+            .build();
+        assert_eq!(metadata_test.level(), Level::Debug);
+        assert_eq!(metadata_test.target(), "myApp");
+    }
+
+    #[test]
+    fn test_record_builder() {
+        use super::{MetadataBuilder, RecordBuilder};
+        let target = "myApp";
+        let metadata = MetadataBuilder::new().target(target).build();
+        let fmt_args = format_args!("hello");
+        let record_test = RecordBuilder::new()
+            .args(fmt_args)
+            .metadata(metadata)
+            .module_path(Some("foo"))
+            .file(Some("bar"))
+            .line(Some(30))
+            .build();
+        assert_eq!(record_test.metadata().target(), "myApp");
+        assert_eq!(record_test.module_path(), Some("foo"));
+        assert_eq!(record_test.file(), Some("bar"));
+        assert_eq!(record_test.line(), Some(30));
+    }
+
+    #[test]
+    fn test_record_convenience_builder() {
+        use super::{Metadata, Record};
+        let target = "myApp";
+        let metadata = Metadata::builder().target(target).build();
+        let fmt_args = format_args!("hello");
+        let record_test = Record::builder()
+            .args(fmt_args)
+            .metadata(metadata)
+            .module_path(Some("foo"))
+            .file(Some("bar"))
+            .line(Some(30))
+            .build();
+        assert_eq!(record_test.target(), "myApp");
+        assert_eq!(record_test.module_path(), Some("foo"));
+        assert_eq!(record_test.file(), Some("bar"));
+        assert_eq!(record_test.line(), Some(30));
+    }
+
+    #[test]
+    fn test_record_complete_builder() {
+        use super::{Level, Record};
+        let target = "myApp";
+        let record_test = Record::builder()
+            .module_path(Some("foo"))
+            .file(Some("bar"))
+            .line(Some(30))
+            .target(target)
+            .level(Level::Error)
+            .build();
+        assert_eq!(record_test.target(), "myApp");
+        assert_eq!(record_test.level(), Level::Error);
+        assert_eq!(record_test.module_path(), Some("foo"));
+        assert_eq!(record_test.file(), Some("bar"));
+        assert_eq!(record_test.line(), Some(30));
+    }
+
+    #[test]
+    #[cfg(feature = "kv_unstable")]
+    fn test_record_key_values_builder() {
+        use super::Record;
+        use kv::{self, Visitor};
+
+        struct TestVisitor {
+            seen_pairs: usize,
+        }
+
+        impl<'kvs> Visitor<'kvs> for TestVisitor {
+            fn visit_pair(
+                &mut self,
+                _: kv::Key<'kvs>,
+                _: kv::Value<'kvs>,
+            ) -> Result<(), kv::Error> {
+                self.seen_pairs += 1;
+                Ok(())
+            }
+        }
+
+        let kvs: &[(&str, i32)] = &[("a", 1), ("b", 2)];
+        let record_test = Record::builder().key_values(&kvs).build();
+
+        let mut visitor = TestVisitor { seen_pairs: 0 };
+
+        record_test.key_values().visit(&mut visitor).unwrap();
+
+        assert_eq!(2, visitor.seen_pairs);
+    }
+
+    #[test]
+    #[cfg(feature = "kv_unstable")]
+    fn test_record_key_values_get_coerce() {
+        use super::Record;
+
+        let kvs: &[(&str, &str)] = &[("a", "1"), ("b", "2")];
+        let record = Record::builder().key_values(&kvs).build();
+
+        assert_eq!(
+            "2",
+            record
+                .key_values()
+                .get("b".into())
+                .expect("missing key")
+                .to_borrowed_str()
+                .expect("invalid value")
+        );
+    }
+
+    // Test that the `impl Log for Foo` blocks work
+    // This test mostly operates on a type level, so failures will be compile errors
+    #[test]
+    fn test_foreign_impl() {
+        use super::Log;
+        #[cfg(feature = "std")]
+        use std::sync::Arc;
+
+        fn assert_is_log<T: Log + ?Sized>() {}
+
+        assert_is_log::<&dyn Log>();
+
+        #[cfg(feature = "std")]
+        assert_is_log::<Box<dyn Log>>();
+
+        #[cfg(feature = "std")]
+        assert_is_log::<Arc<dyn Log>>();
+
+        // Assert these statements for all T: Log + ?Sized
+        #[allow(unused)]
+        fn forall<T: Log + ?Sized>() {
+            #[cfg(feature = "std")]
+            assert_is_log::<Box<T>>();
+
+            assert_is_log::<&T>();
+
+            #[cfg(feature = "std")]
+            assert_is_log::<Arc<T>>();
+        }
+    }
+}

zeroidc/vendor/log/src/macros.rs

@@ -1,280 +1,280 @@
-// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/// The standard logging macro.
-///
-/// This macro will generically log with the specified `Level` and `format!`
-/// based argument list.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::{log, Level};
-///
-/// # fn main() {
-/// let data = (42, "Forty-two");
-/// let private_data = "private";
-///
-/// log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
-/// log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
-///     data.0, data.1, private_data);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! log {
-    // log!(target: "my_target", Level::Info; key1 = 42, key2 = true; "a {} event", "log");
-    (target: $target:expr, $lvl:expr, $($key:tt = $value:expr),+; $($arg:tt)+) => ({
-        let lvl = $lvl;
-        if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
-            $crate::__private_api_log(
-                __log_format_args!($($arg)+),
-                lvl,
-                &($target, __log_module_path!(), __log_file!(), __log_line!()),
-                $crate::__private_api::Option::Some(&[$((__log_key!($key), &$value)),+])
-            );
-        }
-    });
-
-    // log!(target: "my_target", Level::Info; "a {} event", "log");
-    (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({
-        let lvl = $lvl;
-        if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
-            $crate::__private_api_log(
-                __log_format_args!($($arg)+),
-                lvl,
-                &($target, __log_module_path!(), __log_file!(), __log_line!()),
-                $crate::__private_api::Option::None,
-            );
-        }
-    });
-
-    // log!(Level::Info, "a log event")
-    ($lvl:expr, $($arg:tt)+) => (log!(target: __log_module_path!(), $lvl, $($arg)+));
-}
-
-/// Logs a message at the error level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::error;
-///
-/// # fn main() {
-/// let (err_info, port) = ("No connection", 22);
-///
-/// error!("Error: {} on port {}", err_info, port);
-/// error!(target: "app_events", "App Error: {}, Port: {}", err_info, 22);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! error {
-    // error!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
-    // error!(target: "my_target", "a {} event", "log")
-    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Error, $($arg)+));
-
-    // error!("a {} event", "log")
-    ($($arg:tt)+) => (log!($crate::Level::Error, $($arg)+))
-}
-
-/// Logs a message at the warn level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::warn;
-///
-/// # fn main() {
-/// let warn_description = "Invalid Input";
-///
-/// warn!("Warning! {}!", warn_description);
-/// warn!(target: "input_events", "App received warning: {}", warn_description);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! warn {
-    // warn!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
-    // warn!(target: "my_target", "a {} event", "log")
-    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Warn, $($arg)+));
-
-    // warn!("a {} event", "log")
-    ($($arg:tt)+) => (log!($crate::Level::Warn, $($arg)+))
-}
-
-/// Logs a message at the info level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::info;
-///
-/// # fn main() {
-/// # struct Connection { port: u32, speed: f32 }
-/// let conn_info = Connection { port: 40, speed: 3.20 };
-///
-/// info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);
-/// info!(target: "connection_events", "Successfull connection, port: {}, speed: {}",
-///       conn_info.port, conn_info.speed);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! info {
-    // info!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
-    // info!(target: "my_target", "a {} event", "log")
-    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Info, $($arg)+));
-
-    // info!("a {} event", "log")
-    ($($arg:tt)+) => (log!($crate::Level::Info, $($arg)+))
-}
-
-/// Logs a message at the debug level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::debug;
-///
-/// # fn main() {
-/// # struct Position { x: f32, y: f32 }
-/// let pos = Position { x: 3.234, y: -1.223 };
-///
-/// debug!("New position: x: {}, y: {}", pos.x, pos.y);
-/// debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! debug {
-    // debug!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
-    // debug!(target: "my_target", "a {} event", "log")
-    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Debug, $($arg)+));
-
-    // debug!("a {} event", "log")
-    ($($arg:tt)+) => (log!($crate::Level::Debug, $($arg)+))
-}
-
-/// Logs a message at the trace level.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::trace;
-///
-/// # fn main() {
-/// # struct Position { x: f32, y: f32 }
-/// let pos = Position { x: 3.234, y: -1.223 };
-///
-/// trace!("Position is: x: {}, y: {}", pos.x, pos.y);
-/// trace!(target: "app_events", "x is {} and y is {}",
-///        if pos.x >= 0.0 { "positive" } else { "negative" },
-///        if pos.y >= 0.0 { "positive" } else { "negative" });
-/// # }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! trace {
-    // trace!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
-    // trace!(target: "my_target", "a {} event", "log")
-    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Trace, $($arg)+));
-
-    // trace!("a {} event", "log")
-    ($($arg:tt)+) => (log!($crate::Level::Trace, $($arg)+))
-}
-
-/// Determines if a message logged at the specified level in that module will
-/// be logged.
-///
-/// This can be used to avoid expensive computation of log message arguments if
-/// the message would be ignored anyway.
-///
-/// # Examples
-///
-/// ```edition2018
-/// use log::Level::Debug;
-/// use log::{debug, log_enabled};
-///
-/// # fn foo() {
-/// if log_enabled!(Debug) {
-///     let data = expensive_call();
-///     debug!("expensive debug data: {} {}", data.x, data.y);
-/// }
-/// if log_enabled!(target: "Global", Debug) {
-///    let data = expensive_call();
-///    debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
-/// }
-/// # }
-/// # struct Data { x: u32, y: u32 }
-/// # fn expensive_call() -> Data { Data { x: 0, y: 0 } }
-/// # fn main() {}
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! log_enabled {
-    (target: $target:expr, $lvl:expr) => {{
-        let lvl = $lvl;
-        lvl <= $crate::STATIC_MAX_LEVEL
-            && lvl <= $crate::max_level()
-            && $crate::__private_api_enabled(lvl, $target)
-    }};
-    ($lvl:expr) => {
-        log_enabled!(target: __log_module_path!(), $lvl)
-    };
-}
-
-// The log macro above cannot invoke format_args directly because it uses
-// local_inner_macros. A format_args invocation there would resolve to
-// $crate::format_args which does not exist. Instead invoke format_args here
-// outside of local_inner_macros so that it resolves (probably) to
-// core::format_args or std::format_args. Same for the several macros that
-// follow.
-//
-// This is a workaround until we drop support for pre-1.30 compilers. At that
-// point we can remove use of local_inner_macros, use $crate:: when invoking
-// local macros, and invoke format_args directly.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_format_args {
-    ($($args:tt)*) => {
-        format_args!($($args)*)
-    };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_module_path {
-    () => {
-        module_path!()
-    };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_file {
-    () => {
-        file!()
-    };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_line {
-    () => {
-        line!()
-    };
-}
-
-#[doc(hidden)]
-#[macro_export]
-macro_rules! __log_key {
-    // key1 = 42
-    ($($args:ident)*) => {
-        stringify!($($args)*)
-    };
-    // "key1" = 42
-    ($($args:expr)*) => {
-        $($args)*
-    };
-}
+// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// The standard logging macro.
+///
+/// This macro will generically log with the specified `Level` and `format!`
+/// based argument list.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::{log, Level};
+///
+/// # fn main() {
+/// let data = (42, "Forty-two");
+/// let private_data = "private";
+///
+/// log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
+/// log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
+///     data.0, data.1, private_data);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! log {
+    // log!(target: "my_target", Level::Info; key1 = 42, key2 = true; "a {} event", "log");
+    (target: $target:expr, $lvl:expr, $($key:tt = $value:expr),+; $($arg:tt)+) => ({
+        let lvl = $lvl;
+        if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
+            $crate::__private_api_log(
+                __log_format_args!($($arg)+),
+                lvl,
+                &($target, __log_module_path!(), __log_file!(), __log_line!()),
+                $crate::__private_api::Option::Some(&[$((__log_key!($key), &$value)),+])
+            );
+        }
+    });
+
+    // log!(target: "my_target", Level::Info; "a {} event", "log");
+    (target: $target:expr, $lvl:expr, $($arg:tt)+) => ({
+        let lvl = $lvl;
+        if lvl <= $crate::STATIC_MAX_LEVEL && lvl <= $crate::max_level() {
+            $crate::__private_api_log(
+                __log_format_args!($($arg)+),
+                lvl,
+                &($target, __log_module_path!(), __log_file!(), __log_line!()),
+                $crate::__private_api::Option::None,
+            );
+        }
+    });
+
+    // log!(Level::Info, "a log event")
+    ($lvl:expr, $($arg:tt)+) => (log!(target: __log_module_path!(), $lvl, $($arg)+));
+}
+
+/// Logs a message at the error level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::error;
+///
+/// # fn main() {
+/// let (err_info, port) = ("No connection", 22);
+///
+/// error!("Error: {} on port {}", err_info, port);
+/// error!(target: "app_events", "App Error: {}, Port: {}", err_info, 22);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! error {
+    // error!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
+    // error!(target: "my_target", "a {} event", "log")
+    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Error, $($arg)+));
+
+    // error!("a {} event", "log")
+    ($($arg:tt)+) => (log!($crate::Level::Error, $($arg)+))
+}
+
+/// Logs a message at the warn level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::warn;
+///
+/// # fn main() {
+/// let warn_description = "Invalid Input";
+///
+/// warn!("Warning! {}!", warn_description);
+/// warn!(target: "input_events", "App received warning: {}", warn_description);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! warn {
+    // warn!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
+    // warn!(target: "my_target", "a {} event", "log")
+    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Warn, $($arg)+));
+
+    // warn!("a {} event", "log")
+    ($($arg:tt)+) => (log!($crate::Level::Warn, $($arg)+))
+}
+
+/// Logs a message at the info level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::info;
+///
+/// # fn main() {
+/// # struct Connection { port: u32, speed: f32 }
+/// let conn_info = Connection { port: 40, speed: 3.20 };
+///
+/// info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);
+/// info!(target: "connection_events", "Successfull connection, port: {}, speed: {}",
+///       conn_info.port, conn_info.speed);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! info {
+    // info!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
+    // info!(target: "my_target", "a {} event", "log")
+    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Info, $($arg)+));
+
+    // info!("a {} event", "log")
+    ($($arg:tt)+) => (log!($crate::Level::Info, $($arg)+))
+}
+
+/// Logs a message at the debug level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::debug;
+///
+/// # fn main() {
+/// # struct Position { x: f32, y: f32 }
+/// let pos = Position { x: 3.234, y: -1.223 };
+///
+/// debug!("New position: x: {}, y: {}", pos.x, pos.y);
+/// debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! debug {
+    // debug!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
+    // debug!(target: "my_target", "a {} event", "log")
+    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Debug, $($arg)+));
+
+    // debug!("a {} event", "log")
+    ($($arg:tt)+) => (log!($crate::Level::Debug, $($arg)+))
+}
+
+/// Logs a message at the trace level.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::trace;
+///
+/// # fn main() {
+/// # struct Position { x: f32, y: f32 }
+/// let pos = Position { x: 3.234, y: -1.223 };
+///
+/// trace!("Position is: x: {}, y: {}", pos.x, pos.y);
+/// trace!(target: "app_events", "x is {} and y is {}",
+///        if pos.x >= 0.0 { "positive" } else { "negative" },
+///        if pos.y >= 0.0 { "positive" } else { "negative" });
+/// # }
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! trace {
+    // trace!(target: "my_target", key1 = 42, key2 = true; "a {} event", "log")
+    // trace!(target: "my_target", "a {} event", "log")
+    (target: $target:expr, $($arg:tt)+) => (log!(target: $target, $crate::Level::Trace, $($arg)+));
+
+    // trace!("a {} event", "log")
+    ($($arg:tt)+) => (log!($crate::Level::Trace, $($arg)+))
+}
+
+/// Determines if a message logged at the specified level in that module will
+/// be logged.
+///
+/// This can be used to avoid expensive computation of log message arguments if
+/// the message would be ignored anyway.
+///
+/// # Examples
+///
+/// ```edition2018
+/// use log::Level::Debug;
+/// use log::{debug, log_enabled};
+///
+/// # fn foo() {
+/// if log_enabled!(Debug) {
+///     let data = expensive_call();
+///     debug!("expensive debug data: {} {}", data.x, data.y);
+/// }
+/// if log_enabled!(target: "Global", Debug) {
+///    let data = expensive_call();
+///    debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
+/// }
+/// # }
+/// # struct Data { x: u32, y: u32 }
+/// # fn expensive_call() -> Data { Data { x: 0, y: 0 } }
+/// # fn main() {}
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! log_enabled {
+    (target: $target:expr, $lvl:expr) => {{
+        let lvl = $lvl;
+        lvl <= $crate::STATIC_MAX_LEVEL
+            && lvl <= $crate::max_level()
+            && $crate::__private_api_enabled(lvl, $target)
+    }};
+    ($lvl:expr) => {
+        log_enabled!(target: __log_module_path!(), $lvl)
+    };
+}
+
+// The log macro above cannot invoke format_args directly because it uses
+// local_inner_macros. A format_args invocation there would resolve to
+// $crate::format_args which does not exist. Instead invoke format_args here
+// outside of local_inner_macros so that it resolves (probably) to
+// core::format_args or std::format_args. Same for the several macros that
+// follow.
+//
+// This is a workaround until we drop support for pre-1.30 compilers. At that
+// point we can remove use of local_inner_macros, use $crate:: when invoking
+// local macros, and invoke format_args directly.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_format_args {
+    ($($args:tt)*) => {
+        format_args!($($args)*)
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_module_path {
+    () => {
+        module_path!()
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_file {
+    () => {
+        file!()
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_line {
+    () => {
+        line!()
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __log_key {
+    // key1 = 42
+    ($($args:ident)*) => {
+        stringify!($($args)*)
+    };
+    // "key1" = 42
+    ($($args:expr)*) => {
+        $($args)*
+    };
+}

zeroidc/vendor/log/src/serde.rs

@@ -1,400 +1,400 @@
-#![cfg(feature = "serde")]
-
-extern crate serde;
-use self::serde::de::{
-    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, Unexpected, VariantAccess,
-    Visitor,
-};
-use self::serde::ser::{Serialize, Serializer};
-
-use {Level, LevelFilter, LOG_LEVEL_NAMES};
-
-use std::fmt;
-use std::str::{self, FromStr};
-
-// The Deserialize impls are handwritten to be case insensitive using FromStr.
-
-impl Serialize for Level {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Level::Error => serializer.serialize_unit_variant("Level", 0, "ERROR"),
-            Level::Warn => serializer.serialize_unit_variant("Level", 1, "WARN"),
-            Level::Info => serializer.serialize_unit_variant("Level", 2, "INFO"),
-            Level::Debug => serializer.serialize_unit_variant("Level", 3, "DEBUG"),
-            Level::Trace => serializer.serialize_unit_variant("Level", 4, "TRACE"),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for Level {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct LevelIdentifier;
-
-        impl<'de> Visitor<'de> for LevelIdentifier {
-            type Value = Level;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("log level")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                // Case insensitive.
-                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
-            }
-
-            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                let variant = str::from_utf8(value)
-                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
-
-                self.visit_str(variant)
-            }
-
-            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                let variant = LOG_LEVEL_NAMES[1..]
-                    .get(v as usize)
-                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;
-
-                self.visit_str(variant)
-            }
-        }
-
-        impl<'de> DeserializeSeed<'de> for LevelIdentifier {
-            type Value = Level;
-
-            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                deserializer.deserialize_identifier(LevelIdentifier)
-            }
-        }
-
-        struct LevelEnum;
-
-        impl<'de> Visitor<'de> for LevelEnum {
-            type Value = Level;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("log level")
-            }
-
-            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                let (level, variant) = value.variant_seed(LevelIdentifier)?;
-                // Every variant is a unit variant.
-                variant.unit_variant()?;
-                Ok(level)
-            }
-        }
-
-        deserializer.deserialize_enum("Level", &LOG_LEVEL_NAMES[1..], LevelEnum)
-    }
-}
-
-impl Serialize for LevelFilter {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            LevelFilter::Off => serializer.serialize_unit_variant("LevelFilter", 0, "OFF"),
-            LevelFilter::Error => serializer.serialize_unit_variant("LevelFilter", 1, "ERROR"),
-            LevelFilter::Warn => serializer.serialize_unit_variant("LevelFilter", 2, "WARN"),
-            LevelFilter::Info => serializer.serialize_unit_variant("LevelFilter", 3, "INFO"),
-            LevelFilter::Debug => serializer.serialize_unit_variant("LevelFilter", 4, "DEBUG"),
-            LevelFilter::Trace => serializer.serialize_unit_variant("LevelFilter", 5, "TRACE"),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for LevelFilter {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct LevelFilterIdentifier;
-
-        impl<'de> Visitor<'de> for LevelFilterIdentifier {
-            type Value = LevelFilter;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("log level filter")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                // Case insensitive.
-                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
-            }
-
-            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                let variant = str::from_utf8(value)
-                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
-
-                self.visit_str(variant)
-            }
-
-            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-            where
-                E: Error,
-            {
-                let variant = LOG_LEVEL_NAMES
-                    .get(v as usize)
-                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;
-
-                self.visit_str(variant)
-            }
-        }
-
-        impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
-            type Value = LevelFilter;
-
-            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                deserializer.deserialize_identifier(LevelFilterIdentifier)
-            }
-        }
-
-        struct LevelFilterEnum;
-
-        impl<'de> Visitor<'de> for LevelFilterEnum {
-            type Value = LevelFilter;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("log level filter")
-            }
-
-            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                let (level_filter, variant) = value.variant_seed(LevelFilterIdentifier)?;
-                // Every variant is a unit variant.
-                variant.unit_variant()?;
-                Ok(level_filter)
-            }
-        }
-
-        deserializer.deserialize_enum("LevelFilter", &LOG_LEVEL_NAMES, LevelFilterEnum)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    extern crate serde_test;
-    use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};
-
-    use {Level, LevelFilter};
-
-    fn level_token(variant: &'static str) -> Token {
-        Token::UnitVariant {
-            name: "Level",
-            variant: variant,
-        }
-    }
-
-    fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
-        [
-            Token::Enum { name: "Level" },
-            Token::Bytes(variant),
-            Token::Unit,
-        ]
-    }
-
-    fn level_variant_tokens(variant: u32) -> [Token; 3] {
-        [
-            Token::Enum { name: "Level" },
-            Token::U32(variant),
-            Token::Unit,
-        ]
-    }
-
-    fn level_filter_token(variant: &'static str) -> Token {
-        Token::UnitVariant {
-            name: "LevelFilter",
-            variant: variant,
-        }
-    }
-
-    fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
-        [
-            Token::Enum {
-                name: "LevelFilter",
-            },
-            Token::Bytes(variant),
-            Token::Unit,
-        ]
-    }
-
-    fn level_filter_variant_tokens(variant: u32) -> [Token; 3] {
-        [
-            Token::Enum {
-                name: "LevelFilter",
-            },
-            Token::U32(variant),
-            Token::Unit,
-        ]
-    }
-
-    #[test]
-    fn test_level_ser_de() {
-        let cases = [
-            (Level::Error, [level_token("ERROR")]),
-            (Level::Warn, [level_token("WARN")]),
-            (Level::Info, [level_token("INFO")]),
-            (Level::Debug, [level_token("DEBUG")]),
-            (Level::Trace, [level_token("TRACE")]),
-        ];
-
-        for &(s, expected) in &cases {
-            assert_tokens(&s, &expected);
-        }
-    }
-
-    #[test]
-    fn test_level_case_insensitive() {
-        let cases = [
-            (Level::Error, [level_token("error")]),
-            (Level::Warn, [level_token("warn")]),
-            (Level::Info, [level_token("info")]),
-            (Level::Debug, [level_token("debug")]),
-            (Level::Trace, [level_token("trace")]),
-        ];
-
-        for &(s, expected) in &cases {
-            assert_de_tokens(&s, &expected);
-        }
-    }
-
-    #[test]
-    fn test_level_de_bytes() {
-        let cases = [
-            (Level::Error, level_bytes_tokens(b"ERROR")),
-            (Level::Warn, level_bytes_tokens(b"WARN")),
-            (Level::Info, level_bytes_tokens(b"INFO")),
-            (Level::Debug, level_bytes_tokens(b"DEBUG")),
-            (Level::Trace, level_bytes_tokens(b"TRACE")),
-        ];
-
-        for &(value, tokens) in &cases {
-            assert_de_tokens(&value, &tokens);
-        }
-    }
-
-    #[test]
-    fn test_level_de_variant_index() {
-        let cases = [
-            (Level::Error, level_variant_tokens(0)),
-            (Level::Warn, level_variant_tokens(1)),
-            (Level::Info, level_variant_tokens(2)),
-            (Level::Debug, level_variant_tokens(3)),
-            (Level::Trace, level_variant_tokens(4)),
-        ];
-
-        for &(value, tokens) in &cases {
-            assert_de_tokens(&value, &tokens);
-        }
-    }
-
-    #[test]
-    fn test_level_de_error() {
-        let msg = "unknown variant `errorx`, expected one of \
-                   `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
-        assert_de_tokens_error::<Level>(&[level_token("errorx")], msg);
-    }
-
-    #[test]
-    fn test_level_filter_ser_de() {
-        let cases = [
-            (LevelFilter::Off, [level_filter_token("OFF")]),
-            (LevelFilter::Error, [level_filter_token("ERROR")]),
-            (LevelFilter::Warn, [level_filter_token("WARN")]),
-            (LevelFilter::Info, [level_filter_token("INFO")]),
-            (LevelFilter::Debug, [level_filter_token("DEBUG")]),
-            (LevelFilter::Trace, [level_filter_token("TRACE")]),
-        ];
-
-        for &(s, expected) in &cases {
-            assert_tokens(&s, &expected);
-        }
-    }
-
-    #[test]
-    fn test_level_filter_case_insensitive() {
-        let cases = [
-            (LevelFilter::Off, [level_filter_token("off")]),
-            (LevelFilter::Error, [level_filter_token("error")]),
-            (LevelFilter::Warn, [level_filter_token("warn")]),
-            (LevelFilter::Info, [level_filter_token("info")]),
-            (LevelFilter::Debug, [level_filter_token("debug")]),
-            (LevelFilter::Trace, [level_filter_token("trace")]),
-        ];
-
-        for &(s, expected) in &cases {
-            assert_de_tokens(&s, &expected);
-        }
-    }
-
-    #[test]
-    fn test_level_filter_de_bytes() {
-        let cases = [
-            (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
-            (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
-            (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
-            (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
-            (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
-            (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
-        ];
-
-        for &(value, tokens) in &cases {
-            assert_de_tokens(&value, &tokens);
-        }
-    }
-
-    #[test]
-    fn test_level_filter_de_variant_index() {
-        let cases = [
-            (LevelFilter::Off, level_filter_variant_tokens(0)),
-            (LevelFilter::Error, level_filter_variant_tokens(1)),
-            (LevelFilter::Warn, level_filter_variant_tokens(2)),
-            (LevelFilter::Info, level_filter_variant_tokens(3)),
-            (LevelFilter::Debug, level_filter_variant_tokens(4)),
-            (LevelFilter::Trace, level_filter_variant_tokens(5)),
-        ];
-
-        for &(value, tokens) in &cases {
-            assert_de_tokens(&value, &tokens);
-        }
-    }
-
-    #[test]
-    fn test_level_filter_de_error() {
-        let msg = "unknown variant `errorx`, expected one of \
-                   `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
-        assert_de_tokens_error::<LevelFilter>(&[level_filter_token("errorx")], msg);
-    }
-}
+#![cfg(feature = "serde")]
+
+extern crate serde;
+use self::serde::de::{
+    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, Unexpected, VariantAccess,
+    Visitor,
+};
+use self::serde::ser::{Serialize, Serializer};
+
+use {Level, LevelFilter, LOG_LEVEL_NAMES};
+
+use std::fmt;
+use std::str::{self, FromStr};
+
+// The Deserialize impls are handwritten to be case insensitive using FromStr.
+
+impl Serialize for Level {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            Level::Error => serializer.serialize_unit_variant("Level", 0, "ERROR"),
+            Level::Warn => serializer.serialize_unit_variant("Level", 1, "WARN"),
+            Level::Info => serializer.serialize_unit_variant("Level", 2, "INFO"),
+            Level::Debug => serializer.serialize_unit_variant("Level", 3, "DEBUG"),
+            Level::Trace => serializer.serialize_unit_variant("Level", 4, "TRACE"),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Level {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct LevelIdentifier;
+
+        impl<'de> Visitor<'de> for LevelIdentifier {
+            type Value = Level;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("log level")
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                // Case insensitive.
+                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
+            }
+
+            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                let variant = str::from_utf8(value)
+                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
+
+                self.visit_str(variant)
+            }
+
+            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                let variant = LOG_LEVEL_NAMES[1..]
+                    .get(v as usize)
+                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;
+
+                self.visit_str(variant)
+            }
+        }
+
+        impl<'de> DeserializeSeed<'de> for LevelIdentifier {
+            type Value = Level;
+
+            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                deserializer.deserialize_identifier(LevelIdentifier)
+            }
+        }
+
+        struct LevelEnum;
+
+        impl<'de> Visitor<'de> for LevelEnum {
+            type Value = Level;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("log level")
+            }
+
+            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
+            where
+                A: EnumAccess<'de>,
+            {
+                let (level, variant) = value.variant_seed(LevelIdentifier)?;
+                // Every variant is a unit variant.
+                variant.unit_variant()?;
+                Ok(level)
+            }
+        }
+
+        deserializer.deserialize_enum("Level", &LOG_LEVEL_NAMES[1..], LevelEnum)
+    }
+}
+
+impl Serialize for LevelFilter {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            LevelFilter::Off => serializer.serialize_unit_variant("LevelFilter", 0, "OFF"),
+            LevelFilter::Error => serializer.serialize_unit_variant("LevelFilter", 1, "ERROR"),
+            LevelFilter::Warn => serializer.serialize_unit_variant("LevelFilter", 2, "WARN"),
+            LevelFilter::Info => serializer.serialize_unit_variant("LevelFilter", 3, "INFO"),
+            LevelFilter::Debug => serializer.serialize_unit_variant("LevelFilter", 4, "DEBUG"),
+            LevelFilter::Trace => serializer.serialize_unit_variant("LevelFilter", 5, "TRACE"),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LevelFilter {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct LevelFilterIdentifier;
+
+        impl<'de> Visitor<'de> for LevelFilterIdentifier {
+            type Value = LevelFilter;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("log level filter")
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                // Case insensitive.
+                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
+            }
+
+            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                let variant = str::from_utf8(value)
+                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;
+
+                self.visit_str(variant)
+            }
+
+            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                let variant = LOG_LEVEL_NAMES
+                    .get(v as usize)
+                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;
+
+                self.visit_str(variant)
+            }
+        }
+
+        impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
+            type Value = LevelFilter;
+
+            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                deserializer.deserialize_identifier(LevelFilterIdentifier)
+            }
+        }
+
+        struct LevelFilterEnum;
+
+        impl<'de> Visitor<'de> for LevelFilterEnum {
+            type Value = LevelFilter;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("log level filter")
+            }
+
+            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
+            where
+                A: EnumAccess<'de>,
+            {
+                let (level_filter, variant) = value.variant_seed(LevelFilterIdentifier)?;
+                // Every variant is a unit variant.
+                variant.unit_variant()?;
+                Ok(level_filter)
+            }
+        }
+
+        deserializer.deserialize_enum("LevelFilter", &LOG_LEVEL_NAMES, LevelFilterEnum)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate serde_test;
+    use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};
+
+    use {Level, LevelFilter};
+
+    fn level_token(variant: &'static str) -> Token {
+        Token::UnitVariant {
+            name: "Level",
+            variant: variant,
+        }
+    }
+
+    fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
+        [
+            Token::Enum { name: "Level" },
+            Token::Bytes(variant),
+            Token::Unit,
+        ]
+    }
+
+    fn level_variant_tokens(variant: u32) -> [Token; 3] {
+        [
+            Token::Enum { name: "Level" },
+            Token::U32(variant),
+            Token::Unit,
+        ]
+    }
+
+    fn level_filter_token(variant: &'static str) -> Token {
+        Token::UnitVariant {
+            name: "LevelFilter",
+            variant: variant,
+        }
+    }
+
+    fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
+        [
+            Token::Enum {
+                name: "LevelFilter",
+            },
+            Token::Bytes(variant),
+            Token::Unit,
+        ]
+    }
+
+    fn level_filter_variant_tokens(variant: u32) -> [Token; 3] {
+        [
+            Token::Enum {
+                name: "LevelFilter",
+            },
+            Token::U32(variant),
+            Token::Unit,
+        ]
+    }
+
+    #[test]
+    fn test_level_ser_de() {
+        let cases = [
+            (Level::Error, [level_token("ERROR")]),
+            (Level::Warn, [level_token("WARN")]),
+            (Level::Info, [level_token("INFO")]),
+            (Level::Debug, [level_token("DEBUG")]),
+            (Level::Trace, [level_token("TRACE")]),
+        ];
+
+        for &(s, expected) in &cases {
+            assert_tokens(&s, &expected);
+        }
+    }
+
+    #[test]
+    fn test_level_case_insensitive() {
+        let cases = [
+            (Level::Error, [level_token("error")]),
+            (Level::Warn, [level_token("warn")]),
+            (Level::Info, [level_token("info")]),
+            (Level::Debug, [level_token("debug")]),
+            (Level::Trace, [level_token("trace")]),
+        ];
+
+        for &(s, expected) in &cases {
+            assert_de_tokens(&s, &expected);
+        }
+    }
+
+    #[test]
+    fn test_level_de_bytes() {
+        let cases = [
+            (Level::Error, level_bytes_tokens(b"ERROR")),
+            (Level::Warn, level_bytes_tokens(b"WARN")),
+            (Level::Info, level_bytes_tokens(b"INFO")),
+            (Level::Debug, level_bytes_tokens(b"DEBUG")),
+            (Level::Trace, level_bytes_tokens(b"TRACE")),
+        ];
+
+        for &(value, tokens) in &cases {
+            assert_de_tokens(&value, &tokens);
+        }
+    }
+
+    #[test]
+    fn test_level_de_variant_index() {
+        let cases = [
+            (Level::Error, level_variant_tokens(0)),
+            (Level::Warn, level_variant_tokens(1)),
+            (Level::Info, level_variant_tokens(2)),
+            (Level::Debug, level_variant_tokens(3)),
+            (Level::Trace, level_variant_tokens(4)),
+        ];
+
+        for &(value, tokens) in &cases {
+            assert_de_tokens(&value, &tokens);
+        }
+    }
+
+    #[test]
+    fn test_level_de_error() {
+        let msg = "unknown variant `errorx`, expected one of \
+                   `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
+        assert_de_tokens_error::<Level>(&[level_token("errorx")], msg);
+    }
+
+    #[test]
+    fn test_level_filter_ser_de() {
+        let cases = [
+            (LevelFilter::Off, [level_filter_token("OFF")]),
+            (LevelFilter::Error, [level_filter_token("ERROR")]),
+            (LevelFilter::Warn, [level_filter_token("WARN")]),
+            (LevelFilter::Info, [level_filter_token("INFO")]),
+            (LevelFilter::Debug, [level_filter_token("DEBUG")]),
+            (LevelFilter::Trace, [level_filter_token("TRACE")]),
+        ];
+
+        for &(s, expected) in &cases {
+            assert_tokens(&s, &expected);
+        }
+    }
+
+    #[test]
+    fn test_level_filter_case_insensitive() {
+        let cases = [
+            (LevelFilter::Off, [level_filter_token("off")]),
+            (LevelFilter::Error, [level_filter_token("error")]),
+            (LevelFilter::Warn, [level_filter_token("warn")]),
+            (LevelFilter::Info, [level_filter_token("info")]),
+            (LevelFilter::Debug, [level_filter_token("debug")]),
+            (LevelFilter::Trace, [level_filter_token("trace")]),
+        ];
+
+        for &(s, expected) in &cases {
+            assert_de_tokens(&s, &expected);
+        }
+    }
+
+    #[test]
+    fn test_level_filter_de_bytes() {
+        let cases = [
+            (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
+            (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
+            (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
+            (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
+            (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
+            (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
+        ];
+
+        for &(value, tokens) in &cases {
+            assert_de_tokens(&value, &tokens);
+        }
+    }
+
+    #[test]
+    fn test_level_filter_de_variant_index() {
+        let cases = [
+            (LevelFilter::Off, level_filter_variant_tokens(0)),
+            (LevelFilter::Error, level_filter_variant_tokens(1)),
+            (LevelFilter::Warn, level_filter_variant_tokens(2)),
+            (LevelFilter::Info, level_filter_variant_tokens(3)),
+            (LevelFilter::Debug, level_filter_variant_tokens(4)),
+            (LevelFilter::Trace, level_filter_variant_tokens(5)),
+        ];
+
+        for &(value, tokens) in &cases {
+            assert_de_tokens(&value, &tokens);
+        }
+    }
+
+    #[test]
+    fn test_level_filter_de_error() {
+        let msg = "unknown variant `errorx`, expected one of \
+                   `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
+        assert_de_tokens_error::<LevelFilter>(&[level_filter_token("errorx")], msg);
+    }
+}

zeroidc/vendor/log/triagebot.toml

@@ -1 +1 @@
-[assign]
+[assign]

zeroidc/vendor/remove_dir_all/LICENCE-APACHE

@@ -1,191 +1,191 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-Copyright 2017 Aaron Power
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2017 Aaron Power
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

zeroidc/vendor/remove_dir_all/LICENCE-MIT

@@ -1,26 +1,26 @@
-Copyright (c) 2017 Aaron Power
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
+Copyright (c) 2017 Aaron Power
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+

zeroidc/vendor/remove_dir_all/README.md

@@ -1,20 +1,20 @@
-# remove_dir_all
-
-[![Latest Version](https://img.shields.io/crates/v/remove_dir_all.svg)](https://crates.io/crates/remove_dir_all)
-[![Docs](https://docs.rs/remove_dir_all/badge.svg)](https://docs.rs/remove_dir_all)
-[![License](https://img.shields.io/github/license/XAMPPRocky/remove_dir_all.svg)](https://github.com/XAMPPRocky/remove_dir_all)
-
-## Description
-
-A reliable implementation of `remove_dir_all` for Windows. For Unix systems
-re-exports `std::fs::remove_dir_all`.
-
-```rust,no_run
-extern crate remove_dir_all;
-
-use remove_dir_all::*;
-
-fn main() {
-    remove_dir_all("./temp/").unwrap();
-}
-```
+# remove_dir_all
+
+[![Latest Version](https://img.shields.io/crates/v/remove_dir_all.svg)](https://crates.io/crates/remove_dir_all)
+[![Docs](https://docs.rs/remove_dir_all/badge.svg)](https://docs.rs/remove_dir_all)
+[![License](https://img.shields.io/github/license/XAMPPRocky/remove_dir_all.svg)](https://github.com/XAMPPRocky/remove_dir_all)
+
+## Description
+
+A reliable implementation of `remove_dir_all` for Windows. For Unix systems
+re-exports `std::fs::remove_dir_all`.
+
+```rust,no_run
+extern crate remove_dir_all;
+
+use remove_dir_all::*;
+
+fn main() {
+    remove_dir_all("./temp/").unwrap();
+}
+```

zeroidc/vendor/remove_dir_all/src/fs.rs

@@ -1,278 +1,278 @@
-use std::ffi::OsString;
-use std::fs::{self, File, OpenOptions};
-use std::os::windows::prelude::*;
-use std::path::{Path, PathBuf};
-use std::{io, ptr};
-
-use winapi::shared::minwindef::*;
-use winapi::shared::winerror::*;
-use winapi::um::errhandlingapi::*;
-use winapi::um::fileapi::*;
-use winapi::um::minwinbase::*;
-use winapi::um::winbase::*;
-use winapi::um::winnt::*;
-
-pub const VOLUME_NAME_DOS: DWORD = 0x0;
-
-struct RmdirContext<'a> {
-    base_dir: &'a Path,
-    readonly: bool,
-    counter: u64,
-}
-
-/// Reliably removes a directory and all of its children.
-///
-/// ```rust
-/// extern crate remove_dir_all;
-///
-/// use std::fs;
-/// use remove_dir_all::*;
-///
-/// fn main() {
-///     fs::create_dir("./temp/").unwrap();
-///     remove_dir_all("./temp/").unwrap();
-/// }
-/// ```
-pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
-    // On Windows it is not enough to just recursively remove the contents of a
-    // directory and then the directory itself. Deleting does not happen
-    // instantaneously, but is scheduled.
-    // To work around this, we move the file or directory to some `base_dir`
-    // right before deletion to avoid races.
-    //
-    // As `base_dir` we choose the parent dir of the directory we want to
-    // remove. We very probably have permission to create files here, as we
-    // already need write permission in this dir to delete the directory. And it
-    // should be on the same volume.
-    //
-    // To handle files with names like `CON` and `morse .. .`,  and when a
-    // directory structure is so deep it needs long path names the path is first
-    // converted to a `//?/`-path with `get_path()`.
-    //
-    // To make sure we don't leave a moved file laying around if the process
-    // crashes before we can delete the file, we do all operations on an file
-    // handle. By opening a file with `FILE_FLAG_DELETE_ON_CLOSE` Windows will
-    // always delete the file when the handle closes.
-    //
-    // All files are renamed to be in the `base_dir`, and have their name
-    // changed to "rm-<counter>". After every rename the counter is increased.
-    // Rename should not overwrite possibly existing files in the base dir. So
-    // if it fails with `AlreadyExists`, we just increase the counter and try
-    // again.
-    //
-    // For read-only files and directories we first have to remove the read-only
-    // attribute before we can move or delete them. This also removes the
-    // attribute from possible hardlinks to the file, so just before closing we
-    // restore the read-only attribute.
-    //
-    // If 'path' points to a directory symlink or junction we should not
-    // recursively remove the target of the link, but only the link itself.
-    //
-    // Moving and deleting is guaranteed to succeed if we are able to open the
-    // file with `DELETE` permission. If others have the file open we only have
-    // `DELETE` permission if they have specified `FILE_SHARE_DELETE`. We can
-    // also delete the file now, but it will not disappear until all others have
-    // closed the file. But no-one can open the file after we have flagged it
-    // for deletion.
-
-    // Open the path once to get the canonical path, file type and attributes.
-    let (path, metadata) = {
-        let path = path.as_ref();
-        let mut opts = OpenOptions::new();
-        opts.access_mode(FILE_READ_ATTRIBUTES);
-        opts.custom_flags(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT);
-        let file = opts.open(path)?;
-        (get_path(&file)?, path.metadata()?)
-    };
-
-    let mut ctx = RmdirContext {
-        base_dir: match path.parent() {
-            Some(dir) => dir,
-            None => {
-                return Err(io::Error::new(
-                    io::ErrorKind::PermissionDenied,
-                    "Can't delete root directory",
-                ))
-            }
-        },
-        readonly: metadata.permissions().readonly(),
-        counter: 0,
-    };
-
-    let filetype = metadata.file_type();
-    if filetype.is_dir() {
-        if !filetype.is_symlink() {
-            remove_dir_all_recursive(path.as_ref(), &mut ctx)
-        } else {
-            remove_item(path.as_ref(), &mut ctx)
-        }
-    } else {
-        Err(io::Error::new(
-            io::ErrorKind::PermissionDenied,
-            "Not a directory",
-        ))
-    }
-}
-
-fn remove_item(path: &Path, ctx: &mut RmdirContext) -> io::Result<()> {
-    if ctx.readonly {
-        // remove read-only permision
-        let mut permissions = path.metadata()?.permissions();
-        permissions.set_readonly(false);
-
-        fs::set_permissions(path, permissions)?;
-    }
-
-    let mut opts = OpenOptions::new();
-    opts.access_mode(DELETE);
-    opts.custom_flags(
-        FILE_FLAG_BACKUP_SEMANTICS | // delete directory
-                        FILE_FLAG_OPEN_REPARSE_POINT | // delete symlink
-                        FILE_FLAG_DELETE_ON_CLOSE,
-    );
-    let file = opts.open(path)?;
-    move_item(&file, ctx)?;
-
-    if ctx.readonly {
-        // restore read-only flag just in case there are other hard links
-        match fs::metadata(&path) {
-            Ok(metadata) => {
-                let mut perm = metadata.permissions();
-                perm.set_readonly(true);
-                fs::set_permissions(&path, perm)?;
-            }
-            Err(ref err) if err.kind() == io::ErrorKind::NotFound => {}
-            err => return err.map(|_| ()),
-        }
-    }
-
-    Ok(())
-}
-
-fn move_item(file: &File, ctx: &mut RmdirContext) -> io::Result<()> {
-    let mut tmpname = ctx.base_dir.join(format! {"rm-{}", ctx.counter});
-    ctx.counter += 1;
-
-    // Try to rename the file. If it already exists, just retry with an other
-    // filename.
-    while let Err(err) = rename(file, &tmpname, false) {
-        if err.kind() != io::ErrorKind::AlreadyExists {
-            return Err(err);
-        };
-        tmpname = ctx.base_dir.join(format!("rm-{}", ctx.counter));
-        ctx.counter += 1;
-    }
-
-    Ok(())
-}
-
-fn rename(file: &File, new: &Path, replace: bool) -> io::Result<()> {
-    // &self must be opened with DELETE permission
-    use std::iter;
-    #[cfg(target_pointer_width = "32")]
-    const STRUCT_SIZE: usize = 12;
-    #[cfg(target_pointer_width = "64")]
-    const STRUCT_SIZE: usize = 20;
-
-    // FIXME: check for internal NULs in 'new'
-    let mut data: Vec<u16> = iter::repeat(0u16)
-        .take(STRUCT_SIZE / 2)
-        .chain(new.as_os_str().encode_wide())
-        .collect();
-    data.push(0);
-    let size = data.len() * 2;
-
-    unsafe {
-        // Thanks to alignment guarantees on Windows this works
-        // (8 for 32-bit and 16 for 64-bit)
-        let info = data.as_mut_ptr() as *mut FILE_RENAME_INFO;
-        // The type of ReplaceIfExists is BOOL, but it actually expects a
-        // BOOLEAN. This means true is -1, not c::TRUE.
-        (*info).ReplaceIfExists = if replace { -1 } else { FALSE };
-        (*info).RootDirectory = ptr::null_mut();
-        (*info).FileNameLength = (size - STRUCT_SIZE) as DWORD;
-        let result = SetFileInformationByHandle(
-            file.as_raw_handle(),
-            FileRenameInfo,
-            data.as_mut_ptr() as *mut _ as *mut _,
-            size as DWORD,
-        );
-
-        if result == 0 {
-            Err(io::Error::last_os_error())
-        } else {
-            Ok(())
-        }
-    }
-}
-
-fn get_path(f: &File) -> io::Result<PathBuf> {
-    fill_utf16_buf(
-        |buf, sz| unsafe { GetFinalPathNameByHandleW(f.as_raw_handle(), buf, sz, VOLUME_NAME_DOS) },
-        |buf| PathBuf::from(OsString::from_wide(buf)),
-    )
-}
-
-fn remove_dir_all_recursive(path: &Path, ctx: &mut RmdirContext) -> io::Result<()> {
-    let dir_readonly = ctx.readonly;
-    for child in fs::read_dir(path)? {
-        let child = child?;
-        let child_type = child.file_type()?;
-        ctx.readonly = child.metadata()?.permissions().readonly();
-        if child_type.is_dir() {
-            remove_dir_all_recursive(&child.path(), ctx)?;
-        } else {
-            remove_item(&child.path().as_ref(), ctx)?;
-        }
-    }
-    ctx.readonly = dir_readonly;
-    remove_item(path, ctx)
-}
-
-fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> io::Result<T>
-where
-    F1: FnMut(*mut u16, DWORD) -> DWORD,
-    F2: FnOnce(&[u16]) -> T,
-{
-    // Start off with a stack buf but then spill over to the heap if we end up
-    // needing more space.
-    let mut stack_buf = [0u16; 512];
-    let mut heap_buf = Vec::new();
-    unsafe {
-        let mut n = stack_buf.len();
-
-        loop {
-            let buf = if n <= stack_buf.len() {
-                &mut stack_buf[..]
-            } else {
-                let extra = n - heap_buf.len();
-                heap_buf.reserve(extra);
-                heap_buf.set_len(n);
-                &mut heap_buf[..]
-            };
-
-            // This function is typically called on windows API functions which
-            // will return the correct length of the string, but these functions
-            // also return the `0` on error. In some cases, however, the
-            // returned "correct length" may actually be 0!
-            //
-            // To handle this case we call `SetLastError` to reset it to 0 and
-            // then check it again if we get the "0 error value". If the "last
-            // error" is still 0 then we interpret it as a 0 length buffer and
-            // not an actual error.
-            SetLastError(0);
-            let k = match f1(buf.as_mut_ptr(), n as DWORD) {
-                0 if GetLastError() == 0 => 0,
-                0 => return Err(io::Error::last_os_error()),
-                n => n,
-            } as usize;
-            if k == n && GetLastError() == ERROR_INSUFFICIENT_BUFFER {
-                n *= 2;
-            } else if k >= n {
-                n = k;
-            } else {
-                return Ok(f2(&buf[..k]));
-            }
-        }
-    }
-}
+use std::ffi::OsString;
+use std::fs::{self, File, OpenOptions};
+use std::os::windows::prelude::*;
+use std::path::{Path, PathBuf};
+use std::{io, ptr};
+
+use winapi::shared::minwindef::*;
+use winapi::shared::winerror::*;
+use winapi::um::errhandlingapi::*;
+use winapi::um::fileapi::*;
+use winapi::um::minwinbase::*;
+use winapi::um::winbase::*;
+use winapi::um::winnt::*;
+
+pub const VOLUME_NAME_DOS: DWORD = 0x0;
+
+struct RmdirContext<'a> {
+    base_dir: &'a Path,
+    readonly: bool,
+    counter: u64,
+}
+
+/// Reliably removes a directory and all of its children.
+///
+/// ```rust
+/// extern crate remove_dir_all;
+///
+/// use std::fs;
+/// use remove_dir_all::*;
+///
+/// fn main() {
+///     fs::create_dir("./temp/").unwrap();
+///     remove_dir_all("./temp/").unwrap();
+/// }
+/// ```
+pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
+    // On Windows it is not enough to just recursively remove the contents of a
+    // directory and then the directory itself. Deleting does not happen
+    // instantaneously, but is scheduled.
+    // To work around this, we move the file or directory to some `base_dir`
+    // right before deletion to avoid races.
+    //
+    // As `base_dir` we choose the parent dir of the directory we want to
+    // remove. We very probably have permission to create files here, as we
+    // already need write permission in this dir to delete the directory. And it
+    // should be on the same volume.
+    //
+    // To handle files with names like `CON` and `morse .. .`,  and when a
+    // directory structure is so deep it needs long path names the path is first
+    // converted to a `//?/`-path with `get_path()`.
+    //
+    // To make sure we don't leave a moved file laying around if the process
+    // crashes before we can delete the file, we do all operations on an file
+    // handle. By opening a file with `FILE_FLAG_DELETE_ON_CLOSE` Windows will
+    // always delete the file when the handle closes.
+    //
+    // All files are renamed to be in the `base_dir`, and have their name
+    // changed to "rm-<counter>". After every rename the counter is increased.
+    // Rename should not overwrite possibly existing files in the base dir. So
+    // if it fails with `AlreadyExists`, we just increase the counter and try
+    // again.
+    //
+    // For read-only files and directories we first have to remove the read-only
+    // attribute before we can move or delete them. This also removes the
+    // attribute from possible hardlinks to the file, so just before closing we
+    // restore the read-only attribute.
+    //
+    // If 'path' points to a directory symlink or junction we should not
+    // recursively remove the target of the link, but only the link itself.
+    //
+    // Moving and deleting is guaranteed to succeed if we are able to open the
+    // file with `DELETE` permission. If others have the file open we only have
+    // `DELETE` permission if they have specified `FILE_SHARE_DELETE`. We can
+    // also delete the file now, but it will not disappear until all others have
+    // closed the file. But no-one can open the file after we have flagged it
+    // for deletion.
+
+    // Open the path once to get the canonical path, file type and attributes.
+    let (path, metadata) = {
+        let path = path.as_ref();
+        let mut opts = OpenOptions::new();
+        opts.access_mode(FILE_READ_ATTRIBUTES);
+        opts.custom_flags(FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT);
+        let file = opts.open(path)?;
+        (get_path(&file)?, path.metadata()?)
+    };
+
+    let mut ctx = RmdirContext {
+        base_dir: match path.parent() {
+            Some(dir) => dir,
+            None => {
+                return Err(io::Error::new(
+                    io::ErrorKind::PermissionDenied,
+                    "Can't delete root directory",
+                ))
+            }
+        },
+        readonly: metadata.permissions().readonly(),
+        counter: 0,
+    };
+
+    let filetype = metadata.file_type();
+    if filetype.is_dir() {
+        if !filetype.is_symlink() {
+            remove_dir_all_recursive(path.as_ref(), &mut ctx)
+        } else {
+            remove_item(path.as_ref(), &mut ctx)
+        }
+    } else {
+        Err(io::Error::new(
+            io::ErrorKind::PermissionDenied,
+            "Not a directory",
+        ))
+    }
+}
+
+fn remove_item(path: &Path, ctx: &mut RmdirContext) -> io::Result<()> {
+    if ctx.readonly {
+        // remove read-only permision
+        let mut permissions = path.metadata()?.permissions();
+        permissions.set_readonly(false);
+
+        fs::set_permissions(path, permissions)?;
+    }
+
+    let mut opts = OpenOptions::new();
+    opts.access_mode(DELETE);
+    opts.custom_flags(
+        FILE_FLAG_BACKUP_SEMANTICS | // delete directory
+                        FILE_FLAG_OPEN_REPARSE_POINT | // delete symlink
+                        FILE_FLAG_DELETE_ON_CLOSE,
+    );
+    let file = opts.open(path)?;
+    move_item(&file, ctx)?;
+
+    if ctx.readonly {
+        // restore read-only flag just in case there are other hard links
+        match fs::metadata(&path) {
+            Ok(metadata) => {
+                let mut perm = metadata.permissions();
+                perm.set_readonly(true);
+                fs::set_permissions(&path, perm)?;
+            }
+            Err(ref err) if err.kind() == io::ErrorKind::NotFound => {}
+            err => return err.map(|_| ()),
+        }
+    }
+
+    Ok(())
+}
+
+fn move_item(file: &File, ctx: &mut RmdirContext) -> io::Result<()> {
+    let mut tmpname = ctx.base_dir.join(format! {"rm-{}", ctx.counter});
+    ctx.counter += 1;
+
+    // Try to rename the file. If it already exists, just retry with an other
+    // filename.
+    while let Err(err) = rename(file, &tmpname, false) {
+        if err.kind() != io::ErrorKind::AlreadyExists {
+            return Err(err);
+        };
+        tmpname = ctx.base_dir.join(format!("rm-{}", ctx.counter));
+        ctx.counter += 1;
+    }
+
+    Ok(())
+}
+
+fn rename(file: &File, new: &Path, replace: bool) -> io::Result<()> {
+    // &self must be opened with DELETE permission
+    use std::iter;
+    #[cfg(target_pointer_width = "32")]
+    const STRUCT_SIZE: usize = 12;
+    #[cfg(target_pointer_width = "64")]
+    const STRUCT_SIZE: usize = 20;
+
+    // FIXME: check for internal NULs in 'new'
+    let mut data: Vec<u16> = iter::repeat(0u16)
+        .take(STRUCT_SIZE / 2)
+        .chain(new.as_os_str().encode_wide())
+        .collect();
+    data.push(0);
+    let size = data.len() * 2;
+
+    unsafe {
+        // Thanks to alignment guarantees on Windows this works
+        // (8 for 32-bit and 16 for 64-bit)
+        let info = data.as_mut_ptr() as *mut FILE_RENAME_INFO;
+        // The type of ReplaceIfExists is BOOL, but it actually expects a
+        // BOOLEAN. This means true is -1, not c::TRUE.
+        (*info).ReplaceIfExists = if replace { -1 } else { FALSE };
+        (*info).RootDirectory = ptr::null_mut();
+        (*info).FileNameLength = (size - STRUCT_SIZE) as DWORD;
+        let result = SetFileInformationByHandle(
+            file.as_raw_handle(),
+            FileRenameInfo,
+            data.as_mut_ptr() as *mut _ as *mut _,
+            size as DWORD,
+        );
+
+        if result == 0 {
+            Err(io::Error::last_os_error())
+        } else {
+            Ok(())
+        }
+    }
+}
+
+fn get_path(f: &File) -> io::Result<PathBuf> {
+    fill_utf16_buf(
+        |buf, sz| unsafe { GetFinalPathNameByHandleW(f.as_raw_handle(), buf, sz, VOLUME_NAME_DOS) },
+        |buf| PathBuf::from(OsString::from_wide(buf)),
+    )
+}
+
+fn remove_dir_all_recursive(path: &Path, ctx: &mut RmdirContext) -> io::Result<()> {
+    let dir_readonly = ctx.readonly;
+    for child in fs::read_dir(path)? {
+        let child = child?;
+        let child_type = child.file_type()?;
+        ctx.readonly = child.metadata()?.permissions().readonly();
+        if child_type.is_dir() {
+            remove_dir_all_recursive(&child.path(), ctx)?;
+        } else {
+            remove_item(&child.path().as_ref(), ctx)?;
+        }
+    }
+    ctx.readonly = dir_readonly;
+    remove_item(path, ctx)
+}
+
+fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> io::Result<T>
+where
+    F1: FnMut(*mut u16, DWORD) -> DWORD,
+    F2: FnOnce(&[u16]) -> T,
+{
+    // Start off with a stack buf but then spill over to the heap if we end up
+    // needing more space.
+    let mut stack_buf = [0u16; 512];
+    let mut heap_buf = Vec::new();
+    unsafe {
+        let mut n = stack_buf.len();
+
+        loop {
+            let buf = if n <= stack_buf.len() {
+                &mut stack_buf[..]
+            } else {
+                let extra = n - heap_buf.len();
+                heap_buf.reserve(extra);
+                heap_buf.set_len(n);
+                &mut heap_buf[..]
+            };
+
+            // This function is typically called on windows API functions which
+            // will return the correct length of the string, but these functions
+            // also return the `0` on error. In some cases, however, the
+            // returned "correct length" may actually be 0!
+            //
+            // To handle this case we call `SetLastError` to reset it to 0 and
+            // then check it again if we get the "0 error value". If the "last
+            // error" is still 0 then we interpret it as a 0 length buffer and
+            // not an actual error.
+            SetLastError(0);
+            let k = match f1(buf.as_mut_ptr(), n as DWORD) {
+                0 if GetLastError() == 0 => 0,
+                0 => return Err(io::Error::last_os_error()),
+                n => n,
+            } as usize;
+            if k == n && GetLastError() == ERROR_INSUFFICIENT_BUFFER {
+                n *= 2;
+            } else if k >= n {
+                n = k;
+            } else {
+                return Ok(f2(&buf[..k]));
+            }
+        }
+    }
+}

zeroidc/vendor/remove_dir_all/src/lib.rs

@@ -1,26 +1,26 @@
-//! Reliably remove a directory and all of its children.
-//!
-//! This library provides a reliable implementation of `remove_dir_all` for Windows.
-//! For Unix systems, it re-exports `std::fs::remove_dir_all`.
-
-#![deny(missing_debug_implementations)]
-#![deny(missing_docs)]
-
-#[cfg(windows)]
-extern crate winapi;
-
-#[cfg(doctest)]
-#[macro_use]
-extern crate doc_comment;
-
-#[cfg(doctest)]
-doctest!("../README.md");
-
-#[cfg(windows)]
-mod fs;
-
-#[cfg(windows)]
-pub use self::fs::remove_dir_all;
-
-#[cfg(not(windows))]
-pub use std::fs::remove_dir_all;
+//! Reliably remove a directory and all of its children.
+//!
+//! This library provides a reliable implementation of `remove_dir_all` for Windows.
+//! For Unix systems, it re-exports `std::fs::remove_dir_all`.
+
+#![deny(missing_debug_implementations)]
+#![deny(missing_docs)]
+
+#[cfg(windows)]
+extern crate winapi;
+
+#[cfg(doctest)]
+#[macro_use]
+extern crate doc_comment;
+
+#[cfg(doctest)]
+doctest!("../README.md");
+
+#[cfg(windows)]
+mod fs;
+
+#[cfg(windows)]
+pub use self::fs::remove_dir_all;
+
+#[cfg(not(windows))]
+pub use std::fs::remove_dir_all;

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA1Monte.rsp

@@ -1,309 +1,309 @@
-#  CAVS 11.1
-#  "SHA-1 Monte" information for "sha_values"
-#  SHA tests are configured for BYTE oriented implementations
-#  Generated on Wed May 11 17:26:02 2011
-
-[L = 20]
-
-Seed = dd4df644eaf3d85bace2b21accaa22b28821f5cd
-
-COUNT = 0
-MD = 11f5c38b4479d4ad55cb69fadf62de0b036d5163
-
-COUNT = 1
-MD = 5c26de848c21586bec36995809cb02d3677423d9
-
-COUNT = 2
-MD = 453b5fcf263d01c891d7897d4013990f7c1fb0ab
-
-COUNT = 3
-MD = 36d0273ae363f992bbc313aa4ff602e95c207be3
-
-COUNT = 4
-MD = d1c65e9ac55727fbf30eaf5f00cc22b9bab81a2c
-
-COUNT = 5
-MD = 2c477cd77e5749da7fc4e5ca7eed77166e8ceae6
-
-COUNT = 6
-MD = 60b11211137f46863501a32a435976eabd4532f3
-
-COUNT = 7
-MD = 0894f4f012a1e5344044e0ecfa6f078382064602
-
-COUNT = 8
-MD = 06b6222855cae9bed77e9e3050d164a98286ea5f
-
-COUNT = 9
-MD = e2872694d3d23a68a24419c35bd9ac9006248a8f
-
-COUNT = 10
-MD = ea43595eb1cff3a7e045c5868d0775b4409b14a3
-
-COUNT = 11
-MD = 05a9e94fdc792a61aa60bcd37592acee1f983280
-
-COUNT = 12
-MD = 7d11aa9413cd89a387a5c0f9aa5ce541be2aa6e8
-
-COUNT = 13
-MD = 37297d053aaa4a845cc9ce0c0165644ab8d0e00b
-
-COUNT = 14
-MD = d9dcde396d69748c1fe357f8b662a27ce89082c8
-
-COUNT = 15
-MD = 737a484499b6858b14e656c328979e8aa56b0a43
-
-COUNT = 16
-MD = 4e9c8b3bce910432ac2ad17d51e6b9ec4f92c1ad
-
-COUNT = 17
-MD = 62325b9a7cebcc6da3bfe781d84eb53a6eb7b019
-
-COUNT = 18
-MD = 4710670e071609d470f7d628d8ea978dfb9234ac
-
-COUNT = 19
-MD = 23baee80eee052f3263ac26dd12ea6504a5bd234
-
-COUNT = 20
-MD = 9451efb9c9586a403747acfa3ec74d359bb9d7ff
-
-COUNT = 21
-MD = 37e9d7c81b79f090c8e05848050936c64a1bd662
-
-COUNT = 22
-MD = a6489ff37141f7a86dd978f685fdd4789d1993dc
-
-COUNT = 23
-MD = 39650d32501dfcee212d0de10af9db47e4e5af65
-
-COUNT = 24
-MD = cd4ea3474e046b281da5a4bf69fd873ef8d568d6
-
-COUNT = 25
-MD = 0d7b518c07c6da877eee35301a99c7563f1840df
-
-COUNT = 26
-MD = 68a70ae466532f7f61af138889c0d3f9670f3590
-
-COUNT = 27
-MD = c0222aae5fd2b9eff143ac93c4493abe5c8806af
-
-COUNT = 28
-MD = d2efc5aa0b29db15f3e5de82aaa0a8ce888ffb2f
-
-COUNT = 29
-MD = eec4f55d02c627dcee36b5b5606603bdc9a94a26
-
-COUNT = 30
-MD = 0e706fb1a1fa26aab74efcef57ab6a49c07ca7bd
-
-COUNT = 31
-MD = 2ea392ca8043686424f7e9500edfb9e9297943f7
-
-COUNT = 32
-MD = 74737ef257b32a4cb9428c866b65bee62ccbe653
-
-COUNT = 33
-MD = df3e86e49a0429fa81f553b04b9fc003510e9a51
-
-COUNT = 34
-MD = 79c3049944fbf8b80dadadc7f5174e5cfdf996de
-
-COUNT = 35
-MD = f25e2eca4cfb6da8e8b7b62f581672fab80754fa
-
-COUNT = 36
-MD = 76509239d9fd6c6f050c0d9b3777b5645e4d4c70
-
-COUNT = 37
-MD = cf4bb3e1f330c862e239d9b010bd842f302bd227
-
-COUNT = 38
-MD = 4eeac7ab2ac9e4c81ed1a93a300b2af75beddb08
-
-COUNT = 39
-MD = 46443ba72a64fff4b5252fbac9ef93c2949f8585
-
-COUNT = 40
-MD = 5e9c42482343a54aadb11ab00c2e00cbe25ec91a
-
-COUNT = 41
-MD = 93acee1977128f2a4218678b32e2844f23eb526b
-
-COUNT = 42
-MD = 226065d299b2d6c582d386897b93f2adf14de00b
-
-COUNT = 43
-MD = 672fed0d90c21d4ec0111a7284bcf1bbd72af9bd
-
-COUNT = 44
-MD = 90d642f12f28cb3dad7daad84cf0f94ded1137ae
-
-COUNT = 45
-MD = 4a2815b58ffc858e5e7e9e6106765458d2af4ec3
-
-COUNT = 46
-MD = 29fa3679032421b78b7a08c54766c1592f6739c1
-
-COUNT = 47
-MD = 19f4e30393eb66c6e200744fa8999d224e6df173
-
-COUNT = 48
-MD = 30650026be77212088ab50438e04b4b8e3761977
-
-COUNT = 49
-MD = 993d0e135bcd598fa673c6f19251bcbde18b7b34
-
-COUNT = 50
-MD = c9eaf20b473219a70efe85940620426c6ff6f4a4
-
-COUNT = 51
-MD = 6325d0b83c308bd42854ce69446e85ba36348d7d
-
-COUNT = 52
-MD = 2fb354f8a68030efb747f78812060a9c05e92164
-
-COUNT = 53
-MD = a7e33bd16f770c17e8818ad5a5fc4fee673eae56
-
-COUNT = 54
-MD = ff23e7105bc9f4dad0fb9c6519d1eae16439a5d6
-
-COUNT = 55
-MD = a31aca821e163213cd2ae84cf56c1134daa4a621
-
-COUNT = 56
-MD = 94ab9cfd4cf9bf2e4409dbcdc9ef2c8b611cc69d
-
-COUNT = 57
-MD = c0194064ce48dde771b7871efa86a4a6e87eec76
-
-COUNT = 58
-MD = f1a9065e3e7f98753c6f833f5ffe74133f6b887f
-
-COUNT = 59
-MD = b8b3cd6ca1d5b5610e43212f8df75211aaddcf96
-
-COUNT = 60
-MD = 33c3a8d739cc2f83be597aa11c43e2ad6f0d2436
-
-COUNT = 61
-MD = 4f5c67e5110f3663b7aa88759dbba6fa82f2d705
-
-COUNT = 62
-MD = b1ebc87c7b2b8fe73e7a882d3f4f0492946e0d7c
-
-COUNT = 63
-MD = 01566616fe4a8c7cf22f21031ac6ea7fb7ce15db
-
-COUNT = 64
-MD = 5650f3517a393792781d23b4c9d360bf8bd31d65
-
-COUNT = 65
-MD = a4fdbd24cb4a328b898b804b103caa98baedd3fa
-
-COUNT = 66
-MD = 0cf01eecec4b85aa39f40aa9b4dce208d68eb17b
-
-COUNT = 67
-MD = ae9ac147bab7c10609abe6e931a5ab087a41dc5a
-
-COUNT = 68
-MD = c0328145ce63fb0aceeb414e791d2be92009b1ec
-
-COUNT = 69
-MD = 60343e5fb7eee00d31ea507b820ddbb7ef405dc7
-
-COUNT = 70
-MD = e0b97cd9149ff9955b6a35b3a79ecb3bdbd2a5a5
-
-COUNT = 71
-MD = 4e4fdcd382ae0f3f4fbda5fd934eee0d6ad37df5
-
-COUNT = 72
-MD = 9d97dd237d193482cf3ab862a38843762e69077f
-
-COUNT = 73
-MD = 2bc927d17ff2f8a844f6f36a944a64d73d431192
-
-COUNT = 74
-MD = b91200306b769aab18e5e411b5bd5e7bce1cc80e
-
-COUNT = 75
-MD = c47493a666085e1b7a75618761a80c402f46546d
-
-COUNT = 76
-MD = 31355869b80ff84fac239db694ada07d3be26b15
-
-COUNT = 77
-MD = 1a2022f6330bf96f025cb7d8f0201a7d70b3b58e
-
-COUNT = 78
-MD = 0f60d7c5ad49efce939c3a27da9973f7f1747848
-
-COUNT = 79
-MD = ceada087801616fc6c08cfa469658f3dc5239ca7
-
-COUNT = 80
-MD = 4ad0cf9181122b06df714397bd5366aa90bfc9fa
-
-COUNT = 81
-MD = ac6404e6b9d5c0fa17fa77fd39850f22b76ecd83
-
-COUNT = 82
-MD = f0658218adffb9ee9328577854b6387393957a3a
-
-COUNT = 83
-MD = 6fe9992747897389957b9a91467a4ec983829ab6
-
-COUNT = 84
-MD = 74320b3ddde6dbfbdad3ad29a7695f5a275b2105
-
-COUNT = 85
-MD = 2009ea5d6452f51d12477740e374e0e313134779
-
-COUNT = 86
-MD = 7dbf33d7125709f101fea4ec03436ab95a900c28
-
-COUNT = 87
-MD = 0c05b78e324cb265bd6adc7452249eaa85bccb3f
-
-COUNT = 88
-MD = 10c1b9b2de8a9050fb6f4b10a99f7e1e47159f25
-
-COUNT = 89
-MD = 20072c1f691142d9b83a090dd01f446b4e325a1c
-
-COUNT = 90
-MD = ffcb6a1525f20803cfc79deb40addfd3e7b2f05c
-
-COUNT = 91
-MD = bdcbb4ed636e244bb0fe6af4bc53998936df4ebc
-
-COUNT = 92
-MD = f58ccbc65a2ffa5b35274dd0ceb4ea70eb73c26a
-
-COUNT = 93
-MD = fbe95ac75e4b9cccd1a5debf757fa1a502d07944
-
-COUNT = 94
-MD = a8babac55950dba4993601d35adff874a2b9bb2a
-
-COUNT = 95
-MD = 594db79de71c7651e9eef2f08bb7be3d26b6ee99
-
-COUNT = 96
-MD = 63377d45d0e2d0c987bebe8086c76a5e8b63a14b
-
-COUNT = 97
-MD = cd1e7a192130866aa87fd1c8b43e9b7a0eab7615
-
-COUNT = 98
-MD = b3c69ad5dbdd34b7b45b2a89dad72f4cf1d8fd73
-
-COUNT = 99
-MD = 01b7be5b70ef64843a03fdbb3b247a6278d2cbe1
-
+#  CAVS 11.1
+#  "SHA-1 Monte" information for "sha_values"
+#  SHA tests are configured for BYTE oriented implementations
+#  Generated on Wed May 11 17:26:02 2011
+
+[L = 20]
+
+Seed = dd4df644eaf3d85bace2b21accaa22b28821f5cd
+
+COUNT = 0
+MD = 11f5c38b4479d4ad55cb69fadf62de0b036d5163
+
+COUNT = 1
+MD = 5c26de848c21586bec36995809cb02d3677423d9
+
+COUNT = 2
+MD = 453b5fcf263d01c891d7897d4013990f7c1fb0ab
+
+COUNT = 3
+MD = 36d0273ae363f992bbc313aa4ff602e95c207be3
+
+COUNT = 4
+MD = d1c65e9ac55727fbf30eaf5f00cc22b9bab81a2c
+
+COUNT = 5
+MD = 2c477cd77e5749da7fc4e5ca7eed77166e8ceae6
+
+COUNT = 6
+MD = 60b11211137f46863501a32a435976eabd4532f3
+
+COUNT = 7
+MD = 0894f4f012a1e5344044e0ecfa6f078382064602
+
+COUNT = 8
+MD = 06b6222855cae9bed77e9e3050d164a98286ea5f
+
+COUNT = 9
+MD = e2872694d3d23a68a24419c35bd9ac9006248a8f
+
+COUNT = 10
+MD = ea43595eb1cff3a7e045c5868d0775b4409b14a3
+
+COUNT = 11
+MD = 05a9e94fdc792a61aa60bcd37592acee1f983280
+
+COUNT = 12
+MD = 7d11aa9413cd89a387a5c0f9aa5ce541be2aa6e8
+
+COUNT = 13
+MD = 37297d053aaa4a845cc9ce0c0165644ab8d0e00b
+
+COUNT = 14
+MD = d9dcde396d69748c1fe357f8b662a27ce89082c8
+
+COUNT = 15
+MD = 737a484499b6858b14e656c328979e8aa56b0a43
+
+COUNT = 16
+MD = 4e9c8b3bce910432ac2ad17d51e6b9ec4f92c1ad
+
+COUNT = 17
+MD = 62325b9a7cebcc6da3bfe781d84eb53a6eb7b019
+
+COUNT = 18
+MD = 4710670e071609d470f7d628d8ea978dfb9234ac
+
+COUNT = 19
+MD = 23baee80eee052f3263ac26dd12ea6504a5bd234
+
+COUNT = 20
+MD = 9451efb9c9586a403747acfa3ec74d359bb9d7ff
+
+COUNT = 21
+MD = 37e9d7c81b79f090c8e05848050936c64a1bd662
+
+COUNT = 22
+MD = a6489ff37141f7a86dd978f685fdd4789d1993dc
+
+COUNT = 23
+MD = 39650d32501dfcee212d0de10af9db47e4e5af65
+
+COUNT = 24
+MD = cd4ea3474e046b281da5a4bf69fd873ef8d568d6
+
+COUNT = 25
+MD = 0d7b518c07c6da877eee35301a99c7563f1840df
+
+COUNT = 26
+MD = 68a70ae466532f7f61af138889c0d3f9670f3590
+
+COUNT = 27
+MD = c0222aae5fd2b9eff143ac93c4493abe5c8806af
+
+COUNT = 28
+MD = d2efc5aa0b29db15f3e5de82aaa0a8ce888ffb2f
+
+COUNT = 29
+MD = eec4f55d02c627dcee36b5b5606603bdc9a94a26
+
+COUNT = 30
+MD = 0e706fb1a1fa26aab74efcef57ab6a49c07ca7bd
+
+COUNT = 31
+MD = 2ea392ca8043686424f7e9500edfb9e9297943f7
+
+COUNT = 32
+MD = 74737ef257b32a4cb9428c866b65bee62ccbe653
+
+COUNT = 33
+MD = df3e86e49a0429fa81f553b04b9fc003510e9a51
+
+COUNT = 34
+MD = 79c3049944fbf8b80dadadc7f5174e5cfdf996de
+
+COUNT = 35
+MD = f25e2eca4cfb6da8e8b7b62f581672fab80754fa
+
+COUNT = 36
+MD = 76509239d9fd6c6f050c0d9b3777b5645e4d4c70
+
+COUNT = 37
+MD = cf4bb3e1f330c862e239d9b010bd842f302bd227
+
+COUNT = 38
+MD = 4eeac7ab2ac9e4c81ed1a93a300b2af75beddb08
+
+COUNT = 39
+MD = 46443ba72a64fff4b5252fbac9ef93c2949f8585
+
+COUNT = 40
+MD = 5e9c42482343a54aadb11ab00c2e00cbe25ec91a
+
+COUNT = 41
+MD = 93acee1977128f2a4218678b32e2844f23eb526b
+
+COUNT = 42
+MD = 226065d299b2d6c582d386897b93f2adf14de00b
+
+COUNT = 43
+MD = 672fed0d90c21d4ec0111a7284bcf1bbd72af9bd
+
+COUNT = 44
+MD = 90d642f12f28cb3dad7daad84cf0f94ded1137ae
+
+COUNT = 45
+MD = 4a2815b58ffc858e5e7e9e6106765458d2af4ec3
+
+COUNT = 46
+MD = 29fa3679032421b78b7a08c54766c1592f6739c1
+
+COUNT = 47
+MD = 19f4e30393eb66c6e200744fa8999d224e6df173
+
+COUNT = 48
+MD = 30650026be77212088ab50438e04b4b8e3761977
+
+COUNT = 49
+MD = 993d0e135bcd598fa673c6f19251bcbde18b7b34
+
+COUNT = 50
+MD = c9eaf20b473219a70efe85940620426c6ff6f4a4
+
+COUNT = 51
+MD = 6325d0b83c308bd42854ce69446e85ba36348d7d
+
+COUNT = 52
+MD = 2fb354f8a68030efb747f78812060a9c05e92164
+
+COUNT = 53
+MD = a7e33bd16f770c17e8818ad5a5fc4fee673eae56
+
+COUNT = 54
+MD = ff23e7105bc9f4dad0fb9c6519d1eae16439a5d6
+
+COUNT = 55
+MD = a31aca821e163213cd2ae84cf56c1134daa4a621
+
+COUNT = 56
+MD = 94ab9cfd4cf9bf2e4409dbcdc9ef2c8b611cc69d
+
+COUNT = 57
+MD = c0194064ce48dde771b7871efa86a4a6e87eec76
+
+COUNT = 58
+MD = f1a9065e3e7f98753c6f833f5ffe74133f6b887f
+
+COUNT = 59
+MD = b8b3cd6ca1d5b5610e43212f8df75211aaddcf96
+
+COUNT = 60
+MD = 33c3a8d739cc2f83be597aa11c43e2ad6f0d2436
+
+COUNT = 61
+MD = 4f5c67e5110f3663b7aa88759dbba6fa82f2d705
+
+COUNT = 62
+MD = b1ebc87c7b2b8fe73e7a882d3f4f0492946e0d7c
+
+COUNT = 63
+MD = 01566616fe4a8c7cf22f21031ac6ea7fb7ce15db
+
+COUNT = 64
+MD = 5650f3517a393792781d23b4c9d360bf8bd31d65
+
+COUNT = 65
+MD = a4fdbd24cb4a328b898b804b103caa98baedd3fa
+
+COUNT = 66
+MD = 0cf01eecec4b85aa39f40aa9b4dce208d68eb17b
+
+COUNT = 67
+MD = ae9ac147bab7c10609abe6e931a5ab087a41dc5a
+
+COUNT = 68
+MD = c0328145ce63fb0aceeb414e791d2be92009b1ec
+
+COUNT = 69
+MD = 60343e5fb7eee00d31ea507b820ddbb7ef405dc7
+
+COUNT = 70
+MD = e0b97cd9149ff9955b6a35b3a79ecb3bdbd2a5a5
+
+COUNT = 71
+MD = 4e4fdcd382ae0f3f4fbda5fd934eee0d6ad37df5
+
+COUNT = 72
+MD = 9d97dd237d193482cf3ab862a38843762e69077f
+
+COUNT = 73
+MD = 2bc927d17ff2f8a844f6f36a944a64d73d431192
+
+COUNT = 74
+MD = b91200306b769aab18e5e411b5bd5e7bce1cc80e
+
+COUNT = 75
+MD = c47493a666085e1b7a75618761a80c402f46546d
+
+COUNT = 76
+MD = 31355869b80ff84fac239db694ada07d3be26b15
+
+COUNT = 77
+MD = 1a2022f6330bf96f025cb7d8f0201a7d70b3b58e
+
+COUNT = 78
+MD = 0f60d7c5ad49efce939c3a27da9973f7f1747848
+
+COUNT = 79
+MD = ceada087801616fc6c08cfa469658f3dc5239ca7
+
+COUNT = 80
+MD = 4ad0cf9181122b06df714397bd5366aa90bfc9fa
+
+COUNT = 81
+MD = ac6404e6b9d5c0fa17fa77fd39850f22b76ecd83
+
+COUNT = 82
+MD = f0658218adffb9ee9328577854b6387393957a3a
+
+COUNT = 83
+MD = 6fe9992747897389957b9a91467a4ec983829ab6
+
+COUNT = 84
+MD = 74320b3ddde6dbfbdad3ad29a7695f5a275b2105
+
+COUNT = 85
+MD = 2009ea5d6452f51d12477740e374e0e313134779
+
+COUNT = 86
+MD = 7dbf33d7125709f101fea4ec03436ab95a900c28
+
+COUNT = 87
+MD = 0c05b78e324cb265bd6adc7452249eaa85bccb3f
+
+COUNT = 88
+MD = 10c1b9b2de8a9050fb6f4b10a99f7e1e47159f25
+
+COUNT = 89
+MD = 20072c1f691142d9b83a090dd01f446b4e325a1c
+
+COUNT = 90
+MD = ffcb6a1525f20803cfc79deb40addfd3e7b2f05c
+
+COUNT = 91
+MD = bdcbb4ed636e244bb0fe6af4bc53998936df4ebc
+
+COUNT = 92
+MD = f58ccbc65a2ffa5b35274dd0ceb4ea70eb73c26a
+
+COUNT = 93
+MD = fbe95ac75e4b9cccd1a5debf757fa1a502d07944
+
+COUNT = 94
+MD = a8babac55950dba4993601d35adff874a2b9bb2a
+
+COUNT = 95
+MD = 594db79de71c7651e9eef2f08bb7be3d26b6ee99
+
+COUNT = 96
+MD = 63377d45d0e2d0c987bebe8086c76a5e8b63a14b
+
+COUNT = 97
+MD = cd1e7a192130866aa87fd1c8b43e9b7a0eab7615
+
+COUNT = 98
+MD = b3c69ad5dbdd34b7b45b2a89dad72f4cf1d8fd73
+
+COUNT = 99
+MD = 01b7be5b70ef64843a03fdbb3b247a6278d2cbe1
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA1ShortMsg.rsp

@@ -1,267 +1,267 @@
-#  CAVS 11.0
-#  "SHA-1 ShortMsg" information
-#  SHA-1 tests are configured for BYTE oriented implementations
-#  Generated on Tue Mar 15 08:23:35 2011
-
-[L = 20]
-
-Len = 0
-Msg = 00
-MD = da39a3ee5e6b4b0d3255bfef95601890afd80709
-
-Len = 8
-Msg = 36
-MD = c1dfd96eea8cc2b62785275bca38ac261256e278
-
-Len = 16
-Msg = 195a
-MD = 0a1c2d555bbe431ad6288af5a54f93e0449c9232
-
-Len = 24
-Msg = df4bd2
-MD = bf36ed5d74727dfd5d7854ec6b1d49468d8ee8aa
-
-Len = 32
-Msg = 549e959e
-MD = b78bae6d14338ffccfd5d5b5674a275f6ef9c717
-
-Len = 40
-Msg = f7fb1be205
-MD = 60b7d5bb560a1acf6fa45721bd0abb419a841a89
-
-Len = 48
-Msg = c0e5abeaea63
-MD = a6d338459780c08363090fd8fc7d28dc80e8e01f
-
-Len = 56
-Msg = 63bfc1ed7f78ab
-MD = 860328d80509500c1783169ebf0ba0c4b94da5e5
-
-Len = 64
-Msg = 7e3d7b3eada98866
-MD = 24a2c34b976305277ce58c2f42d5092031572520
-
-Len = 72
-Msg = 9e61e55d9ed37b1c20
-MD = 411ccee1f6e3677df12698411eb09d3ff580af97
-
-Len = 80
-Msg = 9777cf90dd7c7e863506
-MD = 05c915b5ed4e4c4afffc202961f3174371e90b5c
-
-Len = 88
-Msg = 4eb08c9e683c94bea00dfa
-MD = af320b42d7785ca6c8dd220463be23a2d2cb5afc
-
-Len = 96
-Msg = 0938f2e2ebb64f8af8bbfc91
-MD = 9f4e66b6ceea40dcf4b9166c28f1c88474141da9
-
-Len = 104
-Msg = 74c9996d14e87d3e6cbea7029d
-MD = e6c4363c0852951991057f40de27ec0890466f01
-
-Len = 112
-Msg = 51dca5c0f8e5d49596f32d3eb874
-MD = 046a7b396c01379a684a894558779b07d8c7da20
-
-Len = 120
-Msg = 3a36ea49684820a2adc7fc4175ba78
-MD = d58a262ee7b6577c07228e71ae9b3e04c8abcda9
-
-Len = 128
-Msg = 3552694cdf663fd94b224747ac406aaf
-MD = a150de927454202d94e656de4c7c0ca691de955d
-
-Len = 136
-Msg = f216a1cbde2446b1edf41e93481d33e2ed
-MD = 35a4b39fef560e7ea61246676e1b7e13d587be30
-
-Len = 144
-Msg = a3cf714bf112647e727e8cfd46499acd35a6
-MD = 7ce69b1acdce52ea7dbd382531fa1a83df13cae7
-
-Len = 152
-Msg = 148de640f3c11591a6f8c5c48632c5fb79d3b7
-MD = b47be2c64124fa9a124a887af9551a74354ca411
-
-Len = 160
-Msg = 63a3cc83fd1ec1b6680e9974a0514e1a9ecebb6a
-MD = 8bb8c0d815a9c68a1d2910f39d942603d807fbcc
-
-Len = 168
-Msg = 875a90909a8afc92fb7070047e9d081ec92f3d08b8
-MD = b486f87fb833ebf0328393128646a6f6e660fcb1
-
-Len = 176
-Msg = 444b25f9c9259dc217772cc4478c44b6feff62353673
-MD = 76159368f99dece30aadcfb9b7b41dab33688858
-
-Len = 184
-Msg = 487351c8a5f440e4d03386483d5fe7bb669d41adcbfdb7
-MD = dbc1cb575ce6aeb9dc4ebf0f843ba8aeb1451e89
-
-Len = 192
-Msg = 46b061ef132b87f6d3b0ee2462f67d910977da20aed13705
-MD = d7a98289679005eb930ab75efd8f650f991ee952
-
-Len = 200
-Msg = 3842b6137bb9d27f3ca5bafe5bbb62858344fe4ba5c41589a5
-MD = fda26fa9b4874ab701ed0bb64d134f89b9c4cc50
-
-Len = 208
-Msg = 44d91d3d465a4111462ba0c7ec223da6735f4f5200453cf132c3
-MD = c2ff7ccde143c8f0601f6974b1903eb8d5741b6e
-
-Len = 216
-Msg = cce73f2eabcb52f785d5a6df63c0a105f34a91ca237fe534ee399d
-MD = 643c9dc20a929608f6caa9709d843ca6fa7a76f4
-
-Len = 224
-Msg = 664e6e7946839203037a65a12174b244de8cbc6ec3f578967a84f9ce
-MD = 509ef787343d5b5a269229b961b96241864a3d74
-
-Len = 232
-Msg = 9597f714b2e45e3399a7f02aec44921bd78be0fefee0c5e9b499488f6e
-MD = b61ce538f1a1e6c90432b233d7af5b6524ebfbe3
-
-Len = 240
-Msg = 75c5ad1f3cbd22e8a95fc3b089526788fb4ebceed3e7d4443da6e081a35e
-MD = 5b7b94076b2fc20d6adb82479e6b28d07c902b75
-
-Len = 248
-Msg = dd245bffe6a638806667768360a95d0574e1a0bd0d18329fdb915ca484ac0d
-MD = 6066db99fc358952cf7fb0ec4d89cb0158ed91d7
-
-Len = 256
-Msg = 0321794b739418c24e7c2e565274791c4be749752ad234ed56cb0a6347430c6b
-MD = b89962c94d60f6a332fd60f6f07d4f032a586b76
-
-Len = 264
-Msg = 4c3dcf95c2f0b5258c651fcd1d51bd10425d6203067d0748d37d1340d9ddda7db3
-MD = 17bda899c13d35413d2546212bcd8a93ceb0657b
-
-Len = 272
-Msg = b8d12582d25b45290a6e1bb95da429befcfdbf5b4dd41cdf3311d6988fa17cec0723
-MD = badcdd53fdc144b8bf2cc1e64d10f676eebe66ed
-
-Len = 280
-Msg = 6fda97527a662552be15efaeba32a3aea4ed449abb5c1ed8d9bfff544708a425d69b72
-MD = 01b4646180f1f6d2e06bbe22c20e50030322673a
-
-Len = 288
-Msg = 09fa2792acbb2417e8ed269041cc03c77006466e6e7ae002cf3f1af551e8ce0bb506d705
-MD = 10016dc3a2719f9034ffcc689426d28292c42fc9
-
-Len = 296
-Msg = 5efa2987da0baf0a54d8d728792bcfa707a15798dc66743754406914d1cfe3709b1374eaeb
-MD = 9f42fa2bce6ef021d93c6b2d902273797e426535
-
-Len = 304
-Msg = 2836de99c0f641cd55e89f5af76638947b8227377ef88bfba662e5682babc1ec96c6992bc9a0
-MD = cdf48bacbff6f6152515323f9b43a286e0cb8113
-
-Len = 312
-Msg = 42143a2b9e1d0b354df3264d08f7b602f54aad922a3d63006d097f683dc11b90178423bff2f7fe
-MD = b88fb75274b9b0fd57c0045988cfcef6c3ce6554
-
-Len = 320
-Msg = eb60c28ad8aeda807d69ebc87552024ad8aca68204f1bcd29dc5a81dd228b591e2efb7c4df75ef03
-MD = c06d3a6a12d9e8db62e8cff40ca23820d61d8aa7
-
-Len = 328
-Msg = 7de4ba85ec54747cdc42b1f23546b7e490e31280f066e52fac117fd3b0792e4de62d5843ee98c72015
-MD = 6e40f9e83a4be93874bc97cdebb8da6889ae2c7a
-
-Len = 336
-Msg = e70653637bc5e388ccd8dc44e5eace36f7398f2bac993042b9bc2f4fb3b0ee7e23a96439dc01134b8c7d
-MD = 3efc940c312ef0dfd4e1143812248db89542f6a5
-
-Len = 344
-Msg = dd37bc9f0b3a4788f9b54966f252174c8ce487cbe59c53c22b81bf77621a7ce7616dcb5b1e2ee63c2c309b
-MD = a0cf03f7badd0c3c3c4ea3717f5a4fb7e67b2e56
-
-Len = 352
-Msg = 5f485c637ae30b1e30497f0fb7ec364e13c906e2813daa34161b7ac4a4fd7a1bddd79601bbd22cef1f57cbc7
-MD = a544e06f1a07ceb175a51d6d9c0111b3e15e9859
-
-Len = 360
-Msg = f6c237fb3cfe95ec8414cc16d203b4874e644cc9a543465cad2dc563488a659e8a2e7c981e2a9f22e5e868ffe1
-MD = 199d986ed991b99a071f450c6b1121a727e8c735
-
-Len = 368
-Msg = da7ab3291553c659873c95913768953c6e526d3a26590898c0ade89ff56fbd110f1436af590b17fed49f8c4b2b1e
-MD = 33bac6104b0ad6128d091b5d5e2999099c9f05de
-
-Len = 376
-Msg = 8cfa5fd56ee239ca47737591cba103e41a18acf8e8d257b0dbe8851134a81ff6b2e97104b39b76e19da256a17ce52d
-MD = 76d7db6e18c1f4ae225ce8ccc93c8f9a0dfeb969
-
-Len = 384
-Msg = 57e89659d878f360af6de45a9a5e372ef40c384988e82640a3d5e4b76d2ef181780b9a099ac06ef0f8a7f3f764209720
-MD = f652f3b1549f16710c7402895911e2b86a9b2aee
-
-Len = 392
-Msg = b91e64235dbd234eea2ae14a92a173ebe835347239cff8b02074416f55c6b60dc6ced06ae9f8d705505f0d617e4b29aef9
-MD = 63faebb807f32be708cf00fc35519991dc4e7f68
-
-Len = 400
-Msg = e42a67362a581e8cf3d847502215755d7ad425ca030c4360b0f7ef513e6980265f61c9fa18dd9ce668f38dbc2a1ef8f83cd6
-MD = 0e6730bc4a0e9322ea205f4edfff1fffda26af0a
-
-Len = 408
-Msg = 634db92c22010e1cbf1e1623923180406c515272209a8acc42de05cc2e96a1e94c1f9f6b93234b7f4c55de8b1961a3bf352259
-MD = b61a3a6f42e8e6604b93196c43c9e84d5359e6fe
-
-Len = 416
-Msg = cc6ca3a8cb391cd8a5aff1faa7b3ffbdd21a5a3ce66cfaddbfe8b179e4c860be5ec66bd2c6de6a39a25622f9f2fcb3fc05af12b5
-MD = 32d979ca1b3ed0ed8c890d99ec6dd85e6c16abf4
-
-Len = 424
-Msg = 7c0e6a0d35f8ac854c7245ebc73693731bbbc3e6fab644466de27bb522fcb99307126ae718fe8f00742e6e5cb7a687c88447cbc961
-MD = 6f18190bd2d02fc93bce64756575cea36d08b1c3
-
-Len = 432
-Msg = c5581d40b331e24003901bd6bf244aca9e9601b9d81252bb38048642731f1146b8a4c69f88e148b2c8f8c14f15e1d6da57b2daa9991e
-MD = 68f525feea1d8dbe0117e417ca46708d18d7629a
-
-Len = 440
-Msg = ec6b4a88713df27c0f2d02e738b69db43abda3921317259c864c1c386e9a5a3f533dc05f3beeb2bec2aac8e06db4c6cb3cddcf697e03d5
-MD = a7272e2308622ff7a339460adc61efd0ea8dabdc
-
-Len = 448
-Msg = 0321736beba578e90abc1a90aa56157d871618f6de0d764cc8c91e06c68ecd3b9de3824064503384db67beb7fe012232dacaef93a000fba7
-MD = aef843b86916c16f66c84d83a6005d23fd005c9e
-
-Len = 456
-Msg = d0a249a97b5f1486721a50d4c4ab3f5d674a0e29925d5bf2678ef6d8d521e456bd84aa755328c83fc890837726a8e7877b570dba39579aabdd
-MD = be2cd6f380969be59cde2dff5e848a44e7880bd6
-
-Len = 464
-Msg = c32138531118f08c7dcc292428ad20b45ab27d9517a18445f38b8f0c2795bcdfe3ffe384e65ecbf74d2c9d0da88398575326074904c1709ba072
-MD = e5eb4543deee8f6a5287845af8b593a95a9749a1
-
-Len = 472
-Msg = b0f4cfb939ea785eabb7e7ca7c476cdd9b227f015d905368ba00ae96b9aaf720297491b3921267576b72c8f58d577617e844f9f0759b399c6b064c
-MD = 534c850448dd486787b62bdec2d4a0b140a1b170
-
-Len = 480
-Msg = bd02e51b0cf2c2b8d204a026b41a66fbfc2ac37ee9411fc449c8d1194a0792a28ee731407dfc89b6dfc2b10faa27723a184afef8fd83def858a32d3f
-MD = 6fbfa6e4edce4cc85a845bf0d228dc39acefc2fa
-
-Len = 488
-Msg = e33146b83e4bb671392218da9a77f8d9f5974147182fb95ba662cb66011989c16d9af104735d6f79841aa4d1df276615b50108df8a29dbc9de31f4260d
-MD = 018872691d9b04e8220e09187df5bc5fa6257cd9
-
-Len = 496
-Msg = 411c13c75073c1e2d4b1ecf13139ba9656cd35c14201f1c7c6f0eeb58d2dbfe35bfdeccc92c3961cfabb590bc1eb77eac15732fb0275798680e0c7292e50
-MD = d98d512a35572f8bd20de62e9510cc21145c5bf4
-
-Len = 504
-Msg = f2c76ef617fa2bfc8a4d6bcbb15fe88436fdc2165d3074629579079d4d5b86f5081ab177b4c3f530376c9c924cbd421a8daf8830d0940c4fb7589865830699
-MD = 9f3ea255f6af95c5454e55d7354cabb45352ea0b
-
-Len = 512
-Msg = 45927e32ddf801caf35e18e7b5078b7f5435278212ec6bb99df884f49b327c6486feae46ba187dc1cc9145121e1492e6b06e9007394dc33b7748f86ac3207cfe
-MD = a70cfbfe7563dd0e665c7c6715a96a8d756950c0
-
+#  CAVS 11.0
+#  "SHA-1 ShortMsg" information
+#  SHA-1 tests are configured for BYTE oriented implementations
+#  Generated on Tue Mar 15 08:23:35 2011
+
+[L = 20]
+
+Len = 0
+Msg = 00
+MD = da39a3ee5e6b4b0d3255bfef95601890afd80709
+
+Len = 8
+Msg = 36
+MD = c1dfd96eea8cc2b62785275bca38ac261256e278
+
+Len = 16
+Msg = 195a
+MD = 0a1c2d555bbe431ad6288af5a54f93e0449c9232
+
+Len = 24
+Msg = df4bd2
+MD = bf36ed5d74727dfd5d7854ec6b1d49468d8ee8aa
+
+Len = 32
+Msg = 549e959e
+MD = b78bae6d14338ffccfd5d5b5674a275f6ef9c717
+
+Len = 40
+Msg = f7fb1be205
+MD = 60b7d5bb560a1acf6fa45721bd0abb419a841a89
+
+Len = 48
+Msg = c0e5abeaea63
+MD = a6d338459780c08363090fd8fc7d28dc80e8e01f
+
+Len = 56
+Msg = 63bfc1ed7f78ab
+MD = 860328d80509500c1783169ebf0ba0c4b94da5e5
+
+Len = 64
+Msg = 7e3d7b3eada98866
+MD = 24a2c34b976305277ce58c2f42d5092031572520
+
+Len = 72
+Msg = 9e61e55d9ed37b1c20
+MD = 411ccee1f6e3677df12698411eb09d3ff580af97
+
+Len = 80
+Msg = 9777cf90dd7c7e863506
+MD = 05c915b5ed4e4c4afffc202961f3174371e90b5c
+
+Len = 88
+Msg = 4eb08c9e683c94bea00dfa
+MD = af320b42d7785ca6c8dd220463be23a2d2cb5afc
+
+Len = 96
+Msg = 0938f2e2ebb64f8af8bbfc91
+MD = 9f4e66b6ceea40dcf4b9166c28f1c88474141da9
+
+Len = 104
+Msg = 74c9996d14e87d3e6cbea7029d
+MD = e6c4363c0852951991057f40de27ec0890466f01
+
+Len = 112
+Msg = 51dca5c0f8e5d49596f32d3eb874
+MD = 046a7b396c01379a684a894558779b07d8c7da20
+
+Len = 120
+Msg = 3a36ea49684820a2adc7fc4175ba78
+MD = d58a262ee7b6577c07228e71ae9b3e04c8abcda9
+
+Len = 128
+Msg = 3552694cdf663fd94b224747ac406aaf
+MD = a150de927454202d94e656de4c7c0ca691de955d
+
+Len = 136
+Msg = f216a1cbde2446b1edf41e93481d33e2ed
+MD = 35a4b39fef560e7ea61246676e1b7e13d587be30
+
+Len = 144
+Msg = a3cf714bf112647e727e8cfd46499acd35a6
+MD = 7ce69b1acdce52ea7dbd382531fa1a83df13cae7
+
+Len = 152
+Msg = 148de640f3c11591a6f8c5c48632c5fb79d3b7
+MD = b47be2c64124fa9a124a887af9551a74354ca411
+
+Len = 160
+Msg = 63a3cc83fd1ec1b6680e9974a0514e1a9ecebb6a
+MD = 8bb8c0d815a9c68a1d2910f39d942603d807fbcc
+
+Len = 168
+Msg = 875a90909a8afc92fb7070047e9d081ec92f3d08b8
+MD = b486f87fb833ebf0328393128646a6f6e660fcb1
+
+Len = 176
+Msg = 444b25f9c9259dc217772cc4478c44b6feff62353673
+MD = 76159368f99dece30aadcfb9b7b41dab33688858
+
+Len = 184
+Msg = 487351c8a5f440e4d03386483d5fe7bb669d41adcbfdb7
+MD = dbc1cb575ce6aeb9dc4ebf0f843ba8aeb1451e89
+
+Len = 192
+Msg = 46b061ef132b87f6d3b0ee2462f67d910977da20aed13705
+MD = d7a98289679005eb930ab75efd8f650f991ee952
+
+Len = 200
+Msg = 3842b6137bb9d27f3ca5bafe5bbb62858344fe4ba5c41589a5
+MD = fda26fa9b4874ab701ed0bb64d134f89b9c4cc50
+
+Len = 208
+Msg = 44d91d3d465a4111462ba0c7ec223da6735f4f5200453cf132c3
+MD = c2ff7ccde143c8f0601f6974b1903eb8d5741b6e
+
+Len = 216
+Msg = cce73f2eabcb52f785d5a6df63c0a105f34a91ca237fe534ee399d
+MD = 643c9dc20a929608f6caa9709d843ca6fa7a76f4
+
+Len = 224
+Msg = 664e6e7946839203037a65a12174b244de8cbc6ec3f578967a84f9ce
+MD = 509ef787343d5b5a269229b961b96241864a3d74
+
+Len = 232
+Msg = 9597f714b2e45e3399a7f02aec44921bd78be0fefee0c5e9b499488f6e
+MD = b61ce538f1a1e6c90432b233d7af5b6524ebfbe3
+
+Len = 240
+Msg = 75c5ad1f3cbd22e8a95fc3b089526788fb4ebceed3e7d4443da6e081a35e
+MD = 5b7b94076b2fc20d6adb82479e6b28d07c902b75
+
+Len = 248
+Msg = dd245bffe6a638806667768360a95d0574e1a0bd0d18329fdb915ca484ac0d
+MD = 6066db99fc358952cf7fb0ec4d89cb0158ed91d7
+
+Len = 256
+Msg = 0321794b739418c24e7c2e565274791c4be749752ad234ed56cb0a6347430c6b
+MD = b89962c94d60f6a332fd60f6f07d4f032a586b76
+
+Len = 264
+Msg = 4c3dcf95c2f0b5258c651fcd1d51bd10425d6203067d0748d37d1340d9ddda7db3
+MD = 17bda899c13d35413d2546212bcd8a93ceb0657b
+
+Len = 272
+Msg = b8d12582d25b45290a6e1bb95da429befcfdbf5b4dd41cdf3311d6988fa17cec0723
+MD = badcdd53fdc144b8bf2cc1e64d10f676eebe66ed
+
+Len = 280
+Msg = 6fda97527a662552be15efaeba32a3aea4ed449abb5c1ed8d9bfff544708a425d69b72
+MD = 01b4646180f1f6d2e06bbe22c20e50030322673a
+
+Len = 288
+Msg = 09fa2792acbb2417e8ed269041cc03c77006466e6e7ae002cf3f1af551e8ce0bb506d705
+MD = 10016dc3a2719f9034ffcc689426d28292c42fc9
+
+Len = 296
+Msg = 5efa2987da0baf0a54d8d728792bcfa707a15798dc66743754406914d1cfe3709b1374eaeb
+MD = 9f42fa2bce6ef021d93c6b2d902273797e426535
+
+Len = 304
+Msg = 2836de99c0f641cd55e89f5af76638947b8227377ef88bfba662e5682babc1ec96c6992bc9a0
+MD = cdf48bacbff6f6152515323f9b43a286e0cb8113
+
+Len = 312
+Msg = 42143a2b9e1d0b354df3264d08f7b602f54aad922a3d63006d097f683dc11b90178423bff2f7fe
+MD = b88fb75274b9b0fd57c0045988cfcef6c3ce6554
+
+Len = 320
+Msg = eb60c28ad8aeda807d69ebc87552024ad8aca68204f1bcd29dc5a81dd228b591e2efb7c4df75ef03
+MD = c06d3a6a12d9e8db62e8cff40ca23820d61d8aa7
+
+Len = 328
+Msg = 7de4ba85ec54747cdc42b1f23546b7e490e31280f066e52fac117fd3b0792e4de62d5843ee98c72015
+MD = 6e40f9e83a4be93874bc97cdebb8da6889ae2c7a
+
+Len = 336
+Msg = e70653637bc5e388ccd8dc44e5eace36f7398f2bac993042b9bc2f4fb3b0ee7e23a96439dc01134b8c7d
+MD = 3efc940c312ef0dfd4e1143812248db89542f6a5
+
+Len = 344
+Msg = dd37bc9f0b3a4788f9b54966f252174c8ce487cbe59c53c22b81bf77621a7ce7616dcb5b1e2ee63c2c309b
+MD = a0cf03f7badd0c3c3c4ea3717f5a4fb7e67b2e56
+
+Len = 352
+Msg = 5f485c637ae30b1e30497f0fb7ec364e13c906e2813daa34161b7ac4a4fd7a1bddd79601bbd22cef1f57cbc7
+MD = a544e06f1a07ceb175a51d6d9c0111b3e15e9859
+
+Len = 360
+Msg = f6c237fb3cfe95ec8414cc16d203b4874e644cc9a543465cad2dc563488a659e8a2e7c981e2a9f22e5e868ffe1
+MD = 199d986ed991b99a071f450c6b1121a727e8c735
+
+Len = 368
+Msg = da7ab3291553c659873c95913768953c6e526d3a26590898c0ade89ff56fbd110f1436af590b17fed49f8c4b2b1e
+MD = 33bac6104b0ad6128d091b5d5e2999099c9f05de
+
+Len = 376
+Msg = 8cfa5fd56ee239ca47737591cba103e41a18acf8e8d257b0dbe8851134a81ff6b2e97104b39b76e19da256a17ce52d
+MD = 76d7db6e18c1f4ae225ce8ccc93c8f9a0dfeb969
+
+Len = 384
+Msg = 57e89659d878f360af6de45a9a5e372ef40c384988e82640a3d5e4b76d2ef181780b9a099ac06ef0f8a7f3f764209720
+MD = f652f3b1549f16710c7402895911e2b86a9b2aee
+
+Len = 392
+Msg = b91e64235dbd234eea2ae14a92a173ebe835347239cff8b02074416f55c6b60dc6ced06ae9f8d705505f0d617e4b29aef9
+MD = 63faebb807f32be708cf00fc35519991dc4e7f68
+
+Len = 400
+Msg = e42a67362a581e8cf3d847502215755d7ad425ca030c4360b0f7ef513e6980265f61c9fa18dd9ce668f38dbc2a1ef8f83cd6
+MD = 0e6730bc4a0e9322ea205f4edfff1fffda26af0a
+
+Len = 408
+Msg = 634db92c22010e1cbf1e1623923180406c515272209a8acc42de05cc2e96a1e94c1f9f6b93234b7f4c55de8b1961a3bf352259
+MD = b61a3a6f42e8e6604b93196c43c9e84d5359e6fe
+
+Len = 416
+Msg = cc6ca3a8cb391cd8a5aff1faa7b3ffbdd21a5a3ce66cfaddbfe8b179e4c860be5ec66bd2c6de6a39a25622f9f2fcb3fc05af12b5
+MD = 32d979ca1b3ed0ed8c890d99ec6dd85e6c16abf4
+
+Len = 424
+Msg = 7c0e6a0d35f8ac854c7245ebc73693731bbbc3e6fab644466de27bb522fcb99307126ae718fe8f00742e6e5cb7a687c88447cbc961
+MD = 6f18190bd2d02fc93bce64756575cea36d08b1c3
+
+Len = 432
+Msg = c5581d40b331e24003901bd6bf244aca9e9601b9d81252bb38048642731f1146b8a4c69f88e148b2c8f8c14f15e1d6da57b2daa9991e
+MD = 68f525feea1d8dbe0117e417ca46708d18d7629a
+
+Len = 440
+Msg = ec6b4a88713df27c0f2d02e738b69db43abda3921317259c864c1c386e9a5a3f533dc05f3beeb2bec2aac8e06db4c6cb3cddcf697e03d5
+MD = a7272e2308622ff7a339460adc61efd0ea8dabdc
+
+Len = 448
+Msg = 0321736beba578e90abc1a90aa56157d871618f6de0d764cc8c91e06c68ecd3b9de3824064503384db67beb7fe012232dacaef93a000fba7
+MD = aef843b86916c16f66c84d83a6005d23fd005c9e
+
+Len = 456
+Msg = d0a249a97b5f1486721a50d4c4ab3f5d674a0e29925d5bf2678ef6d8d521e456bd84aa755328c83fc890837726a8e7877b570dba39579aabdd
+MD = be2cd6f380969be59cde2dff5e848a44e7880bd6
+
+Len = 464
+Msg = c32138531118f08c7dcc292428ad20b45ab27d9517a18445f38b8f0c2795bcdfe3ffe384e65ecbf74d2c9d0da88398575326074904c1709ba072
+MD = e5eb4543deee8f6a5287845af8b593a95a9749a1
+
+Len = 472
+Msg = b0f4cfb939ea785eabb7e7ca7c476cdd9b227f015d905368ba00ae96b9aaf720297491b3921267576b72c8f58d577617e844f9f0759b399c6b064c
+MD = 534c850448dd486787b62bdec2d4a0b140a1b170
+
+Len = 480
+Msg = bd02e51b0cf2c2b8d204a026b41a66fbfc2ac37ee9411fc449c8d1194a0792a28ee731407dfc89b6dfc2b10faa27723a184afef8fd83def858a32d3f
+MD = 6fbfa6e4edce4cc85a845bf0d228dc39acefc2fa
+
+Len = 488
+Msg = e33146b83e4bb671392218da9a77f8d9f5974147182fb95ba662cb66011989c16d9af104735d6f79841aa4d1df276615b50108df8a29dbc9de31f4260d
+MD = 018872691d9b04e8220e09187df5bc5fa6257cd9
+
+Len = 496
+Msg = 411c13c75073c1e2d4b1ecf13139ba9656cd35c14201f1c7c6f0eeb58d2dbfe35bfdeccc92c3961cfabb590bc1eb77eac15732fb0275798680e0c7292e50
+MD = d98d512a35572f8bd20de62e9510cc21145c5bf4
+
+Len = 504
+Msg = f2c76ef617fa2bfc8a4d6bcbb15fe88436fdc2165d3074629579079d4d5b86f5081ab177b4c3f530376c9c924cbd421a8daf8830d0940c4fb7589865830699
+MD = 9f3ea255f6af95c5454e55d7354cabb45352ea0b
+
+Len = 512
+Msg = 45927e32ddf801caf35e18e7b5078b7f5435278212ec6bb99df884f49b327c6486feae46ba187dc1cc9145121e1492e6b06e9007394dc33b7748f86ac3207cfe
+MD = a70cfbfe7563dd0e665c7c6715a96a8d756950c0
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA224Monte.rsp

@@ -1,309 +1,309 @@
-#  CAVS 11.1
-#  "SHA-224 Monte" information for "sha_values"
-#  SHA-224 tests are configured for BYTE oriented implementations
-#  Generated on Wed May 11 17:26:02 2011
-
-[L = 28]
-
-Seed = ed2b70d575d9d0b4196ae84a03eed940057ea89cdd729b95b7d4e6a5
-
-COUNT = 0
-MD = cd94d7da13c030208b2d0d78fcfe9ea22fa8906df66aa9a1f42afa70
-
-COUNT = 1
-MD = 555846e884633639565d5e0c01dd93ba58edb01ee18e68ccca28f7b8
-
-COUNT = 2
-MD = 44d5f4a179b33231f24cc209ed2542ddb931391f2a2d604f80ed460b
-
-COUNT = 3
-MD = 18678e3c151f05f92a89fc5b2ec56bfc6fafa66d73ffc1937fcab4d0
-
-COUNT = 4
-MD = b285f829b0499ff45f8454eda2d4e0997b3f438c2728f1a25cfbb05a
-
-COUNT = 5
-MD = 206d442c6605be0e675b0efc76243c2f18f2260a93375fb36e469631
-
-COUNT = 6
-MD = 1cd8ea34d8483b6a513c52a74e416bac2f322bbaeee02c6b0b05a781
-
-COUNT = 7
-MD = 00cee48001fe8442ef39c3433ed05473179f34205d337940d4bfd3cd
-
-COUNT = 8
-MD = ead3ad27819401912bc9abfdb50037672a3aed0e94fbaa1cc0560621
-
-COUNT = 9
-MD = 8f4dd5aef9cea829d8802ffcced2e8ed6b48ac23bbfbb0fae2fad0fd
-
-COUNT = 10
-MD = 03aeb918feab459e39af29ff3aaf406088bf06d793338bbd563641a2
-
-COUNT = 11
-MD = de80c312b153fbd7241c8bc432d1ed253d26dcc6f458b953ac2d9259
-
-COUNT = 12
-MD = 3eb8d347cc2565ddd71f7fc21cff7eb3a2cf8e85c5e1d4c751f69f26
-
-COUNT = 13
-MD = dbfd7033a4f884ecf7053f07b4c51f3efb1c09084cc7bbe667196a3e
-
-COUNT = 14
-MD = 5323fc60310fe29900eb7a500f29897001c37945c5f8849674725553
-
-COUNT = 15
-MD = c3d9416549bebebf679c0122a9c5bb86c0b514c6a4e9eda1e9782040
-
-COUNT = 16
-MD = 749fc9c8c21957ddcaf5eff69c297284d722c79be1fc6c910495a586
-
-COUNT = 17
-MD = aa307d91c4037372ff0ca60eb17ec8f1faba862601b95754783ea808
-
-COUNT = 18
-MD = 071e361909c38791e941d995b0b25a3294bdf39456cc012806ada3c5
-
-COUNT = 19
-MD = 18751a765f3b06fc2c9a1888d4bb78b2d2226799a54dba72b5429f25
-
-COUNT = 20
-MD = 54b39c96f6377e3fc2ae0ba4ec89049a6c04808da3fa0415c9053ce4
-
-COUNT = 21
-MD = 58c1eda7eab2fc4046ae153ee95de5df036dbba25b9bb5c5428ea882
-
-COUNT = 22
-MD = 3a02eaf55d04b6052b7d79b96d1e316f90f5dbbb3217dbfaea55faef
-
-COUNT = 23
-MD = c8b5eac17f450458c60c075a8f75a24a1dbc58247fcd0ccfaf03e446
-
-COUNT = 24
-MD = 53084cacfebbc4d1ff2db614b42714c18ddde36c6b7c2fbc3b1a8706
-
-COUNT = 25
-MD = 528b867aa481d42fc4931a47d24c3c905aaafa8f6dd5820c67d3579c
-
-COUNT = 26
-MD = f0a3cd3f53eb72df80ab67d264a973b6bb2f58bde8f636d9100e8864
-
-COUNT = 27
-MD = 7912f20299d803ba917f408a5a59822d147bcd1008ad5c7b678e2390
-
-COUNT = 28
-MD = 6f0e49505c15669302133d66e45d192e0c6ad02fc5b9aa128aa5517a
-
-COUNT = 29
-MD = d06aed0f18e6c377174fd00cc74a92020b3df218c376eac0501a094a
-
-COUNT = 30
-MD = cb1bbf7cc5dad591d32534c570e5bca93b8952832779dd6e0ccdc91c
-
-COUNT = 31
-MD = 4775bc11834930118654a3e66e5b7f51871d6f5068f4305dc2845574
-
-COUNT = 32
-MD = ce3b5703ed9f946ec4af62fade6e69c2751474ab8da570064ecd2ef6
-
-COUNT = 33
-MD = 49a9e1aa84700874ac27eee43f193df69ed6718b131c4854f729a32e
-
-COUNT = 34
-MD = d2c6592251a27cae7d819ac7b476c8a2ff608e57b018f79e0cf19b87
-
-COUNT = 35
-MD = a861be4fe188858b913aad179ba575cec91bed54c1ca27608daa27dc
-
-COUNT = 36
-MD = bf7975e63aa7f1bef84e7446f1c4a00a75c13285fd7c4a7a8318b1cf
-
-COUNT = 37
-MD = 5d125b14e966c9e431bdc5592d3e6305fae678dc5d6dd064fa1345f9
-
-COUNT = 38
-MD = 8c0fbb471404371145dbb66e8b1c6fc428e6dcfa263e3f5ddb47b30d
-
-COUNT = 39
-MD = 7148b69b04457296fca18e6f7b7f2145d9af9e6bc8f48b8571af0e53
-
-COUNT = 40
-MD = 0bd47a04fc42fb3d9643496e5b0719c22262f741e862adfcef91d61c
-
-COUNT = 41
-MD = 3dbb14133351e5d4bc885d9594c07f7f0f99d4a7c745eff3e7aadc2c
-
-COUNT = 42
-MD = 94f6ba7f94ba9903f7e9bde9b131353fce560c7de7159458f1a39cfa
-
-COUNT = 43
-MD = 65fc03fabbf57904f572358c20f004aa16e0b5ae6530fa961ea10b9d
-
-COUNT = 44
-MD = e46532e3e4bd0a0cb389abfba5d679e916a7c193324f1bac498ee1ee
-
-COUNT = 45
-MD = 131d096c684345311cff958706eded139676a74d97a1beb861998485
-
-COUNT = 46
-MD = fe3e03637088ac8ee2e035bfc1e7f4e944304663c832c26089e85f9f
-
-COUNT = 47
-MD = d570c2b7040fc721b41f2d213f6ee87ac1e37f2b86526cf46c699aa7
-
-COUNT = 48
-MD = 82ede72ad163b914be7c22c085cd99438b6d5557ddd3b752f0a9fb7b
-
-COUNT = 49
-MD = 343c21a0cbde3cccdbbd66eee32c50f5a54b0ac267ec3f41ec07a67f
-
-COUNT = 50
-MD = 94ad254f3b4a76f6140d0dd3775bd75eb3c081085fcb76c91b4cca92
-
-COUNT = 51
-MD = 65fa84f358bc32caaff799129bc2cad883636826415703a2dd1a3cbe
-
-COUNT = 52
-MD = 1c2f47c532856198d03dd85275357dce085c8f6c5a871aac4ff4ea28
-
-COUNT = 53
-MD = 1d51c1019131b41a076cc603f4a8e56b2f4ee70dba326af30d926827
-
-COUNT = 54
-MD = 9789daba3a8e9702d2d0b319878f88b08ebc5876dd5dff6414bf1922
-
-COUNT = 55
-MD = 1968789785f1ef61f849bcb29fbc1491c006021f729718e72f29b80d
-
-COUNT = 56
-MD = 62dca9550461f8a85e1abca4192a8a55a6e6663ebcda9ba6fb95f10c
-
-COUNT = 57
-MD = ee190aa251c1a2ae0a376b4c6b6ab3bb09f743fa01eafaab68d170e3
-
-COUNT = 58
-MD = 02273be94aaaf4a1d22496821e8abda8c418d3a4c278947c27d6c912
-
-COUNT = 59
-MD = 3998a213e392978a38016545a59bd435180da66d2b3da373088f406a
-
-COUNT = 60
-MD = 7308f2145d345bdb01c38a9993a0ec81ed5164ed0c6caabfa3b23fea
-
-COUNT = 61
-MD = 3ccde61f4734978995b7489bad8c1e6bafe03f7c3886e9b4ef0f1aa0
-
-COUNT = 62
-MD = cca9745f59f3ae2bbb8d65d31c171aa33960c8c6fa4689bb7e6d2152
-
-COUNT = 63
-MD = c976de72db46c1a254293af6093c563ce43232077c249584c016ff6f
-
-COUNT = 64
-MD = f1448af3cfe317aff1470f0a3de7bf533d77dc7f55e8dd790fd57727
-
-COUNT = 65
-MD = d4be0ccfe4913851c9636ed036c625524e72891c5c0627aae50288ce
-
-COUNT = 66
-MD = 6bd99c53693d4e2467ba6094710a6d2f48cc2ae907c4ae28604586a1
-
-COUNT = 67
-MD = 2eb4fa0872ede2a378386e40002cb00b4d1c2fca3413b944ed210915
-
-COUNT = 68
-MD = 48b624151c9d3a1cc8e9d6665d42d4e640ac91abcd3556a31ff0250c
-
-COUNT = 69
-MD = 31159840b7cb040d819ebee1ed0e52d09f5805be523cccc22eeacba9
-
-COUNT = 70
-MD = f9a67791dcae0aea00f77f8536ddba439e9fcf7e5b1ed827f83818a8
-
-COUNT = 71
-MD = a5913105fba645ba0df942da96d271a1d5efb923a4f61eb463450ea9
-
-COUNT = 72
-MD = 6ece291f81eceaa9eb5a5e228c9924f165b8b10e2cf0e143dd5fe601
-
-COUNT = 73
-MD = e07ab143f09eb8ad0d381b888adb22229c2e2a8b067e0fd012ef67a7
-
-COUNT = 74
-MD = 88a33980be5bc911c1713d5c2bd2e5ecca7fc87879501aefa9722c89
-
-COUNT = 75
-MD = a709d188da8ee187d91bd17069f785ebb379df013d78844a45b2bfe5
-
-COUNT = 76
-MD = 306fa7bd696b3e9841f84d1c861712acba0febddd7a952499b96579e
-
-COUNT = 77
-MD = 61341dee2e2869112bba2e1077fb409375f755dcafc1457bf49e0e8e
-
-COUNT = 78
-MD = 0959a6e3b727c6213119b9e8411132b5819eb848bec6ebda0b75578a
-
-COUNT = 79
-MD = 11cef0312aaedb9d0b26de64656406c8f4c358e6d3db459d364481de
-
-COUNT = 80
-MD = 5de71b191eec70e591c22ebe3a5d2973aa3172f1c272e926cc0d4873
-
-COUNT = 81
-MD = ab218bf4268aec9b41dd2db80622e4c0319cc0de12a60e06d80414ea
-
-COUNT = 82
-MD = 5c83874afe6da0443abfbbbf8ceef38f9400b63593ee7a29d467b4f5
-
-COUNT = 83
-MD = ba0fd01f699a0d00a0dff4c63f6ad19e9530a7ad11fec504e6481816
-
-COUNT = 84
-MD = 835ec2c57424baaeed09a7c0c0b6e8bf9d1cec83de4c719846c990fb
-
-COUNT = 85
-MD = 64d95f2c92343d8fca6f6914fba8814478850b5d4c2eb227f4ae6fa1
-
-COUNT = 86
-MD = f8dd5355827ac4bd040fc05ed6cb2914d013f126487a6d5f2c22f767
-
-COUNT = 87
-MD = be5bbf68d6b99749edefa6b113638ca5cf5fddfd8fcd4d719aeb54b5
-
-COUNT = 88
-MD = 3434d03e98d0af69281e7a7ff8301369c5bc6166cd29b83397ad3fd7
-
-COUNT = 89
-MD = 747b2a7cfb8c4fef7de0a08499f8b19f37e9161b855a84bd50ef84c5
-
-COUNT = 90
-MD = c1c1fa2bbb10c5672b040ed0c33d4d93e0fd210d1373fc7fd2312c0c
-
-COUNT = 91
-MD = 671f67380b7676ee7c9fbfe71f3807e3575745ec3ae3128420a141fd
-
-COUNT = 92
-MD = e88394adf710b9764a448abc6d62928b0268c6b119306f3c93d7b6d2
-
-COUNT = 93
-MD = 711cc90bfdeed121bd5a8629a9cba6df7bf8df89184ec64ee918cc67
-
-COUNT = 94
-MD = 3f63432484eaa1f389d27947a84e256618f9bc81015993cac386887a
-
-COUNT = 95
-MD = e00e0bf2a32227461230a065bbd2eeb5364277e83a850c53ef5c92e9
-
-COUNT = 96
-MD = 1977311cea23a681c83dc58a6863e362bf6c02e30f4c9c4c8439ab4e
-
-COUNT = 97
-MD = 2853a64f56c6282de53e30eba9418dd62eccb8c9a662c313b4768265
-
-COUNT = 98
-MD = ca9d0a2eeb484b9809c3850f166362d893f951f5e93cc7a3c72522e0
-
-COUNT = 99
-MD = 27033d2d89329ba9d2a39c0292552a5f1f945c115d5abf2064e93754
-
+#  CAVS 11.1
+#  "SHA-224 Monte" information for "sha_values"
+#  SHA-224 tests are configured for BYTE oriented implementations
+#  Generated on Wed May 11 17:26:02 2011
+
+[L = 28]
+
+Seed = ed2b70d575d9d0b4196ae84a03eed940057ea89cdd729b95b7d4e6a5
+
+COUNT = 0
+MD = cd94d7da13c030208b2d0d78fcfe9ea22fa8906df66aa9a1f42afa70
+
+COUNT = 1
+MD = 555846e884633639565d5e0c01dd93ba58edb01ee18e68ccca28f7b8
+
+COUNT = 2
+MD = 44d5f4a179b33231f24cc209ed2542ddb931391f2a2d604f80ed460b
+
+COUNT = 3
+MD = 18678e3c151f05f92a89fc5b2ec56bfc6fafa66d73ffc1937fcab4d0
+
+COUNT = 4
+MD = b285f829b0499ff45f8454eda2d4e0997b3f438c2728f1a25cfbb05a
+
+COUNT = 5
+MD = 206d442c6605be0e675b0efc76243c2f18f2260a93375fb36e469631
+
+COUNT = 6
+MD = 1cd8ea34d8483b6a513c52a74e416bac2f322bbaeee02c6b0b05a781
+
+COUNT = 7
+MD = 00cee48001fe8442ef39c3433ed05473179f34205d337940d4bfd3cd
+
+COUNT = 8
+MD = ead3ad27819401912bc9abfdb50037672a3aed0e94fbaa1cc0560621
+
+COUNT = 9
+MD = 8f4dd5aef9cea829d8802ffcced2e8ed6b48ac23bbfbb0fae2fad0fd
+
+COUNT = 10
+MD = 03aeb918feab459e39af29ff3aaf406088bf06d793338bbd563641a2
+
+COUNT = 11
+MD = de80c312b153fbd7241c8bc432d1ed253d26dcc6f458b953ac2d9259
+
+COUNT = 12
+MD = 3eb8d347cc2565ddd71f7fc21cff7eb3a2cf8e85c5e1d4c751f69f26
+
+COUNT = 13
+MD = dbfd7033a4f884ecf7053f07b4c51f3efb1c09084cc7bbe667196a3e
+
+COUNT = 14
+MD = 5323fc60310fe29900eb7a500f29897001c37945c5f8849674725553
+
+COUNT = 15
+MD = c3d9416549bebebf679c0122a9c5bb86c0b514c6a4e9eda1e9782040
+
+COUNT = 16
+MD = 749fc9c8c21957ddcaf5eff69c297284d722c79be1fc6c910495a586
+
+COUNT = 17
+MD = aa307d91c4037372ff0ca60eb17ec8f1faba862601b95754783ea808
+
+COUNT = 18
+MD = 071e361909c38791e941d995b0b25a3294bdf39456cc012806ada3c5
+
+COUNT = 19
+MD = 18751a765f3b06fc2c9a1888d4bb78b2d2226799a54dba72b5429f25
+
+COUNT = 20
+MD = 54b39c96f6377e3fc2ae0ba4ec89049a6c04808da3fa0415c9053ce4
+
+COUNT = 21
+MD = 58c1eda7eab2fc4046ae153ee95de5df036dbba25b9bb5c5428ea882
+
+COUNT = 22
+MD = 3a02eaf55d04b6052b7d79b96d1e316f90f5dbbb3217dbfaea55faef
+
+COUNT = 23
+MD = c8b5eac17f450458c60c075a8f75a24a1dbc58247fcd0ccfaf03e446
+
+COUNT = 24
+MD = 53084cacfebbc4d1ff2db614b42714c18ddde36c6b7c2fbc3b1a8706
+
+COUNT = 25
+MD = 528b867aa481d42fc4931a47d24c3c905aaafa8f6dd5820c67d3579c
+
+COUNT = 26
+MD = f0a3cd3f53eb72df80ab67d264a973b6bb2f58bde8f636d9100e8864
+
+COUNT = 27
+MD = 7912f20299d803ba917f408a5a59822d147bcd1008ad5c7b678e2390
+
+COUNT = 28
+MD = 6f0e49505c15669302133d66e45d192e0c6ad02fc5b9aa128aa5517a
+
+COUNT = 29
+MD = d06aed0f18e6c377174fd00cc74a92020b3df218c376eac0501a094a
+
+COUNT = 30
+MD = cb1bbf7cc5dad591d32534c570e5bca93b8952832779dd6e0ccdc91c
+
+COUNT = 31
+MD = 4775bc11834930118654a3e66e5b7f51871d6f5068f4305dc2845574
+
+COUNT = 32
+MD = ce3b5703ed9f946ec4af62fade6e69c2751474ab8da570064ecd2ef6
+
+COUNT = 33
+MD = 49a9e1aa84700874ac27eee43f193df69ed6718b131c4854f729a32e
+
+COUNT = 34
+MD = d2c6592251a27cae7d819ac7b476c8a2ff608e57b018f79e0cf19b87
+
+COUNT = 35
+MD = a861be4fe188858b913aad179ba575cec91bed54c1ca27608daa27dc
+
+COUNT = 36
+MD = bf7975e63aa7f1bef84e7446f1c4a00a75c13285fd7c4a7a8318b1cf
+
+COUNT = 37
+MD = 5d125b14e966c9e431bdc5592d3e6305fae678dc5d6dd064fa1345f9
+
+COUNT = 38
+MD = 8c0fbb471404371145dbb66e8b1c6fc428e6dcfa263e3f5ddb47b30d
+
+COUNT = 39
+MD = 7148b69b04457296fca18e6f7b7f2145d9af9e6bc8f48b8571af0e53
+
+COUNT = 40
+MD = 0bd47a04fc42fb3d9643496e5b0719c22262f741e862adfcef91d61c
+
+COUNT = 41
+MD = 3dbb14133351e5d4bc885d9594c07f7f0f99d4a7c745eff3e7aadc2c
+
+COUNT = 42
+MD = 94f6ba7f94ba9903f7e9bde9b131353fce560c7de7159458f1a39cfa
+
+COUNT = 43
+MD = 65fc03fabbf57904f572358c20f004aa16e0b5ae6530fa961ea10b9d
+
+COUNT = 44
+MD = e46532e3e4bd0a0cb389abfba5d679e916a7c193324f1bac498ee1ee
+
+COUNT = 45
+MD = 131d096c684345311cff958706eded139676a74d97a1beb861998485
+
+COUNT = 46
+MD = fe3e03637088ac8ee2e035bfc1e7f4e944304663c832c26089e85f9f
+
+COUNT = 47
+MD = d570c2b7040fc721b41f2d213f6ee87ac1e37f2b86526cf46c699aa7
+
+COUNT = 48
+MD = 82ede72ad163b914be7c22c085cd99438b6d5557ddd3b752f0a9fb7b
+
+COUNT = 49
+MD = 343c21a0cbde3cccdbbd66eee32c50f5a54b0ac267ec3f41ec07a67f
+
+COUNT = 50
+MD = 94ad254f3b4a76f6140d0dd3775bd75eb3c081085fcb76c91b4cca92
+
+COUNT = 51
+MD = 65fa84f358bc32caaff799129bc2cad883636826415703a2dd1a3cbe
+
+COUNT = 52
+MD = 1c2f47c532856198d03dd85275357dce085c8f6c5a871aac4ff4ea28
+
+COUNT = 53
+MD = 1d51c1019131b41a076cc603f4a8e56b2f4ee70dba326af30d926827
+
+COUNT = 54
+MD = 9789daba3a8e9702d2d0b319878f88b08ebc5876dd5dff6414bf1922
+
+COUNT = 55
+MD = 1968789785f1ef61f849bcb29fbc1491c006021f729718e72f29b80d
+
+COUNT = 56
+MD = 62dca9550461f8a85e1abca4192a8a55a6e6663ebcda9ba6fb95f10c
+
+COUNT = 57
+MD = ee190aa251c1a2ae0a376b4c6b6ab3bb09f743fa01eafaab68d170e3
+
+COUNT = 58
+MD = 02273be94aaaf4a1d22496821e8abda8c418d3a4c278947c27d6c912
+
+COUNT = 59
+MD = 3998a213e392978a38016545a59bd435180da66d2b3da373088f406a
+
+COUNT = 60
+MD = 7308f2145d345bdb01c38a9993a0ec81ed5164ed0c6caabfa3b23fea
+
+COUNT = 61
+MD = 3ccde61f4734978995b7489bad8c1e6bafe03f7c3886e9b4ef0f1aa0
+
+COUNT = 62
+MD = cca9745f59f3ae2bbb8d65d31c171aa33960c8c6fa4689bb7e6d2152
+
+COUNT = 63
+MD = c976de72db46c1a254293af6093c563ce43232077c249584c016ff6f
+
+COUNT = 64
+MD = f1448af3cfe317aff1470f0a3de7bf533d77dc7f55e8dd790fd57727
+
+COUNT = 65
+MD = d4be0ccfe4913851c9636ed036c625524e72891c5c0627aae50288ce
+
+COUNT = 66
+MD = 6bd99c53693d4e2467ba6094710a6d2f48cc2ae907c4ae28604586a1
+
+COUNT = 67
+MD = 2eb4fa0872ede2a378386e40002cb00b4d1c2fca3413b944ed210915
+
+COUNT = 68
+MD = 48b624151c9d3a1cc8e9d6665d42d4e640ac91abcd3556a31ff0250c
+
+COUNT = 69
+MD = 31159840b7cb040d819ebee1ed0e52d09f5805be523cccc22eeacba9
+
+COUNT = 70
+MD = f9a67791dcae0aea00f77f8536ddba439e9fcf7e5b1ed827f83818a8
+
+COUNT = 71
+MD = a5913105fba645ba0df942da96d271a1d5efb923a4f61eb463450ea9
+
+COUNT = 72
+MD = 6ece291f81eceaa9eb5a5e228c9924f165b8b10e2cf0e143dd5fe601
+
+COUNT = 73
+MD = e07ab143f09eb8ad0d381b888adb22229c2e2a8b067e0fd012ef67a7
+
+COUNT = 74
+MD = 88a33980be5bc911c1713d5c2bd2e5ecca7fc87879501aefa9722c89
+
+COUNT = 75
+MD = a709d188da8ee187d91bd17069f785ebb379df013d78844a45b2bfe5
+
+COUNT = 76
+MD = 306fa7bd696b3e9841f84d1c861712acba0febddd7a952499b96579e
+
+COUNT = 77
+MD = 61341dee2e2869112bba2e1077fb409375f755dcafc1457bf49e0e8e
+
+COUNT = 78
+MD = 0959a6e3b727c6213119b9e8411132b5819eb848bec6ebda0b75578a
+
+COUNT = 79
+MD = 11cef0312aaedb9d0b26de64656406c8f4c358e6d3db459d364481de
+
+COUNT = 80
+MD = 5de71b191eec70e591c22ebe3a5d2973aa3172f1c272e926cc0d4873
+
+COUNT = 81
+MD = ab218bf4268aec9b41dd2db80622e4c0319cc0de12a60e06d80414ea
+
+COUNT = 82
+MD = 5c83874afe6da0443abfbbbf8ceef38f9400b63593ee7a29d467b4f5
+
+COUNT = 83
+MD = ba0fd01f699a0d00a0dff4c63f6ad19e9530a7ad11fec504e6481816
+
+COUNT = 84
+MD = 835ec2c57424baaeed09a7c0c0b6e8bf9d1cec83de4c719846c990fb
+
+COUNT = 85
+MD = 64d95f2c92343d8fca6f6914fba8814478850b5d4c2eb227f4ae6fa1
+
+COUNT = 86
+MD = f8dd5355827ac4bd040fc05ed6cb2914d013f126487a6d5f2c22f767
+
+COUNT = 87
+MD = be5bbf68d6b99749edefa6b113638ca5cf5fddfd8fcd4d719aeb54b5
+
+COUNT = 88
+MD = 3434d03e98d0af69281e7a7ff8301369c5bc6166cd29b83397ad3fd7
+
+COUNT = 89
+MD = 747b2a7cfb8c4fef7de0a08499f8b19f37e9161b855a84bd50ef84c5
+
+COUNT = 90
+MD = c1c1fa2bbb10c5672b040ed0c33d4d93e0fd210d1373fc7fd2312c0c
+
+COUNT = 91
+MD = 671f67380b7676ee7c9fbfe71f3807e3575745ec3ae3128420a141fd
+
+COUNT = 92
+MD = e88394adf710b9764a448abc6d62928b0268c6b119306f3c93d7b6d2
+
+COUNT = 93
+MD = 711cc90bfdeed121bd5a8629a9cba6df7bf8df89184ec64ee918cc67
+
+COUNT = 94
+MD = 3f63432484eaa1f389d27947a84e256618f9bc81015993cac386887a
+
+COUNT = 95
+MD = e00e0bf2a32227461230a065bbd2eeb5364277e83a850c53ef5c92e9
+
+COUNT = 96
+MD = 1977311cea23a681c83dc58a6863e362bf6c02e30f4c9c4c8439ab4e
+
+COUNT = 97
+MD = 2853a64f56c6282de53e30eba9418dd62eccb8c9a662c313b4768265
+
+COUNT = 98
+MD = ca9d0a2eeb484b9809c3850f166362d893f951f5e93cc7a3c72522e0
+
+COUNT = 99
+MD = 27033d2d89329ba9d2a39c0292552a5f1f945c115d5abf2064e93754
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA224ShortMsg.rsp

@@ -1,267 +1,267 @@
-#  CAVS 11.0
-#  "SHA-224 ShortMsg" information 
-#  SHA-224 tests are configured for BYTE oriented implementations
-#  Generated on Tue Mar 15 08:23:36 2011
-
-[L = 28]
-
-Len = 0
-Msg = 00
-MD = d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f
-
-Len = 8
-Msg = 84
-MD = 3cd36921df5d6963e73739cf4d20211e2d8877c19cff087ade9d0e3a
-
-Len = 16
-Msg = 5c7b
-MD = daff9bce685eb831f97fc1225b03c275a6c112e2d6e76f5faf7a36e6
-
-Len = 24
-Msg = 51ca3d
-MD = 2c8959023515476e38388abb43599a29876b4b33d56adc06032de3a2
-
-Len = 32
-Msg = 6084347e
-MD = ae57c0a6d49739ba338adfa53bdae063e5c09122b77604780a8eeaa3
-
-Len = 40
-Msg = 493e14623c
-MD = 7f631f295e024e74552083245ca8f988a3fb65680ae97c3040d2e65c
-
-Len = 48
-Msg = d729d8cd1631
-MD = 342e8e6b23c1c6a54910631f098e08e836259c57e49c1b1d023d166d
-
-Len = 56
-Msg = cbf2061e10faa5
-MD = 3aa702b1b66dc57d7aec3ccdbdfbd88592d7520f843ba5d0fa481168
-
-Len = 64
-Msg = 5f77b3664823c33e
-MD = bdf21ff325f754157ccf417f4855360a72e8fd117d28c8fe7da3ea38
-
-Len = 72
-Msg = 10713b894de4a734c0
-MD = 03842600c86f5cd60c3a2147a067cb962a05303c3488b05cb45327bd
-
-Len = 80
-Msg = 006470d57dad9893dc03
-MD = c90026cda5ad24115059c62ae9add57793ade445d4742273288bbce7
-
-Len = 88
-Msg = 6f29ca274190400720bba2
-MD = ac53157947aa4b2a19089182382a4363d182dd8e4ca79cd8571390be
-
-Len = 96
-Msg = 17e8556176fcca2addbdde29
-MD = cc6ad0488db0222066f740557b5758a19b30372b302332295d8c3aff
-
-Len = 104
-Msg = dbf163601db9a122a4026824de
-MD = 9849845f4e47e1ece9a1c1e01a0d896ffea61c6c8894a75a11ce5f49
-
-Len = 112
-Msg = 5e1ef2ad86ceaf5439fe87d2ec9b
-MD = 223c5d5d4a0116b32cea044f9af0fe44babea1c5ab201502591bcd5f
-
-Len = 120
-Msg = 65f3b9866fb8002b53cfaf806f702f
-MD = b1e0806a218d593821fde8e9eacc44ab5287c32209a94f011ab66b75
-
-Len = 128
-Msg = b776708ffb91b3515ac46598ab9fa796
-MD = 427311b1d7ab2488791c4deeb4251d783fe5f9806bfdfb5188c5443d
-
-Len = 136
-Msg = a4bc10b1a62c96d459fbaf3a5aa3face73
-MD = d7e6634723ac25cb1879bdb1508da05313530419013fe255967a39e1
-
-Len = 144
-Msg = 9e8f3c6645c1749b55c50d2018ce40dc2427
-MD = 2f5a583bf588c8988a572d128a95bea5ef1b66780a7d4be9c29efc31
-
-Len = 152
-Msg = 2db6d207c0b7d9117f24d78ee59abf2f316978
-MD = 35681fce28307cae19522c23cbd4a77969347f7d8ee4a3088ba90ada
-
-Len = 160
-Msg = 3df5e7f399f6dd61a12a9d4e9464fc4997c1f37b
-MD = a3e68076e30751085a843a6cbfbf0f3dee63d9c4219c914372e50b28
-
-Len = 168
-Msg = 65781d018f27ca0c72a9fa9ab4648ed369646dd3ce
-MD = d15ef0d872d02da6427b8d0349dea2f204e67133b7365b4b150efc3c
-
-Len = 176
-Msg = af48eeddd93fee69d1bd7de428a63986011d10945eaf
-MD = b89d428ee42e397cf11029ecbb27baddd036c8938f51c8ab56b875ac
-
-Len = 184
-Msg = df2bf0d5f9c994ac69d78baa0d512eceb74d8a047531c1
-MD = db8e1ce68c8c6b84d6db755c2b8bf54f3c4b081a881efcddaf303294
-
-Len = 192
-Msg = 48d2f20955ea2d13433c20bc0404eb2e6ad79ed28f7cb4c0
-MD = 3617cc3179f8b59adce181eebeed5e2763f62650949224a67e53694b
-
-Len = 200
-Msg = 218f74a42d3a47ef3b806601fba024b078cbff4e4b85772e0e
-MD = b5f40b95dcc363b97e9d00b67c5d7c37f17ab563297d2d67a4df20c9
-
-Len = 208
-Msg = ef55b1e797000b04fcdb9b3021b09327e3b4e269d20cabdf418f
-MD = 827b223d51240c2e3271c534c19c5637b6fe10083e85bcf06761ef21
-
-Len = 216
-Msg = 96df4387dc2c40297043bea36483f65e4eb1e07e93359cb7e68610
-MD = 98e430a63fcdedafc9419010f7f59a4d816a45b4f973beb62530ff8c
-
-Len = 224
-Msg = 3ec0aa8d30d5ed825b77dc7095f421b1e608158797a377ff8bed641b
-MD = 3108321eb7ff857f6aae69101b937f32a51ea279a6c14ba5232ac8c1
-
-Len = 232
-Msg = 8b0239712039f077ce323b35f4e306787b9b35270096e57735cff45d84
-MD = a5c740d3ce46bb2e0a048488f2b0605c6d0ca0ea2f382d043d13db97
-
-Len = 240
-Msg = 044be30167a9758c46c727921dc4eb4e0dcb965623423e6fdd44e7a4ea52
-MD = 6eb78313c743ea8769d8340f284dda6ded64a1db64392f21abb82c5c
-
-Len = 248
-Msg = 57f6118bacce47ecc31ce8b0c083d3c9219e0dbe9e4fbea154537c41231acc
-MD = 0dbb53c866d63af44c222c76c825df0e379dcedfb958db03b6fd29a5
-
-Len = 256
-Msg = fe1f0fb02c9011f4c8c5905934ed15136771737ce31c5859e67f235fe594f5f6
-MD = bbeaacc632c2a3db2a9b47f157ab54aa27776c6e74cf0bcaa91b06d5
-
-Len = 264
-Msg = 14fb01ae9d6015ecb3e56d6ecdfa4bc0533186adf8457f5e4a5c57c687895f3db3
-MD = 178272c7d7cc71b15074c27e3b7997d4a3ba99626986a1a16cf30030
-
-Len = 272
-Msg = ff6c49712f044f4063c14125c0cdfba18ed8b7138453768a45dfa2d82a05f1e84227
-MD = 403284c888a7280bc8bfc25f0c34182cd378306a21a1404d4e1c40cf
-
-Len = 280
-Msg = f900bd7e0117247f97c8fc7a665c76a35f571c3366571d6c4a3ee5d7fb93f1d1f726e2
-MD = 48235b9820d66d8885faabf6a9ede63ba2a21b6177e987a33242373e
-
-Len = 288
-Msg = 42d38188ac49440cfefb77db975e083e6b22348c4c67f0f8692e88ad140d861dc828d595
-MD = 615344f890e5bcf71b5efe39de1fc942ba1fe30dd9e9146adb6a41bf
-
-Len = 296
-Msg = 74fdd7d958b8ae7c2c3c5cff4266dfb2b3b842c9f59ecbbcaff575edcbcda08ccd6e08b764
-MD = 66d7d6c54fc7775a0ba845ba3e11719fa535b9289f20b098c5f7a342
-
-Len = 304
-Msg = 934416dd0581e22f2bfbece7bb64afe820451fa21342df7e6f9fb37c4103381a1f7cd379bcc4
-MD = fae8f1aa22def4dbaa814c5b0babdec43394951792c937050d2963a6
-
-Len = 312
-Msg = 102401c84a716ae72579c6ae79c359ea309ffd95abffae4c61884c03c9e99df77b6c92e492cacb
-MD = 8f34812d57a16ef8a51ad987660c5f8623e0fa9d89846e28d46d14d9
-
-Len = 320
-Msg = 79bc8fb60f85d15a2386566e3e7314df284533085add1c7bb6ead3ff760c86d5633a66404761b544
-MD = 65c54014cfa30f0bc27d1c6efa96ae8481f4c2505bff272956eab0df
-
-Len = 328
-Msg = db3121ea71294983b185207a9d8de3e484a66c0431bf07c962eb82977c4f834b7c3f1e7931a4a7f7a9
-MD = 9316d2f021c2913d63a7e66924c87c161c3cfde0ea7ba07f54772862
-
-Len = 336
-Msg = 0dd51aa660c5cb4b7f78c46852c1db8707ab451c1367b6187388c8bb3873a1aa4210d0414cc6792a29a7
-MD = 31989e7a62a5132a5070d77250d8904bb82d457dc63469d06b50185e
-
-Len = 344
-Msg = 487fd2e5b694b7071d3789a258a51e8604dc0d3e8f5d62f39131968e602abe1ddf6b0278962a512408b553
-MD = e798683438284626d710877d9eea3a0e02f349fc43acb7f9f8f9e81c
-
-Len = 352
-Msg = 11183bdebfef58e4da5b1cb73be0d30b20da304d8659d921da2e270fd14626799537e4d12119e809ee97004a
-MD = 96870657d6cb668be3995aa8bd31df77840d1d1915d72482e83b6b2c
-
-Len = 360
-Msg = a239de5c8e2644e8f030d94d98f1a30664e6fd961dc2977a9c08be5c31d8de89450945a53d79299ea2a1edde7f
-MD = e99743d4fd26c8800c36a67b6762247c29da6b62794123c59de06dc0
-
-Len = 368
-Msg = 917c4577aa6b0f9df49999fc1c958cb09b7fd5fc80be949670f03545eb27dcaed052076b24f96f5e0f2e2f4527c0
-MD = 7ecd693d4d9cf43929464698efa0bac33c2e1424f816edc769260978
-
-Len = 376
-Msg = c3f1e735a6741aa481ad577a98dbac1f03cc80ea0dae1b94db2369ed4e93facd29c64e4e77b25038279120bdfa3715
-MD = 86f0d89d8e14fd8b6606412d71a7a54a347b304ea5d49c208f2266ab
-
-Len = 384
-Msg = de4fbfd553cdf37019f25afa82dc6b9970f4bb1ebbc37f80d3084c88a70722cdc523a9e3c2afbad0dc0221bfdec9a2f9
-MD = 4c5262acb4a2a44eaa9bc6757024fb202ef4d5a7a16fa37252a422b5
-
-Len = 392
-Msg = db2e2eb636610cf42e9b33433acce1b3b925949f297dd83199f45d2861d64cd910c2db74a60b2089045e22cba0a536137d
-MD = 16bf4e45bcdc60447c68dcb30e6b08f55ce9f4124a29cf1f9a9d065d
-
-Len = 400
-Msg = a8e729d336d5d6ac50e1e22f0b193b66e26042fc6459214129875e740ab2b142918c138aaf941863ad3b7e6065450613b273
-MD = 452bf2e5ebfc4e451cc434bc09e2a10032eed0b7627cf55e7e5ed0e2
-
-Len = 408
-Msg = d05317d4b535f9d10f739d0c2dedf3ffb090c1ad9d205089b1346693f58273c4925c0face57ba45ad6fc687c66a88fc78878be
-MD = 4f03c439e097b51b00e314f675937c4d911505859fb7ab16adc65e44
-
-Len = 416
-Msg = 26bb4ed4f0424c60fe4212ff8c955e89e2f553a7d7701be59416d2089af59fa1074724e214e919b1e30f33fb78374b4b055bbc9b
-MD = e7c899e27009d4dc77c2d300f191b757e52c9e7eac4b023bfab2b52a
-
-Len = 424
-Msg = f015ec83944f03292463c4345fdb1c26d1ea07645facbc9520ae244b6eb191e53dabadb4ac0fb15cda4ed77dfb9e1193abfafb1b81
-MD = 459e40b3fbd612912f0217c60099379ce077cd02505871b0c9c14e7a
-
-Len = 432
-Msg = 0786706f680c27b792d054faa63f499a8e6b5ddb90502946235bf74c022d772c809cb4171bfa4791539aca1abd91900e53ba93ca0efd
-MD = fadebab7c3d0fb8e97e429b79083087735e4ab385a789521260ef3ad
-
-Len = 440
-Msg = 445e8698eeb8accbaac4ffa7d934fffd16014a430ef70f3a9174c6cfe96d1e3f6ab1377f4a7212dbb30146dd17d9f470c4dffc45b8e871
-MD = 4c7ae028c0fe61f2a9cada61fae30685b77f04c6442576e912af9fa6
-
-Len = 448
-Msg = 52839f2f0853a30df14ec897a1914c685c1ac21470d00654c8c37663bfb65fa732dbb694d9dd09ced723b48d8f545846ba168988b61cc724
-MD = 2f755a57674b49d5c25cb37348f35b6fd2de2552c749f2645ba63d20
-
-Len = 456
-Msg = 5fe8c2072d8900287ccaf07f3f66b0c22acd3e0bb91d9573754e19e373ac35271d8b43443436ac0c162850ef3d7f281409ad29a9bf716c77d1
-MD = 42909757f6e229f69f04cc7a863c4e70e48c7c3575057b455c959775
-
-Len = 464
-Msg = e8064d83f3d643af8718c87e3ccd6a9733685eac61d572a22ab943f232fcb04f70858e8984449db14a76bb7eaf2458efc3ed2a32100622c52b7f
-MD = 1a1d8ed54cb45c97bc970754b43eb93d9eabde4c7b07f76ad82d8ede
-
-Len = 472
-Msg = 87c9a517e28d1bb54ad20fca76460efd894d7786e68ee8d746b2f68208682157c8ad06cc324ad7a3189e09c6c39d4c768719c0a49a41669f2767d5
-MD = 605977cf87b9b309bbddaaa64e528ace66b04df9f72c0e7ec88be1da
-
-Len = 480
-Msg = 59fdac3b6b32039291801c7d6f46ede8d26dc5b7a192e007116739b617569f2523680b3c0b6631af453e55805aa760c6970833ac06963bbc9dbd455e
-MD = e9f0cb1dc8337e906385892f2348a8ba4412318ecad9b96e3711531f
-
-Len = 488
-Msg = 30350a4df0b58ff49c0fa09e426fcd7007b290c760c825c1855d9b0023b82caa51e3cab4c60cfa61492be50568e5ac0f6db0fd468e39e4536403e3809f
-MD = 776cc6636c02408fbf65ace73ae80017108b917c16c5a912fd860241
-
-Len = 496
-Msg = ef797a0d43c30b4fe1014bdb9420879c2ff845d27e73d55a7df22930c8ece73253d8bb265b4ef2ff9c69455cc56ff25229b4126bb7bb26ee2c9ff36187b1
-MD = f5b9ffb102affac352a4a535a00f89b06c268cf4881d712668906025
-
-Len = 504
-Msg = 716944de41710c29b659be10480bb25a351a39e577ee30e8f422d57cf62ad95bda39b6e70c61426e33fd84aca84cc7912d5eee45dc34076a5d2323a15c7964
-MD = 61645ac748db567ac862796b8d06a47afebfa2e1783d5c5f3bcd81e2
-
-Len = 512
-Msg = a3310ba064be2e14ad32276e18cd0310c933a6e650c3c754d0243c6c61207865b4b65248f66a08edf6e0832689a9dc3a2e5d2095eeea50bd862bac88c8bd318d
-MD = b2a5586d9cbf0baa999157b4af06d88ae08d7c9faab4bc1a96829d65
-
+#  CAVS 11.0
+#  "SHA-224 ShortMsg" information 
+#  SHA-224 tests are configured for BYTE oriented implementations
+#  Generated on Tue Mar 15 08:23:36 2011
+
+[L = 28]
+
+Len = 0
+Msg = 00
+MD = d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f
+
+Len = 8
+Msg = 84
+MD = 3cd36921df5d6963e73739cf4d20211e2d8877c19cff087ade9d0e3a
+
+Len = 16
+Msg = 5c7b
+MD = daff9bce685eb831f97fc1225b03c275a6c112e2d6e76f5faf7a36e6
+
+Len = 24
+Msg = 51ca3d
+MD = 2c8959023515476e38388abb43599a29876b4b33d56adc06032de3a2
+
+Len = 32
+Msg = 6084347e
+MD = ae57c0a6d49739ba338adfa53bdae063e5c09122b77604780a8eeaa3
+
+Len = 40
+Msg = 493e14623c
+MD = 7f631f295e024e74552083245ca8f988a3fb65680ae97c3040d2e65c
+
+Len = 48
+Msg = d729d8cd1631
+MD = 342e8e6b23c1c6a54910631f098e08e836259c57e49c1b1d023d166d
+
+Len = 56
+Msg = cbf2061e10faa5
+MD = 3aa702b1b66dc57d7aec3ccdbdfbd88592d7520f843ba5d0fa481168
+
+Len = 64
+Msg = 5f77b3664823c33e
+MD = bdf21ff325f754157ccf417f4855360a72e8fd117d28c8fe7da3ea38
+
+Len = 72
+Msg = 10713b894de4a734c0
+MD = 03842600c86f5cd60c3a2147a067cb962a05303c3488b05cb45327bd
+
+Len = 80
+Msg = 006470d57dad9893dc03
+MD = c90026cda5ad24115059c62ae9add57793ade445d4742273288bbce7
+
+Len = 88
+Msg = 6f29ca274190400720bba2
+MD = ac53157947aa4b2a19089182382a4363d182dd8e4ca79cd8571390be
+
+Len = 96
+Msg = 17e8556176fcca2addbdde29
+MD = cc6ad0488db0222066f740557b5758a19b30372b302332295d8c3aff
+
+Len = 104
+Msg = dbf163601db9a122a4026824de
+MD = 9849845f4e47e1ece9a1c1e01a0d896ffea61c6c8894a75a11ce5f49
+
+Len = 112
+Msg = 5e1ef2ad86ceaf5439fe87d2ec9b
+MD = 223c5d5d4a0116b32cea044f9af0fe44babea1c5ab201502591bcd5f
+
+Len = 120
+Msg = 65f3b9866fb8002b53cfaf806f702f
+MD = b1e0806a218d593821fde8e9eacc44ab5287c32209a94f011ab66b75
+
+Len = 128
+Msg = b776708ffb91b3515ac46598ab9fa796
+MD = 427311b1d7ab2488791c4deeb4251d783fe5f9806bfdfb5188c5443d
+
+Len = 136
+Msg = a4bc10b1a62c96d459fbaf3a5aa3face73
+MD = d7e6634723ac25cb1879bdb1508da05313530419013fe255967a39e1
+
+Len = 144
+Msg = 9e8f3c6645c1749b55c50d2018ce40dc2427
+MD = 2f5a583bf588c8988a572d128a95bea5ef1b66780a7d4be9c29efc31
+
+Len = 152
+Msg = 2db6d207c0b7d9117f24d78ee59abf2f316978
+MD = 35681fce28307cae19522c23cbd4a77969347f7d8ee4a3088ba90ada
+
+Len = 160
+Msg = 3df5e7f399f6dd61a12a9d4e9464fc4997c1f37b
+MD = a3e68076e30751085a843a6cbfbf0f3dee63d9c4219c914372e50b28
+
+Len = 168
+Msg = 65781d018f27ca0c72a9fa9ab4648ed369646dd3ce
+MD = d15ef0d872d02da6427b8d0349dea2f204e67133b7365b4b150efc3c
+
+Len = 176
+Msg = af48eeddd93fee69d1bd7de428a63986011d10945eaf
+MD = b89d428ee42e397cf11029ecbb27baddd036c8938f51c8ab56b875ac
+
+Len = 184
+Msg = df2bf0d5f9c994ac69d78baa0d512eceb74d8a047531c1
+MD = db8e1ce68c8c6b84d6db755c2b8bf54f3c4b081a881efcddaf303294
+
+Len = 192
+Msg = 48d2f20955ea2d13433c20bc0404eb2e6ad79ed28f7cb4c0
+MD = 3617cc3179f8b59adce181eebeed5e2763f62650949224a67e53694b
+
+Len = 200
+Msg = 218f74a42d3a47ef3b806601fba024b078cbff4e4b85772e0e
+MD = b5f40b95dcc363b97e9d00b67c5d7c37f17ab563297d2d67a4df20c9
+
+Len = 208
+Msg = ef55b1e797000b04fcdb9b3021b09327e3b4e269d20cabdf418f
+MD = 827b223d51240c2e3271c534c19c5637b6fe10083e85bcf06761ef21
+
+Len = 216
+Msg = 96df4387dc2c40297043bea36483f65e4eb1e07e93359cb7e68610
+MD = 98e430a63fcdedafc9419010f7f59a4d816a45b4f973beb62530ff8c
+
+Len = 224
+Msg = 3ec0aa8d30d5ed825b77dc7095f421b1e608158797a377ff8bed641b
+MD = 3108321eb7ff857f6aae69101b937f32a51ea279a6c14ba5232ac8c1
+
+Len = 232
+Msg = 8b0239712039f077ce323b35f4e306787b9b35270096e57735cff45d84
+MD = a5c740d3ce46bb2e0a048488f2b0605c6d0ca0ea2f382d043d13db97
+
+Len = 240
+Msg = 044be30167a9758c46c727921dc4eb4e0dcb965623423e6fdd44e7a4ea52
+MD = 6eb78313c743ea8769d8340f284dda6ded64a1db64392f21abb82c5c
+
+Len = 248
+Msg = 57f6118bacce47ecc31ce8b0c083d3c9219e0dbe9e4fbea154537c41231acc
+MD = 0dbb53c866d63af44c222c76c825df0e379dcedfb958db03b6fd29a5
+
+Len = 256
+Msg = fe1f0fb02c9011f4c8c5905934ed15136771737ce31c5859e67f235fe594f5f6
+MD = bbeaacc632c2a3db2a9b47f157ab54aa27776c6e74cf0bcaa91b06d5
+
+Len = 264
+Msg = 14fb01ae9d6015ecb3e56d6ecdfa4bc0533186adf8457f5e4a5c57c687895f3db3
+MD = 178272c7d7cc71b15074c27e3b7997d4a3ba99626986a1a16cf30030
+
+Len = 272
+Msg = ff6c49712f044f4063c14125c0cdfba18ed8b7138453768a45dfa2d82a05f1e84227
+MD = 403284c888a7280bc8bfc25f0c34182cd378306a21a1404d4e1c40cf
+
+Len = 280
+Msg = f900bd7e0117247f97c8fc7a665c76a35f571c3366571d6c4a3ee5d7fb93f1d1f726e2
+MD = 48235b9820d66d8885faabf6a9ede63ba2a21b6177e987a33242373e
+
+Len = 288
+Msg = 42d38188ac49440cfefb77db975e083e6b22348c4c67f0f8692e88ad140d861dc828d595
+MD = 615344f890e5bcf71b5efe39de1fc942ba1fe30dd9e9146adb6a41bf
+
+Len = 296
+Msg = 74fdd7d958b8ae7c2c3c5cff4266dfb2b3b842c9f59ecbbcaff575edcbcda08ccd6e08b764
+MD = 66d7d6c54fc7775a0ba845ba3e11719fa535b9289f20b098c5f7a342
+
+Len = 304
+Msg = 934416dd0581e22f2bfbece7bb64afe820451fa21342df7e6f9fb37c4103381a1f7cd379bcc4
+MD = fae8f1aa22def4dbaa814c5b0babdec43394951792c937050d2963a6
+
+Len = 312
+Msg = 102401c84a716ae72579c6ae79c359ea309ffd95abffae4c61884c03c9e99df77b6c92e492cacb
+MD = 8f34812d57a16ef8a51ad987660c5f8623e0fa9d89846e28d46d14d9
+
+Len = 320
+Msg = 79bc8fb60f85d15a2386566e3e7314df284533085add1c7bb6ead3ff760c86d5633a66404761b544
+MD = 65c54014cfa30f0bc27d1c6efa96ae8481f4c2505bff272956eab0df
+
+Len = 328
+Msg = db3121ea71294983b185207a9d8de3e484a66c0431bf07c962eb82977c4f834b7c3f1e7931a4a7f7a9
+MD = 9316d2f021c2913d63a7e66924c87c161c3cfde0ea7ba07f54772862
+
+Len = 336
+Msg = 0dd51aa660c5cb4b7f78c46852c1db8707ab451c1367b6187388c8bb3873a1aa4210d0414cc6792a29a7
+MD = 31989e7a62a5132a5070d77250d8904bb82d457dc63469d06b50185e
+
+Len = 344
+Msg = 487fd2e5b694b7071d3789a258a51e8604dc0d3e8f5d62f39131968e602abe1ddf6b0278962a512408b553
+MD = e798683438284626d710877d9eea3a0e02f349fc43acb7f9f8f9e81c
+
+Len = 352
+Msg = 11183bdebfef58e4da5b1cb73be0d30b20da304d8659d921da2e270fd14626799537e4d12119e809ee97004a
+MD = 96870657d6cb668be3995aa8bd31df77840d1d1915d72482e83b6b2c
+
+Len = 360
+Msg = a239de5c8e2644e8f030d94d98f1a30664e6fd961dc2977a9c08be5c31d8de89450945a53d79299ea2a1edde7f
+MD = e99743d4fd26c8800c36a67b6762247c29da6b62794123c59de06dc0
+
+Len = 368
+Msg = 917c4577aa6b0f9df49999fc1c958cb09b7fd5fc80be949670f03545eb27dcaed052076b24f96f5e0f2e2f4527c0
+MD = 7ecd693d4d9cf43929464698efa0bac33c2e1424f816edc769260978
+
+Len = 376
+Msg = c3f1e735a6741aa481ad577a98dbac1f03cc80ea0dae1b94db2369ed4e93facd29c64e4e77b25038279120bdfa3715
+MD = 86f0d89d8e14fd8b6606412d71a7a54a347b304ea5d49c208f2266ab
+
+Len = 384
+Msg = de4fbfd553cdf37019f25afa82dc6b9970f4bb1ebbc37f80d3084c88a70722cdc523a9e3c2afbad0dc0221bfdec9a2f9
+MD = 4c5262acb4a2a44eaa9bc6757024fb202ef4d5a7a16fa37252a422b5
+
+Len = 392
+Msg = db2e2eb636610cf42e9b33433acce1b3b925949f297dd83199f45d2861d64cd910c2db74a60b2089045e22cba0a536137d
+MD = 16bf4e45bcdc60447c68dcb30e6b08f55ce9f4124a29cf1f9a9d065d
+
+Len = 400
+Msg = a8e729d336d5d6ac50e1e22f0b193b66e26042fc6459214129875e740ab2b142918c138aaf941863ad3b7e6065450613b273
+MD = 452bf2e5ebfc4e451cc434bc09e2a10032eed0b7627cf55e7e5ed0e2
+
+Len = 408
+Msg = d05317d4b535f9d10f739d0c2dedf3ffb090c1ad9d205089b1346693f58273c4925c0face57ba45ad6fc687c66a88fc78878be
+MD = 4f03c439e097b51b00e314f675937c4d911505859fb7ab16adc65e44
+
+Len = 416
+Msg = 26bb4ed4f0424c60fe4212ff8c955e89e2f553a7d7701be59416d2089af59fa1074724e214e919b1e30f33fb78374b4b055bbc9b
+MD = e7c899e27009d4dc77c2d300f191b757e52c9e7eac4b023bfab2b52a
+
+Len = 424
+Msg = f015ec83944f03292463c4345fdb1c26d1ea07645facbc9520ae244b6eb191e53dabadb4ac0fb15cda4ed77dfb9e1193abfafb1b81
+MD = 459e40b3fbd612912f0217c60099379ce077cd02505871b0c9c14e7a
+
+Len = 432
+Msg = 0786706f680c27b792d054faa63f499a8e6b5ddb90502946235bf74c022d772c809cb4171bfa4791539aca1abd91900e53ba93ca0efd
+MD = fadebab7c3d0fb8e97e429b79083087735e4ab385a789521260ef3ad
+
+Len = 440
+Msg = 445e8698eeb8accbaac4ffa7d934fffd16014a430ef70f3a9174c6cfe96d1e3f6ab1377f4a7212dbb30146dd17d9f470c4dffc45b8e871
+MD = 4c7ae028c0fe61f2a9cada61fae30685b77f04c6442576e912af9fa6
+
+Len = 448
+Msg = 52839f2f0853a30df14ec897a1914c685c1ac21470d00654c8c37663bfb65fa732dbb694d9dd09ced723b48d8f545846ba168988b61cc724
+MD = 2f755a57674b49d5c25cb37348f35b6fd2de2552c749f2645ba63d20
+
+Len = 456
+Msg = 5fe8c2072d8900287ccaf07f3f66b0c22acd3e0bb91d9573754e19e373ac35271d8b43443436ac0c162850ef3d7f281409ad29a9bf716c77d1
+MD = 42909757f6e229f69f04cc7a863c4e70e48c7c3575057b455c959775
+
+Len = 464
+Msg = e8064d83f3d643af8718c87e3ccd6a9733685eac61d572a22ab943f232fcb04f70858e8984449db14a76bb7eaf2458efc3ed2a32100622c52b7f
+MD = 1a1d8ed54cb45c97bc970754b43eb93d9eabde4c7b07f76ad82d8ede
+
+Len = 472
+Msg = 87c9a517e28d1bb54ad20fca76460efd894d7786e68ee8d746b2f68208682157c8ad06cc324ad7a3189e09c6c39d4c768719c0a49a41669f2767d5
+MD = 605977cf87b9b309bbddaaa64e528ace66b04df9f72c0e7ec88be1da
+
+Len = 480
+Msg = 59fdac3b6b32039291801c7d6f46ede8d26dc5b7a192e007116739b617569f2523680b3c0b6631af453e55805aa760c6970833ac06963bbc9dbd455e
+MD = e9f0cb1dc8337e906385892f2348a8ba4412318ecad9b96e3711531f
+
+Len = 488
+Msg = 30350a4df0b58ff49c0fa09e426fcd7007b290c760c825c1855d9b0023b82caa51e3cab4c60cfa61492be50568e5ac0f6db0fd468e39e4536403e3809f
+MD = 776cc6636c02408fbf65ace73ae80017108b917c16c5a912fd860241
+
+Len = 496
+Msg = ef797a0d43c30b4fe1014bdb9420879c2ff845d27e73d55a7df22930c8ece73253d8bb265b4ef2ff9c69455cc56ff25229b4126bb7bb26ee2c9ff36187b1
+MD = f5b9ffb102affac352a4a535a00f89b06c268cf4881d712668906025
+
+Len = 504
+Msg = 716944de41710c29b659be10480bb25a351a39e577ee30e8f422d57cf62ad95bda39b6e70c61426e33fd84aca84cc7912d5eee45dc34076a5d2323a15c7964
+MD = 61645ac748db567ac862796b8d06a47afebfa2e1783d5c5f3bcd81e2
+
+Len = 512
+Msg = a3310ba064be2e14ad32276e18cd0310c933a6e650c3c754d0243c6c61207865b4b65248f66a08edf6e0832689a9dc3a2e5d2095eeea50bd862bac88c8bd318d
+MD = b2a5586d9cbf0baa999157b4af06d88ae08d7c9faab4bc1a96829d65
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA256Monte.rsp

@@ -1,309 +1,309 @@
-#  CAVS 11.1
-#  "SHA-256 Monte" information for "sha_values"
-#  SHA-256 tests are configured for BYTE oriented implementations
-#  Generated on Wed May 11 17:26:03 2011
-
-[L = 32]
-
-Seed = 6d1e72ad03ddeb5de891e572e2396f8da015d899ef0e79503152d6010a3fe691
-
-COUNT = 0
-MD = e93c330ae5447738c8aa85d71a6c80f2a58381d05872d26bdd39f1fcd4f2b788
-
-COUNT = 1
-MD = 2e78f8c8772ea7c9331d41ed3f9cdf27d8f514a99342ee766ee3b8b0d0b121c0
-
-COUNT = 2
-MD = d6a23dff1b7f2eddc1a212f8a218397523a799b07386a30692fd6fe9d2bf0944
-
-COUNT = 3
-MD = fb0099a964fad5a88cf12952f2991ce256a4ac3049f3d389c3b9e6c00e585db4
-
-COUNT = 4
-MD = f9eba2a4cf6263826beaf6150057849eb975a9513c0b76ecad0f1c19ebbad89b
-
-COUNT = 5
-MD = 3ddf05ba8dfec982451a3e9a97695ea9cdb7098c877d0c2cd2c64e58a87754d9
-
-COUNT = 6
-MD = 2cc3fe501e3b2e33e60407b0a27025735dd04fd7623bb4fceeebae5cad67ad4b
-
-COUNT = 7
-MD = c534802a459b40c792e1fa68e54ceab69e333fbeeecad65fb124d2f3cc1f1fc1
-
-COUNT = 8
-MD = 8986e95d85e64822287c78cb7a714339431332182107109d57827776c6cc930e
-
-COUNT = 9
-MD = 72361401c670d07f1151a95e2ee914665c2bdb1228581833c7dc53b89c01c927
-
-COUNT = 10
-MD = 124c443bad9d955e084a3961b079c43c59b5e0d666af38f2f37846e85369a618
-
-COUNT = 11
-MD = 81914b78674a2a6204eef78ff51369526bf0c2e121cd364eb40a8435479dda14
-
-COUNT = 12
-MD = 8eac9d963b44021b70a527ea07420b03f51a998d0d6cb73ad4cb7fc688b4d174
-
-COUNT = 13
-MD = 0427263b4dd3ebfcb7871939dbaca5ca94e794f748c02920c9759dfa554ea534
-
-COUNT = 14
-MD = 3e9d754f2ec273b0056c2fcad2e891aaf9616fe74005d36cbf5ccba2e037b5b3
-
-COUNT = 15
-MD = 986b6594ed96a819e49edb9f65db2ea52168973d7e18ae9e0b8869a8b5dd29a0
-
-COUNT = 16
-MD = 117578126a35176a00f8c0cf999442df0890737be1880f06e6a7270959c114c6
-
-COUNT = 17
-MD = fd7f5574788d8ef64b83333ffb62e4cd3311e638db0c514071c19b84e9117afe
-
-COUNT = 18
-MD = 19db7ba6e3488a9e935af33ffb912d60c9d3b98a0be1d78e0b374dcb5274a7fb
-
-COUNT = 19
-MD = 52519e6319505df7a9aa83778618ec10b78c5771bac50e8d3f59bc815dabfb1f
-
-COUNT = 20
-MD = 434d7795fc7510af04b613e120f7f48e6d613ec056ae9fbc7c869b87c1dce63e
-
-COUNT = 21
-MD = 020324de7f6763be57bc4a6a0960258ea401ffe40d68f854e82ccfa9e0612ff7
-
-COUNT = 22
-MD = b87c7fd0ec4cd35fab077b64d00917ad06aaccb095bbe4603466644ce6cbce18
-
-COUNT = 23
-MD = 01abbd12b2b476b2d540d0c47edcb56263ea658a8080a8f08dbb313942562f00
-
-COUNT = 24
-MD = ce95bb2bf2d5c91402e13ed5271615607f39e0678aae776d18a78351b90b5838
-
-COUNT = 25
-MD = b81af264b0bb485f6656be91478f7b96c324fe262fcc366d9ce3edd44ccb85d0
-
-COUNT = 26
-MD = 9e2ad901200ca524c91373f7b5eda9cda142353e763862e350314f793a0b700d
-
-COUNT = 27
-MD = dbfabc7124338d6845f083cb1bbdf7b4060274d8e0e98d08bb7ca3779059b45b
-
-COUNT = 28
-MD = d93c2cd61f5476ea08d85f741720ab2ce5c4e38cd8254758238155fd68ea7723
-
-COUNT = 29
-MD = 232d9c3b583e297439c859150738e1b1d530812d63a9a2c1cb8e40cb50a2f27b
-
-COUNT = 30
-MD = 8b9c858bd135138d9023a0b5fcf3f12ebbc3b7f721ee0b44be1871187f21f506
-
-COUNT = 31
-MD = 05cedbd568ce9adcf5022999b8f3a28995a910c572375186da5febd775d62b79
-
-COUNT = 32
-MD = 24282cba8f5dfce7e423a103488a9a924080d549853c699159d27816dbdbe5d9
-
-COUNT = 33
-MD = ba6e3c38128f93f288e781af8a13e7ce5120c2a43a6d1c0d4edc831247350079
-
-COUNT = 34
-MD = 706fffec5b69f5ef5465b6a8663c302143af743c6b7cd5fec9f3fa9bf9b2e285
-
-COUNT = 35
-MD = 6d32c55c005eea65dacdf0e90f436943d0d0acec3c2355c36e2df1a86d1a11a7
-
-COUNT = 36
-MD = b353f425293db464ad814177ea9689f43054bcdbaf75675e918b78a82ca97a50
-
-COUNT = 37
-MD = c3fa9993130b3c95d9aed30243ba902035933d18adf5e21d2567674769062e81
-
-COUNT = 38
-MD = 1e77e07988ebd618740c2f89a7bcf0ae2542279ea8895b39aa70ba8bc37ee00f
-
-COUNT = 39
-MD = 063927892a0b095be7d21987ff8157cd4c674c1cd01ab9f0834824e8efbcf938
-
-COUNT = 40
-MD = f43054c280f05371cfbac776d43d6001f71350d898677f035aa8f7e5bd7b3fa3
-
-COUNT = 41
-MD = 2427934b28c7a9c2b18a5b7e996351aa567523744f60d54dc35bbb61f56f6fd4
-
-COUNT = 42
-MD = 3633976d174279161e13b49e5866c144ce8c1d17ec1901ad56a02c900273fe11
-
-COUNT = 43
-MD = 5f9788660d82c80155a7fea91896be3be2eb6a7b2ce963f3804cd09da5ac0c8f
-
-COUNT = 44
-MD = 097ef57de6df98c29346e67e7f676569ad402f7a1c88d1cf39ce2d44fd706f72
-
-COUNT = 45
-MD = fedcc810c74706a27fc0b6663ab2f9de0761089682dff1279fcd91312af1b8e3
-
-COUNT = 46
-MD = bd5d61fea8d23089f3f30266b1daa636a352e49476526e71cc0735cbd17054fe
-
-COUNT = 47
-MD = 5ead027c03d7a55c17f0c783b6d77670cdb8942772077d09dff9a46ecd527bec
-
-COUNT = 48
-MD = 7a06eeea07ca9eb94a98a5e9f00b7efd8de9843b6aa888822c3dccf803637732
-
-COUNT = 49
-MD = 44b6a895058ed3f31a5549407af8f788631f8a6eb8c0a5f2e15facc9190b5672
-
-COUNT = 50
-MD = f8a58bff4b54aaebe18fc3f0bb1d24974a125530756dd4a0f15628c35c02ea1c
-
-COUNT = 51
-MD = 3bf2ae5408399aba59f42e5bed35a00d038fada16013ffa5da9e8b7207f6012c
-
-COUNT = 52
-MD = 31d33c0275986b06f6dccf570d1064c7b36e1574cc4371d4bba2e55321d75397
-
-COUNT = 53
-MD = bda59cbd65e87a57df3f03c89e4d9511de71da05e2eee0560948696b37615f8f
-
-COUNT = 54
-MD = f431cc1817569e92c8ba11ec4741e6dd2e361156575af7b482587ed78e9fb7fe
-
-COUNT = 55
-MD = 1b3b3789a32165f725167da6f5ef89d95de5992783961440fce67b66c3351ea6
-
-COUNT = 56
-MD = c9873a09c079ca7f477b5601519ce51896c2a35a28fe05fe8b13e990813c6634
-
-COUNT = 57
-MD = fb16cc865ddcf513be298c7d514033ab3fae7a80b285d2b43e82363342e498f4
-
-COUNT = 58
-MD = ebaebc261b327f8be24026e32099a6b15927c54dbe390b72756f3f6362ea3b3a
-
-COUNT = 59
-MD = ae5a4fdc779d808ba898966c8c14a6c9894107ef3e1d680f6ae37e95cb7e1b67
-
-COUNT = 60
-MD = 5a4a67451c197b038c540878b6e7bc6fce3eea9c95795d611359703d6cc7ca02
-
-COUNT = 61
-MD = efb075aa051070a6b2303e026f81a5262a6e64eabb270ec5e13fc6efa3529f6f
-
-COUNT = 62
-MD = 8ff3df1a5cd0840bce61520f1e5645ce272a37b884c1750c69a957134c1a20d2
-
-COUNT = 63
-MD = 8fbd86567c20dc3ea9948dd5ea6f5204028c4ba258c35052994e7c86de2d7701
-
-COUNT = 64
-MD = 670559572a74e9af0513a3f9243bfbfd5805b837705faedc3c480d67a92bc124
-
-COUNT = 65
-MD = ef2ad8656fac9c593d301fcfac77a7815d50b42526d3a44e1573316a25b05904
-
-COUNT = 66
-MD = a3484a7a6cb5c941e15346a3ac4e09e99a5189cc96a87104d196af3c43cf995e
-
-COUNT = 67
-MD = 966851a0ef41f8d8ff970f4340a8dae8eec4f1999f5fd4f6cbcfa372fbf85495
-
-COUNT = 68
-MD = 8e1559cd4431febfa15662a2ccf2cac82f5401b2657551480bb0e3dd2111032c
-
-COUNT = 69
-MD = 5f535e2e7351cb8caf0070166218238a843c17472cea2f5911008be5d7fd6ba2
-
-COUNT = 70
-MD = 86ac4ea15f10c264b158058f5c13a36a87ac72f840071bbc45399b36823a5709
-
-COUNT = 71
-MD = 5c0d3fe289b2aac7d1bbaf57f4154b8d10875cffc9d8bd2402255ed1615f1d5f
-
-COUNT = 72
-MD = d7d808366d0c8b76ce3e7ab80ea11b4e2f8758f9ff404a3aafbf5b0cc191adcb
-
-COUNT = 73
-MD = e0768536856d1d7399667d6fd2c32f72416eeea1c40a313ee6edc910a5c3b786
-
-COUNT = 74
-MD = d670923731b3e598f5c4db4c7e57fe2275cc6c49b4bf67cb91d520846aec256e
-
-COUNT = 75
-MD = 2cb0bdcc305ef3b3d6b7265ab62bee555c524102679da122424713a9a01d69f6
-
-COUNT = 76
-MD = 5acdc323fe067a4b915ee521ac8eb81bcff4e205d53e4e7f9a69d436035cc5ad
-
-COUNT = 77
-MD = e634c43558d12c2a8710f2d6f10a86411cfad5a014e6b6cc159733c8ccece283
-
-COUNT = 78
-MD = 4a05f4bc3fcaf50e6d0916d7e7024b0ed22e9a3c413ff4bbcc0922d2326dcf6e
-
-COUNT = 79
-MD = 17c9d6029e15d3fd84e6809c5ef8a279a040f49ada91601a3ba4572cef7c08bd
-
-COUNT = 80
-MD = 1f21e137da2427536758409f3fbf5842589c5f587f0b9d2d10430f840faaaf45
-
-COUNT = 81
-MD = e3d38cff8a8d7fc00693dca5e37b03e7b10dafe4926023e26d937106ddac6a78
-
-COUNT = 82
-MD = cd749eb05c67038fe837910310b3b4cdda190f6235fa970602f865bec1b61a1b
-
-COUNT = 83
-MD = d596ccddea01b4ae29b68b0e8a191007f0c89a1016c380b49786f2d4fac4c43d
-
-COUNT = 84
-MD = cbccb1ff23e33c59dc4c858093c9e215c3759acfe6bc84ff75940b59b25a4e40
-
-COUNT = 85
-MD = 7214c134e9a963d6c43969d3ef44ece825dd9cf35bda5fcce92a6b9d0d3fd1b8
-
-COUNT = 86
-MD = aceaf5b775779621319f9ab5d4d370a3359cd6553ed2328cdc9dbab5b68840fa
-
-COUNT = 87
-MD = e8123acb0a2fb62978d3811b31676975542993932108ab14d487ad7875ddef72
-
-COUNT = 88
-MD = 660202a436fb05c3d59be699734e77c9750c906c8597ca213d064853ecf8c9f3
-
-COUNT = 89
-MD = 4752b0a5ec3f1fb295d5bfa98fa63a0ba38a02a4c1e1f73b0c4d4e88a07e0317
-
-COUNT = 90
-MD = 1e24f1467c36b051af3241fcf8c2c868b86dcb8e4669931878018e9914129b42
-
-COUNT = 91
-MD = d1c3efc99d9487e147282d811ab932d4a24362d09ac909f4854e783887068891
-
-COUNT = 92
-MD = 7dc455cf6f8b2042b6f0f368c44f18a080e5d3912ce3cdaf7142bd61ae50d02e
-
-COUNT = 93
-MD = 4b991c15789084eb1d6c1d7ce8f0928df4d3931c0c22c571f375849b9a6c2b71
-
-COUNT = 94
-MD = 8b78f95a007cfb0bd054a1f5d962cd8d927665f79a5ce9e0fc31105e57b8460b
-
-COUNT = 95
-MD = bf305423849cf773fc54206d8ae3c000c3e8b359cba8364581d1f91b0a201032
-
-COUNT = 96
-MD = 47006af96cff3843d3ed53bdedb167490d7bfefd93ae3e9ef473cb53aa840fc0
-
-COUNT = 97
-MD = c53cf5026162021fd2345dbad7c53d3a3df47b5bdff8cd34a0ccfee06dbb7328
-
-COUNT = 98
-MD = 3326899b575f93cdaff757f8ab7c3996a2fe930450d5002d4575f4e4cc4b4360
-
-COUNT = 99
-MD = 6a912ba4188391a78e6f13d88ed2d14e13afce9db6f7dcbf4a48c24f3db02778
-
+#  CAVS 11.1
+#  "SHA-256 Monte" information for "sha_values"
+#  SHA-256 tests are configured for BYTE oriented implementations
+#  Generated on Wed May 11 17:26:03 2011
+
+[L = 32]
+
+Seed = 6d1e72ad03ddeb5de891e572e2396f8da015d899ef0e79503152d6010a3fe691
+
+COUNT = 0
+MD = e93c330ae5447738c8aa85d71a6c80f2a58381d05872d26bdd39f1fcd4f2b788
+
+COUNT = 1
+MD = 2e78f8c8772ea7c9331d41ed3f9cdf27d8f514a99342ee766ee3b8b0d0b121c0
+
+COUNT = 2
+MD = d6a23dff1b7f2eddc1a212f8a218397523a799b07386a30692fd6fe9d2bf0944
+
+COUNT = 3
+MD = fb0099a964fad5a88cf12952f2991ce256a4ac3049f3d389c3b9e6c00e585db4
+
+COUNT = 4
+MD = f9eba2a4cf6263826beaf6150057849eb975a9513c0b76ecad0f1c19ebbad89b
+
+COUNT = 5
+MD = 3ddf05ba8dfec982451a3e9a97695ea9cdb7098c877d0c2cd2c64e58a87754d9
+
+COUNT = 6
+MD = 2cc3fe501e3b2e33e60407b0a27025735dd04fd7623bb4fceeebae5cad67ad4b
+
+COUNT = 7
+MD = c534802a459b40c792e1fa68e54ceab69e333fbeeecad65fb124d2f3cc1f1fc1
+
+COUNT = 8
+MD = 8986e95d85e64822287c78cb7a714339431332182107109d57827776c6cc930e
+
+COUNT = 9
+MD = 72361401c670d07f1151a95e2ee914665c2bdb1228581833c7dc53b89c01c927
+
+COUNT = 10
+MD = 124c443bad9d955e084a3961b079c43c59b5e0d666af38f2f37846e85369a618
+
+COUNT = 11
+MD = 81914b78674a2a6204eef78ff51369526bf0c2e121cd364eb40a8435479dda14
+
+COUNT = 12
+MD = 8eac9d963b44021b70a527ea07420b03f51a998d0d6cb73ad4cb7fc688b4d174
+
+COUNT = 13
+MD = 0427263b4dd3ebfcb7871939dbaca5ca94e794f748c02920c9759dfa554ea534
+
+COUNT = 14
+MD = 3e9d754f2ec273b0056c2fcad2e891aaf9616fe74005d36cbf5ccba2e037b5b3
+
+COUNT = 15
+MD = 986b6594ed96a819e49edb9f65db2ea52168973d7e18ae9e0b8869a8b5dd29a0
+
+COUNT = 16
+MD = 117578126a35176a00f8c0cf999442df0890737be1880f06e6a7270959c114c6
+
+COUNT = 17
+MD = fd7f5574788d8ef64b83333ffb62e4cd3311e638db0c514071c19b84e9117afe
+
+COUNT = 18
+MD = 19db7ba6e3488a9e935af33ffb912d60c9d3b98a0be1d78e0b374dcb5274a7fb
+
+COUNT = 19
+MD = 52519e6319505df7a9aa83778618ec10b78c5771bac50e8d3f59bc815dabfb1f
+
+COUNT = 20
+MD = 434d7795fc7510af04b613e120f7f48e6d613ec056ae9fbc7c869b87c1dce63e
+
+COUNT = 21
+MD = 020324de7f6763be57bc4a6a0960258ea401ffe40d68f854e82ccfa9e0612ff7
+
+COUNT = 22
+MD = b87c7fd0ec4cd35fab077b64d00917ad06aaccb095bbe4603466644ce6cbce18
+
+COUNT = 23
+MD = 01abbd12b2b476b2d540d0c47edcb56263ea658a8080a8f08dbb313942562f00
+
+COUNT = 24
+MD = ce95bb2bf2d5c91402e13ed5271615607f39e0678aae776d18a78351b90b5838
+
+COUNT = 25
+MD = b81af264b0bb485f6656be91478f7b96c324fe262fcc366d9ce3edd44ccb85d0
+
+COUNT = 26
+MD = 9e2ad901200ca524c91373f7b5eda9cda142353e763862e350314f793a0b700d
+
+COUNT = 27
+MD = dbfabc7124338d6845f083cb1bbdf7b4060274d8e0e98d08bb7ca3779059b45b
+
+COUNT = 28
+MD = d93c2cd61f5476ea08d85f741720ab2ce5c4e38cd8254758238155fd68ea7723
+
+COUNT = 29
+MD = 232d9c3b583e297439c859150738e1b1d530812d63a9a2c1cb8e40cb50a2f27b
+
+COUNT = 30
+MD = 8b9c858bd135138d9023a0b5fcf3f12ebbc3b7f721ee0b44be1871187f21f506
+
+COUNT = 31
+MD = 05cedbd568ce9adcf5022999b8f3a28995a910c572375186da5febd775d62b79
+
+COUNT = 32
+MD = 24282cba8f5dfce7e423a103488a9a924080d549853c699159d27816dbdbe5d9
+
+COUNT = 33
+MD = ba6e3c38128f93f288e781af8a13e7ce5120c2a43a6d1c0d4edc831247350079
+
+COUNT = 34
+MD = 706fffec5b69f5ef5465b6a8663c302143af743c6b7cd5fec9f3fa9bf9b2e285
+
+COUNT = 35
+MD = 6d32c55c005eea65dacdf0e90f436943d0d0acec3c2355c36e2df1a86d1a11a7
+
+COUNT = 36
+MD = b353f425293db464ad814177ea9689f43054bcdbaf75675e918b78a82ca97a50
+
+COUNT = 37
+MD = c3fa9993130b3c95d9aed30243ba902035933d18adf5e21d2567674769062e81
+
+COUNT = 38
+MD = 1e77e07988ebd618740c2f89a7bcf0ae2542279ea8895b39aa70ba8bc37ee00f
+
+COUNT = 39
+MD = 063927892a0b095be7d21987ff8157cd4c674c1cd01ab9f0834824e8efbcf938
+
+COUNT = 40
+MD = f43054c280f05371cfbac776d43d6001f71350d898677f035aa8f7e5bd7b3fa3
+
+COUNT = 41
+MD = 2427934b28c7a9c2b18a5b7e996351aa567523744f60d54dc35bbb61f56f6fd4
+
+COUNT = 42
+MD = 3633976d174279161e13b49e5866c144ce8c1d17ec1901ad56a02c900273fe11
+
+COUNT = 43
+MD = 5f9788660d82c80155a7fea91896be3be2eb6a7b2ce963f3804cd09da5ac0c8f
+
+COUNT = 44
+MD = 097ef57de6df98c29346e67e7f676569ad402f7a1c88d1cf39ce2d44fd706f72
+
+COUNT = 45
+MD = fedcc810c74706a27fc0b6663ab2f9de0761089682dff1279fcd91312af1b8e3
+
+COUNT = 46
+MD = bd5d61fea8d23089f3f30266b1daa636a352e49476526e71cc0735cbd17054fe
+
+COUNT = 47
+MD = 5ead027c03d7a55c17f0c783b6d77670cdb8942772077d09dff9a46ecd527bec
+
+COUNT = 48
+MD = 7a06eeea07ca9eb94a98a5e9f00b7efd8de9843b6aa888822c3dccf803637732
+
+COUNT = 49
+MD = 44b6a895058ed3f31a5549407af8f788631f8a6eb8c0a5f2e15facc9190b5672
+
+COUNT = 50
+MD = f8a58bff4b54aaebe18fc3f0bb1d24974a125530756dd4a0f15628c35c02ea1c
+
+COUNT = 51
+MD = 3bf2ae5408399aba59f42e5bed35a00d038fada16013ffa5da9e8b7207f6012c
+
+COUNT = 52
+MD = 31d33c0275986b06f6dccf570d1064c7b36e1574cc4371d4bba2e55321d75397
+
+COUNT = 53
+MD = bda59cbd65e87a57df3f03c89e4d9511de71da05e2eee0560948696b37615f8f
+
+COUNT = 54
+MD = f431cc1817569e92c8ba11ec4741e6dd2e361156575af7b482587ed78e9fb7fe
+
+COUNT = 55
+MD = 1b3b3789a32165f725167da6f5ef89d95de5992783961440fce67b66c3351ea6
+
+COUNT = 56
+MD = c9873a09c079ca7f477b5601519ce51896c2a35a28fe05fe8b13e990813c6634
+
+COUNT = 57
+MD = fb16cc865ddcf513be298c7d514033ab3fae7a80b285d2b43e82363342e498f4
+
+COUNT = 58
+MD = ebaebc261b327f8be24026e32099a6b15927c54dbe390b72756f3f6362ea3b3a
+
+COUNT = 59
+MD = ae5a4fdc779d808ba898966c8c14a6c9894107ef3e1d680f6ae37e95cb7e1b67
+
+COUNT = 60
+MD = 5a4a67451c197b038c540878b6e7bc6fce3eea9c95795d611359703d6cc7ca02
+
+COUNT = 61
+MD = efb075aa051070a6b2303e026f81a5262a6e64eabb270ec5e13fc6efa3529f6f
+
+COUNT = 62
+MD = 8ff3df1a5cd0840bce61520f1e5645ce272a37b884c1750c69a957134c1a20d2
+
+COUNT = 63
+MD = 8fbd86567c20dc3ea9948dd5ea6f5204028c4ba258c35052994e7c86de2d7701
+
+COUNT = 64
+MD = 670559572a74e9af0513a3f9243bfbfd5805b837705faedc3c480d67a92bc124
+
+COUNT = 65
+MD = ef2ad8656fac9c593d301fcfac77a7815d50b42526d3a44e1573316a25b05904
+
+COUNT = 66
+MD = a3484a7a6cb5c941e15346a3ac4e09e99a5189cc96a87104d196af3c43cf995e
+
+COUNT = 67
+MD = 966851a0ef41f8d8ff970f4340a8dae8eec4f1999f5fd4f6cbcfa372fbf85495
+
+COUNT = 68
+MD = 8e1559cd4431febfa15662a2ccf2cac82f5401b2657551480bb0e3dd2111032c
+
+COUNT = 69
+MD = 5f535e2e7351cb8caf0070166218238a843c17472cea2f5911008be5d7fd6ba2
+
+COUNT = 70
+MD = 86ac4ea15f10c264b158058f5c13a36a87ac72f840071bbc45399b36823a5709
+
+COUNT = 71
+MD = 5c0d3fe289b2aac7d1bbaf57f4154b8d10875cffc9d8bd2402255ed1615f1d5f
+
+COUNT = 72
+MD = d7d808366d0c8b76ce3e7ab80ea11b4e2f8758f9ff404a3aafbf5b0cc191adcb
+
+COUNT = 73
+MD = e0768536856d1d7399667d6fd2c32f72416eeea1c40a313ee6edc910a5c3b786
+
+COUNT = 74
+MD = d670923731b3e598f5c4db4c7e57fe2275cc6c49b4bf67cb91d520846aec256e
+
+COUNT = 75
+MD = 2cb0bdcc305ef3b3d6b7265ab62bee555c524102679da122424713a9a01d69f6
+
+COUNT = 76
+MD = 5acdc323fe067a4b915ee521ac8eb81bcff4e205d53e4e7f9a69d436035cc5ad
+
+COUNT = 77
+MD = e634c43558d12c2a8710f2d6f10a86411cfad5a014e6b6cc159733c8ccece283
+
+COUNT = 78
+MD = 4a05f4bc3fcaf50e6d0916d7e7024b0ed22e9a3c413ff4bbcc0922d2326dcf6e
+
+COUNT = 79
+MD = 17c9d6029e15d3fd84e6809c5ef8a279a040f49ada91601a3ba4572cef7c08bd
+
+COUNT = 80
+MD = 1f21e137da2427536758409f3fbf5842589c5f587f0b9d2d10430f840faaaf45
+
+COUNT = 81
+MD = e3d38cff8a8d7fc00693dca5e37b03e7b10dafe4926023e26d937106ddac6a78
+
+COUNT = 82
+MD = cd749eb05c67038fe837910310b3b4cdda190f6235fa970602f865bec1b61a1b
+
+COUNT = 83
+MD = d596ccddea01b4ae29b68b0e8a191007f0c89a1016c380b49786f2d4fac4c43d
+
+COUNT = 84
+MD = cbccb1ff23e33c59dc4c858093c9e215c3759acfe6bc84ff75940b59b25a4e40
+
+COUNT = 85
+MD = 7214c134e9a963d6c43969d3ef44ece825dd9cf35bda5fcce92a6b9d0d3fd1b8
+
+COUNT = 86
+MD = aceaf5b775779621319f9ab5d4d370a3359cd6553ed2328cdc9dbab5b68840fa
+
+COUNT = 87
+MD = e8123acb0a2fb62978d3811b31676975542993932108ab14d487ad7875ddef72
+
+COUNT = 88
+MD = 660202a436fb05c3d59be699734e77c9750c906c8597ca213d064853ecf8c9f3
+
+COUNT = 89
+MD = 4752b0a5ec3f1fb295d5bfa98fa63a0ba38a02a4c1e1f73b0c4d4e88a07e0317
+
+COUNT = 90
+MD = 1e24f1467c36b051af3241fcf8c2c868b86dcb8e4669931878018e9914129b42
+
+COUNT = 91
+MD = d1c3efc99d9487e147282d811ab932d4a24362d09ac909f4854e783887068891
+
+COUNT = 92
+MD = 7dc455cf6f8b2042b6f0f368c44f18a080e5d3912ce3cdaf7142bd61ae50d02e
+
+COUNT = 93
+MD = 4b991c15789084eb1d6c1d7ce8f0928df4d3931c0c22c571f375849b9a6c2b71
+
+COUNT = 94
+MD = 8b78f95a007cfb0bd054a1f5d962cd8d927665f79a5ce9e0fc31105e57b8460b
+
+COUNT = 95
+MD = bf305423849cf773fc54206d8ae3c000c3e8b359cba8364581d1f91b0a201032
+
+COUNT = 96
+MD = 47006af96cff3843d3ed53bdedb167490d7bfefd93ae3e9ef473cb53aa840fc0
+
+COUNT = 97
+MD = c53cf5026162021fd2345dbad7c53d3a3df47b5bdff8cd34a0ccfee06dbb7328
+
+COUNT = 98
+MD = 3326899b575f93cdaff757f8ab7c3996a2fe930450d5002d4575f4e4cc4b4360
+
+COUNT = 99
+MD = 6a912ba4188391a78e6f13d88ed2d14e13afce9db6f7dcbf4a48c24f3db02778
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA256ShortMsg.rsp

@@ -1,267 +1,267 @@
-#  CAVS 11.0
-#  "SHA-256 ShortMsg" information
-#  SHA-256 tests are configured for BYTE oriented implementations
-#  Generated on Tue Mar 15 08:23:38 2011
-
-[L = 32]
-
-Len = 0
-Msg = 00
-MD = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
-
-Len = 8
-Msg = d3
-MD = 28969cdfa74a12c82f3bad960b0b000aca2ac329deea5c2328ebc6f2ba9802c1
-
-Len = 16
-Msg = 11af
-MD = 5ca7133fa735326081558ac312c620eeca9970d1e70a4b95533d956f072d1f98
-
-Len = 24
-Msg = b4190e
-MD = dff2e73091f6c05e528896c4c831b9448653dc2ff043528f6769437bc7b975c2
-
-Len = 32
-Msg = 74ba2521
-MD = b16aa56be3880d18cd41e68384cf1ec8c17680c45a02b1575dc1518923ae8b0e
-
-Len = 40
-Msg = c299209682
-MD = f0887fe961c9cd3beab957e8222494abb969b1ce4c6557976df8b0f6d20e9166
-
-Len = 48
-Msg = e1dc724d5621
-MD = eca0a060b489636225b4fa64d267dabbe44273067ac679f20820bddc6b6a90ac
-
-Len = 56
-Msg = 06e076f5a442d5
-MD = 3fd877e27450e6bbd5d74bb82f9870c64c66e109418baa8e6bbcff355e287926
-
-Len = 64
-Msg = 5738c929c4f4ccb6
-MD = 963bb88f27f512777aab6c8b1a02c70ec0ad651d428f870036e1917120fb48bf
-
-Len = 72
-Msg = 3334c58075d3f4139e
-MD = 078da3d77ed43bd3037a433fd0341855023793f9afd08b4b08ea1e5597ceef20
-
-Len = 80
-Msg = 74cb9381d89f5aa73368
-MD = 73d6fad1caaa75b43b21733561fd3958bdc555194a037c2addec19dc2d7a52bd
-
-Len = 88
-Msg = 76ed24a0f40a41221ebfcf
-MD = 044cef802901932e46dc46b2545e6c99c0fc323a0ed99b081bda4216857f38ac
-
-Len = 96
-Msg = 9baf69cba317f422fe26a9a0
-MD = fe56287cd657e4afc50dba7a3a54c2a6324b886becdcd1fae473b769e551a09b
-
-Len = 104
-Msg = 68511cdb2dbbf3530d7fb61cbc
-MD = af53430466715e99a602fc9f5945719b04dd24267e6a98471f7a7869bd3b4313
-
-Len = 112
-Msg = af397a8b8dd73ab702ce8e53aa9f
-MD = d189498a3463b18e846b8ab1b41583b0b7efc789dad8a7fb885bbf8fb5b45c5c
-
-Len = 120
-Msg = 294af4802e5e925eb1c6cc9c724f09
-MD = dcbaf335360de853b9cddfdafb90fa75567d0d3d58af8db9d764113aef570125
-
-Len = 128
-Msg = 0a27847cdc98bd6f62220b046edd762b
-MD = 80c25ec1600587e7f28b18b1b18e3cdc89928e39cab3bc25e4d4a4c139bcedc4
-
-Len = 136
-Msg = 1b503fb9a73b16ada3fcf1042623ae7610
-MD = d5c30315f72ed05fe519a1bf75ab5fd0ffec5ac1acb0daf66b6b769598594509
-
-Len = 144
-Msg = 59eb45bbbeb054b0b97334d53580ce03f699
-MD = 32c38c54189f2357e96bd77eb00c2b9c341ebebacc2945f97804f59a93238288
-
-Len = 152
-Msg = 58e5a3259cb0b6d12c83f723379e35fd298b60
-MD = 9b5b37816de8fcdf3ec10b745428708df8f391c550ea6746b2cafe019c2b6ace
-
-Len = 160
-Msg = c1ef39cee58e78f6fcdc12e058b7f902acd1a93b
-MD = 6dd52b0d8b48cc8146cebd0216fbf5f6ef7eeafc0ff2ff9d1422d6345555a142
-
-Len = 168
-Msg = 9cab7d7dcaec98cb3ac6c64dd5d4470d0b103a810c
-MD = 44d34809fc60d1fcafa7f37b794d1d3a765dd0d23194ebbe340f013f0c39b613
-
-Len = 176
-Msg = ea157c02ebaf1b22de221b53f2353936d2359d1e1c97
-MD = 9df5c16a3f580406f07d96149303d8c408869b32053b726cf3defd241e484957
-
-Len = 184
-Msg = da999bc1f9c7acff32828a73e672d0a492f6ee895c6867
-MD = 672b54e43f41ee77584bdf8bf854d97b6252c918f7ea2d26bc4097ea53a88f10
-
-Len = 192
-Msg = 47991301156d1d977c0338efbcad41004133aefbca6bcf7e
-MD = feeb4b2b59fec8fdb1e55194a493d8c871757b5723675e93d3ac034b380b7fc9
-
-Len = 200
-Msg = 2e7ea84da4bc4d7cfb463e3f2c8647057afff3fbececa1d200
-MD = 76e3acbc718836f2df8ad2d0d2d76f0cfa5fea0986be918f10bcee730df441b9
-
-Len = 208
-Msg = 47c770eb4549b6eff6381d62e9beb464cd98d341cc1c09981a7a
-MD = 6733809c73e53666c735b3bd3daf87ebc77c72756150a616a194108d71231272
-
-Len = 216
-Msg = ac4c26d8b43b8579d8f61c9807026e83e9b586e1159bd43b851937
-MD = 0e6e3c143c3a5f7f38505ed6adc9b48c18edf6dedf11635f6e8f9ac73c39fe9e
-
-Len = 224
-Msg = 0777fc1e1ca47304c2e265692838109e26aab9e5c4ae4e8600df4b1f
-MD = ffb4fc03e054f8ecbc31470fc023bedcd4a406b9dd56c71da1b660dcc4842c65
-
-Len = 232
-Msg = 1a57251c431d4e6c2e06d65246a296915071a531425ecf255989422a66
-MD = c644612cd326b38b1c6813b1daded34448805aef317c35f548dfb4a0d74b8106
-
-Len = 240
-Msg = 9b245fdad9baeb890d9c0d0eff816efb4ca138610bc7d78cb1a801ed3273
-MD = c0e29eeeb0d3a7707947e623cdc7d1899adc70dd7861205ea5e5813954fb7957
-
-Len = 248
-Msg = 95a765809caf30ada90ad6d61c2b4b30250df0a7ce23b7753c9187f4319ce2
-MD = a4139b74b102cf1e2fce229a6cd84c87501f50afa4c80feacf7d8cf5ed94f042
-
-Len = 256
-Msg = 09fc1accc230a205e4a208e64a8f204291f581a12756392da4b8c0cf5ef02b95
-MD = 4f44c1c7fbebb6f9601829f3897bfd650c56fa07844be76489076356ac1886a4
-
-Len = 264
-Msg = 0546f7b8682b5b95fd32385faf25854cb3f7b40cc8fa229fbd52b16934aab388a7
-MD = b31ad3cd02b10db282b3576c059b746fb24ca6f09fef69402dc90ece7421cbb7
-
-Len = 272
-Msg = b12db4a1025529b3b7b1e45c6dbc7baa8897a0576e66f64bf3f8236113a6276ee77d
-MD = 1c38bf6bbfd32292d67d1d651fd9d5b623b6ec1e854406223f51d0df46968712
-
-Len = 280
-Msg = e68cb6d8c1866c0a71e7313f83dc11a5809cf5cfbeed1a587ce9c2c92e022abc1644bb
-MD = c2684c0dbb85c232b6da4fb5147dd0624429ec7e657991edd95eda37a587269e
-
-Len = 288
-Msg = 4e3d8ac36d61d9e51480831155b253b37969fe7ef49db3b39926f3a00b69a36774366000
-MD = bf9d5e5b5393053f055b380baed7e792ae85ad37c0ada5fd4519542ccc461cf3
-
-Len = 296
-Msg = 03b264be51e4b941864f9b70b4c958f5355aac294b4b87cb037f11f85f07eb57b3f0b89550
-MD = d1f8bd684001ac5a4b67bbf79f87de524d2da99ac014dec3e4187728f4557471
-
-Len = 304
-Msg = d0fefd96787c65ffa7f910d6d0ada63d64d5c4679960e7f06aeb8c70dfef954f8e39efdb629b
-MD = 49ba38db85c2796f85ffd57dd5ec337007414528ae33935b102d16a6b91ba6c1
-
-Len = 312
-Msg = b7c79d7e5f1eeccdfedf0e7bf43e730d447e607d8d1489823d09e11201a0b1258039e7bd4875b1
-MD = 725e6f8d888ebaf908b7692259ab8839c3248edd22ca115bb13e025808654700
-
-Len = 320
-Msg = 64cd363ecce05fdfda2486d011a3db95b5206a19d3054046819dd0d36783955d7e5bf8ba18bf738a
-MD = 32caef024f84e97c30b4a7b9d04b678b3d8a6eb2259dff5b7f7c011f090845f8
-
-Len = 328
-Msg = 6ac6c63d618eaf00d91c5e2807e83c093912b8e202f78e139703498a79c6067f54497c6127a23910a6
-MD = 4bb33e7c6916e08a9b3ed6bcef790aaaee0dcf2e7a01afb056182dea2dad7d63
-
-Len = 336
-Msg = d26826db9baeaa892691b68900b96163208e806a1da077429e454fa011840951a031327e605ab82ecce2
-MD = 3ac7ac6bed82fdc8cd15b746f0ee7489158192c238f371c1883c9fe90b3e2831
-
-Len = 344
-Msg = 3f7a059b65d6cb0249204aac10b9f1a4ac9e5868adebbe935a9eb5b9019e1c938bfc4e5c5378997a3947f2
-MD = bfce809534eefe871273964d32f091fe756c71a7f512ef5f2300bcd57f699e74
-
-Len = 352
-Msg = 60ffcb23d6b88e485b920af81d1083f6291d06ac8ca3a965b85914bc2add40544a027fca936bbde8f359051c
-MD = 1d26f3e04f89b4eaa9dbed9231bb051eef2e8311ad26fe53d0bf0b821eaf7567
-
-Len = 360
-Msg = 9ecd07b684bb9e0e6692e320cec4510ca79fcdb3a2212c26d90df65db33e692d073cc174840db797504e482eef
-MD = 0ffeb644a49e787ccc6970fe29705a4f4c2bfcfe7d19741c158333ff6982cc9c
-
-Len = 368
-Msg = 9d64de7161895884e7fa3d6e9eb996e7ebe511b01fe19cd4a6b3322e80aaf52bf6447ed1854e71001f4d54f8931d
-MD = d048ee1524014adf9a56e60a388277de194c694cc787fc5a1b554ea9f07abfdf
-
-Len = 376
-Msg = c4ad3c5e78d917ecb0cbbcd1c481fc2aaf232f7e289779f40e504cc309662ee96fecbd20647ef00e46199fbc482f46
-MD = 50dbf40066f8d270484ee2ef6632282dfa300a85a8530eceeb0e04275e1c1efd
-
-Len = 384
-Msg = 4eef5107459bddf8f24fc7656fd4896da8711db50400c0164847f692b886ce8d7f4d67395090b3534efd7b0d298da34b
-MD = 7c5d14ed83dab875ac25ce7feed6ef837d58e79dc601fb3c1fca48d4464e8b83
-
-Len = 392
-Msg = 047d2758e7c2c9623f9bdb93b6597c5e84a0cd34e610014bcb25b49ed05c7e356e98c7a672c3dddcaeb84317ef614d342f
-MD = 7d53eccd03da37bf58c1962a8f0f708a5c5c447f6a7e9e26137c169d5bdd82e4
-
-Len = 400
-Msg = 3d83df37172c81afd0de115139fbf4390c22e098c5af4c5ab4852406510bc0e6cf741769f44430c5270fdae0cb849d71cbab
-MD = 99dc772e91ea02d9e421d552d61901016b9fd4ad2df4a8212c1ec5ba13893ab2
-
-Len = 408
-Msg = 33fd9bc17e2b271fa04c6b93c0bdeae98654a7682d31d9b4dab7e6f32cd58f2f148a68fbe7a88c5ab1d88edccddeb30ab21e5e
-MD = cefdae1a3d75e792e8698d5e71f177cc761314e9ad5df9602c6e60ae65c4c267
-
-Len = 416
-Msg = 77a879cfa11d7fcac7a8282cc38a43dcf37643cc909837213bd6fd95d956b219a1406cbe73c52cd56c600e55b75bc37ea69641bc
-MD = c99d64fa4dadd4bc8a389531c68b4590c6df0b9099c4d583bc00889fb7b98008
-
-Len = 424
-Msg = 45a3e6b86527f20b4537f5af96cfc5ad8777a2dde6cf7511886c5590ece24fc61b226739d207dabfe32ba6efd9ff4cd5db1bd5ead3
-MD = 4d12a849047c6acd4b2eee6be35fa9051b02d21d50d419543008c1d82c427072
-
-Len = 432
-Msg = 25362a4b9d74bde6128c4fdc672305900947bc3ada9d9d316ebcf1667ad4363189937251f149c72e064a48608d940b7574b17fefc0df
-MD = f8e4ccab6c979229f6066cc0cb0cfa81bb21447c16c68773be7e558e9f9d798d
-
-Len = 440
-Msg = 3ebfb06db8c38d5ba037f1363e118550aad94606e26835a01af05078533cc25f2f39573c04b632f62f68c294ab31f2a3e2a1a0d8c2be51
-MD = 6595a2ef537a69ba8583dfbf7f5bec0ab1f93ce4c8ee1916eff44a93af5749c4
-
-Len = 448
-Msg = 2d52447d1244d2ebc28650e7b05654bad35b3a68eedc7f8515306b496d75f3e73385dd1b002625024b81a02f2fd6dffb6e6d561cb7d0bd7a
-MD = cfb88d6faf2de3a69d36195acec2e255e2af2b7d933997f348e09f6ce5758360
-
-Len = 456
-Msg = 4cace422e4a015a75492b3b3bbfbdf3758eaff4fe504b46a26c90dacc119fa9050f603d2b58b398cad6d6d9fa922a154d9e0bc4389968274b0
-MD = 4d54b2d284a6794581224e08f675541c8feab6eefa3ac1cfe5da4e03e62f72e4
-
-Len = 464
-Msg = 8620b86fbcaace4ff3c2921b8466ddd7bacae07eefef693cf17762dcabb89a84010fc9a0fb76ce1c26593ad637a61253f224d1b14a05addccabe
-MD = dba490256c9720c54c612a5bd1ef573cd51dc12b3e7bd8c6db2eabe0aacb846b
-
-Len = 472
-Msg = d1be3f13febafefc14414d9fb7f693db16dc1ae270c5b647d80da8583587c1ad8cb8cb01824324411ca5ace3ca22e179a4ff4986f3f21190f3d7f3
-MD = 02804978eba6e1de65afdbc6a6091ed6b1ecee51e8bff40646a251de6678b7ef
-
-Len = 480
-Msg = f499cc3f6e3cf7c312ffdfba61b1260c37129c1afb391047193367b7b2edeb579253e51d62ba6d911e7b818ccae1553f6146ea780f78e2219f629309
-MD = 0b66c8b4fefebc8dc7da0bbedc1114f228aa63c37d5c30e91ab500f3eadfcec5
-
-Len = 488
-Msg = 6dd6efd6f6caa63b729aa8186e308bc1bda06307c05a2c0ae5a3684e6e460811748690dc2b58775967cfcc645fd82064b1279fdca771803db9dca0ff53
-MD = c464a7bf6d180de4f744bb2fe5dc27a3f681334ffd54a9814650e60260a478e3
-
-Len = 496
-Msg = 6511a2242ddb273178e19a82c57c85cb05a6887ff2014cf1a31cb9ba5df1695aadb25c22b3c5ed51c10d047d256b8e3442842ae4e6c525f8d7a5a944af2a
-MD = d6859c0b5a0b66376a24f56b2ab104286ed0078634ba19112ace0d6d60a9c1ae
-
-Len = 504
-Msg = e2f76e97606a872e317439f1a03fcd92e632e5bd4e7cbc4e97f1afc19a16fde92d77cbe546416b51640cddb92af996534dfd81edb17c4424cf1ac4d75aceeb
-MD = 18041bd4665083001fba8c5411d2d748e8abbfdcdfd9218cb02b68a78e7d4c23
-
-Len = 512
-Msg = 5a86b737eaea8ee976a0a24da63e7ed7eefad18a101c1211e2b3650c5187c2a8a650547208251f6d4237e661c7bf4c77f335390394c37fa1a9f9be836ac28509
-MD = 42e61e174fbb3897d6dd6cef3dd2802fe67b331953b06114a65c772859dfc1aa
-
+#  CAVS 11.0
+#  "SHA-256 ShortMsg" information
+#  SHA-256 tests are configured for BYTE oriented implementations
+#  Generated on Tue Mar 15 08:23:38 2011
+
+[L = 32]
+
+Len = 0
+Msg = 00
+MD = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+
+Len = 8
+Msg = d3
+MD = 28969cdfa74a12c82f3bad960b0b000aca2ac329deea5c2328ebc6f2ba9802c1
+
+Len = 16
+Msg = 11af
+MD = 5ca7133fa735326081558ac312c620eeca9970d1e70a4b95533d956f072d1f98
+
+Len = 24
+Msg = b4190e
+MD = dff2e73091f6c05e528896c4c831b9448653dc2ff043528f6769437bc7b975c2
+
+Len = 32
+Msg = 74ba2521
+MD = b16aa56be3880d18cd41e68384cf1ec8c17680c45a02b1575dc1518923ae8b0e
+
+Len = 40
+Msg = c299209682
+MD = f0887fe961c9cd3beab957e8222494abb969b1ce4c6557976df8b0f6d20e9166
+
+Len = 48
+Msg = e1dc724d5621
+MD = eca0a060b489636225b4fa64d267dabbe44273067ac679f20820bddc6b6a90ac
+
+Len = 56
+Msg = 06e076f5a442d5
+MD = 3fd877e27450e6bbd5d74bb82f9870c64c66e109418baa8e6bbcff355e287926
+
+Len = 64
+Msg = 5738c929c4f4ccb6
+MD = 963bb88f27f512777aab6c8b1a02c70ec0ad651d428f870036e1917120fb48bf
+
+Len = 72
+Msg = 3334c58075d3f4139e
+MD = 078da3d77ed43bd3037a433fd0341855023793f9afd08b4b08ea1e5597ceef20
+
+Len = 80
+Msg = 74cb9381d89f5aa73368
+MD = 73d6fad1caaa75b43b21733561fd3958bdc555194a037c2addec19dc2d7a52bd
+
+Len = 88
+Msg = 76ed24a0f40a41221ebfcf
+MD = 044cef802901932e46dc46b2545e6c99c0fc323a0ed99b081bda4216857f38ac
+
+Len = 96
+Msg = 9baf69cba317f422fe26a9a0
+MD = fe56287cd657e4afc50dba7a3a54c2a6324b886becdcd1fae473b769e551a09b
+
+Len = 104
+Msg = 68511cdb2dbbf3530d7fb61cbc
+MD = af53430466715e99a602fc9f5945719b04dd24267e6a98471f7a7869bd3b4313
+
+Len = 112
+Msg = af397a8b8dd73ab702ce8e53aa9f
+MD = d189498a3463b18e846b8ab1b41583b0b7efc789dad8a7fb885bbf8fb5b45c5c
+
+Len = 120
+Msg = 294af4802e5e925eb1c6cc9c724f09
+MD = dcbaf335360de853b9cddfdafb90fa75567d0d3d58af8db9d764113aef570125
+
+Len = 128
+Msg = 0a27847cdc98bd6f62220b046edd762b
+MD = 80c25ec1600587e7f28b18b1b18e3cdc89928e39cab3bc25e4d4a4c139bcedc4
+
+Len = 136
+Msg = 1b503fb9a73b16ada3fcf1042623ae7610
+MD = d5c30315f72ed05fe519a1bf75ab5fd0ffec5ac1acb0daf66b6b769598594509
+
+Len = 144
+Msg = 59eb45bbbeb054b0b97334d53580ce03f699
+MD = 32c38c54189f2357e96bd77eb00c2b9c341ebebacc2945f97804f59a93238288
+
+Len = 152
+Msg = 58e5a3259cb0b6d12c83f723379e35fd298b60
+MD = 9b5b37816de8fcdf3ec10b745428708df8f391c550ea6746b2cafe019c2b6ace
+
+Len = 160
+Msg = c1ef39cee58e78f6fcdc12e058b7f902acd1a93b
+MD = 6dd52b0d8b48cc8146cebd0216fbf5f6ef7eeafc0ff2ff9d1422d6345555a142
+
+Len = 168
+Msg = 9cab7d7dcaec98cb3ac6c64dd5d4470d0b103a810c
+MD = 44d34809fc60d1fcafa7f37b794d1d3a765dd0d23194ebbe340f013f0c39b613
+
+Len = 176
+Msg = ea157c02ebaf1b22de221b53f2353936d2359d1e1c97
+MD = 9df5c16a3f580406f07d96149303d8c408869b32053b726cf3defd241e484957
+
+Len = 184
+Msg = da999bc1f9c7acff32828a73e672d0a492f6ee895c6867
+MD = 672b54e43f41ee77584bdf8bf854d97b6252c918f7ea2d26bc4097ea53a88f10
+
+Len = 192
+Msg = 47991301156d1d977c0338efbcad41004133aefbca6bcf7e
+MD = feeb4b2b59fec8fdb1e55194a493d8c871757b5723675e93d3ac034b380b7fc9
+
+Len = 200
+Msg = 2e7ea84da4bc4d7cfb463e3f2c8647057afff3fbececa1d200
+MD = 76e3acbc718836f2df8ad2d0d2d76f0cfa5fea0986be918f10bcee730df441b9
+
+Len = 208
+Msg = 47c770eb4549b6eff6381d62e9beb464cd98d341cc1c09981a7a
+MD = 6733809c73e53666c735b3bd3daf87ebc77c72756150a616a194108d71231272
+
+Len = 216
+Msg = ac4c26d8b43b8579d8f61c9807026e83e9b586e1159bd43b851937
+MD = 0e6e3c143c3a5f7f38505ed6adc9b48c18edf6dedf11635f6e8f9ac73c39fe9e
+
+Len = 224
+Msg = 0777fc1e1ca47304c2e265692838109e26aab9e5c4ae4e8600df4b1f
+MD = ffb4fc03e054f8ecbc31470fc023bedcd4a406b9dd56c71da1b660dcc4842c65
+
+Len = 232
+Msg = 1a57251c431d4e6c2e06d65246a296915071a531425ecf255989422a66
+MD = c644612cd326b38b1c6813b1daded34448805aef317c35f548dfb4a0d74b8106
+
+Len = 240
+Msg = 9b245fdad9baeb890d9c0d0eff816efb4ca138610bc7d78cb1a801ed3273
+MD = c0e29eeeb0d3a7707947e623cdc7d1899adc70dd7861205ea5e5813954fb7957
+
+Len = 248
+Msg = 95a765809caf30ada90ad6d61c2b4b30250df0a7ce23b7753c9187f4319ce2
+MD = a4139b74b102cf1e2fce229a6cd84c87501f50afa4c80feacf7d8cf5ed94f042
+
+Len = 256
+Msg = 09fc1accc230a205e4a208e64a8f204291f581a12756392da4b8c0cf5ef02b95
+MD = 4f44c1c7fbebb6f9601829f3897bfd650c56fa07844be76489076356ac1886a4
+
+Len = 264
+Msg = 0546f7b8682b5b95fd32385faf25854cb3f7b40cc8fa229fbd52b16934aab388a7
+MD = b31ad3cd02b10db282b3576c059b746fb24ca6f09fef69402dc90ece7421cbb7
+
+Len = 272
+Msg = b12db4a1025529b3b7b1e45c6dbc7baa8897a0576e66f64bf3f8236113a6276ee77d
+MD = 1c38bf6bbfd32292d67d1d651fd9d5b623b6ec1e854406223f51d0df46968712
+
+Len = 280
+Msg = e68cb6d8c1866c0a71e7313f83dc11a5809cf5cfbeed1a587ce9c2c92e022abc1644bb
+MD = c2684c0dbb85c232b6da4fb5147dd0624429ec7e657991edd95eda37a587269e
+
+Len = 288
+Msg = 4e3d8ac36d61d9e51480831155b253b37969fe7ef49db3b39926f3a00b69a36774366000
+MD = bf9d5e5b5393053f055b380baed7e792ae85ad37c0ada5fd4519542ccc461cf3
+
+Len = 296
+Msg = 03b264be51e4b941864f9b70b4c958f5355aac294b4b87cb037f11f85f07eb57b3f0b89550
+MD = d1f8bd684001ac5a4b67bbf79f87de524d2da99ac014dec3e4187728f4557471
+
+Len = 304
+Msg = d0fefd96787c65ffa7f910d6d0ada63d64d5c4679960e7f06aeb8c70dfef954f8e39efdb629b
+MD = 49ba38db85c2796f85ffd57dd5ec337007414528ae33935b102d16a6b91ba6c1
+
+Len = 312
+Msg = b7c79d7e5f1eeccdfedf0e7bf43e730d447e607d8d1489823d09e11201a0b1258039e7bd4875b1
+MD = 725e6f8d888ebaf908b7692259ab8839c3248edd22ca115bb13e025808654700
+
+Len = 320
+Msg = 64cd363ecce05fdfda2486d011a3db95b5206a19d3054046819dd0d36783955d7e5bf8ba18bf738a
+MD = 32caef024f84e97c30b4a7b9d04b678b3d8a6eb2259dff5b7f7c011f090845f8
+
+Len = 328
+Msg = 6ac6c63d618eaf00d91c5e2807e83c093912b8e202f78e139703498a79c6067f54497c6127a23910a6
+MD = 4bb33e7c6916e08a9b3ed6bcef790aaaee0dcf2e7a01afb056182dea2dad7d63
+
+Len = 336
+Msg = d26826db9baeaa892691b68900b96163208e806a1da077429e454fa011840951a031327e605ab82ecce2
+MD = 3ac7ac6bed82fdc8cd15b746f0ee7489158192c238f371c1883c9fe90b3e2831
+
+Len = 344
+Msg = 3f7a059b65d6cb0249204aac10b9f1a4ac9e5868adebbe935a9eb5b9019e1c938bfc4e5c5378997a3947f2
+MD = bfce809534eefe871273964d32f091fe756c71a7f512ef5f2300bcd57f699e74
+
+Len = 352
+Msg = 60ffcb23d6b88e485b920af81d1083f6291d06ac8ca3a965b85914bc2add40544a027fca936bbde8f359051c
+MD = 1d26f3e04f89b4eaa9dbed9231bb051eef2e8311ad26fe53d0bf0b821eaf7567
+
+Len = 360
+Msg = 9ecd07b684bb9e0e6692e320cec4510ca79fcdb3a2212c26d90df65db33e692d073cc174840db797504e482eef
+MD = 0ffeb644a49e787ccc6970fe29705a4f4c2bfcfe7d19741c158333ff6982cc9c
+
+Len = 368
+Msg = 9d64de7161895884e7fa3d6e9eb996e7ebe511b01fe19cd4a6b3322e80aaf52bf6447ed1854e71001f4d54f8931d
+MD = d048ee1524014adf9a56e60a388277de194c694cc787fc5a1b554ea9f07abfdf
+
+Len = 376
+Msg = c4ad3c5e78d917ecb0cbbcd1c481fc2aaf232f7e289779f40e504cc309662ee96fecbd20647ef00e46199fbc482f46
+MD = 50dbf40066f8d270484ee2ef6632282dfa300a85a8530eceeb0e04275e1c1efd
+
+Len = 384
+Msg = 4eef5107459bddf8f24fc7656fd4896da8711db50400c0164847f692b886ce8d7f4d67395090b3534efd7b0d298da34b
+MD = 7c5d14ed83dab875ac25ce7feed6ef837d58e79dc601fb3c1fca48d4464e8b83
+
+Len = 392
+Msg = 047d2758e7c2c9623f9bdb93b6597c5e84a0cd34e610014bcb25b49ed05c7e356e98c7a672c3dddcaeb84317ef614d342f
+MD = 7d53eccd03da37bf58c1962a8f0f708a5c5c447f6a7e9e26137c169d5bdd82e4
+
+Len = 400
+Msg = 3d83df37172c81afd0de115139fbf4390c22e098c5af4c5ab4852406510bc0e6cf741769f44430c5270fdae0cb849d71cbab
+MD = 99dc772e91ea02d9e421d552d61901016b9fd4ad2df4a8212c1ec5ba13893ab2
+
+Len = 408
+Msg = 33fd9bc17e2b271fa04c6b93c0bdeae98654a7682d31d9b4dab7e6f32cd58f2f148a68fbe7a88c5ab1d88edccddeb30ab21e5e
+MD = cefdae1a3d75e792e8698d5e71f177cc761314e9ad5df9602c6e60ae65c4c267
+
+Len = 416
+Msg = 77a879cfa11d7fcac7a8282cc38a43dcf37643cc909837213bd6fd95d956b219a1406cbe73c52cd56c600e55b75bc37ea69641bc
+MD = c99d64fa4dadd4bc8a389531c68b4590c6df0b9099c4d583bc00889fb7b98008
+
+Len = 424
+Msg = 45a3e6b86527f20b4537f5af96cfc5ad8777a2dde6cf7511886c5590ece24fc61b226739d207dabfe32ba6efd9ff4cd5db1bd5ead3
+MD = 4d12a849047c6acd4b2eee6be35fa9051b02d21d50d419543008c1d82c427072
+
+Len = 432
+Msg = 25362a4b9d74bde6128c4fdc672305900947bc3ada9d9d316ebcf1667ad4363189937251f149c72e064a48608d940b7574b17fefc0df
+MD = f8e4ccab6c979229f6066cc0cb0cfa81bb21447c16c68773be7e558e9f9d798d
+
+Len = 440
+Msg = 3ebfb06db8c38d5ba037f1363e118550aad94606e26835a01af05078533cc25f2f39573c04b632f62f68c294ab31f2a3e2a1a0d8c2be51
+MD = 6595a2ef537a69ba8583dfbf7f5bec0ab1f93ce4c8ee1916eff44a93af5749c4
+
+Len = 448
+Msg = 2d52447d1244d2ebc28650e7b05654bad35b3a68eedc7f8515306b496d75f3e73385dd1b002625024b81a02f2fd6dffb6e6d561cb7d0bd7a
+MD = cfb88d6faf2de3a69d36195acec2e255e2af2b7d933997f348e09f6ce5758360
+
+Len = 456
+Msg = 4cace422e4a015a75492b3b3bbfbdf3758eaff4fe504b46a26c90dacc119fa9050f603d2b58b398cad6d6d9fa922a154d9e0bc4389968274b0
+MD = 4d54b2d284a6794581224e08f675541c8feab6eefa3ac1cfe5da4e03e62f72e4
+
+Len = 464
+Msg = 8620b86fbcaace4ff3c2921b8466ddd7bacae07eefef693cf17762dcabb89a84010fc9a0fb76ce1c26593ad637a61253f224d1b14a05addccabe
+MD = dba490256c9720c54c612a5bd1ef573cd51dc12b3e7bd8c6db2eabe0aacb846b
+
+Len = 472
+Msg = d1be3f13febafefc14414d9fb7f693db16dc1ae270c5b647d80da8583587c1ad8cb8cb01824324411ca5ace3ca22e179a4ff4986f3f21190f3d7f3
+MD = 02804978eba6e1de65afdbc6a6091ed6b1ecee51e8bff40646a251de6678b7ef
+
+Len = 480
+Msg = f499cc3f6e3cf7c312ffdfba61b1260c37129c1afb391047193367b7b2edeb579253e51d62ba6d911e7b818ccae1553f6146ea780f78e2219f629309
+MD = 0b66c8b4fefebc8dc7da0bbedc1114f228aa63c37d5c30e91ab500f3eadfcec5
+
+Len = 488
+Msg = 6dd6efd6f6caa63b729aa8186e308bc1bda06307c05a2c0ae5a3684e6e460811748690dc2b58775967cfcc645fd82064b1279fdca771803db9dca0ff53
+MD = c464a7bf6d180de4f744bb2fe5dc27a3f681334ffd54a9814650e60260a478e3
+
+Len = 496
+Msg = 6511a2242ddb273178e19a82c57c85cb05a6887ff2014cf1a31cb9ba5df1695aadb25c22b3c5ed51c10d047d256b8e3442842ae4e6c525f8d7a5a944af2a
+MD = d6859c0b5a0b66376a24f56b2ab104286ed0078634ba19112ace0d6d60a9c1ae
+
+Len = 504
+Msg = e2f76e97606a872e317439f1a03fcd92e632e5bd4e7cbc4e97f1afc19a16fde92d77cbe546416b51640cddb92af996534dfd81edb17c4424cf1ac4d75aceeb
+MD = 18041bd4665083001fba8c5411d2d748e8abbfdcdfd9218cb02b68a78e7d4c23
+
+Len = 512
+Msg = 5a86b737eaea8ee976a0a24da63e7ed7eefad18a101c1211e2b3650c5187c2a8a650547208251f6d4237e661c7bf4c77f335390394c37fa1a9f9be836ac28509
+MD = 42e61e174fbb3897d6dd6cef3dd2802fe67b331953b06114a65c772859dfc1aa
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA384Monte.rsp

@@ -1,309 +1,309 @@
-#  CAVS 11.1
-#  "SHA-384 Monte" information for "sha_values"
-#  SHA-384 tests are configured for BYTE oriented implementations
-#  Generated on Wed May 11 17:26:04 2011
-
-[L = 48]
-
-Seed = edff07255c71b54a9beae52cdfa083569a08be89949cbba73ddc8acf429359ca5e5be7a673633ca0d9709848f522a9df
-
-COUNT = 0
-MD = e81b86c49a38feddfd185f71ca7da6732a053ed4a2640d52d27f53f9f76422650b0e93645301ac99f8295d6f820f1035
-
-COUNT = 1
-MD = 1d6bd21713bffd50946a10c39a7742d740e8f271f0c8f643d4c95375094fd9bf29d89ee61a76053f22e44a4b058a64ed
-
-COUNT = 2
-MD = 425167b66ae965bd7d68515b54ebfa16f33d2bdb2147a4eac515a75224cd19cea564d692017d2a1c41c1a3f68bb5a209
-
-COUNT = 3
-MD = 9e7477ffd4baad1fcca035f4687b35ed47a57832fb27d131eb8018fcb41edf4d5e25874466d2e2d61ae3accdfc7aa364
-
-COUNT = 4
-MD = d7b4d4e779ca70c8d065630db1f9128ee43b4bde08a81bce13d48659b6ef47b6cfc802af6d8756f6cd43c709bb445bab
-
-COUNT = 5
-MD = a038eaa91772d458a7339612f6a9214e6550f78d5870d91fa7a3dc1c2321e511759c159a371475dda7ad1fd7f51ac82b
-
-COUNT = 6
-MD = 8552b4ea2da9f855fcc7230ac88ecb1c3cb4841cc28e0495bf1ab97d100d4e4c60a1c51949d26723415f560da2951bb0
-
-COUNT = 7
-MD = 668338b2e661d9e25b799d7329e55629b62416ee4d42d2e55245ffe7092e7ae4a3da6903944d532c2a88e4632f9a4b36
-
-COUNT = 8
-MD = c40cd19cb770b1fe81135fcb9223ffb9ef50340d13660658ba60656a88f4ea08ee3b572680e2b4abbaf4392486ea589a
-
-COUNT = 9
-MD = 540c154e82b57914abc0452990abf988e46a2f65b40f5e9ef80a38c7431293d5efa31c7c83df5345b079ad4e31b2c8b2
-
-COUNT = 10
-MD = e112f9359983e7df9b266f53ec950ed2b951b6d832c8fc1ffed22b4be3eae3d015e0771e96d344672000d4959d2829ab
-
-COUNT = 11
-MD = 186e69c28033e11b152542c86a94f59a25ec4edb7ab5b735faff16bdbacc682b2ae79b5f5a68ece9fee5ea4530b8a8f4
-
-COUNT = 12
-MD = a37c790e641f911ef2929bab0ccbb890627c7e38e1a2fbbd71cd4215de919763c2819c35a0e93984b7d85d0e8858573f
-
-COUNT = 13
-MD = f1b4bdcfe0cce284ca26e0b7e01f26de21bf4a7a409ee99fee1019cc8d23e775bc134ec7987a6575fa64160b5c7f849e
-
-COUNT = 14
-MD = 45aabfb784a29d6be30104ae9f3c5daa58e48a9c94f61fed94dccd2ec06b527ed564643573d588ce10d3847361a57961
-
-COUNT = 15
-MD = be3a49139a48dafba418bb9e0e8e2bd195e0d239eec77c43d1f0cee844b65f65c30cddfc05b644f9a792459695883a2e
-
-COUNT = 16
-MD = 3b263277a0d11de4cb4616591d4623e0821da4f111dae33938329cb8cc47f46742c70c09463edb9ff4a0171c4604b243
-
-COUNT = 17
-MD = 2be323079381bd13a02cca824c2f3cd18cbc89b0c3319afbf33c6f06f2abf2fa3af35ea9752ffe153d1775a95e7accbd
-
-COUNT = 18
-MD = 14c8c3ea3f5aea2e74a2f138863accf1b5f563d96194c0dcf08ca816e1ac9156c3f5d15aa5701d93c188c2c1f7237518
-
-COUNT = 19
-MD = b9158943803c47678fefafa91c98966aa3dc1fd96f4e86cfdde7ca879dbf9fa9f54b1988a53376f7005df7fd87b1396b
-
-COUNT = 20
-MD = f4395f88c4dc24b6edca5868fcebd24991ced2e3826c04ec00e4630d7e1f70ee56124a90657a795f446f7db94d8b439e
-
-COUNT = 21
-MD = bb56b4ed4683fce0d6d412ef84b7985ccc5fe30306679a994c8221c1212ff7f1492512095b7ddd250411008ce9d54020
-
-COUNT = 22
-MD = cacaeb081a62a4e384e0082f8b994dcd721f38b3c3e4b5836ddcaaab74bcf2700fdc8b6faf3f4df1ec175a0628728a4c
-
-COUNT = 23
-MD = 231796f44eba3c8c6ad064b0e350093fcae026c3c03d669c28e5f36befa5f35489bf595a0312c38b9b73b7bb4dad5b96
-
-COUNT = 24
-MD = d54559e7eb20534025f8f265bdbdab0e7dd9e2459305288d3ca84190b6d2c6e8ae2cd6f3e51ccb54551d94e9e40b31ac
-
-COUNT = 25
-MD = d6231b809b70ed19478cdf7e05534e92ea01e74e970fe17e92ec9a67b1b7977c4c485cfa74787224fe326b1b8d1ede87
-
-COUNT = 26
-MD = 8ca1d462cc1b16b734c0e4f1a6b7f7d9d0ba9ce8074addc7755243b05fe269afab6618f07fe73089d9379bcbdce6c728
-
-COUNT = 27
-MD = 60fa725bbf21ee56545ab24e6f26ec5ec749c4971bf761923c23415cbcb0c02e6a474deb50144abad2b0f16ddbe850a9
-
-COUNT = 28
-MD = 8b60fe287f5bc133ff842a246bf161a58b4b8ead5be073c702552d664653e384e28e70d28624aa1da951ed33dcdfc7fd
-
-COUNT = 29
-MD = d18a080af3ae7e6318dc69298bd7b13644b7ab00adac18b446c1e9a9366e68dade87687b9129aefae9a98b531309f1c7
-
-COUNT = 30
-MD = faad832a7ce865cf3183e51e07f08aad6570795f8d0274fae52fc5cb637ce4b7cdb8f8092e2ac4a7c96beb70cb288b69
-
-COUNT = 31
-MD = b7bea61748495351409fcf1bd45a94af34e7dd899933ed06d5759fe728f6933781c21f1986b99906c6910d976a0d9c4b
-
-COUNT = 32
-MD = b35027199cf6467302a88e5d0106d01953b41dfa172234b3e11d3ccad33bda9a836e44f43ae94451e2bea28f0dca7989
-
-COUNT = 33
-MD = 8571acd0d5fdd20909e9cd74e125cb9cd65a2e74056eab3f85f6f13e31a5fc1580aa588997d31a0a3ba1a16dea5528d3
-
-COUNT = 34
-MD = 3dcf49cb8d79d4ca3f6e06e8a58bb92a7a42d7915b9e710a29d37ece6c1c32eb89a897e9935354db3cbe384a1149964a
-
-COUNT = 35
-MD = 7b2258c5fbf26780f55054b4aa462a607eecbf7382af941efd75b9b4cadd5b97936a762b9c03e133d7cfb65de501e6df
-
-COUNT = 36
-MD = c54cfebd2381621fed5cf6b82b3dea25965ec99365ce415b184ded71b949eb8009d91c85c02b30b7465fdcf18be885ca
-
-COUNT = 37
-MD = 39bed6de0e885dfd51569f3c5dc967f7f551065e87b6e7108d15ef5ea407419f936f5ae2288aeecf98777249f384fdfa
-
-COUNT = 38
-MD = b1c341b1428e5df6f4bcec533f1b5ca57e02102f5647b82be0986e523fad24b7f27aa29336a3f333817e8a5336a4a3b4
-
-COUNT = 39
-MD = 2e1e67546b9424a2f0bd8931082f9fb8951b9fe57a2b61683a5e197017ebcd96592dc47a75d2ae4ab8f436edd5e5bb4e
-
-COUNT = 40
-MD = 6c84a39bc94af5960715818bf9b4694548dd1f0af8f6344d56b0dc7f86b181d5249172c82572ec8748ff35b6c0a2abd5
-
-COUNT = 41
-MD = 576705bec035d07e31ebb091f180cd68c3873ea306708c5259f50491463c68d912080ba9f11bcc983a4b849ca19df008
-
-COUNT = 42
-MD = d45c7e9080b6223a2185c490363764f9fb0634f3865d57a15bea438fb243e98fccad4176bf24c4cb7247dd2c5728b761
-
-COUNT = 43
-MD = b3021cedd2ba38b69348867729cfe2ab172e4f1643eb4971cde2db002413458a566ea884d651a9c010b1a6b869168497
-
-COUNT = 44
-MD = 1cb9c05e35029fe6b114c85a457091b7d9aaf7c95f32447f3f20cd034bc54f87ae85c4013d18fe2a94de8ecf9c6b9f05
-
-COUNT = 45
-MD = 1e8f037fb920b836b8f36a1ed4875cf7d61390f68d4843e420b2c1ca702a104524c1187c8eec7bb4b174a252e1ae1462
-
-COUNT = 46
-MD = 07c790c3d4948347ad5fad9992d8a0f6603a2133d138f1ff5cbbdc04c39277fb67d45b2e2c8e6c51fdaa6c5883e3a69c
-
-COUNT = 47
-MD = 98ef381d9b6b4e26ebf2bc293743e1e07943a3663b17f1be52d12ef8d19621263efb8525506ef6b95f746567a43577c6
-
-COUNT = 48
-MD = 8beefea2f858f8902928dae6060b10cf6d4a3cd1f91cf1ee5ddef0ee5fc25a8269367c114c1c5c5ab5287c48edc59274
-
-COUNT = 49
-MD = 03a6509ad6eb7f009931e596f3dab586de3bd6549afab4f218eba4fe47daf37c6faa360afdd931c5a95544f1a028195b
-
-COUNT = 50
-MD = bdf7e8d538e7ef418c808bf2dec1242b716326f83bf0a53db81f4d63aba37a2412f6b2bf00957ad6faf8404e4e2067a8
-
-COUNT = 51
-MD = 71ad43312ed6e403a5e174480fb14b3c2a3a60bba36611e1c99adf8013d243fe945b947b362b6dc51a3dd96235472f5e
-
-COUNT = 52
-MD = bec45a229217e5fe28d6d1675dc7440ccb5616c0f02eb5d4c814921fc82fdddb04592ce7af192fee6c61b1a08f6ab6aa
-
-COUNT = 53
-MD = 5d6bc2d2cd0d8f5e41656f73a473bef1eff212fe98b184386cdecade24c5c5e7b92cf76ea16f582b9951634881f85585
-
-COUNT = 54
-MD = 96e3568d30a1f7810404f3be8d2d26e5606da6c3fc064d0ef62298ca327476d587a1e3ef0d6554f4ad529053b7a651fd
-
-COUNT = 55
-MD = e4df3b7028f5e68753c1f21a556d8468a5d80fb048f6b92d405e519ea9ce44c6c95fb362119c553f5921dc9616dd3937
-
-COUNT = 56
-MD = 7881e36eef708df4d9c06e37bfa7af5ce7d41d31a2e4332d23922a518de3e2e6fd4b9f27ee64379afae7ca2570d24748
-
-COUNT = 57
-MD = aa12548b63d3a58f6914744111292cfc1f1358f717f1b19fab1a4ecac6292f1ff4b4c67b8a260b048f00ddc83b42453a
-
-COUNT = 58
-MD = b421b6941b5d7748765a4090c224dbbd98e85dcff9a65a77db0c2a83b92f4cad961b5b8ff76b5513d4a7af45ec4d4550
-
-COUNT = 59
-MD = 14e1b1733b16899c4046a604f8e1e777d55649c5357d7d9e3d7a1c395b6275aecf733a598de1d0bfd7eeaa9ecbd7d1e7
-
-COUNT = 60
-MD = bd05a1f9fa5b77371005a8073f0f3bcc4cb4e08fde3335dd3688921cf9cb5e97cf1b3052ff74bed8a359d170d2bea48f
-
-COUNT = 61
-MD = a319d9b3eeee6da494940ffb08903bcd588b18733a64ed435eadc5d9add6ab4f0c35fc050958bed81303409f388a065e
-
-COUNT = 62
-MD = 6f19824ec874b55e88fe4b1387433dab85415148870bf4a0612aa9c1cbcd9627925616fcdb66d68760c50fb308f628b0
-
-COUNT = 63
-MD = bacb435a1ff538d0ba3e3d0ab04b5e8868bc1f84e964409229d7eada4b846b813c0e30d8e962786aa83aac2dacf02d19
-
-COUNT = 64
-MD = e8f013470eafd5af84f63d51d51af2ca884789d03d79f8c3089810254b95a6f54fb86c08202cae94681ad702ea29451a
-
-COUNT = 65
-MD = 374b07621c018cc3935374c2f2f098e661ca0656181f67f55fb80ac36e23da379c4f6c8a3683c2621f874afa1241b918
-
-COUNT = 66
-MD = 5878f1ebcbe60aa62a7b149bd181167e5898d08a3627a08c589436f007bfb82c040b26ea9944c6f0c9c4079b9b0e1ecf
-
-COUNT = 67
-MD = 05961b57507c99d0cb7dc24ae34eddde94ac484129de621edac5b001ac5c0b974d09d24f75504f3be1a3cd635c44bf71
-
-COUNT = 68
-MD = d961eb883eecbc083533fa5128695c8d28281fbac23308dd2f504eb079d2d311b973f1a52b45aa6275550e14477a8876
-
-COUNT = 69
-MD = a4557f990f4ccce585ba33453090f66af576f0a501d26667031f48f19538b820b84f870579efb554e7550f9f53fea5ea
-
-COUNT = 70
-MD = 82194c49f24084249567f0e8963c5f72a23bc20a8f522a6108f12abf95b7437ad93673860a953264838a09bb3968d0a9
-
-COUNT = 71
-MD = 371dc5573b145f2136eb854591ece253efebf8732d3898bea063fdc3889d07953ee646e533b214f8c2dd66f1355b03cf
-
-COUNT = 72
-MD = cfc4dcecc6103027232029dd9a19850a6f79b9004be7d70054d0af11c692affa44c537f7cd749f2b6317cafe1fa52fe4
-
-COUNT = 73
-MD = 9920b835400795bd3ed8ae0bc12417d58be8c5ffd6eed151ed738c3031e624c74fb85488953ac81c75f395cab74f1679
-
-COUNT = 74
-MD = 4a1b040fa38b5cee63f5d308b55502d2a017b349ead5172c288289f42ba9874d0d11c9ac43255580c428a99067495782
-
-COUNT = 75
-MD = 93c1cb94d0689301728165299057edd78ef48a6dc7654931ae2bf7ea5bc733f3b724f4c3081bc93ed61e7d739c38e137
-
-COUNT = 76
-MD = 8f2e6c868b224b3cd5ac80669da0ba1d7e799e85a124c9e81c6865ebab1c0481e4ed4957a8989902ec565169ac53b7b4
-
-COUNT = 77
-MD = df045c9302fba73f9f27ceb0fb70e6ca3897f410e81a2b8392489e40aa17f15ac59cf8d6893ab10bacd8b59704eab22b
-
-COUNT = 78
-MD = 8ab095f49aa7ebfcb8b1410f42c38fb1755a0560e3638b8b82c7a852e8bce8f4b780015e051dda0d2cbd6d6cb08e30c0
-
-COUNT = 79
-MD = d77fdff2f768188efa63a7e29d73b8ade14c1aeb12e77866a57ea12c81bf0b3e1421d1af57fccf91b2098ba02ffb4118
-
-COUNT = 80
-MD = fac5ee7450b3fd1ae2152f5d020680137f553a2c210c57290d058f330d11407593d74c9d3d9ac88bf4af44e023345168
-
-COUNT = 81
-MD = 39d0ee95db114925ed7ff1577a22eb3dedb8658ce31504bd0f9f8a8f11f90825587203f26c432d216918156ca931fc82
-
-COUNT = 82
-MD = 17d22080e8a9f589a80a5ca8291b0479c41351008dffff79ff522779c35ba0b09acc2dedde936b07e260451d35ce86a9
-
-COUNT = 83
-MD = 9d75befac42e6d4d544e70477f7581264b5f8dda988da0dc40ef32f85c31b709284aef5f4f0246d20a855eee9175948e
-
-COUNT = 84
-MD = 3985f0cbca4c25f624850580516184e3d75996d77f138839c7570b4539b90fae8e751d1cea642816abd7f9ebf9d86c8f
-
-COUNT = 85
-MD = 93cfd14ade34e50deeee23aa75a63a017b6974e23051117e7e6b56b4ddb88f917a5d88d3af2af27da8e63fe130502f8e
-
-COUNT = 86
-MD = 7ae513480491a9500fa9afb8f64b8914ffdbeece3b3103048e91f6510b64cdccc8273257e275e5b34ec14c4c4aff4405
-
-COUNT = 87
-MD = 2585bab1cd98d4b51a1475fbfbe3bca43da2a7be842c5667c98d3b62a9f05918108be94198d96c67388f83c2abebe498
-
-COUNT = 88
-MD = 32f67419616e11fea79e3baeee4524c58d09f0cfb42049cea70f9a4a74e0096df841a0cf5177e402dd5803f4b51c602c
-
-COUNT = 89
-MD = 9f4486d93c599e68e7463d07d5cc9d589ab3a7c3d4d3c2b2d1f81f65b5c85068331f4142215f337c3621d096eb36aa91
-
-COUNT = 90
-MD = e3399ed2ac93c6a4a6c88c11bd89655aac3e573493483c81631fd67dba3bb237d46f9e8ddab3a9fd78236296d00dfd79
-
-COUNT = 91
-MD = bd9d1de114afa5ffacfbeb488d4846d012aa6ef66ce09725ae7b15e680d719fc2447f308eeb8247ae8e91e34b5a21ea2
-
-COUNT = 92
-MD = e1c3511ed2ed26f770bf5212c7ec245ab2ba49e1c09edae2abad6a3ee41c9e25445f5e5317cf7c9c3c3f702ecd6778a5
-
-COUNT = 93
-MD = c363234d1a6272d081f351cd68ac90abea09d3eae3a4d64fae7fab251a252591cb34dc63fb10abcbc5460129464c868b
-
-COUNT = 94
-MD = 6e5f1531eb282a2911a64b72b043cfe43b527d4d557abb9a31a9a632cdf5b5e055317ecb72a517a025eb4286d6f00433
-
-COUNT = 95
-MD = 19c85253b3c703fee80a70bb2ac2ef836bf8e14464d2a17f35bd5e4f2b0b3a059a27891410950a9ce07197f5b306ae3f
-
-COUNT = 96
-MD = eec713a44cb778811795609610f2f9bfc9bba479e415746efe0dc530b6de66d73cb85b8698a8c0c2ef9344a2043b7a31
-
-COUNT = 97
-MD = b799577aab5e8898326ed88eb96de38a27e76280ce44c3f16e70a1f96543ee7020bc29913ea0b9a9b9d92ae201143e0b
-
-COUNT = 98
-MD = e4dcabf1e22134076a21ea7cf9be6e03b099be40efc2b3080b9ec358cb021623ad27d33129bc68fce3eaec6b25aa2329
-
-COUNT = 99
-MD = ccde4359f23e64579c5c0380df837ee950928aa82937a2d2ed33d216e707c46d847efa5ca52dcbda551145e164fbd594
-
+#  CAVS 11.1
+#  "SHA-384 Monte" information for "sha_values"
+#  SHA-384 tests are configured for BYTE oriented implementations
+#  Generated on Wed May 11 17:26:04 2011
+
+[L = 48]
+
+Seed = edff07255c71b54a9beae52cdfa083569a08be89949cbba73ddc8acf429359ca5e5be7a673633ca0d9709848f522a9df
+
+COUNT = 0
+MD = e81b86c49a38feddfd185f71ca7da6732a053ed4a2640d52d27f53f9f76422650b0e93645301ac99f8295d6f820f1035
+
+COUNT = 1
+MD = 1d6bd21713bffd50946a10c39a7742d740e8f271f0c8f643d4c95375094fd9bf29d89ee61a76053f22e44a4b058a64ed
+
+COUNT = 2
+MD = 425167b66ae965bd7d68515b54ebfa16f33d2bdb2147a4eac515a75224cd19cea564d692017d2a1c41c1a3f68bb5a209
+
+COUNT = 3
+MD = 9e7477ffd4baad1fcca035f4687b35ed47a57832fb27d131eb8018fcb41edf4d5e25874466d2e2d61ae3accdfc7aa364
+
+COUNT = 4
+MD = d7b4d4e779ca70c8d065630db1f9128ee43b4bde08a81bce13d48659b6ef47b6cfc802af6d8756f6cd43c709bb445bab
+
+COUNT = 5
+MD = a038eaa91772d458a7339612f6a9214e6550f78d5870d91fa7a3dc1c2321e511759c159a371475dda7ad1fd7f51ac82b
+
+COUNT = 6
+MD = 8552b4ea2da9f855fcc7230ac88ecb1c3cb4841cc28e0495bf1ab97d100d4e4c60a1c51949d26723415f560da2951bb0
+
+COUNT = 7
+MD = 668338b2e661d9e25b799d7329e55629b62416ee4d42d2e55245ffe7092e7ae4a3da6903944d532c2a88e4632f9a4b36
+
+COUNT = 8
+MD = c40cd19cb770b1fe81135fcb9223ffb9ef50340d13660658ba60656a88f4ea08ee3b572680e2b4abbaf4392486ea589a
+
+COUNT = 9
+MD = 540c154e82b57914abc0452990abf988e46a2f65b40f5e9ef80a38c7431293d5efa31c7c83df5345b079ad4e31b2c8b2
+
+COUNT = 10
+MD = e112f9359983e7df9b266f53ec950ed2b951b6d832c8fc1ffed22b4be3eae3d015e0771e96d344672000d4959d2829ab
+
+COUNT = 11
+MD = 186e69c28033e11b152542c86a94f59a25ec4edb7ab5b735faff16bdbacc682b2ae79b5f5a68ece9fee5ea4530b8a8f4
+
+COUNT = 12
+MD = a37c790e641f911ef2929bab0ccbb890627c7e38e1a2fbbd71cd4215de919763c2819c35a0e93984b7d85d0e8858573f
+
+COUNT = 13
+MD = f1b4bdcfe0cce284ca26e0b7e01f26de21bf4a7a409ee99fee1019cc8d23e775bc134ec7987a6575fa64160b5c7f849e
+
+COUNT = 14
+MD = 45aabfb784a29d6be30104ae9f3c5daa58e48a9c94f61fed94dccd2ec06b527ed564643573d588ce10d3847361a57961
+
+COUNT = 15
+MD = be3a49139a48dafba418bb9e0e8e2bd195e0d239eec77c43d1f0cee844b65f65c30cddfc05b644f9a792459695883a2e
+
+COUNT = 16
+MD = 3b263277a0d11de4cb4616591d4623e0821da4f111dae33938329cb8cc47f46742c70c09463edb9ff4a0171c4604b243
+
+COUNT = 17
+MD = 2be323079381bd13a02cca824c2f3cd18cbc89b0c3319afbf33c6f06f2abf2fa3af35ea9752ffe153d1775a95e7accbd
+
+COUNT = 18
+MD = 14c8c3ea3f5aea2e74a2f138863accf1b5f563d96194c0dcf08ca816e1ac9156c3f5d15aa5701d93c188c2c1f7237518
+
+COUNT = 19
+MD = b9158943803c47678fefafa91c98966aa3dc1fd96f4e86cfdde7ca879dbf9fa9f54b1988a53376f7005df7fd87b1396b
+
+COUNT = 20
+MD = f4395f88c4dc24b6edca5868fcebd24991ced2e3826c04ec00e4630d7e1f70ee56124a90657a795f446f7db94d8b439e
+
+COUNT = 21
+MD = bb56b4ed4683fce0d6d412ef84b7985ccc5fe30306679a994c8221c1212ff7f1492512095b7ddd250411008ce9d54020
+
+COUNT = 22
+MD = cacaeb081a62a4e384e0082f8b994dcd721f38b3c3e4b5836ddcaaab74bcf2700fdc8b6faf3f4df1ec175a0628728a4c
+
+COUNT = 23
+MD = 231796f44eba3c8c6ad064b0e350093fcae026c3c03d669c28e5f36befa5f35489bf595a0312c38b9b73b7bb4dad5b96
+
+COUNT = 24
+MD = d54559e7eb20534025f8f265bdbdab0e7dd9e2459305288d3ca84190b6d2c6e8ae2cd6f3e51ccb54551d94e9e40b31ac
+
+COUNT = 25
+MD = d6231b809b70ed19478cdf7e05534e92ea01e74e970fe17e92ec9a67b1b7977c4c485cfa74787224fe326b1b8d1ede87
+
+COUNT = 26
+MD = 8ca1d462cc1b16b734c0e4f1a6b7f7d9d0ba9ce8074addc7755243b05fe269afab6618f07fe73089d9379bcbdce6c728
+
+COUNT = 27
+MD = 60fa725bbf21ee56545ab24e6f26ec5ec749c4971bf761923c23415cbcb0c02e6a474deb50144abad2b0f16ddbe850a9
+
+COUNT = 28
+MD = 8b60fe287f5bc133ff842a246bf161a58b4b8ead5be073c702552d664653e384e28e70d28624aa1da951ed33dcdfc7fd
+
+COUNT = 29
+MD = d18a080af3ae7e6318dc69298bd7b13644b7ab00adac18b446c1e9a9366e68dade87687b9129aefae9a98b531309f1c7
+
+COUNT = 30
+MD = faad832a7ce865cf3183e51e07f08aad6570795f8d0274fae52fc5cb637ce4b7cdb8f8092e2ac4a7c96beb70cb288b69
+
+COUNT = 31
+MD = b7bea61748495351409fcf1bd45a94af34e7dd899933ed06d5759fe728f6933781c21f1986b99906c6910d976a0d9c4b
+
+COUNT = 32
+MD = b35027199cf6467302a88e5d0106d01953b41dfa172234b3e11d3ccad33bda9a836e44f43ae94451e2bea28f0dca7989
+
+COUNT = 33
+MD = 8571acd0d5fdd20909e9cd74e125cb9cd65a2e74056eab3f85f6f13e31a5fc1580aa588997d31a0a3ba1a16dea5528d3
+
+COUNT = 34
+MD = 3dcf49cb8d79d4ca3f6e06e8a58bb92a7a42d7915b9e710a29d37ece6c1c32eb89a897e9935354db3cbe384a1149964a
+
+COUNT = 35
+MD = 7b2258c5fbf26780f55054b4aa462a607eecbf7382af941efd75b9b4cadd5b97936a762b9c03e133d7cfb65de501e6df
+
+COUNT = 36
+MD = c54cfebd2381621fed5cf6b82b3dea25965ec99365ce415b184ded71b949eb8009d91c85c02b30b7465fdcf18be885ca
+
+COUNT = 37
+MD = 39bed6de0e885dfd51569f3c5dc967f7f551065e87b6e7108d15ef5ea407419f936f5ae2288aeecf98777249f384fdfa
+
+COUNT = 38
+MD = b1c341b1428e5df6f4bcec533f1b5ca57e02102f5647b82be0986e523fad24b7f27aa29336a3f333817e8a5336a4a3b4
+
+COUNT = 39
+MD = 2e1e67546b9424a2f0bd8931082f9fb8951b9fe57a2b61683a5e197017ebcd96592dc47a75d2ae4ab8f436edd5e5bb4e
+
+COUNT = 40
+MD = 6c84a39bc94af5960715818bf9b4694548dd1f0af8f6344d56b0dc7f86b181d5249172c82572ec8748ff35b6c0a2abd5
+
+COUNT = 41
+MD = 576705bec035d07e31ebb091f180cd68c3873ea306708c5259f50491463c68d912080ba9f11bcc983a4b849ca19df008
+
+COUNT = 42
+MD = d45c7e9080b6223a2185c490363764f9fb0634f3865d57a15bea438fb243e98fccad4176bf24c4cb7247dd2c5728b761
+
+COUNT = 43
+MD = b3021cedd2ba38b69348867729cfe2ab172e4f1643eb4971cde2db002413458a566ea884d651a9c010b1a6b869168497
+
+COUNT = 44
+MD = 1cb9c05e35029fe6b114c85a457091b7d9aaf7c95f32447f3f20cd034bc54f87ae85c4013d18fe2a94de8ecf9c6b9f05
+
+COUNT = 45
+MD = 1e8f037fb920b836b8f36a1ed4875cf7d61390f68d4843e420b2c1ca702a104524c1187c8eec7bb4b174a252e1ae1462
+
+COUNT = 46
+MD = 07c790c3d4948347ad5fad9992d8a0f6603a2133d138f1ff5cbbdc04c39277fb67d45b2e2c8e6c51fdaa6c5883e3a69c
+
+COUNT = 47
+MD = 98ef381d9b6b4e26ebf2bc293743e1e07943a3663b17f1be52d12ef8d19621263efb8525506ef6b95f746567a43577c6
+
+COUNT = 48
+MD = 8beefea2f858f8902928dae6060b10cf6d4a3cd1f91cf1ee5ddef0ee5fc25a8269367c114c1c5c5ab5287c48edc59274
+
+COUNT = 49
+MD = 03a6509ad6eb7f009931e596f3dab586de3bd6549afab4f218eba4fe47daf37c6faa360afdd931c5a95544f1a028195b
+
+COUNT = 50
+MD = bdf7e8d538e7ef418c808bf2dec1242b716326f83bf0a53db81f4d63aba37a2412f6b2bf00957ad6faf8404e4e2067a8
+
+COUNT = 51
+MD = 71ad43312ed6e403a5e174480fb14b3c2a3a60bba36611e1c99adf8013d243fe945b947b362b6dc51a3dd96235472f5e
+
+COUNT = 52
+MD = bec45a229217e5fe28d6d1675dc7440ccb5616c0f02eb5d4c814921fc82fdddb04592ce7af192fee6c61b1a08f6ab6aa
+
+COUNT = 53
+MD = 5d6bc2d2cd0d8f5e41656f73a473bef1eff212fe98b184386cdecade24c5c5e7b92cf76ea16f582b9951634881f85585
+
+COUNT = 54
+MD = 96e3568d30a1f7810404f3be8d2d26e5606da6c3fc064d0ef62298ca327476d587a1e3ef0d6554f4ad529053b7a651fd
+
+COUNT = 55
+MD = e4df3b7028f5e68753c1f21a556d8468a5d80fb048f6b92d405e519ea9ce44c6c95fb362119c553f5921dc9616dd3937
+
+COUNT = 56
+MD = 7881e36eef708df4d9c06e37bfa7af5ce7d41d31a2e4332d23922a518de3e2e6fd4b9f27ee64379afae7ca2570d24748
+
+COUNT = 57
+MD = aa12548b63d3a58f6914744111292cfc1f1358f717f1b19fab1a4ecac6292f1ff4b4c67b8a260b048f00ddc83b42453a
+
+COUNT = 58
+MD = b421b6941b5d7748765a4090c224dbbd98e85dcff9a65a77db0c2a83b92f4cad961b5b8ff76b5513d4a7af45ec4d4550
+
+COUNT = 59
+MD = 14e1b1733b16899c4046a604f8e1e777d55649c5357d7d9e3d7a1c395b6275aecf733a598de1d0bfd7eeaa9ecbd7d1e7
+
+COUNT = 60
+MD = bd05a1f9fa5b77371005a8073f0f3bcc4cb4e08fde3335dd3688921cf9cb5e97cf1b3052ff74bed8a359d170d2bea48f
+
+COUNT = 61
+MD = a319d9b3eeee6da494940ffb08903bcd588b18733a64ed435eadc5d9add6ab4f0c35fc050958bed81303409f388a065e
+
+COUNT = 62
+MD = 6f19824ec874b55e88fe4b1387433dab85415148870bf4a0612aa9c1cbcd9627925616fcdb66d68760c50fb308f628b0
+
+COUNT = 63
+MD = bacb435a1ff538d0ba3e3d0ab04b5e8868bc1f84e964409229d7eada4b846b813c0e30d8e962786aa83aac2dacf02d19
+
+COUNT = 64
+MD = e8f013470eafd5af84f63d51d51af2ca884789d03d79f8c3089810254b95a6f54fb86c08202cae94681ad702ea29451a
+
+COUNT = 65
+MD = 374b07621c018cc3935374c2f2f098e661ca0656181f67f55fb80ac36e23da379c4f6c8a3683c2621f874afa1241b918
+
+COUNT = 66
+MD = 5878f1ebcbe60aa62a7b149bd181167e5898d08a3627a08c589436f007bfb82c040b26ea9944c6f0c9c4079b9b0e1ecf
+
+COUNT = 67
+MD = 05961b57507c99d0cb7dc24ae34eddde94ac484129de621edac5b001ac5c0b974d09d24f75504f3be1a3cd635c44bf71
+
+COUNT = 68
+MD = d961eb883eecbc083533fa5128695c8d28281fbac23308dd2f504eb079d2d311b973f1a52b45aa6275550e14477a8876
+
+COUNT = 69
+MD = a4557f990f4ccce585ba33453090f66af576f0a501d26667031f48f19538b820b84f870579efb554e7550f9f53fea5ea
+
+COUNT = 70
+MD = 82194c49f24084249567f0e8963c5f72a23bc20a8f522a6108f12abf95b7437ad93673860a953264838a09bb3968d0a9
+
+COUNT = 71
+MD = 371dc5573b145f2136eb854591ece253efebf8732d3898bea063fdc3889d07953ee646e533b214f8c2dd66f1355b03cf
+
+COUNT = 72
+MD = cfc4dcecc6103027232029dd9a19850a6f79b9004be7d70054d0af11c692affa44c537f7cd749f2b6317cafe1fa52fe4
+
+COUNT = 73
+MD = 9920b835400795bd3ed8ae0bc12417d58be8c5ffd6eed151ed738c3031e624c74fb85488953ac81c75f395cab74f1679
+
+COUNT = 74
+MD = 4a1b040fa38b5cee63f5d308b55502d2a017b349ead5172c288289f42ba9874d0d11c9ac43255580c428a99067495782
+
+COUNT = 75
+MD = 93c1cb94d0689301728165299057edd78ef48a6dc7654931ae2bf7ea5bc733f3b724f4c3081bc93ed61e7d739c38e137
+
+COUNT = 76
+MD = 8f2e6c868b224b3cd5ac80669da0ba1d7e799e85a124c9e81c6865ebab1c0481e4ed4957a8989902ec565169ac53b7b4
+
+COUNT = 77
+MD = df045c9302fba73f9f27ceb0fb70e6ca3897f410e81a2b8392489e40aa17f15ac59cf8d6893ab10bacd8b59704eab22b
+
+COUNT = 78
+MD = 8ab095f49aa7ebfcb8b1410f42c38fb1755a0560e3638b8b82c7a852e8bce8f4b780015e051dda0d2cbd6d6cb08e30c0
+
+COUNT = 79
+MD = d77fdff2f768188efa63a7e29d73b8ade14c1aeb12e77866a57ea12c81bf0b3e1421d1af57fccf91b2098ba02ffb4118
+
+COUNT = 80
+MD = fac5ee7450b3fd1ae2152f5d020680137f553a2c210c57290d058f330d11407593d74c9d3d9ac88bf4af44e023345168
+
+COUNT = 81
+MD = 39d0ee95db114925ed7ff1577a22eb3dedb8658ce31504bd0f9f8a8f11f90825587203f26c432d216918156ca931fc82
+
+COUNT = 82
+MD = 17d22080e8a9f589a80a5ca8291b0479c41351008dffff79ff522779c35ba0b09acc2dedde936b07e260451d35ce86a9
+
+COUNT = 83
+MD = 9d75befac42e6d4d544e70477f7581264b5f8dda988da0dc40ef32f85c31b709284aef5f4f0246d20a855eee9175948e
+
+COUNT = 84
+MD = 3985f0cbca4c25f624850580516184e3d75996d77f138839c7570b4539b90fae8e751d1cea642816abd7f9ebf9d86c8f
+
+COUNT = 85
+MD = 93cfd14ade34e50deeee23aa75a63a017b6974e23051117e7e6b56b4ddb88f917a5d88d3af2af27da8e63fe130502f8e
+
+COUNT = 86
+MD = 7ae513480491a9500fa9afb8f64b8914ffdbeece3b3103048e91f6510b64cdccc8273257e275e5b34ec14c4c4aff4405
+
+COUNT = 87
+MD = 2585bab1cd98d4b51a1475fbfbe3bca43da2a7be842c5667c98d3b62a9f05918108be94198d96c67388f83c2abebe498
+
+COUNT = 88
+MD = 32f67419616e11fea79e3baeee4524c58d09f0cfb42049cea70f9a4a74e0096df841a0cf5177e402dd5803f4b51c602c
+
+COUNT = 89
+MD = 9f4486d93c599e68e7463d07d5cc9d589ab3a7c3d4d3c2b2d1f81f65b5c85068331f4142215f337c3621d096eb36aa91
+
+COUNT = 90
+MD = e3399ed2ac93c6a4a6c88c11bd89655aac3e573493483c81631fd67dba3bb237d46f9e8ddab3a9fd78236296d00dfd79
+
+COUNT = 91
+MD = bd9d1de114afa5ffacfbeb488d4846d012aa6ef66ce09725ae7b15e680d719fc2447f308eeb8247ae8e91e34b5a21ea2
+
+COUNT = 92
+MD = e1c3511ed2ed26f770bf5212c7ec245ab2ba49e1c09edae2abad6a3ee41c9e25445f5e5317cf7c9c3c3f702ecd6778a5
+
+COUNT = 93
+MD = c363234d1a6272d081f351cd68ac90abea09d3eae3a4d64fae7fab251a252591cb34dc63fb10abcbc5460129464c868b
+
+COUNT = 94
+MD = 6e5f1531eb282a2911a64b72b043cfe43b527d4d557abb9a31a9a632cdf5b5e055317ecb72a517a025eb4286d6f00433
+
+COUNT = 95
+MD = 19c85253b3c703fee80a70bb2ac2ef836bf8e14464d2a17f35bd5e4f2b0b3a059a27891410950a9ce07197f5b306ae3f
+
+COUNT = 96
+MD = eec713a44cb778811795609610f2f9bfc9bba479e415746efe0dc530b6de66d73cb85b8698a8c0c2ef9344a2043b7a31
+
+COUNT = 97
+MD = b799577aab5e8898326ed88eb96de38a27e76280ce44c3f16e70a1f96543ee7020bc29913ea0b9a9b9d92ae201143e0b
+
+COUNT = 98
+MD = e4dcabf1e22134076a21ea7cf9be6e03b099be40efc2b3080b9ec358cb021623ad27d33129bc68fce3eaec6b25aa2329
+
+COUNT = 99
+MD = ccde4359f23e64579c5c0380df837ee950928aa82937a2d2ed33d216e707c46d847efa5ca52dcbda551145e164fbd594
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA384ShortMsg.rsp

@@ -1,523 +1,523 @@
-#  CAVS 11.0
-#  "SHA-384 ShortMsg" information 
-#  SHA-384 tests are configured for BYTE oriented implementations
-#  Generated on Tue Mar 15 08:23:39 2011
-
-[L = 48]
-
-Len = 0
-Msg = 00
-MD = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b
-
-Len = 8
-Msg = c5
-MD = b52b72da75d0666379e20f9b4a79c33a329a01f06a2fb7865c9062a28c1de860ba432edfd86b4cb1cb8a75b46076e3b1
-
-Len = 16
-Msg = 6ece
-MD = 53d4773da50d8be4145d8f3a7098ff3691a554a29ae6f652cc7121eb8bc96fd2210e06ae2fa2a36c4b3b3497341e70f0
-
-Len = 24
-Msg = 1fa4d5
-MD = e4ca4663dff189541cd026dcc056626419028774666f5b379b99f4887c7237bdbd3bea46d5388be0efc2d4b7989ab2c4
-
-Len = 32
-Msg = 50e3853d
-MD = 936a3c3991716ba4c413bc03de20f5ce1c63703b3a5bdb6ab558c9ff70d537e46eb4a15d9f2c85e68d8678de5682695e
-
-Len = 40
-Msg = 4b5fab61e0
-MD = fb390aa5b70b068a54d6d5127df6a6227becc4d6f891fd3f6068b917a883c9b66f318fddb6384d10be8c7af0d3132f03
-
-Len = 48
-Msg = dad95a4b4d37
-MD = 3a2b40f453925bc3ce17d640757ee0e899390b4a8d984d0297c1bae6b60b9f2603bf71c323fd171011372335e5702e40
-
-Len = 56
-Msg = 121835fe3700b7
-MD = 7bd06a94acba7beb3c5a9b9e8769c3da6691c482d78b1e5c7619b36630eba4e596d11c410a4c87006f4716b6f17bb9a0
-
-Len = 64
-Msg = de60275bdafce4b1
-MD = a3d861d866c1362423eb21c6bec8e44b74ce993c55baa2b6640567560ebecdaeda07183dbbbd95e0f522caee5ddbdaf0
-
-Len = 72
-Msg = 8d45a55d5ce1f928e6
-MD = de76683575a050e2eb5ef95ee201f82416478a1d14bf3d96d1fd4efd52b1a28fed8dfee1830070001dc102a21f761d20
-
-Len = 80
-Msg = 5c7dde9b3894d73cefe1
-MD = f31b22115fa7178e78223e06aae870547ab93c6eb3c3910b0ee16e6106db55935d6c0eb820132a2078ece1067efc81c3
-
-Len = 88
-Msg = 967fa34c07e4945a77051a
-MD = f8f24d81c4f8f23ecb42d76ed5d2b34c9cbc1f0a97234d1114804b5999759f3131c741d5768cc928163503c5f55f594b
-
-Len = 96
-Msg = 2209112ee779bf6d95711105
-MD = 09c54bf533a26c7447caa5783db2ec7ef5e55752da7f2a2c4e360982a94ec1ca2cb6a157d34eed28de978b4145e17ebc
-
-Len = 104
-Msg = 20442e1c3f3c88919c39978b78
-MD = 50bc95b036e0f54d833032a80d45c2ac38b3d29e9c7f72a2eb14781e9241d2a4b8e8dba6ee6f4c9e46a758d5712dbd39
-
-Len = 112
-Msg = 4d43702be4f0530319555d7f1a33
-MD = 83c8f0bb762801eb26cc5115abebb657c18ff811de500b32b7a568a220a287e900b6c75224fe7429169fbd534cb588e1
-
-Len = 120
-Msg = 5e2a79a544af85f150f7a9d209fd44
-MD = 8051ebc9cabb052cabe07e4023e2140808b77d25b07b96d2e3c22393f71b116c1a1e41bf62e57f73ff67871da7c93cf9
-
-Len = 128
-Msg = e1bb967b5d379a4aa39050274d09bd93
-MD = 3b04f96965ad2fbabd4df25d5d8c95589d069c312ee48539090b2d7b495d2446c31eb2b8f8ffb3012bdce065323d9f48
-
-Len = 136
-Msg = bb84a014cd17cc232c98ae8b0709917e9d
-MD = 85227ae057f2082adf178cae996449100b6a3119e4c415a99e25be6ef20ba8c0eae818d60f71c5c83ff2d4c59aa75263
-
-Len = 144
-Msg = c3411a0592f1f4fa698815238997db356418
-MD = 233ac44170d9f452a1a0231622030b15c104ff8ecaa3fccdb9e9e5031fd5b4220186a8edd032849c8b93dc183a5c8627
-
-Len = 152
-Msg = e831b739e8eb9f787f63c0bb071ddcc9f44cab
-MD = 91722d4b7aecc211bb8a5480c6855f3b71be4647e1dde0380c23afaa03f45c642606a24506e0317bf51506a483de28ac
-
-Len = 160
-Msg = b8a7bbccde46e85f1223237d9353b78c3b19727b
-MD = 28ba69dc05e6e29de91924114d6c9fc7612f6d2a68b07fa001df059bcf98f7aa85389caeb966eaa299c79fe1fd1e40e3
-
-Len = 168
-Msg = cf391b8aabec6f81288c8b7b92843be23d2e847574
-MD = 121e5ef697df491a53d7bae121416aa653d759a37db9d0b993031b18a0ef160ed98842a291e1ba2cea8b998bc5eee0b1
-
-Len = 176
-Msg = 9d65d88bffed764c286f34894f991600d1a67d622382
-MD = 84b6e0d6a45329daf47a793418ed5dbde01336b4b9468bb69e5da61c42b691e6794e6ed0e8fb1b8e7d4cd3cbaadc520a
-
-Len = 184
-Msg = bab6ea46fb717f73f0628132a2b96be383774f1e5d8b6d
-MD = e969aca1b50e928cad29a0d756457f6de8d7a4e589fd41e53a1e758c3b20f9b81b36bf098a49102fbf869651ca9a98b5
-
-Len = 192
-Msg = 8853b00e869764adb527a07b073c85a24e6c208ba47eef4e
-MD = 09ad44e85ac190e2d1c3ceb4efbea10ded34d0de961fe4ee268132c48e38660e6cf585bfffb8f7b00b0fad1514312b63
-
-Len = 200
-Msg = 71fe1ba5d299495d2a56039c64032ec6263d437f55e3f5bedb
-MD = b41a5d3b4af6d4b9c349e0788538e9a0311086894df7b72cf5aaf4091a7e039e4e89cc77a123474e6d1bac438e5e9f88
-
-Len = 208
-Msg = 4ebe07d03c93e849b4bbfe9f2d2294bf6ccab457f76d3f99cb64
-MD = beba464d7065185587fad89bfcea9635bf0ab775c3eb8c147b5b2bd8601db6dba0590b50dd1068733f20dc68e004a090
-
-Len = 216
-Msg = 918ac0a97ec1632908489e5242ba284bc811aa7197242cf7226fcd
-MD = c4baf6397a4c6e26492b63a4aab7dffdd0051d8f51938ac24cfd8dae2f7afed1a4aa2430d7aeb0be2a72b21a6c50198c
-
-Len = 224
-Msg = 97477f7272d8a89e38e796c533e9f8a8ae4c92ccaa5d907ed26a1a15
-MD = d1ad524ebe908d7c5aff50e6cb780fd3a70e87c914a36b93c4e35f5b2cb03850b122b480ef8587d4a44f22467f4c480c
-
-Len = 232
-Msg = 718e0cfe1386cb1421b4799b15788b862bf03a8072bb30d02303888032
-MD = 6d8b8a5bc7ea365ea07f11d3b12e95872a9633684752495cc431636caf1b273a35321044af31c974d8575d38711f56c6
-
-Len = 240
-Msg = d3b07f0fd5d4cd3188aead8dc8338de42056e2e8487eca51ec37ef2daf27
-MD = adcc2e954c91db3db2d71d0dee1f030e723bee1a23816fe003ac5dc862a0872ef51ff386c18be6ebcaa493f32d1195b9
-
-Len = 248
-Msg = 695b9efe1809abd5d44eae957ddf9c2cd3c75fae2f522855712a07c639c0b9
-MD = 3bb95d164d94595a1187f77fc26c280ffbb08e74ec7947aa3e5b38bec7c6f8115c4d880788c2402dbb3e5b94afd130ee
-
-Len = 256
-Msg = be01e520e69f04174ccf95455b1c81445298264d9adc4958574a52843d95b8ba
-MD = c5cf54b8e3105b1c7bf7a43754d915b0947f28b6dc94a019182929b5c848e11441c9e4e90c7449f4c3cd12954f0f5d99
-
-Len = 264
-Msg = 98ef7301f957d73d4e821d5873e8a9b5970fbd219d5cf74ec2291b8381181391b4
-MD = b2564bbb159c3aeadbae0e4a4437f7c5111020e9ad0f4eb508147a961ac22a01e1a26df046b14ee5e8a49d9ed22b8cd1
-
-Len = 272
-Msg = 873ba7f8b71517ec50297b21cf94cdb7a58abbb8829206f0d3f328ff8a6939ac1d1d
-MD = 7405fdd557d2b5d4f65e9e85f508d3791495f1820d37cabfc8dbb74d7b41df8613d995c612d378dd88337e00951d0280
-
-Len = 280
-Msg = e3bd4bc3a60cddd26c20aa86364bd44f4a07f3302825ad0ac127881de4eafbccf988cb
-MD = 199d5423a0e26438f4cea0081a89e0b6c84ca93f7c3120c8104b51c6edc04e0f6a203bb77d59973a7411a0efbe93a09d
-
-Len = 288
-Msg = 8716e4b86deff9da2a8ed55baa43582a7586ec9cd38ac3a933156158cd8e5b7887585e91
-MD = 0d2306d9c0a8ce57bc7869b439376c07ce352a41d86ab6cf4a5654cccd5c724fe1b62b2c1101c986222f5264ab3fdd66
-
-Len = 296
-Msg = f8a503aaa25ef2cea25e31930c3a90db468cd3a862f4a93aab5de2777e82dc905cb03ee23c
-MD = 773ee958fe93dfd1b73af24d27ddce33144a9249d5a671682a56df30d0bbf92b9327130022075185d396de752959304f
-
-Len = 304
-Msg = 669025175ea917cdd7a71ff4ec0c45bf1246d2a6f031c00b71de701e17939bfe92128b21911e
-MD = 9ff6be3f02c7c5d0206f4b944c0843cb68bea8f9b7c8cc0b729503db5005c7cd5cb14e3457d8f5eabf733fca9084f16b
-
-Len = 312
-Msg = b35fb2262edfa14938a0fba03eb2a25d377974b11f556491a781d0ba2b3c0ff3e42749925fef8b
-MD = 835b05a4bf00c2594c3c8c13da6c273a0d9efdea0da72b71b19d326bf5ce968c2e577a7d99fc0f985afd23b46423129d
-
-Len = 320
-Msg = 9d86b45df8d7dae0cf6b0bc208666ee1163a39e6116d6d240c9dc1c3a3c1db1dd3b1c6680fe9a196
-MD = a84c469c24696f81d7df4ee8cd76aa584f8c9960eaa9908d3e3ebc5eea7d0b50afdded39deb94fd59323a21a6539e93f
-
-Len = 328
-Msg = 414f5619f6dfd45853bbabd224cc305d77350ad253358910a74f3a4381a9b86680b3c4068c089849c4
-MD = 848d481e3bbf5dd726f625cf6a444d995b36262c9f80d583b77accf1707e3f49bb3dc480a560694d769aa1ce65d69428
-
-Len = 336
-Msg = e2658324821ae7b0faa0cdd63ee9efb9fcbe82092d04696feb3da92c82521dfdc98f6b41b3ef365d219a
-MD = 3ea5d0799f1a4dcab9149a40ab74bec9c8d76d8e392c1e63e080ddec2ec535f80be9f00927be281ec97ac0c882bb0bbf
-
-Len = 344
-Msg = 7e80271bb5f2cc7ddae4158658e4e8d06e04a39385da0ecac1cb8e91d68a9bd21ddb7320e79d10e3110758
-MD = fa00bc0359a642dcb3559656094eb2fd4f63bc57f0d34abff26df5c54cc63dbeb4eac75905296e7fb69f871e134083f6
-
-Len = 352
-Msg = 43d2828e86f7856b78c66cfa3d602387c290975afd021a8b76af0918069cac35dec45de3cc52edc4ba14432e
-MD = 6c9e367e066032ce47ba2575565932002cc786f533c5551656abfe7391e7dcb5f9d9e047adace23d32f8acedfd0cafc5
-
-Len = 360
-Msg = 3f49bb645cced7530b8b82e6cf07fbf670f7ef0ba0583d16debafc639bdfbfc99b8417249f7f5a05410aa3a71f
-MD = 2b301a14647a67429cc3e7da02c4093a739640f7b47a305251d2855e75e09e60e262b279a073077d1fb6d0f04788f2b8
-
-Len = 368
-Msg = 31aac06a59b74bf478617c1637fa6c5593df168b8d58b1e923bf3e3d80e55d7170b16454160ab29ee1f7412ebc05
-MD = ddd245c9b29ceac60506fb6bd6e8037889cb73d6ecc669fd129060a8a8f58971ac572d3ec9b44404f81381d0fd35a649
-
-Len = 376
-Msg = c10b2852054d8034e07906c7fce3ce99402321a648bb881f13fb276afc224c6aecc64800cd767ed2429db94b95a9c3
-MD = a44640fb4ce6dfd4a10290a0aecdb453054a9b54f2583e97bb7dc2b005e5fa2b4fda17b1f75902f51c18c0caad35833c
-
-Len = 384
-Msg = b1eeef324b499f19eba322215fe3ce19c9f000b698d2b2dab7145015046cc86d049ee15ad59dcd1564f30112e06444cb
-MD = 38742d18bfa6e918b888d68d1034e61f65dec0759172c2dbf08cf1e132b217eaf4ec29e15db7f4b07e08a70cc5662012
-
-Len = 392
-Msg = 790dbba09965c9774dd60a32e010c50d6d518968a220141dc33e7410f2da6c08ad0419bd9864d5327d2c5c44914b2e83f9
-MD = 9174958bc8f4ed4731eced999bea2f63032f52bc8c46bcd903232f3fbc5046f0d6c203d43a078b822fc05101404f2635
-
-Len = 400
-Msg = f7b577f1396b23c27eb637e53d3d92460270b001cc612fd3b4d68bcdd09c2d50571ea4350636324cc2428a087e7bd8785f82
-MD = 80afe111e44ad9aff9e39c4cf9e6b4c520072b4550e62b1740160a04f8d530612dc098917a556b44977d0e73df518bee
-
-Len = 408
-Msg = 7370d9b453936955b9c9d336f4b283237986232de007bf412fb426ff5b4093c80c428c19a12e0b187484dc6d5f4746537fb1ed
-MD = 6cd29159820d34e5706dd867e6363758d312660d4daca8d2abf677f234746e97a0a6224eb054066a0b74e18c70965368
-
-Len = 416
-Msg = e8620170f0f39328bdf8888148cfd17730f314ea68d8fea02d16d98a3cca61484139d3ee92b748091dc841dda08483f1184025ce
-MD = 29c408a6a5045f397b56dfb5292c7c16028c63f068e699b86a891ff8501208ec9398dbaf463c00f39af7b2cbe45bac15
-
-Len = 424
-Msg = 75d4216bad77943bfe82be216157843b0da0fd16eeee847153a00b43e707b2ffe2c898168081f0bdb3af58f214cf67b920c385aca1
-MD = 0170357385a20865a8d30c2df39406903ff88c7f70fa1a7a5aaa86711d64046c432a1b139668ae5abed637d1dc4107b7
-
-Len = 432
-Msg = 2fa90c2210e3096caed122b74eb9559977120e5d9a97eeb3f99bcba6c19cf8cf791ac6c8a0a94ae49246611dace7f24eb05673a36b3e
-MD = 6c2ced3fae94dbd92f4170b63f1ff6fcd8194f60937b22b4f3c95fc9e104b77148f9bc6c16a890de86d9ef1554c96fa0
-
-Len = 440
-Msg = a8de55170c6dc0d80de32f508bf49b7046aeea4b975a511b5ea3dc853bfa4b1e0138202d6785f6b3017914a86f824288d586dc0e8bc924
-MD = 2bc3b10c148200f7919b57afe1d7db773ffd235e04fec6897dd94f13ad9c437ef50900a40937f82a39daf2aa2b3dfd68
-
-Len = 448
-Msg = accd9d05fb7ef3043470836137554af117440b3ccca7a280285494f90dfaea60dcbf40b230271932cd3875b1d3dca60d38865ff874180efa
-MD = b9e02df93e9254180d6a15288d77088b5a5ce517644109b4e2532be315f08dee43491608a1127dcdf69397406e23d231
-
-Len = 456
-Msg = 32b835c180cc4006c11a61c65b03c099510e1d4f0a94b63d54bd6bd5a8ab207ab0f4639206564edc3fa6af03280a67744f68106dc51ee35723
-MD = df97a1c5dda6f9dde749f213e429db84f0dcd481d43bf58e6142968d629ecf05b262830a7dac87f67f4383975f3e821d
-
-Len = 464
-Msg = 9409f9efadbf190b253367629f8f368c9d5ac262e94ab86f3559f9a1fe1a9b44b64e313121b34d43001c430bedc62fc586ea398acd8f17c7cfa2
-MD = e1a69388ee6b6d234108ec29402cd0afd74957d990c7bdb544cf11e8eb2ccd170b6b5a74431be70364d7a31b926ff53c
-
-Len = 472
-Msg = 289586baf8daced50db14c936529a0a6438eb5da8d3d469172b6a06f4ff3a956d4f9219563ac285cb8e70074cfcc152c02593a97733c36f4a9e97f
-MD = 509e996c1e11611c243021b8b78f2ad90c5a9263bbf35910db7c8ec102aa7c518066fff8ce88562fec2cd6dfe04056ae
-
-Len = 480
-Msg = 156530cd6ed3baf1fd7232c7ff204f3c7d4d106016afa3bdff3786e84843ec556115626fdc84b2e874f1074e4f7d53e08079ee9fd01f80a8be7f20c0
-MD = 7b8a598029ca0ed475a72c0644ac81c63d72fd51305dada07b0ab4a29e47422f59e12643179269ca3d7d10446b372b2c
-
-Len = 488
-Msg = 30655a6b5a5965db992e7248d24141055e988d726abb8e729dc5c21ffcbaedbc0b1b5fea35b8751f6ec6625517312fff2234014176269b60959723787c
-MD = cfaf443e95deeb3cc1910771a2c0692a54b18b3633dc5414e71ae08877f0804818f67f7196c52e26b762dd12bb7a86ca
-
-Len = 496
-Msg = 345c3c022e20144e135604078762ef5c8a8f038cf1b1d6a91709b59dd068396a9e971ab628f74886e765384a23607c1a1e6e973f8fbb0ff55104c46f5db3
-MD = bfb1d5ee3a0b629058ecc521c706c2f9241c48cda3dcfdba660a2601d832a7a872a2bb840f3b98d21c37e28f9041a5b2
-
-Len = 504
-Msg = 0b94a0f43a92408963a59ded01a9338283a6ff1bfbacd9051a0104445c7f041e8037afde3b5a87d22d5a4796144cbc944091d6cc47b5ffd1f997ab1496ca31
-MD = 07a045c9590e9901d0598e604c4649554a823de996fa438cc81a634344eeb98e5f3c0c234ba30e2285a4d7ab568f2610
-
-Len = 512
-Msg = 93035d3a13ae1b06dd033e764aca0124961da79c366c6c756bc4bcc11850a3a8d120854f34290fff7c8d6d83531dbdd1e81cc4ed4246e00bd4113ef451334daa
-MD = 8d46cc84b6c2deb206aa5c861798798751a26ee74b1daf3a557c41aebd65adc027559f7cd92b255b374c83bd55568b45
-
-Len = 520
-Msg = bfb94dfbe0d9a509b78d164a722050054dad91c9a8e260545d037eb450321aac48ed4459fdd8a41572bd6c9c84d18b6ec339247482cc3ee52a1bbd6bd4ae918216
-MD = 13af0be02986ea3176e8c65534ec9f32c23b53c93a73b15c26b9ecbd8a1181ae184a372e9f5e0596cd6606849aeae8e0
-
-Len = 528
-Msg = 1c8924a16fa7c602aff5ee961798bd44fe53798bf44c3d6b0d13ef837de07377651c1e94ed236eb79349f86ac31ba151a7e711c5407e65beb63824f6ec39754b58f3
-MD = 5be6482851ddafde582f2804071a702ae39bacb688741b7c37bbae99821ce4d3f47d5b097fd8eefa0ef9248a34f5d3ce
-
-Len = 536
-Msg = 184215145da49db417e8bdd573d6282de073e674c3dea86b6c78591d4947f5655a9d9eb0e5f4ed046b1d8642da9aefa80448a299504160a1b000c9b4d3c62ab69b3d96
-MD = 8995cd7fc0956e124075440686beece17a6256b282e7988a0c998f790e3995c974383179893477bcc32d1f114129b496
-
-Len = 544
-Msg = ca7a63adf41f4da33142910c967706b5c8a093350eb3e6d3aabe69a46a2872f47a39bbe77cdc1160daa450225b0e8e36f506978ce3ac9ae5f75721ef30da46b28f07242c
-MD = b89cc12b11e3afa58908580c47b25407abbf584f8e8d4b5631e9f450464c7e53cfd7e9f9d3cf35e587a6f02957ce4c28
-
-Len = 552
-Msg = 1da41a0af202b079521deb6109e312c2ade48544d2b498c07e91a102dd4650ce354f3f201b3ecab8e85e21d667959b43d08f4e90fa18dca2ccca8f6ff5e9a902dc8bf5c5da
-MD = 5c297e20c307aab7f325939fd4e2883b034fd547f1dd17fb6b97ade8b148e06ebbf3ff60cbf469e4933d5f48f0166cb7
-
-Len = 560
-Msg = dece42c8849be40c78b8de6da96c2a8d7e940545b9f3f39aa1ca03ec60a85471aa84d8e29f095874f331b90a4c157da9eb048d2c8fd235399672707366c766f10bb833f02183
-MD = bb509e33e9ffcc4c01233146226ee9364cdac5658132460a76edf617a035b197c86434ee889438581458102618769382
-
-Len = 568
-Msg = 952008ebdedd480449bb96a025576c5f617bbb8307958a010767e0d736ffe5a196ea4467d8a5d3ba1f5476ff07b6410ae659dcef520a2c14e3902f8b399a289f41f5fdadb502dd
-MD = 9b63d9145bc714a8253dcdb8341b2f5714eb58b9d4b22ce45aae07f51297a3dc9c5b691a8a3cd438dc5bd18be400af21
-
-Len = 576
-Msg = 100132c315bfc9c4fb93023f5d3500d7208a68acb4d2c63096232c361a161c4c67c0a74bc3e4d72c11664b1d970321d405401924b3a0f6ce2b1a2899e7caa9a55ce725fc37f55d6a
-MD = b6ca04467ed3e623dba36f2e0248cefbe134cf555fdc14731175eaaf08e244ab0b15fca2f173a0ec98feaf359fb84a11
-
-Len = 584
-Msg = 99cba4019f5478789e674e08fe5d6ceadd698b0757ca39c605457c22c3d3b8ffb797d2be8f12960f099a5606b908d47207b2636a779948282de3661bb08b1b37ee576590800a492730
-MD = e5378c7c251ae96f0359a30b3134fd77d61d0db68c42a1a2aac293195a596df42f677e6cb98abec90d6722baac63fc86
-
-Len = 592
-Msg = bb327a0bcb2574df47080e8c0d8a45ee1c0424ae0414dc0a9b8717d9f27d8ac987c7c9ecbc946073884d1fb96dbdb583aa758186b16fa429dbf15b8d5bb48cca71469e7ce0ad8e7fa14d
-MD = 0f75e65ff8494ae28d9a0a2e65959653275fc34b2fa27b9e10faafff07c45addef3b8f25953d5a2e54e31ebe6d429d26
-
-Len = 600
-Msg = 7fd9eeb5ff368040d299fd17a943b21d65deb2eccf6128d18a33eb174693538935374c32c333a867821dba08636f20022c2ce01826c7b7e41640ad186f90ed0ac647d47086744867e5c54b
-MD = 007251a2a577add048b1edc79d96c7df8fd5b5fa0d7264f122e4cb54c50bc316a8bc5f4f9dfd4469e29e9b030f563a6d
-
-Len = 608
-Msg = 7ca9e369e82186984d5fc729e111a7e5d8ec19c5d74e13b5ab22e4993b05c88ebba6ba72237389a6e0722e12c96c5d6a54515ab00ad80efb38665a76e831abab0fa5cf020807078441585de5
-MD = 3ee8c4184de9ceaecd0d3aea16271835f3d45c873358c93a515539c38e819414ea63b08d0a109346793d5e0f703125eb
-
-Len = 616
-Msg = 5b4d945d55dea22e37821ec396476a4bfb617d2f392ad93afe67bcfda9cd9b725bc4ccdf516a83fd71dbff5a22b005fc61c58e471240bd2193ce13539730e63232f70f80308be48dab7266a1dd
-MD = df82d242e4cdc2eb40bf3db6a56e1aa0a66e553f1914bedc65c8cc6ad9564b6e85df59f4c443cbe4e0aee05986f7d690
-
-Len = 624
-Msg = e865f4a42bbbd0b73fe275b8ab90d3a9fb74ec5070192d38f60efef9564498b9adb716f31d50cf77c20ae4b2e85515307bb8d95fbeb9ad964001ac550dbc60cf213fd8a522edfaf54e5b1b93b2b2
-MD = 091fa9ae2184e2268ef9ef23c7c809efad244536e00aa9e8b3a6c228d90e31da051b40f268a13bd6f62e69c91ae8cd2d
-
-Len = 632
-Msg = 1d408c7b68e168f41bb46f9b2e9c8b04f968e4080252546814cc1cb2917dd5690886a9600a09c2673aec0329a4daf655508b06fc1646ef3bb3a472191d964db214a96a96fa89576ce4c4f6dbf1d176
-MD = 7e23472c03431925f3b4559d886e8d5d837b3d39b8efe1b7a91e61a13810c4dbc2439634d7c6ababfc66e9b18e6541db
-
-Len = 640
-Msg = 54ae030a4e27a05c1ea4a12e69c67544af9b4044cf157dc8cebbe8b2d49f9bc0779077603c90c5c55b891d3ac33b87b65e79e1b19695813718191b3bd8b7e42d5583f7cf1e60f84495b8f869f3719969
-MD = cb65f823585773cb8802b6339182f13752a82864c898b445be5a11a969657ac2dc4a3bbeb87ac0abb232a2b124171096
-
-Len = 648
-Msg = f73cd386f73d0c6ade05771b33117117c602e52693f05b47e90032eacc39295f9793258fe6512eeab291baa0be222e143295a28e8697e42fa27ec02b44217f32a1edae2f4f35213562ca37b6d6cc5ef72d
-MD = f665c4d17a83d65a7ff16bfce279b58558250d76af68b8eb943753e411a57ceb31c1a131e54bcb7672584416e3d5719e
-
-Len = 656
-Msg = 1d259612e6867e7d788c71d03c5136864ad6d84f24eaf913a34e69333116f812395288d4dcee6665e6d7dabd005ffc6327e3ca305cab78569d1107a115e619fc90110436317925066726774d1da3639c31a6
-MD = 5dcf512e2b93d6ecdf7c3304534554ea79d22392e59bbe90df21e978c9fa3b34ff82e6dcfe8fe2236aa4af4e662e2a9d
-
-Len = 664
-Msg = da8734414c45fc1d5a75a3cbacadb1bfb523d6fc391f882d0db0eef21f9ffd78b6a1e14cfad09e71b65cf7b05d7e8f2f4bae4e454e16068d65465639c729cfa92738563d37edc9676b7be604ffbc68ec3b6b72
-MD = 8b328a31adf67dc7aeb864a359628410d5814a2f0cc683303f61432ce32177e1f538feead7e5000343916c7042f8b3cd
-
-Len = 672
-Msg = b228c75903d80fbc6d1cf629ff1d14a92ec4bf0e121fd97bd306ed265efe7a5d5c5d8fc764af98ed6f5978f88d7cd8bcd71cbef6a58261d201de3cb15b3161287e6a104cc2cf882d839f1da0d3f68b426cf08ab9
-MD = fc92ba4eac9a1bf120a7b6c2cc30335b9615b1a98e55d14854ff872966e71040737401c6bc08db5842ceace14cb7e7ea
-
-Len = 680
-Msg = c90d473a6fd30be9a98bf442a9ad65a697d4629c33cd517dbbed02710fa8ee991360bc8e557b0a0bf0b869e6b0c3a9457607580edec3859f2060c9c0340289d53a5d755918ca54876599045a86a9bcb8163795ea8c
-MD = 807582b2520e990cfb74367343268b9148b2519b9e7cd9182edb3db9ae7afebedfe8ca118130e2ef9d31af9081da8222
-
-Len = 688
-Msg = 6df8c5c28d1728975a0b766cd7de63bbe7f48c3db3e6fd5a4b8df6e3905cef0351f3d973b4f2a7eed80b0de5b85c877353fb9e930ad2679149ad4cbe69910e68d5500b096c5abdbf27d684fcfcf1a57f02769283d5a0
-MD = 7bda57d21a4434aada6758e282e612a4c0f41b242f9c790804d5bee25b81a821dc6f2a0ba56f1b3704802c9a6e153d85
-
-Len = 696
-Msg = 2cfc76f88cb6fb90927b69526ad5f03d6bd335f4f75b52b6a3c21e8f989ab0d03acb1ebe07e68a87c1b5607acf17d976e10ac4a3d30a8561d49a5e7ec720edace9f5f632b4bd63e104f4894a79caad2e1c31c736453485
-MD = e16670ea837c259e418d3c0e1eaad4948c3457e15b1573056e24da25bff5c66b7e95d24c6bc1b8d6c2b812f64adc9553
-
-Len = 704
-Msg = 3f05108c2f33d39b3aa9e73efbad4b011b4e9e9fba409b7611e7e03956b2f3e5e0aa86f68c4bfada5f9223a66d574b08f9dd797cdda8f3c32d8e01921711f4870dec676027ecc56fc2010b496e95cfbf071c820f21edf25b
-MD = b272bab680f3ab27de72d94df384323f8555f1d17facd2588ac8648def2451f82f9b99c05ead8316fd181a2cfb97483a
-
-Len = 712
-Msg = 1ffbe1aff0a1e7fa3e68be31a74612a1519b59397e7007ef61fc015f316d55b57be528cebcc2f09a2f22e3c5e4a6ae9612776b17ae87cd763c1a9eabe6846c5bcb347ffc99f10e3b5e64b29a9bd71a5e9b3c01a802715de2a9
-MD = f08bda9d6762607519d53fecb0bffbfd3ff2924854833a759d631e910c42ca86741fc2e290af42e94b94898609b91390
-
-Len = 720
-Msg = f755d6b5642378f2847893901d9aa91c54a4b7abb97c5c7184063e8f1e97aa2de4ad7ac927dd3cce770c906921e2d298f67cf9844e61bf104db803b265b86b821c5f4d901067d07b38764e3f6c95fd4f28e3cfe48d8a9694a8f3
-MD = f85e98ea054455242280854e97c4ed399b85ee7bc5c5fc3d62910a76f3a9600c3d904c832b70b58d7d998db8dc978135
-
-Len = 728
-Msg = 773577f3a642c4f13b1cb1f4103e9f6b2da86268a52f449cbb174c8349e3c0dc636ce85c373115a337eee26f7b70ba1060a79a1c76fd186399e6a5255db80f83b0be4a34ba876f7908840553ead380f3195507729d067ac2ee8eb4
-MD = cc27869cd7e63695d19082446b068b77dde4e8604f8c0e9ce20a1b71aa9eff1460f32d5a54476275bdee8e7621491f46
-
-Len = 736
-Msg = 651589927e17e1aef780690f3100a377f0179b18b31fd5b4418c84038573fc559b496a782beec3dcf6e9faf5aef676e10bbec34b1be5888fda49b91e02890d2524c5b369f8a54175f29dedf8156fff690cf186ec77104a798315033b
-MD = da846042fb908eee5f5defd1055ff3e57103708278d379a8681f58bedc6ef89670b9f957c4e0edcaa42dfd8cd49df6ea
-
-Len = 744
-Msg = 678652600eee42580f73623412e9c011cc02dec4d4cc1b79b27b6f9939695bf2185b2012ab0630f317d2e2de95dd69890e430783e99d7ed121c7c8da9ae70780b5aabf9022d1435cf5ed6da6fc6692c050c2b5f22b24fb1cf9135f9cb2
-MD = 8a6ae41c9bccc16eac4860bd5fa91205a86fbfd09692578f7f36b3c135d96f9e9001c192dbeda975f7375bd43a23ba68
-
-Len = 752
-Msg = 416d3fb7b401fa5e78cd96d479d8860df147eef03adf13fce1c61131fb89cc2ebc63289745bd7db9bef14571a55318496572dbe52b9b349ef59f406cecd68909f364325380bb75f3aa62503c84f47a55aa6b9c9b199ebe414409ff3964cd
-MD = c5f20542e0c0ac1eb433de6229fe5baccfd4502e2c2275439385efda6374a1d0fc50cd9bba4233d470ad91a3356ea315
-
-Len = 760
-Msg = 6f09e876c0b83c9934ffb777f006338c5142a31375e9b21cfea9a7de12998c4ea6708ff1fdf5a8ee6bb67c675ffd8209a10064e2d758a8734eb48f07f7cf3d43b09f1bfdc5d07a52b77079f23cec28bf863bed97c859276df7f7129fce71eb
-MD = b3c968f3025f87dbd5cd3d364bf673e62827c35889532431becd87cfbe2cc75b7ef45696d19cd3452d0e7c2b69d09544
-
-Len = 768
-Msg = 0dc2b226b3431c69a76addc018fcbda22bd72c8ff01ed6549596798bd950f361c489a09c95cee2dcfd6401208ae6368d6630026b417cc4718ccb8b42e8872937de66895fd09142c42f066bf0ef3ab2b03803a8185fb65fc7148c376ddd4bf58a
-MD = aa645a4f8f602411260ace24d381f3f5dff0000c246343eb528e3dd027cd743815737906ac5c74ea83c2755e56b99509
-
-Len = 776
-Msg = 8dc71c84c8772753c86ab6afd80e8d1df9b0d7e8d69ebe67fa883a82412c26738c3399cab95573b4d3c4367c85c81852d5a6564c0fc7caaafe16c05e62aa06cc9fa542ceb35c88fb6ab82c29d5dcd530f807d3f1c3bcb3974421101d1aa6ac112d
-MD = 12239813097124e6248e7dbec985a6a25f622b1d07295cfcfbaff33b847df7fd94265e439fa535f3becbdb576922ac41
-
-Len = 784
-Msg = 3df3edd9fc93be9960b5a632e2847b30b10187c8f83de5b45fcb2e3ed475569a8b2ed0784348f9dacce7b323c6b65071abd8b32d1022b1e12787bd4989d3c5ac329d576ccd7608dd336716532e9b4c7f825826fb2e343623ef85c6270619bf5e3b27
-MD = f36590f5211a9cf84eeb0a3b2e5dc1164e813191cda7cb883f3f4a074605ce6780cf2f1a105658706fbd2829db8a2a58
-
-Len = 792
-Msg = ced0ec6500cb891e6433d104ba5b1c1ebca397f3a5eeeaa0f0561729621ea50d4ae7ff1d0827178dccd84e4ca06d9891a90adbb7a9f4994ac947cf6296e71d2f49b826d64b123a7bf86f339fa4679caddbdf19cfed7d0206aa5f527a6b0cc00f52aa2b
-MD = c2c2d7d65d0b9108648e3233d15fc4e4cb62ed8fee9cdd18ab44b8486e2100fbe45ddcf74f46c15eb77fb1c893c12202
-
-Len = 800
-Msg = afa4a2c4fbaffe838dd149c78ea7851ea9396304b41806a093a90aae59c0c5bdb170cc9a7d22b90cbce52cc1b105108942df20c29ef3a913223b915e7ebc98ef135adefaa0f0a6441ea05920e868ce9d1ff6c8fe4dbec06a4849e5e55ad0627f9e09dfcb
-MD = cf6ef91d8567414f5c7f0b1f4ad09a976afc7c8327a382fca90f5a136b19be33100a664390a377f8d8a3015fb882125b
-
-Len = 808
-Msg = 00f65a485bfd381113d6e79bf9e0d5e518c891988c073ba198ac3a20f25c2c81619723e88a3c0ed3075075fbbafb6a7b61d3bc336a5e6d6f08d166c4861e6a3bdc2e49b2806b567e7e821a55cb674a6cd699f7dc61a7054a8ff3dec73eb667f59644346be2
-MD = 809c6b5d41da7cd10df90b02b193ac7d40cf2e46c139e9dbd208a988da2b25002cdbad1db2ecc1322da20b7d054e5fe6
-
-Len = 816
-Msg = b9ce382e1e82a873cc444248a3008c2cf64d18759057abe8f91c9d87f5dc83aa4eca0c51d30829b9a1d2712da1fac31f52942d77c9f20c2bf6d3751028d7d4f0d336d3dc92b27ec368caa4444b3180c1e37e98b58f25e647a9a6361f0b04cf78d17955766168
-MD = 18cd10b3ea907b3770e8eb91c974666e2da2525afe7020b872b3ec6689e5e1cd0059dd4fd49ce44d75dc4c8430c322d6
-
-Len = 824
-Msg = 6778d82f3a98eecdfac55ddeebc52476a070094fbd65831801fdd60f837d80d23b90d472c5f4e5ca6273a50f40154ea8fb94013f6310ad18800433a1d379c84bdf799a99e8c7b676fbcd29cc2ed66552297de7a6e565179bb42b70d48299e0925a1d72ca2c792a
-MD = 71f08d9333df5cb885fd23d6cbb1db84f9b55908d069df50fa4795cc713a18439bcab8daca078356f5c75a619f2f8782
-
-Len = 832
-Msg = ba3a54a77d7c2b8ccec6d53136cd48827c87acdd1cd86ad1f56e862642ea2e1dcb4093f85d60f7bd77160738462e6c3fd3dd9d3a7c5cf7e2a1d60f489f84471902179f21f656ce0fff089278ea14441e04e7af71891622565f44c428044728fcc686212a32a5d809
-MD = 3cc154f0542d8e3cacf9d79f231416816178a7ef2275fb257a48a2f763ffa2e15a33c27b970a416a057925aa0412d268
-
-Len = 840
-Msg = 7eec4f4f491b4eeaeb1cdbdb95e9511c2872372bf64a1f61cda1cd8032729c8beafd1edabf78036d80023c814ad8606106cb4e7f33f214c3e69c0f230e885474fd594f7f2444aa581e0c70ebf13073d89063eb81a43c5f608b2fc99fa1bcf5e2bfe62a6802e70c52ce
-MD = 2f8c5682a07438043e55f0b7759fe7eea5d9bdfc8b0f89800ebcf777bc05a941ea7f3cac45d4659de0f505d814590b6b
-
-Len = 848
-Msg = f3715b9e3ddd7862e15ee87aa23f1aaa0580591e55cff3fee9b49b42aa0c0cc8cfb8efa3eb96ffb72ab06b83d7b47b3d22a5772421cfc51214005150edf532af10138ad45758add459908601eccc3703e810002a2e4c6202e98d84281475d55d3de9f3d98809cce1f665
-MD = 04e7d55b0eb4bc3d3a21cfd2941dbb4dc44706588967186b40da54902aeea97b262c97f75e37ebe3cd60a804e7b9feca
-
-Len = 856
-Msg = dfd7d792e162bf7a889109550a0fc4c415232af0c0d72dcbc2595299e1a1c2aeae549f7970e994c15e0ab02f113d740d38c32a4d8ec079cd099d37d954ab7ef2800902cdf7c7a19fb14b3c98aaf4c6ad93fe9a9bc7a61229828e55ad4d6270d1bdbca9975d450f9be91e56
-MD = 08e5ef57d0c2aa23edfc75cfae39e6bc1a43b5db08b2e27bc9823114edf760367db9cf3cd9c3779755f6d39e219b7079
-
-Len = 864
-Msg = ffbc7c47f52e69f5c667f4ed578b46ff4592048f789081f3fb39321d0aa4627a6d4f261905649410a53a301c231fa787ae55c04f615a8f84196cecf2844d23007b44edd892649fc8ed10a2e855bf23fe8afd0b9edbb33296f5a7cf89f94634d9d1a2b8cac3b7f4e546f2329b
-MD = be10c7baf94608408a0accfbc8ce95e159d08d8ca75dd6c273f935947a7ec3463e10a58d3ceaa0b2198b0887a3a24a29
-
-Len = 872
-Msg = a39f202d866e8e96765fbb53b6772537dec043322f4a7475247036d7495c987850cef2a46218d3fab36e3bcd595c0aca5e98b9db14fa484ca8c9772dfa3839f7ac3066727a50b0d5c933d82f82f1220720e8063f08bc283f199c8a4f85c70043df4fe55e751d0d71df36fa43d8
-MD = 3b2664ccb555a1b1f3ec996860146ea75ef7f3bd62028a19c26f63339399f4275a07f3c064d34766ebe8e4dd532f6629
-
-Len = 880
-Msg = b2c8261853e2218dfa135cb5387810352b8962e94e9fdc8695b41e7dba6ad122d14fdd0d2360dcc039ccce8b37fa0ead6ccc85bc26261d47cbaa78b925c6e380fef1856fed31dc616fe16b2039b1ac85cdee4ce04c0497998b41321868db08e35f358606585e0bb8c3da9a3be7a6
-MD = 45b286f49fd05c45c921b7bfdbe2cb024441c372e07394dcccae0de834cd541f13a79dbb3e5078896e88438542bd2f12
-
-Len = 888
-Msg = a04f390a9cc2effad05db80d9076a8d4b6cc8bba97b27b423670b290b8e69c2b187230011c1481ac88d090f39154659494db5e410851c6e8b2b8a93717cae76037e0881978124fe7e1a0929d8891491f4e99646cc94062dc82411fa66130eda46560e75b98048236439465125e737b
-MD = e7089d72945cef851e689b4409cfb63d135f0b5cdfb0dac6c3a292dd70371ab4b79da1997d7992906ac7213502662920
-
-Len = 896
-Msg = f419494c3c6d0727b3395a483a2167182a7252f4fd099c2d4b71b053f94bb8b3adf3b51e8460cfec084ce9415c95798fbae4975c208c544645b54c44d2b97f2ecfce5c805be61f5ba1d35dcc07afdd51a87baa990506668cf710e18be9b0ebf943f366fa29c69f7a6616de72a3353b66
-MD = aead8688c58c6ba4e9cadb4756b465dce0fb06f1cfaa478197f2ea89414e47e9572034adfed160703c79b82b3fd7ab78
-
-Len = 904
-Msg = aaf7584d53006cbf2d2040e51b7feebd2bbf1e9f6d817cd8062a6a9680e7f10464eefeb50b07cb46b14b9b3fcb2caa3b9ab664490115d5919456613bf172b58c5388fd52646a5783535b88212717ef605314b70b8a085024d4ab1fcbe2be74609e4cbdec0730fabd3cd77151d647a3767b
-MD = e6e79d8c61d0ea9fc70dd4dec1fa432849c3396e717b170badbd87a4c7974efc590ab8c1183a6232beff14534f004b02
-
-Len = 912
-Msg = a467f77369730201f2812204fd63ad0d2757be580d937dfeb221a06b21ed3213531d936152a0c1f09f0ad5fed19fd11e80ad982c61203e86b2508279d91d99fa483e2e97a3d6a6ad2548a8da404dddb58344f4bdc1c9ea907088885e4f532d9c4c73cdfda43c3a9e4ce5a2809096593cfac1
-MD = 5a7508c2cc096bf65a4d4d337aea22008edb9a3bae869f94e09fb526a52c3368e9b28576fb950f078b7e43b5562120e6
-
-Len = 920
-Msg = 01abc90e9180fc9bb8ea67a405073ed6848bf33048076566476c55836bcb19d3e55e9400c5cc657bc7a95f1d703c390f5a8687e7cd7fe9138ea3837bfcadad6258a3eb8d65121fa8319bfde532aec0e694961bddd2b673f284124be5781100f40381b6ff99db92ea9cc82a4372e53924dac398
-MD = 96b209d7cb2c2033b38350744767fa5c253e1bfdb99fe8418bff83804df02248140fe3b77b0bfd4a79b51f70405a434b
-
-Len = 928
-Msg = b555d99056362bfc2bac2a1bbb71ba112d644e50b82b015e5a1ce3d9cd5e90b8b74b08d32119baa62abae251fc0015e400051ada4ecafce3681e5de727c20d47f5cadc663d46ac682022ca396a4b7ed1c413e0b72bd7eec4a0dfdc2a2185abb5d99afd50940528ca75ad89daeb9a1b61e15747f0
-MD = abd39f79d72c6cd2e8e130f3603032fe3cef4177c3563930096df1f10b87e79cd4e2059cf1b9f8252184bb26f659a5da
-
-Len = 936
-Msg = 14fb01ae9d6015ecb3e56d6ecdfa4bc0533186adf8457f5e4a5c57c687895f3db395d06ae7ffbd67ec41452009550dfc1878eec0df2eeab09e8665f7e59f9148a86b2bc695b36521a55b2302f2e869aac83f14d6feafc9e587322c3c44f052ea1c0578884f84f56307bc6dde31ba48118a0f62b6fd
-MD = fc9b9a95a8ce1c157720cb63101a7594df24f4cc74baf735b0ccf6abb925478ad507cd048d30cde1c788806f43ed3a81
-
-Len = 944
-Msg = 11ae0cbfee7bb3df90ce585f09b9cf8ff5bea69a68eeb6c22553f8ed118c9a61e7b752cc2c94f38766e63e1b891dfa05b23347b617d42fde3ec17eea6e76d3cb640bf8fa46586fb9dd5c4d9bfee04c4649571b781709f848ad7081afb6e2c746f071a551251050fd5df72ee65248ecdc24f2cbe74ed5
-MD = 3214b5feec925059149fa852e3ae285a6eb377df926504e2f824572a3aebd2050a20144e7bede7e7fe238ee83e69f72c
-
-Len = 952
-Msg = a5c4a47a04f4714269d5d922ba4694060aa2df49193720c819fac93bb8787ec55a107ac9a6602f0045fd2cc8e66744bf863ced91eeabe60e7d2c1d80276ecf3bbe91f1757096cf589214f3569c2c48bd74be7f8befddb28395814780a47c180a58b0d0276a7e9873d682f473e27de7275c925ede23b6cc
-MD = 6bd9e1303579d815f58e8c6c9855850133251778a632f7b312c4b3163b29b5ef6cb9511a08a31a237d9a7604afbfa056
-
-Len = 960
-Msg = 75264774af69ec7ee3125e205bd6d1cb8fdb22f7ea6dbe72d1f2c0f7e2205902796d75e379c79b11498615c21c9f52b8761a885eecc69d132b2b48c63bc074c3055ee5cc13f51d6c987e8188b030b837e8f754d40122b451f15b28cd2bdd576920e1de5806593a36d8e1e89b9ef3caefee5acd80b3e9c9d1
-MD = ffa9e4e856d06227c1ccb959be558309cc10633173f4b66ceb382923b52b9150acfb08a7393500477a6ee4425a827e76
-
-Len = 968
-Msg = 791a36d748695e62db5003a8ad367df1f051c1ac6a21d711823e8e069b546e3fa06ceeaae06de70a1de249e1dffd0d940edc6acac00c4c15504c02d4b0933658005423455f00023b01cdc5b681b6083379c24595518a47c654f5e1a10947df10c05a3d716b2a973faf98e1ee3b675816598bb8d4c2a3b06eb7
-MD = f8d33369680524ed6c6a716d4c502de3eac891f340f40e82e37501be1a90fb61d26e5daafe92bc6ef5ec0ae431168842
-
-Len = 976
-Msg = 74cd86bbed14d895301d8a54b2956b1c5cd1451eebab620b978d4ecef2cbdf7a14367381f5ee79281a773337740fb9f5853f4253c4b19f684341081d8f561b2ad773224151099588da90e04dddd565f67596c536d64c5b87e9480ad43601397507ad1b61ca0e349fb88f19feb48f770676fd562ee8259f50d0c9
-MD = 73ee8d29c30821dcdfa4441639f037fb6ba3a9ca596dc43428043785756608f6207d80b7f78e573174fb9dfd42f0b8cd
-
-Len = 984
-Msg = 46612e1a4d016c41700a3b5ccb38323353bd8da5b9942c9c9212df40b4bee06be362a15dad62c8b2924d789168b2d325fe35bd5100e1e29f1ac0fa7a60a94c9eee5a70cccbc75ac214b1946a5679cb523b378d5c690751b7a7a3b80d413712feae7024ce71d6295a3d5d16515c3622a052eb862ebdab81ca7fe3a0
-MD = cac13a3784225be03d526f9abc1eb50a762e72c0e01172a15d578801089e5c9f26e53cc00ff755909453e2964d7df838
-
-Len = 992
-Msg = 1a857c1f105d068ceab0b1e12494890ec196362a48b0200a0d75d712b18fb14bec6bb5b68a33b7e0b4fdc5b77142c29c6d9151b9f884f59551f476e5256986a653d4a468f28141ed954721f2cd02054df0438738194545ed70234173ac4988b7d62812de4f2feada14f68e3b41bc9948d4139f4fb4da5939f26c0261
-MD = b75d92b5cd3772846f7b68064a3567ae43e5010099f2b649f35087e7592aeec176646fc8c2629288944261cd35b5fcba
-
-Len = 1000
-Msg = 9d36818d0c5a008be7904d1917aa3eccb5ef4f38cecb8c4e63c4b2e9b4b091a3bf25b4ed0332445f894c2a4c258b749afa17fad03cdd41713a869f899ba9a085e73fa9474a58db7a950d3a2386b60f79495d8bf73e72acaffdbf65e1989ff9cc206ba8c46a368d8512bac7c7c191d713aca949d45df297b1b6594a1a33
-MD = a88da844579f3e3725d00daa8e1e287da4bfbb2d931ebe8d3b16021154be503341d6371d382ada744f86f5bbb56cdcfa
-
-Len = 1008
-Msg = 4ae50ed626ee60dc5ea556e3ce0d3c18b9e6225b5620814e8b9621acf8f939dd370ad9c7620d85e6d67a229f37f517d1b580acae8df0b5c9d29d756f6d5ebd3b63b554e556469b5b4f8e7113bad1559fb254ca827fcd00425d18b0be7f2b48c2544c48d90982ec624f490be65e893fa93ac9467f35a0a8e1b56d9a403748
-MD = f8cd943f429333c7c8d30a8576827f92c92ae18e0dbcae770601b79687bccf8c23e9e589dfeb45c3b9bcafdd545e45e7
-
-Len = 1016
-Msg = dbed7612448d46cbe0a384d1c93233f02ffd1c984ba765299518656d3723b766c1658d4b1e7047cdc729459e366ef9349efc40cbd990f2a9a24db7a5045e1dea12dce8f9d9f2aaed933f93031e7b8959ac5e7bf6bbbdf30b48f7eb783f8fe292371a2f245c5c94b4acae160767a20ce7c0ea7723d97691d8eedda9efd1fe2d
-MD = fb531a1ed181c732311e56f4b56ed91dcacc0dd6bf1eb4a44be6f87dd7cb1ef9dfb0310f4a79eaaa3f32bf3914d8624e
-
-Len = 1024
-Msg = 3bf52cc5ee86b9a0190f390a5c0366a560b557000dbe5115fd9ee11630a62769011575f15881198f227876e8fe685a6939bc8b89fd48a34ec5e71e131462b2886794dffa68ccc6d564733e67ffef25e627c6f4b5460796e3bce67bf58ca6e8e555bc916a8531697ac948b90dc8616f25101db90b50c3d3dbc9e21e42ff387187
-MD = 12b6cb35eda92ee37356ddee77781a17b3d90e563824a984faffc6fdd1693bd7626039635563cfc3b9a2b00f9c65eefd
-
+#  CAVS 11.0
+#  "SHA-384 ShortMsg" information 
+#  SHA-384 tests are configured for BYTE oriented implementations
+#  Generated on Tue Mar 15 08:23:39 2011
+
+[L = 48]
+
+Len = 0
+Msg = 00
+MD = 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b
+
+Len = 8
+Msg = c5
+MD = b52b72da75d0666379e20f9b4a79c33a329a01f06a2fb7865c9062a28c1de860ba432edfd86b4cb1cb8a75b46076e3b1
+
+Len = 16
+Msg = 6ece
+MD = 53d4773da50d8be4145d8f3a7098ff3691a554a29ae6f652cc7121eb8bc96fd2210e06ae2fa2a36c4b3b3497341e70f0
+
+Len = 24
+Msg = 1fa4d5
+MD = e4ca4663dff189541cd026dcc056626419028774666f5b379b99f4887c7237bdbd3bea46d5388be0efc2d4b7989ab2c4
+
+Len = 32
+Msg = 50e3853d
+MD = 936a3c3991716ba4c413bc03de20f5ce1c63703b3a5bdb6ab558c9ff70d537e46eb4a15d9f2c85e68d8678de5682695e
+
+Len = 40
+Msg = 4b5fab61e0
+MD = fb390aa5b70b068a54d6d5127df6a6227becc4d6f891fd3f6068b917a883c9b66f318fddb6384d10be8c7af0d3132f03
+
+Len = 48
+Msg = dad95a4b4d37
+MD = 3a2b40f453925bc3ce17d640757ee0e899390b4a8d984d0297c1bae6b60b9f2603bf71c323fd171011372335e5702e40
+
+Len = 56
+Msg = 121835fe3700b7
+MD = 7bd06a94acba7beb3c5a9b9e8769c3da6691c482d78b1e5c7619b36630eba4e596d11c410a4c87006f4716b6f17bb9a0
+
+Len = 64
+Msg = de60275bdafce4b1
+MD = a3d861d866c1362423eb21c6bec8e44b74ce993c55baa2b6640567560ebecdaeda07183dbbbd95e0f522caee5ddbdaf0
+
+Len = 72
+Msg = 8d45a55d5ce1f928e6
+MD = de76683575a050e2eb5ef95ee201f82416478a1d14bf3d96d1fd4efd52b1a28fed8dfee1830070001dc102a21f761d20
+
+Len = 80
+Msg = 5c7dde9b3894d73cefe1
+MD = f31b22115fa7178e78223e06aae870547ab93c6eb3c3910b0ee16e6106db55935d6c0eb820132a2078ece1067efc81c3
+
+Len = 88
+Msg = 967fa34c07e4945a77051a
+MD = f8f24d81c4f8f23ecb42d76ed5d2b34c9cbc1f0a97234d1114804b5999759f3131c741d5768cc928163503c5f55f594b
+
+Len = 96
+Msg = 2209112ee779bf6d95711105
+MD = 09c54bf533a26c7447caa5783db2ec7ef5e55752da7f2a2c4e360982a94ec1ca2cb6a157d34eed28de978b4145e17ebc
+
+Len = 104
+Msg = 20442e1c3f3c88919c39978b78
+MD = 50bc95b036e0f54d833032a80d45c2ac38b3d29e9c7f72a2eb14781e9241d2a4b8e8dba6ee6f4c9e46a758d5712dbd39
+
+Len = 112
+Msg = 4d43702be4f0530319555d7f1a33
+MD = 83c8f0bb762801eb26cc5115abebb657c18ff811de500b32b7a568a220a287e900b6c75224fe7429169fbd534cb588e1
+
+Len = 120
+Msg = 5e2a79a544af85f150f7a9d209fd44
+MD = 8051ebc9cabb052cabe07e4023e2140808b77d25b07b96d2e3c22393f71b116c1a1e41bf62e57f73ff67871da7c93cf9
+
+Len = 128
+Msg = e1bb967b5d379a4aa39050274d09bd93
+MD = 3b04f96965ad2fbabd4df25d5d8c95589d069c312ee48539090b2d7b495d2446c31eb2b8f8ffb3012bdce065323d9f48
+
+Len = 136
+Msg = bb84a014cd17cc232c98ae8b0709917e9d
+MD = 85227ae057f2082adf178cae996449100b6a3119e4c415a99e25be6ef20ba8c0eae818d60f71c5c83ff2d4c59aa75263
+
+Len = 144
+Msg = c3411a0592f1f4fa698815238997db356418
+MD = 233ac44170d9f452a1a0231622030b15c104ff8ecaa3fccdb9e9e5031fd5b4220186a8edd032849c8b93dc183a5c8627
+
+Len = 152
+Msg = e831b739e8eb9f787f63c0bb071ddcc9f44cab
+MD = 91722d4b7aecc211bb8a5480c6855f3b71be4647e1dde0380c23afaa03f45c642606a24506e0317bf51506a483de28ac
+
+Len = 160
+Msg = b8a7bbccde46e85f1223237d9353b78c3b19727b
+MD = 28ba69dc05e6e29de91924114d6c9fc7612f6d2a68b07fa001df059bcf98f7aa85389caeb966eaa299c79fe1fd1e40e3
+
+Len = 168
+Msg = cf391b8aabec6f81288c8b7b92843be23d2e847574
+MD = 121e5ef697df491a53d7bae121416aa653d759a37db9d0b993031b18a0ef160ed98842a291e1ba2cea8b998bc5eee0b1
+
+Len = 176
+Msg = 9d65d88bffed764c286f34894f991600d1a67d622382
+MD = 84b6e0d6a45329daf47a793418ed5dbde01336b4b9468bb69e5da61c42b691e6794e6ed0e8fb1b8e7d4cd3cbaadc520a
+
+Len = 184
+Msg = bab6ea46fb717f73f0628132a2b96be383774f1e5d8b6d
+MD = e969aca1b50e928cad29a0d756457f6de8d7a4e589fd41e53a1e758c3b20f9b81b36bf098a49102fbf869651ca9a98b5
+
+Len = 192
+Msg = 8853b00e869764adb527a07b073c85a24e6c208ba47eef4e
+MD = 09ad44e85ac190e2d1c3ceb4efbea10ded34d0de961fe4ee268132c48e38660e6cf585bfffb8f7b00b0fad1514312b63
+
+Len = 200
+Msg = 71fe1ba5d299495d2a56039c64032ec6263d437f55e3f5bedb
+MD = b41a5d3b4af6d4b9c349e0788538e9a0311086894df7b72cf5aaf4091a7e039e4e89cc77a123474e6d1bac438e5e9f88
+
+Len = 208
+Msg = 4ebe07d03c93e849b4bbfe9f2d2294bf6ccab457f76d3f99cb64
+MD = beba464d7065185587fad89bfcea9635bf0ab775c3eb8c147b5b2bd8601db6dba0590b50dd1068733f20dc68e004a090
+
+Len = 216
+Msg = 918ac0a97ec1632908489e5242ba284bc811aa7197242cf7226fcd
+MD = c4baf6397a4c6e26492b63a4aab7dffdd0051d8f51938ac24cfd8dae2f7afed1a4aa2430d7aeb0be2a72b21a6c50198c
+
+Len = 224
+Msg = 97477f7272d8a89e38e796c533e9f8a8ae4c92ccaa5d907ed26a1a15
+MD = d1ad524ebe908d7c5aff50e6cb780fd3a70e87c914a36b93c4e35f5b2cb03850b122b480ef8587d4a44f22467f4c480c
+
+Len = 232
+Msg = 718e0cfe1386cb1421b4799b15788b862bf03a8072bb30d02303888032
+MD = 6d8b8a5bc7ea365ea07f11d3b12e95872a9633684752495cc431636caf1b273a35321044af31c974d8575d38711f56c6
+
+Len = 240
+Msg = d3b07f0fd5d4cd3188aead8dc8338de42056e2e8487eca51ec37ef2daf27
+MD = adcc2e954c91db3db2d71d0dee1f030e723bee1a23816fe003ac5dc862a0872ef51ff386c18be6ebcaa493f32d1195b9
+
+Len = 248
+Msg = 695b9efe1809abd5d44eae957ddf9c2cd3c75fae2f522855712a07c639c0b9
+MD = 3bb95d164d94595a1187f77fc26c280ffbb08e74ec7947aa3e5b38bec7c6f8115c4d880788c2402dbb3e5b94afd130ee
+
+Len = 256
+Msg = be01e520e69f04174ccf95455b1c81445298264d9adc4958574a52843d95b8ba
+MD = c5cf54b8e3105b1c7bf7a43754d915b0947f28b6dc94a019182929b5c848e11441c9e4e90c7449f4c3cd12954f0f5d99
+
+Len = 264
+Msg = 98ef7301f957d73d4e821d5873e8a9b5970fbd219d5cf74ec2291b8381181391b4
+MD = b2564bbb159c3aeadbae0e4a4437f7c5111020e9ad0f4eb508147a961ac22a01e1a26df046b14ee5e8a49d9ed22b8cd1
+
+Len = 272
+Msg = 873ba7f8b71517ec50297b21cf94cdb7a58abbb8829206f0d3f328ff8a6939ac1d1d
+MD = 7405fdd557d2b5d4f65e9e85f508d3791495f1820d37cabfc8dbb74d7b41df8613d995c612d378dd88337e00951d0280
+
+Len = 280
+Msg = e3bd4bc3a60cddd26c20aa86364bd44f4a07f3302825ad0ac127881de4eafbccf988cb
+MD = 199d5423a0e26438f4cea0081a89e0b6c84ca93f7c3120c8104b51c6edc04e0f6a203bb77d59973a7411a0efbe93a09d
+
+Len = 288
+Msg = 8716e4b86deff9da2a8ed55baa43582a7586ec9cd38ac3a933156158cd8e5b7887585e91
+MD = 0d2306d9c0a8ce57bc7869b439376c07ce352a41d86ab6cf4a5654cccd5c724fe1b62b2c1101c986222f5264ab3fdd66
+
+Len = 296
+Msg = f8a503aaa25ef2cea25e31930c3a90db468cd3a862f4a93aab5de2777e82dc905cb03ee23c
+MD = 773ee958fe93dfd1b73af24d27ddce33144a9249d5a671682a56df30d0bbf92b9327130022075185d396de752959304f
+
+Len = 304
+Msg = 669025175ea917cdd7a71ff4ec0c45bf1246d2a6f031c00b71de701e17939bfe92128b21911e
+MD = 9ff6be3f02c7c5d0206f4b944c0843cb68bea8f9b7c8cc0b729503db5005c7cd5cb14e3457d8f5eabf733fca9084f16b
+
+Len = 312
+Msg = b35fb2262edfa14938a0fba03eb2a25d377974b11f556491a781d0ba2b3c0ff3e42749925fef8b
+MD = 835b05a4bf00c2594c3c8c13da6c273a0d9efdea0da72b71b19d326bf5ce968c2e577a7d99fc0f985afd23b46423129d
+
+Len = 320
+Msg = 9d86b45df8d7dae0cf6b0bc208666ee1163a39e6116d6d240c9dc1c3a3c1db1dd3b1c6680fe9a196
+MD = a84c469c24696f81d7df4ee8cd76aa584f8c9960eaa9908d3e3ebc5eea7d0b50afdded39deb94fd59323a21a6539e93f
+
+Len = 328
+Msg = 414f5619f6dfd45853bbabd224cc305d77350ad253358910a74f3a4381a9b86680b3c4068c089849c4
+MD = 848d481e3bbf5dd726f625cf6a444d995b36262c9f80d583b77accf1707e3f49bb3dc480a560694d769aa1ce65d69428
+
+Len = 336
+Msg = e2658324821ae7b0faa0cdd63ee9efb9fcbe82092d04696feb3da92c82521dfdc98f6b41b3ef365d219a
+MD = 3ea5d0799f1a4dcab9149a40ab74bec9c8d76d8e392c1e63e080ddec2ec535f80be9f00927be281ec97ac0c882bb0bbf
+
+Len = 344
+Msg = 7e80271bb5f2cc7ddae4158658e4e8d06e04a39385da0ecac1cb8e91d68a9bd21ddb7320e79d10e3110758
+MD = fa00bc0359a642dcb3559656094eb2fd4f63bc57f0d34abff26df5c54cc63dbeb4eac75905296e7fb69f871e134083f6
+
+Len = 352
+Msg = 43d2828e86f7856b78c66cfa3d602387c290975afd021a8b76af0918069cac35dec45de3cc52edc4ba14432e
+MD = 6c9e367e066032ce47ba2575565932002cc786f533c5551656abfe7391e7dcb5f9d9e047adace23d32f8acedfd0cafc5
+
+Len = 360
+Msg = 3f49bb645cced7530b8b82e6cf07fbf670f7ef0ba0583d16debafc639bdfbfc99b8417249f7f5a05410aa3a71f
+MD = 2b301a14647a67429cc3e7da02c4093a739640f7b47a305251d2855e75e09e60e262b279a073077d1fb6d0f04788f2b8
+
+Len = 368
+Msg = 31aac06a59b74bf478617c1637fa6c5593df168b8d58b1e923bf3e3d80e55d7170b16454160ab29ee1f7412ebc05
+MD = ddd245c9b29ceac60506fb6bd6e8037889cb73d6ecc669fd129060a8a8f58971ac572d3ec9b44404f81381d0fd35a649
+
+Len = 376
+Msg = c10b2852054d8034e07906c7fce3ce99402321a648bb881f13fb276afc224c6aecc64800cd767ed2429db94b95a9c3
+MD = a44640fb4ce6dfd4a10290a0aecdb453054a9b54f2583e97bb7dc2b005e5fa2b4fda17b1f75902f51c18c0caad35833c
+
+Len = 384
+Msg = b1eeef324b499f19eba322215fe3ce19c9f000b698d2b2dab7145015046cc86d049ee15ad59dcd1564f30112e06444cb
+MD = 38742d18bfa6e918b888d68d1034e61f65dec0759172c2dbf08cf1e132b217eaf4ec29e15db7f4b07e08a70cc5662012
+
+Len = 392
+Msg = 790dbba09965c9774dd60a32e010c50d6d518968a220141dc33e7410f2da6c08ad0419bd9864d5327d2c5c44914b2e83f9
+MD = 9174958bc8f4ed4731eced999bea2f63032f52bc8c46bcd903232f3fbc5046f0d6c203d43a078b822fc05101404f2635
+
+Len = 400
+Msg = f7b577f1396b23c27eb637e53d3d92460270b001cc612fd3b4d68bcdd09c2d50571ea4350636324cc2428a087e7bd8785f82
+MD = 80afe111e44ad9aff9e39c4cf9e6b4c520072b4550e62b1740160a04f8d530612dc098917a556b44977d0e73df518bee
+
+Len = 408
+Msg = 7370d9b453936955b9c9d336f4b283237986232de007bf412fb426ff5b4093c80c428c19a12e0b187484dc6d5f4746537fb1ed
+MD = 6cd29159820d34e5706dd867e6363758d312660d4daca8d2abf677f234746e97a0a6224eb054066a0b74e18c70965368
+
+Len = 416
+Msg = e8620170f0f39328bdf8888148cfd17730f314ea68d8fea02d16d98a3cca61484139d3ee92b748091dc841dda08483f1184025ce
+MD = 29c408a6a5045f397b56dfb5292c7c16028c63f068e699b86a891ff8501208ec9398dbaf463c00f39af7b2cbe45bac15
+
+Len = 424
+Msg = 75d4216bad77943bfe82be216157843b0da0fd16eeee847153a00b43e707b2ffe2c898168081f0bdb3af58f214cf67b920c385aca1
+MD = 0170357385a20865a8d30c2df39406903ff88c7f70fa1a7a5aaa86711d64046c432a1b139668ae5abed637d1dc4107b7
+
+Len = 432
+Msg = 2fa90c2210e3096caed122b74eb9559977120e5d9a97eeb3f99bcba6c19cf8cf791ac6c8a0a94ae49246611dace7f24eb05673a36b3e
+MD = 6c2ced3fae94dbd92f4170b63f1ff6fcd8194f60937b22b4f3c95fc9e104b77148f9bc6c16a890de86d9ef1554c96fa0
+
+Len = 440
+Msg = a8de55170c6dc0d80de32f508bf49b7046aeea4b975a511b5ea3dc853bfa4b1e0138202d6785f6b3017914a86f824288d586dc0e8bc924
+MD = 2bc3b10c148200f7919b57afe1d7db773ffd235e04fec6897dd94f13ad9c437ef50900a40937f82a39daf2aa2b3dfd68
+
+Len = 448
+Msg = accd9d05fb7ef3043470836137554af117440b3ccca7a280285494f90dfaea60dcbf40b230271932cd3875b1d3dca60d38865ff874180efa
+MD = b9e02df93e9254180d6a15288d77088b5a5ce517644109b4e2532be315f08dee43491608a1127dcdf69397406e23d231
+
+Len = 456
+Msg = 32b835c180cc4006c11a61c65b03c099510e1d4f0a94b63d54bd6bd5a8ab207ab0f4639206564edc3fa6af03280a67744f68106dc51ee35723
+MD = df97a1c5dda6f9dde749f213e429db84f0dcd481d43bf58e6142968d629ecf05b262830a7dac87f67f4383975f3e821d
+
+Len = 464
+Msg = 9409f9efadbf190b253367629f8f368c9d5ac262e94ab86f3559f9a1fe1a9b44b64e313121b34d43001c430bedc62fc586ea398acd8f17c7cfa2
+MD = e1a69388ee6b6d234108ec29402cd0afd74957d990c7bdb544cf11e8eb2ccd170b6b5a74431be70364d7a31b926ff53c
+
+Len = 472
+Msg = 289586baf8daced50db14c936529a0a6438eb5da8d3d469172b6a06f4ff3a956d4f9219563ac285cb8e70074cfcc152c02593a97733c36f4a9e97f
+MD = 509e996c1e11611c243021b8b78f2ad90c5a9263bbf35910db7c8ec102aa7c518066fff8ce88562fec2cd6dfe04056ae
+
+Len = 480
+Msg = 156530cd6ed3baf1fd7232c7ff204f3c7d4d106016afa3bdff3786e84843ec556115626fdc84b2e874f1074e4f7d53e08079ee9fd01f80a8be7f20c0
+MD = 7b8a598029ca0ed475a72c0644ac81c63d72fd51305dada07b0ab4a29e47422f59e12643179269ca3d7d10446b372b2c
+
+Len = 488
+Msg = 30655a6b5a5965db992e7248d24141055e988d726abb8e729dc5c21ffcbaedbc0b1b5fea35b8751f6ec6625517312fff2234014176269b60959723787c
+MD = cfaf443e95deeb3cc1910771a2c0692a54b18b3633dc5414e71ae08877f0804818f67f7196c52e26b762dd12bb7a86ca
+
+Len = 496
+Msg = 345c3c022e20144e135604078762ef5c8a8f038cf1b1d6a91709b59dd068396a9e971ab628f74886e765384a23607c1a1e6e973f8fbb0ff55104c46f5db3
+MD = bfb1d5ee3a0b629058ecc521c706c2f9241c48cda3dcfdba660a2601d832a7a872a2bb840f3b98d21c37e28f9041a5b2
+
+Len = 504
+Msg = 0b94a0f43a92408963a59ded01a9338283a6ff1bfbacd9051a0104445c7f041e8037afde3b5a87d22d5a4796144cbc944091d6cc47b5ffd1f997ab1496ca31
+MD = 07a045c9590e9901d0598e604c4649554a823de996fa438cc81a634344eeb98e5f3c0c234ba30e2285a4d7ab568f2610
+
+Len = 512
+Msg = 93035d3a13ae1b06dd033e764aca0124961da79c366c6c756bc4bcc11850a3a8d120854f34290fff7c8d6d83531dbdd1e81cc4ed4246e00bd4113ef451334daa
+MD = 8d46cc84b6c2deb206aa5c861798798751a26ee74b1daf3a557c41aebd65adc027559f7cd92b255b374c83bd55568b45
+
+Len = 520
+Msg = bfb94dfbe0d9a509b78d164a722050054dad91c9a8e260545d037eb450321aac48ed4459fdd8a41572bd6c9c84d18b6ec339247482cc3ee52a1bbd6bd4ae918216
+MD = 13af0be02986ea3176e8c65534ec9f32c23b53c93a73b15c26b9ecbd8a1181ae184a372e9f5e0596cd6606849aeae8e0
+
+Len = 528
+Msg = 1c8924a16fa7c602aff5ee961798bd44fe53798bf44c3d6b0d13ef837de07377651c1e94ed236eb79349f86ac31ba151a7e711c5407e65beb63824f6ec39754b58f3
+MD = 5be6482851ddafde582f2804071a702ae39bacb688741b7c37bbae99821ce4d3f47d5b097fd8eefa0ef9248a34f5d3ce
+
+Len = 536
+Msg = 184215145da49db417e8bdd573d6282de073e674c3dea86b6c78591d4947f5655a9d9eb0e5f4ed046b1d8642da9aefa80448a299504160a1b000c9b4d3c62ab69b3d96
+MD = 8995cd7fc0956e124075440686beece17a6256b282e7988a0c998f790e3995c974383179893477bcc32d1f114129b496
+
+Len = 544
+Msg = ca7a63adf41f4da33142910c967706b5c8a093350eb3e6d3aabe69a46a2872f47a39bbe77cdc1160daa450225b0e8e36f506978ce3ac9ae5f75721ef30da46b28f07242c
+MD = b89cc12b11e3afa58908580c47b25407abbf584f8e8d4b5631e9f450464c7e53cfd7e9f9d3cf35e587a6f02957ce4c28
+
+Len = 552
+Msg = 1da41a0af202b079521deb6109e312c2ade48544d2b498c07e91a102dd4650ce354f3f201b3ecab8e85e21d667959b43d08f4e90fa18dca2ccca8f6ff5e9a902dc8bf5c5da
+MD = 5c297e20c307aab7f325939fd4e2883b034fd547f1dd17fb6b97ade8b148e06ebbf3ff60cbf469e4933d5f48f0166cb7
+
+Len = 560
+Msg = dece42c8849be40c78b8de6da96c2a8d7e940545b9f3f39aa1ca03ec60a85471aa84d8e29f095874f331b90a4c157da9eb048d2c8fd235399672707366c766f10bb833f02183
+MD = bb509e33e9ffcc4c01233146226ee9364cdac5658132460a76edf617a035b197c86434ee889438581458102618769382
+
+Len = 568
+Msg = 952008ebdedd480449bb96a025576c5f617bbb8307958a010767e0d736ffe5a196ea4467d8a5d3ba1f5476ff07b6410ae659dcef520a2c14e3902f8b399a289f41f5fdadb502dd
+MD = 9b63d9145bc714a8253dcdb8341b2f5714eb58b9d4b22ce45aae07f51297a3dc9c5b691a8a3cd438dc5bd18be400af21
+
+Len = 576
+Msg = 100132c315bfc9c4fb93023f5d3500d7208a68acb4d2c63096232c361a161c4c67c0a74bc3e4d72c11664b1d970321d405401924b3a0f6ce2b1a2899e7caa9a55ce725fc37f55d6a
+MD = b6ca04467ed3e623dba36f2e0248cefbe134cf555fdc14731175eaaf08e244ab0b15fca2f173a0ec98feaf359fb84a11
+
+Len = 584
+Msg = 99cba4019f5478789e674e08fe5d6ceadd698b0757ca39c605457c22c3d3b8ffb797d2be8f12960f099a5606b908d47207b2636a779948282de3661bb08b1b37ee576590800a492730
+MD = e5378c7c251ae96f0359a30b3134fd77d61d0db68c42a1a2aac293195a596df42f677e6cb98abec90d6722baac63fc86
+
+Len = 592
+Msg = bb327a0bcb2574df47080e8c0d8a45ee1c0424ae0414dc0a9b8717d9f27d8ac987c7c9ecbc946073884d1fb96dbdb583aa758186b16fa429dbf15b8d5bb48cca71469e7ce0ad8e7fa14d
+MD = 0f75e65ff8494ae28d9a0a2e65959653275fc34b2fa27b9e10faafff07c45addef3b8f25953d5a2e54e31ebe6d429d26
+
+Len = 600
+Msg = 7fd9eeb5ff368040d299fd17a943b21d65deb2eccf6128d18a33eb174693538935374c32c333a867821dba08636f20022c2ce01826c7b7e41640ad186f90ed0ac647d47086744867e5c54b
+MD = 007251a2a577add048b1edc79d96c7df8fd5b5fa0d7264f122e4cb54c50bc316a8bc5f4f9dfd4469e29e9b030f563a6d
+
+Len = 608
+Msg = 7ca9e369e82186984d5fc729e111a7e5d8ec19c5d74e13b5ab22e4993b05c88ebba6ba72237389a6e0722e12c96c5d6a54515ab00ad80efb38665a76e831abab0fa5cf020807078441585de5
+MD = 3ee8c4184de9ceaecd0d3aea16271835f3d45c873358c93a515539c38e819414ea63b08d0a109346793d5e0f703125eb
+
+Len = 616
+Msg = 5b4d945d55dea22e37821ec396476a4bfb617d2f392ad93afe67bcfda9cd9b725bc4ccdf516a83fd71dbff5a22b005fc61c58e471240bd2193ce13539730e63232f70f80308be48dab7266a1dd
+MD = df82d242e4cdc2eb40bf3db6a56e1aa0a66e553f1914bedc65c8cc6ad9564b6e85df59f4c443cbe4e0aee05986f7d690
+
+Len = 624
+Msg = e865f4a42bbbd0b73fe275b8ab90d3a9fb74ec5070192d38f60efef9564498b9adb716f31d50cf77c20ae4b2e85515307bb8d95fbeb9ad964001ac550dbc60cf213fd8a522edfaf54e5b1b93b2b2
+MD = 091fa9ae2184e2268ef9ef23c7c809efad244536e00aa9e8b3a6c228d90e31da051b40f268a13bd6f62e69c91ae8cd2d
+
+Len = 632
+Msg = 1d408c7b68e168f41bb46f9b2e9c8b04f968e4080252546814cc1cb2917dd5690886a9600a09c2673aec0329a4daf655508b06fc1646ef3bb3a472191d964db214a96a96fa89576ce4c4f6dbf1d176
+MD = 7e23472c03431925f3b4559d886e8d5d837b3d39b8efe1b7a91e61a13810c4dbc2439634d7c6ababfc66e9b18e6541db
+
+Len = 640
+Msg = 54ae030a4e27a05c1ea4a12e69c67544af9b4044cf157dc8cebbe8b2d49f9bc0779077603c90c5c55b891d3ac33b87b65e79e1b19695813718191b3bd8b7e42d5583f7cf1e60f84495b8f869f3719969
+MD = cb65f823585773cb8802b6339182f13752a82864c898b445be5a11a969657ac2dc4a3bbeb87ac0abb232a2b124171096
+
+Len = 648
+Msg = f73cd386f73d0c6ade05771b33117117c602e52693f05b47e90032eacc39295f9793258fe6512eeab291baa0be222e143295a28e8697e42fa27ec02b44217f32a1edae2f4f35213562ca37b6d6cc5ef72d
+MD = f665c4d17a83d65a7ff16bfce279b58558250d76af68b8eb943753e411a57ceb31c1a131e54bcb7672584416e3d5719e
+
+Len = 656
+Msg = 1d259612e6867e7d788c71d03c5136864ad6d84f24eaf913a34e69333116f812395288d4dcee6665e6d7dabd005ffc6327e3ca305cab78569d1107a115e619fc90110436317925066726774d1da3639c31a6
+MD = 5dcf512e2b93d6ecdf7c3304534554ea79d22392e59bbe90df21e978c9fa3b34ff82e6dcfe8fe2236aa4af4e662e2a9d
+
+Len = 664
+Msg = da8734414c45fc1d5a75a3cbacadb1bfb523d6fc391f882d0db0eef21f9ffd78b6a1e14cfad09e71b65cf7b05d7e8f2f4bae4e454e16068d65465639c729cfa92738563d37edc9676b7be604ffbc68ec3b6b72
+MD = 8b328a31adf67dc7aeb864a359628410d5814a2f0cc683303f61432ce32177e1f538feead7e5000343916c7042f8b3cd
+
+Len = 672
+Msg = b228c75903d80fbc6d1cf629ff1d14a92ec4bf0e121fd97bd306ed265efe7a5d5c5d8fc764af98ed6f5978f88d7cd8bcd71cbef6a58261d201de3cb15b3161287e6a104cc2cf882d839f1da0d3f68b426cf08ab9
+MD = fc92ba4eac9a1bf120a7b6c2cc30335b9615b1a98e55d14854ff872966e71040737401c6bc08db5842ceace14cb7e7ea
+
+Len = 680
+Msg = c90d473a6fd30be9a98bf442a9ad65a697d4629c33cd517dbbed02710fa8ee991360bc8e557b0a0bf0b869e6b0c3a9457607580edec3859f2060c9c0340289d53a5d755918ca54876599045a86a9bcb8163795ea8c
+MD = 807582b2520e990cfb74367343268b9148b2519b9e7cd9182edb3db9ae7afebedfe8ca118130e2ef9d31af9081da8222
+
+Len = 688
+Msg = 6df8c5c28d1728975a0b766cd7de63bbe7f48c3db3e6fd5a4b8df6e3905cef0351f3d973b4f2a7eed80b0de5b85c877353fb9e930ad2679149ad4cbe69910e68d5500b096c5abdbf27d684fcfcf1a57f02769283d5a0
+MD = 7bda57d21a4434aada6758e282e612a4c0f41b242f9c790804d5bee25b81a821dc6f2a0ba56f1b3704802c9a6e153d85
+
+Len = 696
+Msg = 2cfc76f88cb6fb90927b69526ad5f03d6bd335f4f75b52b6a3c21e8f989ab0d03acb1ebe07e68a87c1b5607acf17d976e10ac4a3d30a8561d49a5e7ec720edace9f5f632b4bd63e104f4894a79caad2e1c31c736453485
+MD = e16670ea837c259e418d3c0e1eaad4948c3457e15b1573056e24da25bff5c66b7e95d24c6bc1b8d6c2b812f64adc9553
+
+Len = 704
+Msg = 3f05108c2f33d39b3aa9e73efbad4b011b4e9e9fba409b7611e7e03956b2f3e5e0aa86f68c4bfada5f9223a66d574b08f9dd797cdda8f3c32d8e01921711f4870dec676027ecc56fc2010b496e95cfbf071c820f21edf25b
+MD = b272bab680f3ab27de72d94df384323f8555f1d17facd2588ac8648def2451f82f9b99c05ead8316fd181a2cfb97483a
+
+Len = 712
+Msg = 1ffbe1aff0a1e7fa3e68be31a74612a1519b59397e7007ef61fc015f316d55b57be528cebcc2f09a2f22e3c5e4a6ae9612776b17ae87cd763c1a9eabe6846c5bcb347ffc99f10e3b5e64b29a9bd71a5e9b3c01a802715de2a9
+MD = f08bda9d6762607519d53fecb0bffbfd3ff2924854833a759d631e910c42ca86741fc2e290af42e94b94898609b91390
+
+Len = 720
+Msg = f755d6b5642378f2847893901d9aa91c54a4b7abb97c5c7184063e8f1e97aa2de4ad7ac927dd3cce770c906921e2d298f67cf9844e61bf104db803b265b86b821c5f4d901067d07b38764e3f6c95fd4f28e3cfe48d8a9694a8f3
+MD = f85e98ea054455242280854e97c4ed399b85ee7bc5c5fc3d62910a76f3a9600c3d904c832b70b58d7d998db8dc978135
+
+Len = 728
+Msg = 773577f3a642c4f13b1cb1f4103e9f6b2da86268a52f449cbb174c8349e3c0dc636ce85c373115a337eee26f7b70ba1060a79a1c76fd186399e6a5255db80f83b0be4a34ba876f7908840553ead380f3195507729d067ac2ee8eb4
+MD = cc27869cd7e63695d19082446b068b77dde4e8604f8c0e9ce20a1b71aa9eff1460f32d5a54476275bdee8e7621491f46
+
+Len = 736
+Msg = 651589927e17e1aef780690f3100a377f0179b18b31fd5b4418c84038573fc559b496a782beec3dcf6e9faf5aef676e10bbec34b1be5888fda49b91e02890d2524c5b369f8a54175f29dedf8156fff690cf186ec77104a798315033b
+MD = da846042fb908eee5f5defd1055ff3e57103708278d379a8681f58bedc6ef89670b9f957c4e0edcaa42dfd8cd49df6ea
+
+Len = 744
+Msg = 678652600eee42580f73623412e9c011cc02dec4d4cc1b79b27b6f9939695bf2185b2012ab0630f317d2e2de95dd69890e430783e99d7ed121c7c8da9ae70780b5aabf9022d1435cf5ed6da6fc6692c050c2b5f22b24fb1cf9135f9cb2
+MD = 8a6ae41c9bccc16eac4860bd5fa91205a86fbfd09692578f7f36b3c135d96f9e9001c192dbeda975f7375bd43a23ba68
+
+Len = 752
+Msg = 416d3fb7b401fa5e78cd96d479d8860df147eef03adf13fce1c61131fb89cc2ebc63289745bd7db9bef14571a55318496572dbe52b9b349ef59f406cecd68909f364325380bb75f3aa62503c84f47a55aa6b9c9b199ebe414409ff3964cd
+MD = c5f20542e0c0ac1eb433de6229fe5baccfd4502e2c2275439385efda6374a1d0fc50cd9bba4233d470ad91a3356ea315
+
+Len = 760
+Msg = 6f09e876c0b83c9934ffb777f006338c5142a31375e9b21cfea9a7de12998c4ea6708ff1fdf5a8ee6bb67c675ffd8209a10064e2d758a8734eb48f07f7cf3d43b09f1bfdc5d07a52b77079f23cec28bf863bed97c859276df7f7129fce71eb
+MD = b3c968f3025f87dbd5cd3d364bf673e62827c35889532431becd87cfbe2cc75b7ef45696d19cd3452d0e7c2b69d09544
+
+Len = 768
+Msg = 0dc2b226b3431c69a76addc018fcbda22bd72c8ff01ed6549596798bd950f361c489a09c95cee2dcfd6401208ae6368d6630026b417cc4718ccb8b42e8872937de66895fd09142c42f066bf0ef3ab2b03803a8185fb65fc7148c376ddd4bf58a
+MD = aa645a4f8f602411260ace24d381f3f5dff0000c246343eb528e3dd027cd743815737906ac5c74ea83c2755e56b99509
+
+Len = 776
+Msg = 8dc71c84c8772753c86ab6afd80e8d1df9b0d7e8d69ebe67fa883a82412c26738c3399cab95573b4d3c4367c85c81852d5a6564c0fc7caaafe16c05e62aa06cc9fa542ceb35c88fb6ab82c29d5dcd530f807d3f1c3bcb3974421101d1aa6ac112d
+MD = 12239813097124e6248e7dbec985a6a25f622b1d07295cfcfbaff33b847df7fd94265e439fa535f3becbdb576922ac41
+
+Len = 784
+Msg = 3df3edd9fc93be9960b5a632e2847b30b10187c8f83de5b45fcb2e3ed475569a8b2ed0784348f9dacce7b323c6b65071abd8b32d1022b1e12787bd4989d3c5ac329d576ccd7608dd336716532e9b4c7f825826fb2e343623ef85c6270619bf5e3b27
+MD = f36590f5211a9cf84eeb0a3b2e5dc1164e813191cda7cb883f3f4a074605ce6780cf2f1a105658706fbd2829db8a2a58
+
+Len = 792
+Msg = ced0ec6500cb891e6433d104ba5b1c1ebca397f3a5eeeaa0f0561729621ea50d4ae7ff1d0827178dccd84e4ca06d9891a90adbb7a9f4994ac947cf6296e71d2f49b826d64b123a7bf86f339fa4679caddbdf19cfed7d0206aa5f527a6b0cc00f52aa2b
+MD = c2c2d7d65d0b9108648e3233d15fc4e4cb62ed8fee9cdd18ab44b8486e2100fbe45ddcf74f46c15eb77fb1c893c12202
+
+Len = 800
+Msg = afa4a2c4fbaffe838dd149c78ea7851ea9396304b41806a093a90aae59c0c5bdb170cc9a7d22b90cbce52cc1b105108942df20c29ef3a913223b915e7ebc98ef135adefaa0f0a6441ea05920e868ce9d1ff6c8fe4dbec06a4849e5e55ad0627f9e09dfcb
+MD = cf6ef91d8567414f5c7f0b1f4ad09a976afc7c8327a382fca90f5a136b19be33100a664390a377f8d8a3015fb882125b
+
+Len = 808
+Msg = 00f65a485bfd381113d6e79bf9e0d5e518c891988c073ba198ac3a20f25c2c81619723e88a3c0ed3075075fbbafb6a7b61d3bc336a5e6d6f08d166c4861e6a3bdc2e49b2806b567e7e821a55cb674a6cd699f7dc61a7054a8ff3dec73eb667f59644346be2
+MD = 809c6b5d41da7cd10df90b02b193ac7d40cf2e46c139e9dbd208a988da2b25002cdbad1db2ecc1322da20b7d054e5fe6
+
+Len = 816
+Msg = b9ce382e1e82a873cc444248a3008c2cf64d18759057abe8f91c9d87f5dc83aa4eca0c51d30829b9a1d2712da1fac31f52942d77c9f20c2bf6d3751028d7d4f0d336d3dc92b27ec368caa4444b3180c1e37e98b58f25e647a9a6361f0b04cf78d17955766168
+MD = 18cd10b3ea907b3770e8eb91c974666e2da2525afe7020b872b3ec6689e5e1cd0059dd4fd49ce44d75dc4c8430c322d6
+
+Len = 824
+Msg = 6778d82f3a98eecdfac55ddeebc52476a070094fbd65831801fdd60f837d80d23b90d472c5f4e5ca6273a50f40154ea8fb94013f6310ad18800433a1d379c84bdf799a99e8c7b676fbcd29cc2ed66552297de7a6e565179bb42b70d48299e0925a1d72ca2c792a
+MD = 71f08d9333df5cb885fd23d6cbb1db84f9b55908d069df50fa4795cc713a18439bcab8daca078356f5c75a619f2f8782
+
+Len = 832
+Msg = ba3a54a77d7c2b8ccec6d53136cd48827c87acdd1cd86ad1f56e862642ea2e1dcb4093f85d60f7bd77160738462e6c3fd3dd9d3a7c5cf7e2a1d60f489f84471902179f21f656ce0fff089278ea14441e04e7af71891622565f44c428044728fcc686212a32a5d809
+MD = 3cc154f0542d8e3cacf9d79f231416816178a7ef2275fb257a48a2f763ffa2e15a33c27b970a416a057925aa0412d268
+
+Len = 840
+Msg = 7eec4f4f491b4eeaeb1cdbdb95e9511c2872372bf64a1f61cda1cd8032729c8beafd1edabf78036d80023c814ad8606106cb4e7f33f214c3e69c0f230e885474fd594f7f2444aa581e0c70ebf13073d89063eb81a43c5f608b2fc99fa1bcf5e2bfe62a6802e70c52ce
+MD = 2f8c5682a07438043e55f0b7759fe7eea5d9bdfc8b0f89800ebcf777bc05a941ea7f3cac45d4659de0f505d814590b6b
+
+Len = 848
+Msg = f3715b9e3ddd7862e15ee87aa23f1aaa0580591e55cff3fee9b49b42aa0c0cc8cfb8efa3eb96ffb72ab06b83d7b47b3d22a5772421cfc51214005150edf532af10138ad45758add459908601eccc3703e810002a2e4c6202e98d84281475d55d3de9f3d98809cce1f665
+MD = 04e7d55b0eb4bc3d3a21cfd2941dbb4dc44706588967186b40da54902aeea97b262c97f75e37ebe3cd60a804e7b9feca
+
+Len = 856
+Msg = dfd7d792e162bf7a889109550a0fc4c415232af0c0d72dcbc2595299e1a1c2aeae549f7970e994c15e0ab02f113d740d38c32a4d8ec079cd099d37d954ab7ef2800902cdf7c7a19fb14b3c98aaf4c6ad93fe9a9bc7a61229828e55ad4d6270d1bdbca9975d450f9be91e56
+MD = 08e5ef57d0c2aa23edfc75cfae39e6bc1a43b5db08b2e27bc9823114edf760367db9cf3cd9c3779755f6d39e219b7079
+
+Len = 864
+Msg = ffbc7c47f52e69f5c667f4ed578b46ff4592048f789081f3fb39321d0aa4627a6d4f261905649410a53a301c231fa787ae55c04f615a8f84196cecf2844d23007b44edd892649fc8ed10a2e855bf23fe8afd0b9edbb33296f5a7cf89f94634d9d1a2b8cac3b7f4e546f2329b
+MD = be10c7baf94608408a0accfbc8ce95e159d08d8ca75dd6c273f935947a7ec3463e10a58d3ceaa0b2198b0887a3a24a29
+
+Len = 872
+Msg = a39f202d866e8e96765fbb53b6772537dec043322f4a7475247036d7495c987850cef2a46218d3fab36e3bcd595c0aca5e98b9db14fa484ca8c9772dfa3839f7ac3066727a50b0d5c933d82f82f1220720e8063f08bc283f199c8a4f85c70043df4fe55e751d0d71df36fa43d8
+MD = 3b2664ccb555a1b1f3ec996860146ea75ef7f3bd62028a19c26f63339399f4275a07f3c064d34766ebe8e4dd532f6629
+
+Len = 880
+Msg = b2c8261853e2218dfa135cb5387810352b8962e94e9fdc8695b41e7dba6ad122d14fdd0d2360dcc039ccce8b37fa0ead6ccc85bc26261d47cbaa78b925c6e380fef1856fed31dc616fe16b2039b1ac85cdee4ce04c0497998b41321868db08e35f358606585e0bb8c3da9a3be7a6
+MD = 45b286f49fd05c45c921b7bfdbe2cb024441c372e07394dcccae0de834cd541f13a79dbb3e5078896e88438542bd2f12
+
+Len = 888
+Msg = a04f390a9cc2effad05db80d9076a8d4b6cc8bba97b27b423670b290b8e69c2b187230011c1481ac88d090f39154659494db5e410851c6e8b2b8a93717cae76037e0881978124fe7e1a0929d8891491f4e99646cc94062dc82411fa66130eda46560e75b98048236439465125e737b
+MD = e7089d72945cef851e689b4409cfb63d135f0b5cdfb0dac6c3a292dd70371ab4b79da1997d7992906ac7213502662920
+
+Len = 896
+Msg = f419494c3c6d0727b3395a483a2167182a7252f4fd099c2d4b71b053f94bb8b3adf3b51e8460cfec084ce9415c95798fbae4975c208c544645b54c44d2b97f2ecfce5c805be61f5ba1d35dcc07afdd51a87baa990506668cf710e18be9b0ebf943f366fa29c69f7a6616de72a3353b66
+MD = aead8688c58c6ba4e9cadb4756b465dce0fb06f1cfaa478197f2ea89414e47e9572034adfed160703c79b82b3fd7ab78
+
+Len = 904
+Msg = aaf7584d53006cbf2d2040e51b7feebd2bbf1e9f6d817cd8062a6a9680e7f10464eefeb50b07cb46b14b9b3fcb2caa3b9ab664490115d5919456613bf172b58c5388fd52646a5783535b88212717ef605314b70b8a085024d4ab1fcbe2be74609e4cbdec0730fabd3cd77151d647a3767b
+MD = e6e79d8c61d0ea9fc70dd4dec1fa432849c3396e717b170badbd87a4c7974efc590ab8c1183a6232beff14534f004b02
+
+Len = 912
+Msg = a467f77369730201f2812204fd63ad0d2757be580d937dfeb221a06b21ed3213531d936152a0c1f09f0ad5fed19fd11e80ad982c61203e86b2508279d91d99fa483e2e97a3d6a6ad2548a8da404dddb58344f4bdc1c9ea907088885e4f532d9c4c73cdfda43c3a9e4ce5a2809096593cfac1
+MD = 5a7508c2cc096bf65a4d4d337aea22008edb9a3bae869f94e09fb526a52c3368e9b28576fb950f078b7e43b5562120e6
+
+Len = 920
+Msg = 01abc90e9180fc9bb8ea67a405073ed6848bf33048076566476c55836bcb19d3e55e9400c5cc657bc7a95f1d703c390f5a8687e7cd7fe9138ea3837bfcadad6258a3eb8d65121fa8319bfde532aec0e694961bddd2b673f284124be5781100f40381b6ff99db92ea9cc82a4372e53924dac398
+MD = 96b209d7cb2c2033b38350744767fa5c253e1bfdb99fe8418bff83804df02248140fe3b77b0bfd4a79b51f70405a434b
+
+Len = 928
+Msg = b555d99056362bfc2bac2a1bbb71ba112d644e50b82b015e5a1ce3d9cd5e90b8b74b08d32119baa62abae251fc0015e400051ada4ecafce3681e5de727c20d47f5cadc663d46ac682022ca396a4b7ed1c413e0b72bd7eec4a0dfdc2a2185abb5d99afd50940528ca75ad89daeb9a1b61e15747f0
+MD = abd39f79d72c6cd2e8e130f3603032fe3cef4177c3563930096df1f10b87e79cd4e2059cf1b9f8252184bb26f659a5da
+
+Len = 936
+Msg = 14fb01ae9d6015ecb3e56d6ecdfa4bc0533186adf8457f5e4a5c57c687895f3db395d06ae7ffbd67ec41452009550dfc1878eec0df2eeab09e8665f7e59f9148a86b2bc695b36521a55b2302f2e869aac83f14d6feafc9e587322c3c44f052ea1c0578884f84f56307bc6dde31ba48118a0f62b6fd
+MD = fc9b9a95a8ce1c157720cb63101a7594df24f4cc74baf735b0ccf6abb925478ad507cd048d30cde1c788806f43ed3a81
+
+Len = 944
+Msg = 11ae0cbfee7bb3df90ce585f09b9cf8ff5bea69a68eeb6c22553f8ed118c9a61e7b752cc2c94f38766e63e1b891dfa05b23347b617d42fde3ec17eea6e76d3cb640bf8fa46586fb9dd5c4d9bfee04c4649571b781709f848ad7081afb6e2c746f071a551251050fd5df72ee65248ecdc24f2cbe74ed5
+MD = 3214b5feec925059149fa852e3ae285a6eb377df926504e2f824572a3aebd2050a20144e7bede7e7fe238ee83e69f72c
+
+Len = 952
+Msg = a5c4a47a04f4714269d5d922ba4694060aa2df49193720c819fac93bb8787ec55a107ac9a6602f0045fd2cc8e66744bf863ced91eeabe60e7d2c1d80276ecf3bbe91f1757096cf589214f3569c2c48bd74be7f8befddb28395814780a47c180a58b0d0276a7e9873d682f473e27de7275c925ede23b6cc
+MD = 6bd9e1303579d815f58e8c6c9855850133251778a632f7b312c4b3163b29b5ef6cb9511a08a31a237d9a7604afbfa056
+
+Len = 960
+Msg = 75264774af69ec7ee3125e205bd6d1cb8fdb22f7ea6dbe72d1f2c0f7e2205902796d75e379c79b11498615c21c9f52b8761a885eecc69d132b2b48c63bc074c3055ee5cc13f51d6c987e8188b030b837e8f754d40122b451f15b28cd2bdd576920e1de5806593a36d8e1e89b9ef3caefee5acd80b3e9c9d1
+MD = ffa9e4e856d06227c1ccb959be558309cc10633173f4b66ceb382923b52b9150acfb08a7393500477a6ee4425a827e76
+
+Len = 968
+Msg = 791a36d748695e62db5003a8ad367df1f051c1ac6a21d711823e8e069b546e3fa06ceeaae06de70a1de249e1dffd0d940edc6acac00c4c15504c02d4b0933658005423455f00023b01cdc5b681b6083379c24595518a47c654f5e1a10947df10c05a3d716b2a973faf98e1ee3b675816598bb8d4c2a3b06eb7
+MD = f8d33369680524ed6c6a716d4c502de3eac891f340f40e82e37501be1a90fb61d26e5daafe92bc6ef5ec0ae431168842
+
+Len = 976
+Msg = 74cd86bbed14d895301d8a54b2956b1c5cd1451eebab620b978d4ecef2cbdf7a14367381f5ee79281a773337740fb9f5853f4253c4b19f684341081d8f561b2ad773224151099588da90e04dddd565f67596c536d64c5b87e9480ad43601397507ad1b61ca0e349fb88f19feb48f770676fd562ee8259f50d0c9
+MD = 73ee8d29c30821dcdfa4441639f037fb6ba3a9ca596dc43428043785756608f6207d80b7f78e573174fb9dfd42f0b8cd
+
+Len = 984
+Msg = 46612e1a4d016c41700a3b5ccb38323353bd8da5b9942c9c9212df40b4bee06be362a15dad62c8b2924d789168b2d325fe35bd5100e1e29f1ac0fa7a60a94c9eee5a70cccbc75ac214b1946a5679cb523b378d5c690751b7a7a3b80d413712feae7024ce71d6295a3d5d16515c3622a052eb862ebdab81ca7fe3a0
+MD = cac13a3784225be03d526f9abc1eb50a762e72c0e01172a15d578801089e5c9f26e53cc00ff755909453e2964d7df838
+
+Len = 992
+Msg = 1a857c1f105d068ceab0b1e12494890ec196362a48b0200a0d75d712b18fb14bec6bb5b68a33b7e0b4fdc5b77142c29c6d9151b9f884f59551f476e5256986a653d4a468f28141ed954721f2cd02054df0438738194545ed70234173ac4988b7d62812de4f2feada14f68e3b41bc9948d4139f4fb4da5939f26c0261
+MD = b75d92b5cd3772846f7b68064a3567ae43e5010099f2b649f35087e7592aeec176646fc8c2629288944261cd35b5fcba
+
+Len = 1000
+Msg = 9d36818d0c5a008be7904d1917aa3eccb5ef4f38cecb8c4e63c4b2e9b4b091a3bf25b4ed0332445f894c2a4c258b749afa17fad03cdd41713a869f899ba9a085e73fa9474a58db7a950d3a2386b60f79495d8bf73e72acaffdbf65e1989ff9cc206ba8c46a368d8512bac7c7c191d713aca949d45df297b1b6594a1a33
+MD = a88da844579f3e3725d00daa8e1e287da4bfbb2d931ebe8d3b16021154be503341d6371d382ada744f86f5bbb56cdcfa
+
+Len = 1008
+Msg = 4ae50ed626ee60dc5ea556e3ce0d3c18b9e6225b5620814e8b9621acf8f939dd370ad9c7620d85e6d67a229f37f517d1b580acae8df0b5c9d29d756f6d5ebd3b63b554e556469b5b4f8e7113bad1559fb254ca827fcd00425d18b0be7f2b48c2544c48d90982ec624f490be65e893fa93ac9467f35a0a8e1b56d9a403748
+MD = f8cd943f429333c7c8d30a8576827f92c92ae18e0dbcae770601b79687bccf8c23e9e589dfeb45c3b9bcafdd545e45e7
+
+Len = 1016
+Msg = dbed7612448d46cbe0a384d1c93233f02ffd1c984ba765299518656d3723b766c1658d4b1e7047cdc729459e366ef9349efc40cbd990f2a9a24db7a5045e1dea12dce8f9d9f2aaed933f93031e7b8959ac5e7bf6bbbdf30b48f7eb783f8fe292371a2f245c5c94b4acae160767a20ce7c0ea7723d97691d8eedda9efd1fe2d
+MD = fb531a1ed181c732311e56f4b56ed91dcacc0dd6bf1eb4a44be6f87dd7cb1ef9dfb0310f4a79eaaa3f32bf3914d8624e
+
+Len = 1024
+Msg = 3bf52cc5ee86b9a0190f390a5c0366a560b557000dbe5115fd9ee11630a62769011575f15881198f227876e8fe685a6939bc8b89fd48a34ec5e71e131462b2886794dffa68ccc6d564733e67ffef25e627c6f4b5460796e3bce67bf58ca6e8e555bc916a8531697ac948b90dc8616f25101db90b50c3d3dbc9e21e42ff387187
+MD = 12b6cb35eda92ee37356ddee77781a17b3d90e563824a984faffc6fdd1693bd7626039635563cfc3b9a2b00f9c65eefd
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA512Monte.rsp

@@ -1,309 +1,309 @@
-#  CAVS 11.1
-#  "SHA-512 Monte" information for "sha_values"
-#  SHA-512 tests are configured for BYTE oriented implementations
-#  Generated on Wed May 11 17:26:11 2011
-
-[L = 64]
-
-Seed = 5c337de5caf35d18ed90b5cddfce001ca1b8ee8602f367e7c24ccca6f893802fb1aca7a3dae32dcd60800a59959bc540d63237876b799229ae71a2526fbc52cd
-
-COUNT = 0
-MD = ada69add0071b794463c8806a177326735fa624b68ab7bcab2388b9276c036e4eaaff87333e83c81c0bca0359d4aeebcbcfd314c0630e0c2af68c1fb19cc470e
-
-COUNT = 1
-MD = ef219b37c24ae507a2b2b26d1add51b31fb5327eb8c3b19b882fe38049433dbeccd63b3d5b99ba2398920bcefb8aca98cd28a1ee5d2aaf139ce58a15d71b06b4
-
-COUNT = 2
-MD = c3d5087a62db0e5c6f5755c417f69037308cbce0e54519ea5be8171496cc6d18023ba15768153cfd74c7e7dc103227e9eed4b0f82233362b2a7b1a2cbcda9daf
-
-COUNT = 3
-MD = bb3a58f71148116e377505461d65d6c89906481fedfbcfe481b7aa8ceb977d252b3fe21bfff6e7fbf7575ceecf5936bd635e1cf52698c36ef6908ddbd5b6ae05
-
-COUNT = 4
-MD = b68f0cd2d63566b3934a50666dec6d62ca1db98e49d7733084c1f86d91a8a08c756fa7ece815e20930dd7cb66351bad8c087c2f94e8757cb98e7f4b86b21a8a8
-
-COUNT = 5
-MD = 937d7856a82a84c163c79417d0540c47daaf9ffe662c843737dbbcbe5f865bf6f47a9d2bd10129a4f498073094653c324a2519a1c71ac1279b1623ff7d24647a
-
-COUNT = 6
-MD = f8fbc058c2b9f84131c9decfa543a35ade41581f670398efd61b3abfced9c1cfcb5324f2370487f9c59a65bc668ea596c8d22ce8a33014dfad28357fa7d05f04
-
-COUNT = 7
-MD = 4ab0c9484ff5c30fa64ae6e81510c5fea566eafb88f175f8bc19109f40fe80014c8b77fff10b8750778429bf3c5497e4cb92d9b30014f4cb975dff2a45244c28
-
-COUNT = 8
-MD = 685179397554d276513d630234a03419808c698abf2600d7490aabb8e455c6ab6ea412c7729dc140a79dff66533c6946cbe90f9da9ed16e2e629db1651bea870
-
-COUNT = 9
-MD = 335e6e941ab7dadfecdb74ea6cb4e8584b6e3408841a33a6cf7fd6a63294b1930a60983240311672acac3840a90e64cc366ce75081b2252627e9c31197ebad03
-
-COUNT = 10
-MD = e3217f6af6e279e9445dc3738cbf9ba0e9edba0455844a73648139777afdea2c4d8032e214f541bf92675fb23f24df8e4fe98e0003aadfb6d8f9cc2cd799bbf7
-
-COUNT = 11
-MD = ee2fdfb3ae630613b7d890977cf2515deac272a37f27e4a01961ecf103d4ff5b45cc8aef53b635dd75aa51aabf71c0642555ccd3281e0388f8ca09d83258cf30
-
-COUNT = 12
-MD = 6a30d97cc98af6a25b673dce7aeab8d762bf2e55ea0c6dc899179281f84dd02a2896f77e9c106b472f55f7adbef7b1157be567ee1236ebdac2a3c5d8cb133eb5
-
-COUNT = 13
-MD = ac1176abdc5f71170183d92ae55856221b0d95590af11d9d72ba605ec026bbec52d6974bc43a1efb125ff2b161fbdc616fda00f04193a0bc26aacdfa052a5741
-
-COUNT = 14
-MD = 59fa909480620ecc08d34531a6da1b55158b74fc93ddf68e1d242615b6f3843a7952e63e798c6445cde1b07e0be09d0d711cb7b42a0e7760a593b08acfceb63d
-
-COUNT = 15
-MD = 9eb253319efa61b864f27bd334d7dd78b38d3265fb544e0c8edee950a547e1d8db921a285774ab94d66beae933298d20f2a5aa87c62fe1e383cc3b18e7af18ac
-
-COUNT = 16
-MD = 81735324005671f7bdad9e685ee8257f5e0622b9fcb5d38dbdfb2df27258c3e1d46d76e24c0c92c744e1b50a2b4b0d31525b3af83cc80a75722d921bdeef59c4
-
-COUNT = 17
-MD = 17498cdff4323bb8021e44eca6559e05d8ff9a0ef2ee9d4ba0ac6e73f83972a0dfbb6d47728fa70311d7c82e154966e1b7678263b0f65133e9116969193d429b
-
-COUNT = 18
-MD = 228c4574d7c45eb9ba9240722133fce74abe00c7328ab30b4bde373dc79afdd6e0569d36268cd5eaa2f27205fc00512577bcbb6699e1d66ed85eafaba7548afb
-
-COUNT = 19
-MD = 3d40ccd9cc445bbecca9227c67fe455d89e0b7c1c858d32f30e2b544ca9a5a606535aea2e59fec6ec4d1ba898cc4338c6eadef9c0884bcf56aca2f481a2d7d3e
-
-COUNT = 20
-MD = e1e577aeac92e3a2b7f8a262bf2ac9c037d2274ca6618fbe4cc21db7c699e9946b6671ae45ea433a1e392a5bc9eec96fd641ba8f4a047f022a04a337227004df
-
-COUNT = 21
-MD = 5e4424c0bcb2f0f7a2428821a9d5840a82401f4440ae6bed25c53cd9e71cf9d39904d6a375bd721f4332ab0202529c91feb9c094c3e6d34ca4f66649ee6fa212
-
-COUNT = 22
-MD = 56b199d63ca37189d5ca0d40006ac7bcb9f39cbdc00ef7b8a5697caa7d81d05b645a146995b1151d01958f1589337e14afc6e7dd10a815170e527a398e6ce8c3
-
-COUNT = 23
-MD = d2d498ff93fb03013a64f295b5bc68e57d2fb5600da578aa011d43ff432eae3e0c800f9e2a53155e56fdbf5e068fe2b4beb3e42b2585531b8b16c4d8ca3356c6
-
-COUNT = 24
-MD = 3d3875489903710f17cf4247b5842ace6f017b1a3b99e9ee5fbc04fc7898e78b12693879878028ca40c63cd0f6925fb7d0ca0412e4f06619e3ace223690f03b8
-
-COUNT = 25
-MD = a013e21cd1234483c95c2ea2757be949bc79401ba39b09c316a1612d594642be65ca106e12695ac3808c57c6f2980e895fd1fe188946562afc238414e1e43649
-
-COUNT = 26
-MD = c5f6367d7195489e16242f912fbe0d8002e947de3a7e9c53f77b1e5e90e05bd7ca395e787e34cb5f500c02da59c9d83de35601de7ae80dae74a0d6b4a292d43b
-
-COUNT = 27
-MD = 7c28c44c6aaba83c122f24d68273e28a5afd65b4071d02b7ea3300478d5118971e1356ae57cbc70d2a177ea464a1c2c50d4297b933e789c63b1481797ae8f08c
-
-COUNT = 28
-MD = af7cb42b1c70a85ac1ae1c2991b25b657c19f4fcf83af7f7dc0ae1028c1452a6a17dc98929634fe6ed3855b70b96bc2caa93d82037b94ebeddc77e4c1a7cc563
-
-COUNT = 29
-MD = bd56ad4c0cbd162706053da929d667253aadcf417affb483fff4f2699bf406d128cfdf5196dfbb05bb89ccbf04c5147bd2ebb3156b0bc1768ca6faa171c91c01
-
-COUNT = 30
-MD = 004d7b0fff9bcddf4b3913ae190a76728705a3d23874d92a8b7ff246c8fcad46623cb04723c8aded0cba4968d1a8cc1375b99005786c1bcb7ae4bf13325c3ae0
-
-COUNT = 31
-MD = 8299a5bf5ed64f525c4eebbeca969fc1b91a81adb58c584bdd2d7676386a31fa546643a3cf505007584f02fb712d708cab645bf078a1b9339f5a76aee985d017
-
-COUNT = 32
-MD = ce7100f3455db1a9776a9f40d562ea998afca1f9fee7e0d81c8db34cf68ad23a8bfa6fc04774703e1e56d5196b66966158fcf2a8335a58c6ba7ba1af756ba1dc
-
-COUNT = 33
-MD = 90aaabcb655ee921b8350229efe6064a60051cf0cac858fa3d43afd5b97cc82301bd1b8cc1f874022e5af948185638783a13ca1bbd5049ace7fbf4f6d90c201f
-
-COUNT = 34
-MD = 3cf0a25b33ded3e0806dfe603b9987f1d6f2b3fdcb1ec7f8566828c00e17e8f59e38b3bca302396c7525ca194e6cc8501369059e2e34ae21e3141215876847c4
-
-COUNT = 35
-MD = bdc5266aee339a1ff13fcf5229773cd3d14b47101e83076927c160bb71bf7445590525a2012d52af008e118e16df1b6bfcaf8f22b4e45f9e749f3c20625a2bc8
-
-COUNT = 36
-MD = ef8d2ba885381ab97756d59dbbbf53a1ea35d152b2d8f82c3518430aa34e708359194ea43950d032e151f576d343a5c3cfe6b71d4ed0ead9d3a107402589bad0
-
-COUNT = 37
-MD = 194ea5324c4179998dd7057755f255fdea04dadf533f7851e3e9718b610948e32fd28323077d9421142ac808978adfa325b668c8599a2e01c757a5a14ed2dd37
-
-COUNT = 38
-MD = 106984d2f0087e621dae760552bc6279072267883c204079481af6034354f1a2b77c17e6c039a1063e479342aa3ccd90330dd3fb5a7d5e976619497e2d3326cd
-
-COUNT = 39
-MD = a1347216f1a6db47b90c4ded3c5c75440f54c22c87d538314d1340f86f88acba01378acb933ddad0adc6b75d55bfb7e8efc9c4a531b2a410610b7515b6dac66a
-
-COUNT = 40
-MD = b76e4db147e0eaa4f04880654088b9d0fce518c8c377d92c846345604dc6b2b18d377fdb8e30f06d9bcfe6d7dacc07d6adff73d98d49f8f132b80f3084390830
-
-COUNT = 41
-MD = acd4e527763dfd4513f0def0b1edf8ea12dc78d336b7b796f3dcc32e1068725443a2f55ab4f666b27d6bf2ab39669c98293f0a9108051fd3144d31a1ed171ddd
-
-COUNT = 42
-MD = 10128c15494bc87a87374f676ef9fe2df20b36ffcca41a80bd40b216637b3de710efd070e277827820a7bba3cceb7b21f8fe7f9775d6c4df4d3da5349434ec49
-
-COUNT = 43
-MD = 2632dd5c188c6ed3a4610405fdda704add752f5424d9de65a51400fe478e26cd0412e5f91ca4b744c34f4954f40a3a4254431d21954623208b527b7b4daa687e
-
-COUNT = 44
-MD = 45707f5b6fc5ccd1f78d77f177d10fb8b462c74cc821518cd5cfa4b5d6b40b418044900693c37abbb82367d340fec67f800d74072935da1706b4d90ae26099c7
-
-COUNT = 45
-MD = 56c37f31220b5b3040373d91b2c5e42fe9e601a12f7f8dc4534459bf28e484b8713db243c5782c031e674003a3c14c42fd152e7188789065e82795e10f87d54b
-
-COUNT = 46
-MD = 5da94c899d48bd8299fee3d81662f8d6c5f8f8bc54d18cb0368b13cebaee7ad71e74ea80f34974ad166f04f9a0602809166fe4085a475a8ca86cade12b6754c4
-
-COUNT = 47
-MD = 0664363f97ba910760b0922e31ca880ca97469506cb007e3108c36c3ce3ce1801fb4197609479339e8820632b6a38bffffee05a9adc11cc544b9aa6f5b95cc6f
-
-COUNT = 48
-MD = 732c41a1edaa727c04f627ff158aaff67c18efd667216132b99ab84d108996a10bb008b5d803b22ed1aa78bb0d10f8a762fd34777d7dccce8e84827ba88d4193
-
-COUNT = 49
-MD = fc9c21d67e393a2b05a23a17d8db630cbaebaa3def211181749f1bcad181560627fb60ee20fae2e5980cbf50fce0a19dce807e7fb75c4da0ef008bc75d413a65
-
-COUNT = 50
-MD = 0453b765afc1edffa595efe345177f5805ed3abc1297ceab757ae7161723a6144cb543299f418049276d16b7896662631634fab9549127c10f27505b7dee8665
-
-COUNT = 51
-MD = 3853f3bf024e0668e8d1ea53733a97537f97d9307c5f3a19864ab4eeb1654710693bb961a344dec8a758f5e64b26fcb6dd423419c4a114fa749211a9de06c281
-
-COUNT = 52
-MD = 240137f0dd57beb3f7fc283bb3ead423c67883fd46f4e27471d7be57ad469a49bad03a3658418bd55614678f3a463bceff85291314b90ef43ccbcb028f0a7a07
-
-COUNT = 53
-MD = f9050a5271edbe4cfdb9520ec05bbdc3cbcb9bce36fd212338d3e7028a39b9ab30793e561d75a2e424193264c7f0775e65599ef0c94e0ad24dbfe18252364267
-
-COUNT = 54
-MD = 47caa7a5862fad837aaa409a4a9df2575e645528c35159115911b7c4e2f08ae49d68de97249b31b83ce2c163f649cad4559dc6e6a7191f2922d79a5fd6af167b
-
-COUNT = 55
-MD = 13f5825c41fa49edf6104e3e35c9c224eba93e37374f730004c39c54e7391e4a847fd61865235a3fe32224c96fbe86f7e14c3d5df496e83ec989a71b4f293a44
-
-COUNT = 56
-MD = e5b55e05efe1ca6b9a96a57e3a1523d610d70f837e93b31fa98c2736d3e114d238d46ec6b6e3d19e774b253f6b0c7a2ebe69b7e60fc0874444806b2a2278df45
-
-COUNT = 57
-MD = f14a586ac30f0af255f597a9aef9abba5e99c04d17b01f24427c4ee2c196b52acb1ceefc9b15cb822b3ecffdc2f7c49e11d3fc0769acee33361537d379c62e0c
-
-COUNT = 58
-MD = 7e2d3398807195c48e6ec52d20710bbf8b21ea8de4d1abc197897ccc58aeff40259edc67270cdae0edcc686c0d0dccc5760c1495ab1cf48482dc2000ae2d42ad
-
-COUNT = 59
-MD = 2f3d5c5f990bf615d5e8b396ccbd0337da39fad09b059f955a431db76a9dc720dffc4e02c0be397c7e0463799cd75fd6ab7c52bec66c8df5ef0d47e14a4c5927
-
-COUNT = 60
-MD = 483a1764d308cc494a2b543d29ba616483aefdf91c7769fd084eedaac1add1891df95d317a47430b2bf73e4081f86597020e28afe2d34a22b77ea62b6112d09a
-
-COUNT = 61
-MD = bfa88691ec951511651c6f14af100eeb26d87729e18ac3ef49a80d73ffeaeea53e97c4a7277a7ee9f2fba070b1c9720d6cdba407dd82267019e3f0f5662b2f2b
-
-COUNT = 62
-MD = 4c17c8e2e7132dbf82afebc40efc77926d16f4d2c082d846dac28733aa767e2840ebf04f2563df75933466a36e11968d342e4157827605d04d9627ce9b5216c8
-
-COUNT = 63
-MD = 70bbfc29a2a765220af84e7bb10d759a3152ad4b5643ef6b89966950ec7ef9503d57bc0a28c4ee789a60bf9dcac59139e15241d73b990410cf92eff213da9eca
-
-COUNT = 64
-MD = 8d1d56f37fc19b84984a6fa33aa9c2dbdbf79a29c04ad0b4cf20333e6bec943447be2416242f8cd2f9732e79bb925cc5a61a80c5fc9c079961243fd1c1f5900e
-
-COUNT = 65
-MD = 492fd0171f4dcd5d20ea6c0d34b5576c8894664ae5955e6737f5e3b711c2804d99ccca065b7ec18c82da98b18a3029b765c51ebc7c433b36492e0ed6b8511bb6
-
-COUNT = 66
-MD = 7f49e8e54db7e5b4323cae2db71f3e8b8eba172dcad3602e9b7b058007a5589358732d5afffa56072a46e89b1ea27ef8d556deb86b569c635d394f15d99d8a15
-
-COUNT = 67
-MD = 56884a6a9210d5f371e25823efb2511a9c410c26a441e07c1bdffe8605084267d49c315baf6a692d7d97844b2714b4930877a5d7f52cf6fa151700fcb6980546
-
-COUNT = 68
-MD = 6aaef8284eef221ecb17ea3c9596f075b5155fe7b925d737ed3c6543c761c28c7cd9d9d4b5e2a37b2f183a2a367bbd34b633497bc7a1737d61c8c1f3ef295062
-
-COUNT = 69
-MD = 38ef178f5688e59d47c375252db7b39f40c0c84169878ee7ba5086e4b25fea81076b9c37847e9e6bf24ae0b343689c265ec5ca7469e619acd61b0276721efb1b
-
-COUNT = 70
-MD = e3fe1aabad120777cf24eaae289b486632ca46ceb89afae73dbae5fa87c767879369355a9cc5c21ca604ed91d0f2f58c466573f3e6d88e52c62c0d3cb188e141
-
-COUNT = 71
-MD = 82f5bd920457bb2763a0da031a7fed47b236951b1ea420c20fd2b6de1dbfbb9c4600ea7092788493e2d4be6ee24b6dba04e57af3e8f2f14d9837295420ac7631
-
-COUNT = 72
-MD = 6d0b26208ba9b1615067bb3ff97b292fe67e4c02d240d649c32370e0a4cd22d03bdf864be4d24a3f5f51aeccfd1afd5191e590edeb5f7bec323b0506c3104b89
-
-COUNT = 73
-MD = d081083158054d08371ec84f4d3aa5aa761734ac6091a30330a861fda056f835c750bf4f7981af1693ff28545366bd05cec47bccd77a7d237befb0135c534138
-
-COUNT = 74
-MD = 6ba8b52780b8a07a2a2015dd8f0c5e7437b8e024c4ee428f7ba91dfea118cb72a939872550983317132b841b7cbc29a22b8f1cfea0c55203cafc69b55ed6244a
-
-COUNT = 75
-MD = 312692b0a51f002b7f06d05b39d15a5637dbddd2f4f1a73e6c88a4c841cdba5cd8e69c0939ab39bb1a9c54fa35402143c97edb9704a0e9e1a98701710f6a5dad
-
-COUNT = 76
-MD = aaee960de201a8dcccff95b834fccf0dafc03fe6cffc0429162bf4aff01165ab07a0c9435e9cb412121b7ba010657ccc3152118602b665072136317d92fd4262
-
-COUNT = 77
-MD = 21fdff552e08c86c07f080cefacaaaf31846eb893bfe2e4f88c3c3cd8cbf592a84500942695a5e5ae971ab343ce2695dd1baeb1f94dd4b53d678e14265e421ae
-
-COUNT = 78
-MD = ca8f1a5b2172f6adb474da53b35e3f73ffd88263d3eecde72e48b16e1a0658015b555ee319005a1d82802e91431ee777610f9b1028d819921e1044ad426b0270
-
-COUNT = 79
-MD = ce5ab25eff9c1ddc569a1eaaa66b689109ee269db7066e0b02d39b3564fd14ca6249987b7791e203d3d7c2ebf18558d2f23f94c03dd1d03aa63849e4d2889a76
-
-COUNT = 80
-MD = a6f8b0561000dd4ae8b828c5f676e8c1a6474c4a042a645f1815bd52e9ff53c97dc36d5d8997f8ce332185feead76267f5b2e63f597fb3345ca0046e58fc0f24
-
-COUNT = 81
-MD = fec86794bad4106c5ad1c1a2d9a1b7aae480396ec231eb5cac21c4077d17a0b652da0037363399a5a1dababa4a40e4c54b9124167580dee9108c4dbb24c57512
-
-COUNT = 82
-MD = 594f5dd3f4c87bdc0d81309386e9163a9718e34c7b0dcb4613f8487aa786f9d211cfb61bb247fa9f5ecef042e710f192850f5571807294bfd8a54397850e5773
-
-COUNT = 83
-MD = d81ad866f25ef6a0a6431d267114da564513e5ebdcf48db7e95db8cf32a89f0ab107874d796035db97420ffcf1db5f04dc1a52ddbbb960fc63b7f3f835cc8be6
-
-COUNT = 84
-MD = 431d537e098e9949f6a68108d55d20952e3bfcdeb7273bac3917e37790a84fa5db04c33a79c113a06cf333e831d7702a00853a93fd0aa5146d934f4f71242a6a
-
-COUNT = 85
-MD = 4ed95636c6885ae4e63d042e82f4da830c702dbf3b9746d64770a64dd666b33208315f3a947c4dff790771ef283788a9c74da83e22b97f750286a820ee46698c
-
-COUNT = 86
-MD = a9bcb60b4d7724cdddddbc232b4ac70b94d0d7e9f0724b1222d918930cbb9bdbb04b3ad43e3c8caf3bf8b004ee4aec6bd527ff8eb6189b44827f7ba7057f6a90
-
-COUNT = 87
-MD = d6d5e44d5bb07fc4144ab6ab309f048968f73f7992beb326047e9e2cd7af6240bc8abf46703c32fdb58fb2a8672594a660ef855be74f24cec09d4fb00219de82
-
-COUNT = 88
-MD = dfda9ac0c7147530da97715ccf47814182255f2f2cf40287db97a4c63b43fcd39e6d41e560921492badb253a7dea0aba863c7c33b912bb59d1ff4de03a4f03bb
-
-COUNT = 89
-MD = 0395faaaf2e907f27779d6f1cc9c9db68ec390a38fbb0702c6475b46f7a399498d46fd8014f834b131e1e83abba0359b1f16d8fc0a393580615def2ad0caba73
-
-COUNT = 90
-MD = 41cb98f09029abe85d24a0f131f116c7f69f54f7e91c250642606512bf3da4ca89ba70a4714a5f66d9ae81ff09317dadaff12a02057074c970f0f02a52bfafd2
-
-COUNT = 91
-MD = 8e8f161d48e306c5533ed614b8ef3a1979df6db7e13d0780a73c4a3980ddf0a95f93941d412c93683e39915a660c3fbec0dbb1bb6beea2e2099cd968011535c0
-
-COUNT = 92
-MD = 789593f0b8fb83ef9b3ec50ab8f6e1e47344f763d4f7ceab5600989e7b6fd5fef6ee5e487975f64474af6cd71ae4d9ecce8f009edea0227c7ebe73080b8f961b
-
-COUNT = 93
-MD = f37e1449e0b313d9537a6177f7a31158d353e5b79c781facf02526ec94e0c6cfda37105bac67098b194ea82efb307c2929a9ab8aca0e76c53e829e3f901cd245
-
-COUNT = 94
-MD = 2e74e745caaf2d449ab3b031dd214b48616853a512cf2e95c40cb8e7594fe5e4879ac8a26d02eb35b3b96a5c9e7dcae3e15fd050a0bcc1fb3b9cb9c4df0fad3e
-
-COUNT = 95
-MD = 6eac7069c26082e52574ca6a58abb9b1b9faf452e8cca9f1c7023679ce192ca554892f30e38104d39088a24df35612444a0fc90084af7535fd9344fa51dded84
-
-COUNT = 96
-MD = ada6caf30c4f6e3644d952366e01519af6771b406e2c447552f0c597b8dd10e9e9b4e699c9a835de03f422be8980538d9786172dfd2fe511db272a1543d5aa35
-
-COUNT = 97
-MD = 4d4b0086b2cb05d713f2805caa7e6605c8f7dbbb2e0f92aa159aebdcd63060305f47b748f1bca6e0b6e11cf8f9697fcccb6584b878c4b54a699290728a40aa1b
-
-COUNT = 98
-MD = 97420b8a0ad102aeb92139da2c052d2748dd7d2dbb93a9ea79dc15b520d0ca7cab8cb7a00f5b5aebcb49d7e7f52a27180935ce617aeecdecba04064c668edd37
-
-COUNT = 99
-MD = 4aa7dad74eb51d09a6ae7735c4b795b078f51c314f14f42a0d63071e13bdc5fd9f51612e77b36d44567502a3b5eb66c609ec017e51d8df93e58d1a44f3c1e375
-
+#  CAVS 11.1
+#  "SHA-512 Monte" information for "sha_values"
+#  SHA-512 tests are configured for BYTE oriented implementations
+#  Generated on Wed May 11 17:26:11 2011
+
+[L = 64]
+
+Seed = 5c337de5caf35d18ed90b5cddfce001ca1b8ee8602f367e7c24ccca6f893802fb1aca7a3dae32dcd60800a59959bc540d63237876b799229ae71a2526fbc52cd
+
+COUNT = 0
+MD = ada69add0071b794463c8806a177326735fa624b68ab7bcab2388b9276c036e4eaaff87333e83c81c0bca0359d4aeebcbcfd314c0630e0c2af68c1fb19cc470e
+
+COUNT = 1
+MD = ef219b37c24ae507a2b2b26d1add51b31fb5327eb8c3b19b882fe38049433dbeccd63b3d5b99ba2398920bcefb8aca98cd28a1ee5d2aaf139ce58a15d71b06b4
+
+COUNT = 2
+MD = c3d5087a62db0e5c6f5755c417f69037308cbce0e54519ea5be8171496cc6d18023ba15768153cfd74c7e7dc103227e9eed4b0f82233362b2a7b1a2cbcda9daf
+
+COUNT = 3
+MD = bb3a58f71148116e377505461d65d6c89906481fedfbcfe481b7aa8ceb977d252b3fe21bfff6e7fbf7575ceecf5936bd635e1cf52698c36ef6908ddbd5b6ae05
+
+COUNT = 4
+MD = b68f0cd2d63566b3934a50666dec6d62ca1db98e49d7733084c1f86d91a8a08c756fa7ece815e20930dd7cb66351bad8c087c2f94e8757cb98e7f4b86b21a8a8
+
+COUNT = 5
+MD = 937d7856a82a84c163c79417d0540c47daaf9ffe662c843737dbbcbe5f865bf6f47a9d2bd10129a4f498073094653c324a2519a1c71ac1279b1623ff7d24647a
+
+COUNT = 6
+MD = f8fbc058c2b9f84131c9decfa543a35ade41581f670398efd61b3abfced9c1cfcb5324f2370487f9c59a65bc668ea596c8d22ce8a33014dfad28357fa7d05f04
+
+COUNT = 7
+MD = 4ab0c9484ff5c30fa64ae6e81510c5fea566eafb88f175f8bc19109f40fe80014c8b77fff10b8750778429bf3c5497e4cb92d9b30014f4cb975dff2a45244c28
+
+COUNT = 8
+MD = 685179397554d276513d630234a03419808c698abf2600d7490aabb8e455c6ab6ea412c7729dc140a79dff66533c6946cbe90f9da9ed16e2e629db1651bea870
+
+COUNT = 9
+MD = 335e6e941ab7dadfecdb74ea6cb4e8584b6e3408841a33a6cf7fd6a63294b1930a60983240311672acac3840a90e64cc366ce75081b2252627e9c31197ebad03
+
+COUNT = 10
+MD = e3217f6af6e279e9445dc3738cbf9ba0e9edba0455844a73648139777afdea2c4d8032e214f541bf92675fb23f24df8e4fe98e0003aadfb6d8f9cc2cd799bbf7
+
+COUNT = 11
+MD = ee2fdfb3ae630613b7d890977cf2515deac272a37f27e4a01961ecf103d4ff5b45cc8aef53b635dd75aa51aabf71c0642555ccd3281e0388f8ca09d83258cf30
+
+COUNT = 12
+MD = 6a30d97cc98af6a25b673dce7aeab8d762bf2e55ea0c6dc899179281f84dd02a2896f77e9c106b472f55f7adbef7b1157be567ee1236ebdac2a3c5d8cb133eb5
+
+COUNT = 13
+MD = ac1176abdc5f71170183d92ae55856221b0d95590af11d9d72ba605ec026bbec52d6974bc43a1efb125ff2b161fbdc616fda00f04193a0bc26aacdfa052a5741
+
+COUNT = 14
+MD = 59fa909480620ecc08d34531a6da1b55158b74fc93ddf68e1d242615b6f3843a7952e63e798c6445cde1b07e0be09d0d711cb7b42a0e7760a593b08acfceb63d
+
+COUNT = 15
+MD = 9eb253319efa61b864f27bd334d7dd78b38d3265fb544e0c8edee950a547e1d8db921a285774ab94d66beae933298d20f2a5aa87c62fe1e383cc3b18e7af18ac
+
+COUNT = 16
+MD = 81735324005671f7bdad9e685ee8257f5e0622b9fcb5d38dbdfb2df27258c3e1d46d76e24c0c92c744e1b50a2b4b0d31525b3af83cc80a75722d921bdeef59c4
+
+COUNT = 17
+MD = 17498cdff4323bb8021e44eca6559e05d8ff9a0ef2ee9d4ba0ac6e73f83972a0dfbb6d47728fa70311d7c82e154966e1b7678263b0f65133e9116969193d429b
+
+COUNT = 18
+MD = 228c4574d7c45eb9ba9240722133fce74abe00c7328ab30b4bde373dc79afdd6e0569d36268cd5eaa2f27205fc00512577bcbb6699e1d66ed85eafaba7548afb
+
+COUNT = 19
+MD = 3d40ccd9cc445bbecca9227c67fe455d89e0b7c1c858d32f30e2b544ca9a5a606535aea2e59fec6ec4d1ba898cc4338c6eadef9c0884bcf56aca2f481a2d7d3e
+
+COUNT = 20
+MD = e1e577aeac92e3a2b7f8a262bf2ac9c037d2274ca6618fbe4cc21db7c699e9946b6671ae45ea433a1e392a5bc9eec96fd641ba8f4a047f022a04a337227004df
+
+COUNT = 21
+MD = 5e4424c0bcb2f0f7a2428821a9d5840a82401f4440ae6bed25c53cd9e71cf9d39904d6a375bd721f4332ab0202529c91feb9c094c3e6d34ca4f66649ee6fa212
+
+COUNT = 22
+MD = 56b199d63ca37189d5ca0d40006ac7bcb9f39cbdc00ef7b8a5697caa7d81d05b645a146995b1151d01958f1589337e14afc6e7dd10a815170e527a398e6ce8c3
+
+COUNT = 23
+MD = d2d498ff93fb03013a64f295b5bc68e57d2fb5600da578aa011d43ff432eae3e0c800f9e2a53155e56fdbf5e068fe2b4beb3e42b2585531b8b16c4d8ca3356c6
+
+COUNT = 24
+MD = 3d3875489903710f17cf4247b5842ace6f017b1a3b99e9ee5fbc04fc7898e78b12693879878028ca40c63cd0f6925fb7d0ca0412e4f06619e3ace223690f03b8
+
+COUNT = 25
+MD = a013e21cd1234483c95c2ea2757be949bc79401ba39b09c316a1612d594642be65ca106e12695ac3808c57c6f2980e895fd1fe188946562afc238414e1e43649
+
+COUNT = 26
+MD = c5f6367d7195489e16242f912fbe0d8002e947de3a7e9c53f77b1e5e90e05bd7ca395e787e34cb5f500c02da59c9d83de35601de7ae80dae74a0d6b4a292d43b
+
+COUNT = 27
+MD = 7c28c44c6aaba83c122f24d68273e28a5afd65b4071d02b7ea3300478d5118971e1356ae57cbc70d2a177ea464a1c2c50d4297b933e789c63b1481797ae8f08c
+
+COUNT = 28
+MD = af7cb42b1c70a85ac1ae1c2991b25b657c19f4fcf83af7f7dc0ae1028c1452a6a17dc98929634fe6ed3855b70b96bc2caa93d82037b94ebeddc77e4c1a7cc563
+
+COUNT = 29
+MD = bd56ad4c0cbd162706053da929d667253aadcf417affb483fff4f2699bf406d128cfdf5196dfbb05bb89ccbf04c5147bd2ebb3156b0bc1768ca6faa171c91c01
+
+COUNT = 30
+MD = 004d7b0fff9bcddf4b3913ae190a76728705a3d23874d92a8b7ff246c8fcad46623cb04723c8aded0cba4968d1a8cc1375b99005786c1bcb7ae4bf13325c3ae0
+
+COUNT = 31
+MD = 8299a5bf5ed64f525c4eebbeca969fc1b91a81adb58c584bdd2d7676386a31fa546643a3cf505007584f02fb712d708cab645bf078a1b9339f5a76aee985d017
+
+COUNT = 32
+MD = ce7100f3455db1a9776a9f40d562ea998afca1f9fee7e0d81c8db34cf68ad23a8bfa6fc04774703e1e56d5196b66966158fcf2a8335a58c6ba7ba1af756ba1dc
+
+COUNT = 33
+MD = 90aaabcb655ee921b8350229efe6064a60051cf0cac858fa3d43afd5b97cc82301bd1b8cc1f874022e5af948185638783a13ca1bbd5049ace7fbf4f6d90c201f
+
+COUNT = 34
+MD = 3cf0a25b33ded3e0806dfe603b9987f1d6f2b3fdcb1ec7f8566828c00e17e8f59e38b3bca302396c7525ca194e6cc8501369059e2e34ae21e3141215876847c4
+
+COUNT = 35
+MD = bdc5266aee339a1ff13fcf5229773cd3d14b47101e83076927c160bb71bf7445590525a2012d52af008e118e16df1b6bfcaf8f22b4e45f9e749f3c20625a2bc8
+
+COUNT = 36
+MD = ef8d2ba885381ab97756d59dbbbf53a1ea35d152b2d8f82c3518430aa34e708359194ea43950d032e151f576d343a5c3cfe6b71d4ed0ead9d3a107402589bad0
+
+COUNT = 37
+MD = 194ea5324c4179998dd7057755f255fdea04dadf533f7851e3e9718b610948e32fd28323077d9421142ac808978adfa325b668c8599a2e01c757a5a14ed2dd37
+
+COUNT = 38
+MD = 106984d2f0087e621dae760552bc6279072267883c204079481af6034354f1a2b77c17e6c039a1063e479342aa3ccd90330dd3fb5a7d5e976619497e2d3326cd
+
+COUNT = 39
+MD = a1347216f1a6db47b90c4ded3c5c75440f54c22c87d538314d1340f86f88acba01378acb933ddad0adc6b75d55bfb7e8efc9c4a531b2a410610b7515b6dac66a
+
+COUNT = 40
+MD = b76e4db147e0eaa4f04880654088b9d0fce518c8c377d92c846345604dc6b2b18d377fdb8e30f06d9bcfe6d7dacc07d6adff73d98d49f8f132b80f3084390830
+
+COUNT = 41
+MD = acd4e527763dfd4513f0def0b1edf8ea12dc78d336b7b796f3dcc32e1068725443a2f55ab4f666b27d6bf2ab39669c98293f0a9108051fd3144d31a1ed171ddd
+
+COUNT = 42
+MD = 10128c15494bc87a87374f676ef9fe2df20b36ffcca41a80bd40b216637b3de710efd070e277827820a7bba3cceb7b21f8fe7f9775d6c4df4d3da5349434ec49
+
+COUNT = 43
+MD = 2632dd5c188c6ed3a4610405fdda704add752f5424d9de65a51400fe478e26cd0412e5f91ca4b744c34f4954f40a3a4254431d21954623208b527b7b4daa687e
+
+COUNT = 44
+MD = 45707f5b6fc5ccd1f78d77f177d10fb8b462c74cc821518cd5cfa4b5d6b40b418044900693c37abbb82367d340fec67f800d74072935da1706b4d90ae26099c7
+
+COUNT = 45
+MD = 56c37f31220b5b3040373d91b2c5e42fe9e601a12f7f8dc4534459bf28e484b8713db243c5782c031e674003a3c14c42fd152e7188789065e82795e10f87d54b
+
+COUNT = 46
+MD = 5da94c899d48bd8299fee3d81662f8d6c5f8f8bc54d18cb0368b13cebaee7ad71e74ea80f34974ad166f04f9a0602809166fe4085a475a8ca86cade12b6754c4
+
+COUNT = 47
+MD = 0664363f97ba910760b0922e31ca880ca97469506cb007e3108c36c3ce3ce1801fb4197609479339e8820632b6a38bffffee05a9adc11cc544b9aa6f5b95cc6f
+
+COUNT = 48
+MD = 732c41a1edaa727c04f627ff158aaff67c18efd667216132b99ab84d108996a10bb008b5d803b22ed1aa78bb0d10f8a762fd34777d7dccce8e84827ba88d4193
+
+COUNT = 49
+MD = fc9c21d67e393a2b05a23a17d8db630cbaebaa3def211181749f1bcad181560627fb60ee20fae2e5980cbf50fce0a19dce807e7fb75c4da0ef008bc75d413a65
+
+COUNT = 50
+MD = 0453b765afc1edffa595efe345177f5805ed3abc1297ceab757ae7161723a6144cb543299f418049276d16b7896662631634fab9549127c10f27505b7dee8665
+
+COUNT = 51
+MD = 3853f3bf024e0668e8d1ea53733a97537f97d9307c5f3a19864ab4eeb1654710693bb961a344dec8a758f5e64b26fcb6dd423419c4a114fa749211a9de06c281
+
+COUNT = 52
+MD = 240137f0dd57beb3f7fc283bb3ead423c67883fd46f4e27471d7be57ad469a49bad03a3658418bd55614678f3a463bceff85291314b90ef43ccbcb028f0a7a07
+
+COUNT = 53
+MD = f9050a5271edbe4cfdb9520ec05bbdc3cbcb9bce36fd212338d3e7028a39b9ab30793e561d75a2e424193264c7f0775e65599ef0c94e0ad24dbfe18252364267
+
+COUNT = 54
+MD = 47caa7a5862fad837aaa409a4a9df2575e645528c35159115911b7c4e2f08ae49d68de97249b31b83ce2c163f649cad4559dc6e6a7191f2922d79a5fd6af167b
+
+COUNT = 55
+MD = 13f5825c41fa49edf6104e3e35c9c224eba93e37374f730004c39c54e7391e4a847fd61865235a3fe32224c96fbe86f7e14c3d5df496e83ec989a71b4f293a44
+
+COUNT = 56
+MD = e5b55e05efe1ca6b9a96a57e3a1523d610d70f837e93b31fa98c2736d3e114d238d46ec6b6e3d19e774b253f6b0c7a2ebe69b7e60fc0874444806b2a2278df45
+
+COUNT = 57
+MD = f14a586ac30f0af255f597a9aef9abba5e99c04d17b01f24427c4ee2c196b52acb1ceefc9b15cb822b3ecffdc2f7c49e11d3fc0769acee33361537d379c62e0c
+
+COUNT = 58
+MD = 7e2d3398807195c48e6ec52d20710bbf8b21ea8de4d1abc197897ccc58aeff40259edc67270cdae0edcc686c0d0dccc5760c1495ab1cf48482dc2000ae2d42ad
+
+COUNT = 59
+MD = 2f3d5c5f990bf615d5e8b396ccbd0337da39fad09b059f955a431db76a9dc720dffc4e02c0be397c7e0463799cd75fd6ab7c52bec66c8df5ef0d47e14a4c5927
+
+COUNT = 60
+MD = 483a1764d308cc494a2b543d29ba616483aefdf91c7769fd084eedaac1add1891df95d317a47430b2bf73e4081f86597020e28afe2d34a22b77ea62b6112d09a
+
+COUNT = 61
+MD = bfa88691ec951511651c6f14af100eeb26d87729e18ac3ef49a80d73ffeaeea53e97c4a7277a7ee9f2fba070b1c9720d6cdba407dd82267019e3f0f5662b2f2b
+
+COUNT = 62
+MD = 4c17c8e2e7132dbf82afebc40efc77926d16f4d2c082d846dac28733aa767e2840ebf04f2563df75933466a36e11968d342e4157827605d04d9627ce9b5216c8
+
+COUNT = 63
+MD = 70bbfc29a2a765220af84e7bb10d759a3152ad4b5643ef6b89966950ec7ef9503d57bc0a28c4ee789a60bf9dcac59139e15241d73b990410cf92eff213da9eca
+
+COUNT = 64
+MD = 8d1d56f37fc19b84984a6fa33aa9c2dbdbf79a29c04ad0b4cf20333e6bec943447be2416242f8cd2f9732e79bb925cc5a61a80c5fc9c079961243fd1c1f5900e
+
+COUNT = 65
+MD = 492fd0171f4dcd5d20ea6c0d34b5576c8894664ae5955e6737f5e3b711c2804d99ccca065b7ec18c82da98b18a3029b765c51ebc7c433b36492e0ed6b8511bb6
+
+COUNT = 66
+MD = 7f49e8e54db7e5b4323cae2db71f3e8b8eba172dcad3602e9b7b058007a5589358732d5afffa56072a46e89b1ea27ef8d556deb86b569c635d394f15d99d8a15
+
+COUNT = 67
+MD = 56884a6a9210d5f371e25823efb2511a9c410c26a441e07c1bdffe8605084267d49c315baf6a692d7d97844b2714b4930877a5d7f52cf6fa151700fcb6980546
+
+COUNT = 68
+MD = 6aaef8284eef221ecb17ea3c9596f075b5155fe7b925d737ed3c6543c761c28c7cd9d9d4b5e2a37b2f183a2a367bbd34b633497bc7a1737d61c8c1f3ef295062
+
+COUNT = 69
+MD = 38ef178f5688e59d47c375252db7b39f40c0c84169878ee7ba5086e4b25fea81076b9c37847e9e6bf24ae0b343689c265ec5ca7469e619acd61b0276721efb1b
+
+COUNT = 70
+MD = e3fe1aabad120777cf24eaae289b486632ca46ceb89afae73dbae5fa87c767879369355a9cc5c21ca604ed91d0f2f58c466573f3e6d88e52c62c0d3cb188e141
+
+COUNT = 71
+MD = 82f5bd920457bb2763a0da031a7fed47b236951b1ea420c20fd2b6de1dbfbb9c4600ea7092788493e2d4be6ee24b6dba04e57af3e8f2f14d9837295420ac7631
+
+COUNT = 72
+MD = 6d0b26208ba9b1615067bb3ff97b292fe67e4c02d240d649c32370e0a4cd22d03bdf864be4d24a3f5f51aeccfd1afd5191e590edeb5f7bec323b0506c3104b89
+
+COUNT = 73
+MD = d081083158054d08371ec84f4d3aa5aa761734ac6091a30330a861fda056f835c750bf4f7981af1693ff28545366bd05cec47bccd77a7d237befb0135c534138
+
+COUNT = 74
+MD = 6ba8b52780b8a07a2a2015dd8f0c5e7437b8e024c4ee428f7ba91dfea118cb72a939872550983317132b841b7cbc29a22b8f1cfea0c55203cafc69b55ed6244a
+
+COUNT = 75
+MD = 312692b0a51f002b7f06d05b39d15a5637dbddd2f4f1a73e6c88a4c841cdba5cd8e69c0939ab39bb1a9c54fa35402143c97edb9704a0e9e1a98701710f6a5dad
+
+COUNT = 76
+MD = aaee960de201a8dcccff95b834fccf0dafc03fe6cffc0429162bf4aff01165ab07a0c9435e9cb412121b7ba010657ccc3152118602b665072136317d92fd4262
+
+COUNT = 77
+MD = 21fdff552e08c86c07f080cefacaaaf31846eb893bfe2e4f88c3c3cd8cbf592a84500942695a5e5ae971ab343ce2695dd1baeb1f94dd4b53d678e14265e421ae
+
+COUNT = 78
+MD = ca8f1a5b2172f6adb474da53b35e3f73ffd88263d3eecde72e48b16e1a0658015b555ee319005a1d82802e91431ee777610f9b1028d819921e1044ad426b0270
+
+COUNT = 79
+MD = ce5ab25eff9c1ddc569a1eaaa66b689109ee269db7066e0b02d39b3564fd14ca6249987b7791e203d3d7c2ebf18558d2f23f94c03dd1d03aa63849e4d2889a76
+
+COUNT = 80
+MD = a6f8b0561000dd4ae8b828c5f676e8c1a6474c4a042a645f1815bd52e9ff53c97dc36d5d8997f8ce332185feead76267f5b2e63f597fb3345ca0046e58fc0f24
+
+COUNT = 81
+MD = fec86794bad4106c5ad1c1a2d9a1b7aae480396ec231eb5cac21c4077d17a0b652da0037363399a5a1dababa4a40e4c54b9124167580dee9108c4dbb24c57512
+
+COUNT = 82
+MD = 594f5dd3f4c87bdc0d81309386e9163a9718e34c7b0dcb4613f8487aa786f9d211cfb61bb247fa9f5ecef042e710f192850f5571807294bfd8a54397850e5773
+
+COUNT = 83
+MD = d81ad866f25ef6a0a6431d267114da564513e5ebdcf48db7e95db8cf32a89f0ab107874d796035db97420ffcf1db5f04dc1a52ddbbb960fc63b7f3f835cc8be6
+
+COUNT = 84
+MD = 431d537e098e9949f6a68108d55d20952e3bfcdeb7273bac3917e37790a84fa5db04c33a79c113a06cf333e831d7702a00853a93fd0aa5146d934f4f71242a6a
+
+COUNT = 85
+MD = 4ed95636c6885ae4e63d042e82f4da830c702dbf3b9746d64770a64dd666b33208315f3a947c4dff790771ef283788a9c74da83e22b97f750286a820ee46698c
+
+COUNT = 86
+MD = a9bcb60b4d7724cdddddbc232b4ac70b94d0d7e9f0724b1222d918930cbb9bdbb04b3ad43e3c8caf3bf8b004ee4aec6bd527ff8eb6189b44827f7ba7057f6a90
+
+COUNT = 87
+MD = d6d5e44d5bb07fc4144ab6ab309f048968f73f7992beb326047e9e2cd7af6240bc8abf46703c32fdb58fb2a8672594a660ef855be74f24cec09d4fb00219de82
+
+COUNT = 88
+MD = dfda9ac0c7147530da97715ccf47814182255f2f2cf40287db97a4c63b43fcd39e6d41e560921492badb253a7dea0aba863c7c33b912bb59d1ff4de03a4f03bb
+
+COUNT = 89
+MD = 0395faaaf2e907f27779d6f1cc9c9db68ec390a38fbb0702c6475b46f7a399498d46fd8014f834b131e1e83abba0359b1f16d8fc0a393580615def2ad0caba73
+
+COUNT = 90
+MD = 41cb98f09029abe85d24a0f131f116c7f69f54f7e91c250642606512bf3da4ca89ba70a4714a5f66d9ae81ff09317dadaff12a02057074c970f0f02a52bfafd2
+
+COUNT = 91
+MD = 8e8f161d48e306c5533ed614b8ef3a1979df6db7e13d0780a73c4a3980ddf0a95f93941d412c93683e39915a660c3fbec0dbb1bb6beea2e2099cd968011535c0
+
+COUNT = 92
+MD = 789593f0b8fb83ef9b3ec50ab8f6e1e47344f763d4f7ceab5600989e7b6fd5fef6ee5e487975f64474af6cd71ae4d9ecce8f009edea0227c7ebe73080b8f961b
+
+COUNT = 93
+MD = f37e1449e0b313d9537a6177f7a31158d353e5b79c781facf02526ec94e0c6cfda37105bac67098b194ea82efb307c2929a9ab8aca0e76c53e829e3f901cd245
+
+COUNT = 94
+MD = 2e74e745caaf2d449ab3b031dd214b48616853a512cf2e95c40cb8e7594fe5e4879ac8a26d02eb35b3b96a5c9e7dcae3e15fd050a0bcc1fb3b9cb9c4df0fad3e
+
+COUNT = 95
+MD = 6eac7069c26082e52574ca6a58abb9b1b9faf452e8cca9f1c7023679ce192ca554892f30e38104d39088a24df35612444a0fc90084af7535fd9344fa51dded84
+
+COUNT = 96
+MD = ada6caf30c4f6e3644d952366e01519af6771b406e2c447552f0c597b8dd10e9e9b4e699c9a835de03f422be8980538d9786172dfd2fe511db272a1543d5aa35
+
+COUNT = 97
+MD = 4d4b0086b2cb05d713f2805caa7e6605c8f7dbbb2e0f92aa159aebdcd63060305f47b748f1bca6e0b6e11cf8f9697fcccb6584b878c4b54a699290728a40aa1b
+
+COUNT = 98
+MD = 97420b8a0ad102aeb92139da2c052d2748dd7d2dbb93a9ea79dc15b520d0ca7cab8cb7a00f5b5aebcb49d7e7f52a27180935ce617aeecdecba04064c668edd37
+
+COUNT = 99
+MD = 4aa7dad74eb51d09a6ae7735c4b795b078f51c314f14f42a0d63071e13bdc5fd9f51612e77b36d44567502a3b5eb66c609ec017e51d8df93e58d1a44f3c1e375
+

zeroidc/vendor/ring/third_party/NIST/SHAVS/SHA512ShortMsg.rsp

@@ -1,523 +1,523 @@
-#  CAVS 11.0
-#  "SHA-512 ShortMsg" information 
-#  SHA-512 tests are configured for BYTE oriented implementations
-#  Generated on Tue Mar 15 08:23:49 2011
-
-[L = 64]
-
-Len = 0
-Msg = 00
-MD = cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
-
-Len = 8
-Msg = 21
-MD = 3831a6a6155e509dee59a7f451eb35324d8f8f2df6e3708894740f98fdee23889f4de5adb0c5010dfb555cda77c8ab5dc902094c52de3278f35a75ebc25f093a
-
-Len = 16
-Msg = 9083
-MD = 55586ebba48768aeb323655ab6f4298fc9f670964fc2e5f2731e34dfa4b0c09e6e1e12e3d7286b3145c61c2047fb1a2a1297f36da64160b31fa4c8c2cddd2fb4
-
-Len = 24
-Msg = 0a55db
-MD = 7952585e5330cb247d72bae696fc8a6b0f7d0804577e347d99bc1b11e52f384985a428449382306a89261ae143c2f3fb613804ab20b42dc097e5bf4a96ef919b
-
-Len = 32
-Msg = 23be86d5
-MD = 76d42c8eadea35a69990c63a762f330614a4699977f058adb988f406fb0be8f2ea3dce3a2bbd1d827b70b9b299ae6f9e5058ee97b50bd4922d6d37ddc761f8eb
-
-Len = 40
-Msg = eb0ca946c1
-MD = d39ecedfe6e705a821aee4f58bfc489c3d9433eb4ac1b03a97e321a2586b40dd0522f40fa5aef36afff591a78c916bfc6d1ca515c4983dd8695b1ec7951d723e
-
-Len = 48
-Msg = 38667f39277b
-MD = 85708b8ff05d974d6af0801c152b95f5fa5c06af9a35230c5bea2752f031f9bd84bd844717b3add308a70dc777f90813c20b47b16385664eefc88449f04f2131
-
-Len = 56
-Msg = b39f71aaa8a108
-MD = 258b8efa05b4a06b1e63c7a3f925c5ef11fa03e3d47d631bf4d474983783d8c0b09449009e842fc9fa15de586c67cf8955a17d790b20f41dadf67ee8cdcdfce6
-
-Len = 64
-Msg = 6f8d58b7cab1888c
-MD = a3941def2803c8dfc08f20c06ba7e9a332ae0c67e47ae57365c243ef40059b11be22c91da6a80c2cff0742a8f4bcd941bdee0b861ec872b215433ce8dcf3c031
-
-Len = 72
-Msg = 162b0cf9b3750f9438
-MD = ade217305dc34392aa4b8e57f64f5a3afdd27f1fa969a9a2608353f82b95cfb4ae84598d01575a578a1068a59b34b5045ff6d5299c5cb7ee17180701b2d1d695
-
-Len = 80
-Msg = bad7c618f45be207975e
-MD = 5886828959d1f82254068be0bd14b6a88f59f534061fb20376a0541052dd3635edf3c6f0ca3d08775e13525df9333a2113c0b2af76515887529910b6c793c8a5
-
-Len = 88
-Msg = 6213e10a4420e0d9b77037
-MD = 9982dc2a04dff165567f276fd463efef2b369fa2fbca8cee31ce0de8a79a2eb0b53e437f7d9d1f41c71d725cabb949b513075bad1740c9eefbf6a5c6633400c7
-
-Len = 96
-Msg = 6332c3c2a0a625a61df71858
-MD = 9d60375d9858d9f2416fb86fa0a2189ee4213e8710314fd1ebed0fd158b043e6e7c9a76d62c6ba1e1d411a730902309ec676dd491433c6ef66c8f116233d6ce7
-
-Len = 104
-Msg = f47be3a2b019d1beededf5b80c
-MD = b94292625caa28c7be24a0997eb7328062a76d9b529c0f1d568f850df6d569b5e84df07e9e246be232033ffac3adf2d18f92ab9dacfc0ecf08aff7145f0b833b
-
-Len = 112
-Msg = b1715f782ff02c6b88937f054116
-MD = ee1a56ee78182ec41d2c3ab33d4c41871d437c5c1ca060ee9e219cb83689b4e5a4174dfdab5d1d1096a31a7c8d3abda75c1b5e6da97e1814901c505b0bc07f25
-
-Len = 120
-Msg = 9bcd5262868cd9c8a96c9e82987f03
-MD = 2e07662a001b9755ae922c8e8a95756db5341dc0f2e62ae1cf827038f33ce055f63ad5c00b65391428434ddc01e5535e7fecbf53db66d93099b8e0b7e44e4b25
-
-Len = 128
-Msg = cd67bd4054aaa3baa0db178ce232fd5a
-MD = 0d8521f8f2f3900332d1a1a55c60ba81d04d28dfe8c504b6328ae787925fe0188f2ba91c3a9f0c1653c4bf0ada356455ea36fd31f8e73e3951cad4ebba8c6e04
-
-Len = 136
-Msg = 6ba004fd176791efb381b862e298c67b08
-MD = 112e19144a9c51a223a002b977459920e38afd4ca610bd1c532349e9fa7c0d503215c01ad70e1b2ac5133cf2d10c9e8c1a4c9405f291da2dc45f706761c5e8fe
-
-Len = 144
-Msg = c6a170936568651020edfe15df8012acda8d
-MD = c36c100cdb6c8c45b072f18256d63a66c9843acb4d07de62e0600711d4fbe64c8cf314ec3457c90308147cb7ac7e4d073ba10f0ced78ea724a474b32dae71231
-
-Len = 152
-Msg = 61be0c9f5cf62745c7da47c104597194db245c
-MD = b379249a3ca5f14c29456710114ba6f6136b34c3fc9f6fb91b59d491af782d6b237eb71aaffdd38079461cf690a46d9a4ddd602d19808ab6235d1d8aa01e8200
-
-Len = 160
-Msg = e07056d4f7277bc548099577720a581eec94141d
-MD = 59f1856303ff165e2ab5683dddeb6e8ad81f15bb578579b999eb5746680f22cfec6dba741e591ca4d9e53904837701b374be74bbc0847a92179ac2b67496d807
-
-Len = 168
-Msg = 67ebda0a3573a9a58751d4169e10c7e8663febb3a8
-MD = 13963f81cfabfca71de4739fd24a10ce3897bba1d716907fc0a28490c192a7fc3ccb8db1f91af7a2d250d6617f0dfd1519d221d618a02e3e3fa9041cf35ed1ea
-
-Len = 176
-Msg = 63e09db99eb4cd6238677859a567df313c8520d845b4
-MD = 9083e5348b08eb9810b2d15781d8265845410de54fe61750d4b93853690649adc6e72490bc2b7c365e2390573d9414becc0939719e0cb78eca6b2c80c2fda920
-
-Len = 184
-Msg = f3e06b4bd79e380a65cb679a98ccd732563cc5ebe892e2
-MD = 6b315f106b07c59eedc5ab1df813b3c0b903060e7217cc010e9070278512a885008dac8b2472a521e77835a7f4deadc1d591aa23b624b69948a99bb60121c54e
-
-Len = 192
-Msg = 16b17074d3e3d97557f9ed77d920b4b1bff4e845b345a922
-MD = 6884134582a760046433abcbd53db8ff1a89995862f305b887020f6da6c7b903a314721e972bf438483f452a8b09596298a576c903c91df4a414c7bd20fd1d07
-
-Len = 200
-Msg = 3edf93251349d22806bed25345fd5c190aac96d6cdb2d758b8
-MD = 299e0daf6605e5b0c30e1ec8bb98e7a3bd7b33b388bdb457452dab509594406c8e7b841e6f4e75c8d6fbd614d5eb9e56c359bfafb4285754787ab72b46dd33f0
-
-Len = 208
-Msg = b2d5a14f01e6b778888c562a059ec819ad89992d16a09f7a54b4
-MD = ab2e7d745d8ad393439af2a3fbc9cdc25510d4a04e78b526e12b1c0be3b22966872ebe652e2f46ed5c5acecd2f233a9175dd295ebeb3a0706fc66fa1b137042b
-
-Len = 216
-Msg = 844b66f12ba0c5f9e92731f571539d1eef332e1549a49dbfa4c6de
-MD = c3f9c5781925774783ae9d839772d7513dfcea8c5af8da262c196f9fe80135b2b0c8c6ca0a1604e0a3460247620de20b299f2db7871982d27c2176ae5fa7ad65
-
-Len = 224
-Msg = 6b6cc692d39860b1f30203653e25d09c01e6a8043c1a9cb8b249a41e
-MD = 2e5263d9a4f21b210e0e161ed39df44102864325788647261a6e70ea4b1ee0abb57b57499bc82158d82336dd53f1ef4464c6a08126e138b2cc0892f765f6af85
-
-Len = 232
-Msg = ab1fc9ee845eeb205ec13725daf1fb1f5d50629b14ea9a2235a9350a88
-MD = 72d188a9df5f3b00057bca22c92c0f8228422d974302d22d4b322e7a6c8fc3b2b50ec74c6842781f29f7075c3d4bd065878648846c39bb3e4e2692c0f053f7ed
-
-Len = 240
-Msg = 594ed82acfc03c0e359cc560b8e4b85f6ee77ee59a70023c2b3d5b3285b2
-MD = 5ef322cb4014ecbb713a13659612a222225984d31c187debc4459ba7901f03dac775400acfe3510b306b79894fb0e8437b412150c9193ee5a2164306ebb78301
-
-Len = 248
-Msg = f2c66efbf2a76c5b041860ea576103cd8c6b25e50eca9ff6a2fa88083fe9ac
-MD = 7978f93ef7ed02c4a24abecba124d14dd214e1492ff1e168304c0eab89637da0f7a569c43dc4562bdb9404a018b6314fe0eebaccfb25ba76506aa7e9dcd956a7
-
-Len = 256
-Msg = 8ccb08d2a1a282aa8cc99902ecaf0f67a9f21cffe28005cb27fcf129e963f99d
-MD = 4551def2f9127386eea8d4dae1ea8d8e49b2add0509f27ccbce7d9e950ac7db01d5bca579c271b9f2d806730d88f58252fd0c2587851c3ac8a0e72b4e1dc0da6
-
-Len = 264
-Msg = 9f8c49320af9370cd3db20e9b50d3eaa59a6232d7a86fb7d472f124508d7968b05
-MD = 81b002f15c4d48be8517f7ed89df302fb1435c9435efefed58f3eb8ea11910623f1eb9028a66e02121a7f08a7c604226f2324f483e91548dbbd2c441ab704ce5
-
-Len = 272
-Msg = 4ab9aa069475e54b25e5688a52dd4acd134169c858105f01a0a1b134c72d4af51f8e
-MD = 48ba5a63aba7e7bd8e420475331125a947928c67fdb00f65c4080d9a0b99c0672424e76a1ba6bd76dfe492c730f6f9adccaee7bb11571aadb31f6bb628cfa933
-
-Len = 280
-Msg = f0c1d3407de92ef7421e42df5c9ab31d2ec0a750a9522869cbe4cabd66908d5823ec04
-MD = 9e75c5bca2c2af1d7739787f46e1d981c4f98e493d0724b5252c2fbae3c526719f1d27e6ccd0d705240281e8fbf3db75b9b3205c1413436d3b5d140004b8cca1
-
-Len = 288
-Msg = ae8c9f8fb41b519b6d943833fe1c32d1c4292fb1ddf1dbe2eb227d9e14d31ed74ebaef12
-MD = 042f9fd0a4ed3d9fec3655ae11011c6f2bc7e457e8812b6d8be2cd45fc6c432a94558c88f22c01439618865e8e49e509c448b342ca914b120344aaf7bcbdca18
-
-Len = 296
-Msg = da39fb86237f00303844e61fc6cfe779e42af53349839590bcd2f0e4cbbc279ec0b7e885d1
-MD = ecb43de8c233a731b38e30c5696f8876761b7ea72efe283fd07bedf20029f47c6d2a4427823e100fb087abaf22d7eff42a951c97c3dd05f48a20163fa4367cba
-
-Len = 304
-Msg = 3e7271d2070ef095394620c4b016576c150f34bea60784613a0f660d7fa5ae56872b88c58398
-MD = 8154d0da634ab2266061acc123acb407650ffe9164a22de3fe29bf05393b2aece92cf4db00ea5b4341c31ddb7de151683c8a71b5a44d5c3175790feac67d18ee
-
-Len = 312
-Msg = 311fb67f6a0784bb01a2d5a3f3092c407a9d3322319dff9a79f894291c5fac37319fb408402e18
-MD = 1870fe913abb0a4b4f53b6581ae18322cd05328514556607f3f4d7b6a2ac8e9185d94d947d8b9c88e0efa66d89b59f7439c75fdadd1816f7412306ab2b59d664
-
-Len = 320
-Msg = 7651ab491b8fa86f969d42977d09df5f8bee3e5899180b52c968b0db057a6f02a886ad617a84915a
-MD = f35e50e2e02b8781345f8ceb2198f068ba103476f715cfb487a452882c9f0de0c720b2a088a39d06a8a6b64ce4d6470dfeadc4f65ae06672c057e29f14c4daf9
-
-Len = 328
-Msg = dbe5db685ed7cb848c094524c1723519d49dc66ef9fe6d57e6862a6435750bfa0a70f104f5d396e61a
-MD = 2fa6e5b2c443a68050f093e7fb713bd6b18f6274c061ed61d79bf0688a61dba1940bcc30998276860943ab038902896d0fbf59b88b07c80de927037097150c40
-
-Len = 336
-Msg = 9fa83e96b2a6df23fb372895015678e0b2c9cd18a8542c3eaa2c435a76ae4dc9bd5136d970daff933acf
-MD = 3a2c0ec88a3e5347cf0ea9c078838300ef7356f9a6c342063277c106b880a00ed2be205c13064097bd372fde38007bc306561eb4e74bba2bb20bd354aa690ca6
-
-Len = 344
-Msg = 8a5a45e398bac1d9b896b5a2b4e3566b91d80ad20c977ea7450ff2efb521d82f65019ee762e0c85c6cc841
-MD = 3c704620f4066d79c1ff67752980f39ef3d9c1023fa5a213a5265376b14a15166ffe069b51df7710d8907fef9406bf375d502ce086ac82aff17229aaa7a5a334
-
-Len = 352
-Msg = 49cfffdaf4d031e33b1d28a447450545f6c4293b38d5afbcb9883976c014f080576ec691ac1bff70b742efab
-MD = 8bcc4f1ea2b7862ef1591bfa73916665de8faf65439ddf5cc1be43cebfd5f60f205e835a2b186b675b041258c5cff42669316ce25b46a2f4d4218e102f0f5d6f
-
-Len = 360
-Msg = 2ff845d85efbc4fa5637e9448d950496f19d8d57da99b7bd3df7474822f0a790586736416714e364c6e1fae04e
-MD = 236f6f4ed6e858c02d51787e60c578f731f694f8e52b5df4ecd5b04dff14c78e56bad1028d6f626c29d85aeee151a2a2846d3eed5cfafa9854a69fea8af6d04a
-
-Len = 368
-Msg = cfca05fd893c0f005f5ff796f4da19ba27a1e729956b8b715e67ce4b2d2a382a72ec7814f2f507b1825209a20fcc
-MD = d80969284a4565add4dad6ab9b3bdf53446142f84aaf92d4b23dd22ee7241e6c81489ac8b246edcb6df9bd7b23d91a0c517f546feba4ed5790a2be6e165c1709
-
-Len = 376
-Msg = cfc425759a9c36bb9f4b32eed7767af6566f68ded0adeae25c7a70ca78ec09774d16c8bc357f6d6f7bd441bf62d942
-MD = b587a785cdf455cc9c544e756c1e306300aa3c59f8725012e68ab4d54020b6d227a164d9f83c905e86f8cebeef708a69f976d6e7b18b9bf78e9b98cc4a5cd1b6
-
-Len = 384
-Msg = 097c9db919515242c99d973acb1dc4ed482768f974eb83b465f9f6c82503372006e4490835e2ec8f92301130bfb790b2
-MD = ff5a376f938e73014caef7fe3962944a7230d020b7087869ebe7ec70302721cd06fcdc981c893a425d05e2f99fe198e4db50a088aee2bf1263212110efed422c
-
-Len = 392
-Msg = 77e73d387e7bc80419ebf5482b61d5255caf819fb59251ff6a384e75f601ea026d83ef950ed0b67518fb99dee0d8aaef1f
-MD = c4c89cd882ec945cc888fb9a0127d35e585ecc14a75e4b5b3d8330538d22da28cf6af1ebec96dc247f109cd2aaab9756e6946a3d80db8363a4da3e6ddbb510a1
-
-Len = 400
-Msg = 317e5d9ac73ed0633fa18ebebbca7909ec3a5ef790478f9c38cacec44f196d895835b425774483043341381e7af2d383e51a
-MD = b10bb04491b9c0c334709b407cda1d503efb6b63ee944f2d366b6855e6e63e5b80115be4be7ff63edecdfb5923792e68123976d79212b3884dec2179d1fcf382
-
-Len = 408
-Msg = 209461f20666a346fedf4a530f41a6fa280c43665767be923bc1d80bbcb8c9f8f93ad75782ea2689c8c5d211d2053b993145a0
-MD = 67b7a328d9444056a52ca2f695c5d3f3baafb625a14fb32eee8ff26a40ccb296bec1771a826b55f7ddb6170d4caf7795b612448e66a0f19356fe505927149b47
-
-Len = 416
-Msg = 5d61aa45c446f3bf93604b0511313b4e2f306d6b046fbd94797b926746836f2e1dbdc56124060c6ca9c911b1122192d112420827
-MD = d3931bde2bde8271ed18ca0b9148b12f6f16161e637e376fc961f65bc33bcacf2f6addf26a3eaa81b196653cc37e8a739ec5b3df870d8c38c8f28691c22a39bb
-
-Len = 424
-Msg = 9288c795bb0b86c0419d9c5637dcc37b39bfa18d441e3fbfca75bc0306e5432e8e7b3a5627b5bc7fdc424a77520abdff566e7f2bb8
-MD = e363d0e95d8cd18c384016ebeed6d99c4fa2768e2bd58fca019c5108b9cde1cb46f3f884028a55ce282ec310a10037faa1b16b4a6a669957f0b00f350bbd63d0
-
-Len = 432
-Msg = 780427dc164b2f69b8c7d569266f461e2d30c88c4cd6057fb030a6cf636f24e3c0d0db742a7b6193fdaa15eec50dfb4fae6ec7653c91
-MD = 2964b009fb1bf996de12e030b9d6e0608ae8b9dbf2acfb9beb76fc5361cc104ee85c2a46fb7b4cee90848312da302de49afe61c546477e2b25d223d5e3d33560
-
-Len = 440
-Msg = ec2a92e47f692b53c1355475c71ceff0b0952a8b3541b2938270247d44e7c5cc04e17236b353da028674eab4047d89ec5dad868cfd91ce
-MD = c83aca6147bfcbbc72c377efa8d53654ba0830c5a6a89e1d2a19b713e68fb534640deb833ca512247166dd273b5897e57d526f88eef58f6ff97baee0b4ee5644
-
-Len = 448
-Msg = c99e31ad4e23ac68e15e605d0b02437f8147c44f5445a55b68a10905276cce8676481c33e8cd3efe322bb13fe0107bb546ccbec7b8b38d10
-MD = 52992d45a88221d972958e9f2854adaa9a21d2bf7051e1f1019ae78004da50c5b55c144a02afffe539d753949a2b056534f5b4c21f248a05baa52a6c38c7f5dd
-
-Len = 456
-Msg = 9aa3e8ad92777dfeb121a646ce2e918d1e12b30754bc09470d6da4af6cc9642b012f041ff046569d4fd8d0dccfe448e59feefc908d9ad5af6f
-MD = 994d1cda4de40aff4713237cf9f78f7033af83369ac9c64e504091ea2f1caff6c5152d6a0c5608f82886c0093b3d7fbadd49dfd1f9e0f85accf23bc7dad48904
-
-Len = 464
-Msg = 5842512c37312511a3d8ae41f5801df60cd682d58b4a997342b6e717e94006c214813e6c63e75591f957a7ec301779838bec8ae3ed7febad0805
-MD = 9763c43331ad0eb279d704c5f6e97e02da8724115026827f889e9fcda21f60fd230894ab35abb719890f3afa51afd31bc6852183b9c51059910af460abd2474d
-
-Len = 472
-Msg = ca14e2ea2f37c78f78ef280f58707ec549a31a94361073e37701bfe503e4c01ee1f2e123e00e81a188f08fa050825709128a9b66bb8ae6ea47e41d
-MD = 4600e022a02258739f67fdd367cc1e662631fb087918768352062b9b3c8de8dbca0e9ec751b91f284694fbddb8d325c0637bccb21dd2efa92e48dbab2e5e9c26
-
-Len = 480
-Msg = 647629c779b24c1e76f41744aba17159487532a0156a7d8264db50d645e9595ff81e0c96a850f2aa56c844c613a4b892727a9bfc3d3e20386766f805
-MD = 5bc842fc2d3b7eb31d2d3044df3ec32af114feaa7cfc27ebc8630f46ab6f0c543f59b812e776e5303861d17da3f1f16097641f3b808d4d5cb3e483946409746c
-
-Len = 488
-Msg = 1c5dc0d1dd2e4c717635ff3e9b67caf957aec0f8f63c1b1e221e800a4c14848f4ea06e644e5d3e1de592ef5a8007fa3f07171b24bd07578d68963e5cb1
-MD = cbf1ea86fa5b3dbf67be82fac41e84cccd0d296c757169b37837d273ccc015eecd102b9ce1cff68fdc7f05d22f2b774734f62ded54c8ee0bf57a5a82010d74f5
-
-Len = 496
-Msg = 8a555e75477d065b3af7e615475f37c0a667f73a4c7af5e4a69f28a68d9f4434776a8f90eab7f1d137eb4b22643c0a0d6a16fcfaa1bd62f2783546a9695f
-MD = c088e4a3d7da2f6f99a8f3f717361108872b8ffef921b383c24b8061d4e7c27fc56f4f20dc8f952a14043c5650b5a9e777c49c41cfeb3f2de97ee2e16b2c3924
-
-Len = 504
-Msg = ebb3e2ad7803508ba46e81e220b1cff33ea8381504110e9f8092ef085afef84db0d436931d085d0e1b06bd218cf571c79338da31a83b4cb1ec6c06d6b98768
-MD = f33428d8fc67aa2cc1adcb2822f37f29cbd72abff68190483e415824f0bcecd447cb4f05a9c47031b9c50e0411c552f31cd04c30cea2bc64bcf825a5f8a66028
-
-Len = 512
-Msg = c1ca70ae1279ba0b918157558b4920d6b7fba8a06be515170f202fafd36fb7f79d69fad745dba6150568db1e2b728504113eeac34f527fc82f2200b462ecbf5d
-MD = 046e46623912b3932b8d662ab42583423843206301b58bf20ab6d76fd47f1cbbcf421df536ecd7e56db5354e7e0f98822d2129c197f6f0f222b8ec5231f3967d
-
-Len = 520
-Msg = d3ddddf805b1678a02e39200f6440047acbb062e4a2f046a3ca7f1dd6eb03a18be00cd1eb158706a64af5834c68cf7f105b415194605222c99a2cbf72c50cb14bf
-MD = bae7c5d590bf25a493d8f48b8b4638ccb10541c67996e47287b984322009d27d1348f3ef2999f5ee0d38e112cd5a807a57830cdc318a1181e6c4653cdb8cf122
-
-Len = 528
-Msg = 8e8ef8aa336b3b98894c3126c71878910618838c00ac8590173c91749972ff3d42a61137029ad74501684f75e1b8d1d74336aa908c44082ae9eb162e901867f54905
-MD = 41672931558a93762522b1d55389ecf1b8c0feb8b88f4587fbd417ca809055b0cb630d8bea133ab7f6cf1f21c6b35e2e25c0d19583258808e6c23e1a75336103
-
-Len = 536
-Msg = 52761e1dac0eaea898e0b07cd24f4b2e6bb7bc200ea4b0528842f17b87154559a2ea94459a0e480ae0bdf9f757dd4a335aed0e510138b024a04ed1d591b4323234dbd5
-MD = b826fe80494e19c51b42f2582b2d080ba6b90512f35f2db67dd7fd5ee532eaa16498afba08b4996cbcfdf8d1a2df6b1da939e8265115a48aefa42f38205db436
-
-Len = 544
-Msg = 3804ebc43cbea80c2bd7e4fda5c5515500cd2d2b846a1378dbf218d5c377138606eb3cb8ac88f9076f6ff4436f90717427c9df1ba052acbbe4585e98b6e8e0bf800f1946
-MD = 17dd6d87bc6773051e52047fd444996afa8124b0483fe121877f98553448772bd0e7751fc655e9cc2d29830211015d310f191474ca6adc0477a187c03b8fe252
-
-Len = 552
-Msg = 2249d698c4d807a8e7b4de21c485738959a0d67e5d2ca6f77983dfccb5dbf47931261e1f1537f3cbca253afb6bf4fe5e7672e1dcc860b3d6c8d243afe2d9758b375e955692
-MD = 6af44563fc468d51182f6c3be58d45932af1d985c6f283976c91a9ff421f383fe21dc7322f397ccead583e26b3e3fda067976a7f34665df25a2ced7b4b09cdec
-
-Len = 560
-Msg = 32a9c17033658c54f22c7135ddfc879de94d79593ef2dc7d3041bfa872738389864eeda27801794ccc4ff1fcb5ef3fc48833801d6fe959e3627f8ea1536ad00fa9c7d7d9f043
-MD = 6a47699dd3ada2f11bc4ea42072b06cc20857bf164497df1285400c250f5848b6f71957dbdc845f5daeab913036661f69387893fc2d61c25fa59b9d85b19f401
-
-Len = 568
-Msg = 3d65f69a590a5baaabcd274fe3ef9e88920ffc7adf05c16d7b0f4d18d72bac1e94c3b3d83b8f4c552eb80e9fde3911403f8b000579816f02e1716fd627946031d0af0793e7f3e1
-MD = ffb2d9450943c24b5933c24812459b75d3d9f380344c9bc06fa3e17ee448eca2f98ff79f7e2235ccd9f9a8176f68a2254bbc9b834d6ac8d2bfdbc1597c432c9f
-
-Len = 576
-Msg = 76ff8b20a18cf104f6cdb65e2ba8f66ecf844af7e85e8ef2da19e8848a16052ec405a644dafb5ca08ec48f97327ac52c0e56218402c72a9a6dc1cf344d58a716a78d7d7529680bae
-MD = f8858144c6d709dd0689a526a548a43f17494950ba2ac20544799e8ea27201d78bce5b921e29a7b4029278e68341ef2a0ca4ba3894566b3c8f8950e3e545a689
-
-Len = 584
-Msg = ca88dddfc876a12f45f19562bc9ca250f43267ab251a7f345c3c022e20144e135604078762ef5c8a8f038cf1b1d6a91709b59dd068396a9e971ab628f74886e765384a23607c1a1e6e
-MD = 4f3d9eeef349ca51a7e419af1686f42795abde58a85335ce68d496e81e4436a80a61dc143a4300008c23a3e71f4ba98743195a3694a8d02fee11bd314569abc0
-
-Len = 592
-Msg = 0a78b16b4026f7ec063db4e7b77c42a298e524e268093c5038853e217dcd65f66428650165fca06a1b4c9cf1537fb5d463630ff3bd71cf32c3538b1fdda3fed5c9f601203319b7e1869a
-MD = 6095c3df5b9db7ce524d76123f77421ce888b86a477ae8c6db1d0be8d326d22c852915ab03c0c81a5b7ac71e2c14e74bda17a78d2b10585fa214f6546eb710a0
-
-Len = 600
-Msg = 20f10ef9a0e6128675340171cd248df30b586557620b615ca39a00db534315a9012dbdbfd6a994986eb829dbe6cdaf3a37d4f59ac27298742c8f777b6b12677f21eb289129579868705f27
-MD = b4ead3f860eabbd36c770d66c7356f8107acd1485c7c94178c2eaabd50266d7645d009972586ef83ed43ed92882137df5117b88f35231b894ec1741ae7501145
-
-Len = 608
-Msg = 995c8f747ea418f7d63aba2260b34ac3c7dceebb78438ca4b1f982b7db9798ec1a7f32622264cb024c0d9e60e955a6e1d677c923518851990a459b767d0f13cd803460f61870db3391b44693
-MD = a00a601edeaca83041dc452d438a8de549594e25d843c2cf60a0e009fb92d87abe28a72690ab657c8d35b43cd02d22ec0755de229d1f922fa6ca18a6d6c2aaae
-
-Len = 616
-Msg = 0feb23c7e4a19bcbd70bd300d76ec9045d696f8c9687f49ec4154400e231d2f0862495150cf250b6f12f172a7d130f8fa5d175bf2f25e280172ccdfb327951701165302728a619aa2f242631c9
-MD = eeb6dee30c119fb1e1eb5c15ff2b32d8b9c7464a4e4cc6815cd251a6bae29b49961dd5c2fa9c44a9b142ca062c7072cbf3db04299b767789040196bf0c06aa76
-
-Len = 624
-Msg = ac59a110623f1a64666f160ed32926676cb5be25dd9d962f441951b0efcb5d6a67ac1a4eae473e49c6257860728853ff415c5e8ec76a8a462ecfd343eeac22dad820722c597332fbfd94ebbd32c6
-MD = f65ea942ae0a47e73b02b1442e5b26083db79307f64dd34a039c476faf18d5c514bb77a2c412a6074a7afc326ea66c74e5705fe2abbabf274333325a15b61fd9
-
-Len = 632
-Msg = 9e3e1077e1333a1fb1aa633ccf2f746588ad426489ea08dff5511438b5f4c0b110d1a4d47b540a12b21ea2aa070578ccfa5c22fe0b743ec0cc621c6b3a03b75f4d3eea5dce89e03269afcd9603d0db
-MD = 4b5c5df80c344c12388c723856cd06965b2190af652480476747dc2195ea3716f87c1762359583a5f31522f83f7833bec30f1f47d14540417dd463f5d258cd4a
-
-Len = 640
-Msg = e881e3284c79d8f5237e699e4fbca84090c664bb53229f58cb0842b0436710c9b329d98191b8f030e9c1df89b03858c1569c6ff49a7c07c4a23a8a434b0fde13be4f94cb44ee629d5b44d336090d3de6
-MD = 147d8071c7871ef9256cff32aa63ea031404fa5ee4ec09c56afdd5da919b0cc84a9d35d142c417715203316011cc620cd6855bb117063a5e52867facc680d5f4
-
-Len = 648
-Msg = e58521098911503de84311387d375c25929e6e55076eb6934fd8f2b1bb7b9667fbd76d5ee204828769a341b1f716da5bdfece6c62a9f4d4f988267fce1f5615540dbe375324eef607c910d976b45a5ea5f
-MD = f97ba056fa41f43b8e1987072a09e828c71c5ff6ad4e37f9ab6b89e2a078933dd23052fa72c6615b613904259e9ff9b55ef7b923b89bc8752f6babddd256e117
-
-Len = 656
-Msg = 3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c9f133e5f8527f1b184830e07c3458c83a8ca9f9d9c6998760e610668ba0f22e22b656a737e978b246a17840b7dc4091da85f
-MD = c8a466199acbcbc93f2ce042968508c046901631e3118a2d0bf39a9b42b4197a379b3a86cdeca9df2de1a3eb71b79ae9bf2d6575eadf1878029c4093133f54d3
-
-Len = 664
-Msg = 9af608d031ccf309d7273c607a8e5e36840d449b55db5b13f03aeb9af49fa7e7cf1383ee2ed9c5a8b7515f16fb1c7c84a681590bf90f56597b844db5ebee223d78109b72350772f7c72ea996603e1e84f2ba5f
-MD = f0ded9495b4f64cac585be8a737cfa14247a4a81cdf7f01ebcb134ace71f5a83df2cd72e7773fea1e82beae17e13857372792c8231e2ab9fbeb633e399d5f0ae
-
-Len = 672
-Msg = d0df1bdf1df6203241722fb9c9c1cf7405017497ae154538ccf9224ad752e6ce1d4ae948639aca70cfe86b2b06543cb9914ebd3085aa3e2963f6e9b93d0b03a31ae26fcb9ca974eee016c091a6fcac37b21cc1d7
-MD = c2da3ea3c8a3fd88a5bc5dea2bc076f861abedefae5a5fbd941ddfd1c41cc3312eb2dc826c2c0f65414fe72ebee447d2f9b1a6a56302660d1f86632ee80a175f
-
-Len = 680
-Msg = 8cbc9480553acef7bcdba9716ea8d66b4131780917de2b0b048045fcb32b5cac054808e1fce6e94ad851ecb47fe6cb802225d3551e08ea122093d0078dada564212eacf1d6394e0007cc62a1d595ab14ca08a284bc
-MD = 63b39b88ceb848188b37316e04560e75a5340ab8d417932d231c997e892b41daa69d9fe3e9a14dd19ccfbbfa01488c208e7b946cfaf16ca2b1bf7c8d8da4e6b2
-
-Len = 688
-Msg = 38f184448f3cf82a54cafc556aff336f23f9149e612134b3fc00c8a56455653d88640b12f69062b8432c4335ad8f7ab4ff66cb7eb54f332561a36f024d92c3e26276f4fd48619628cff88e4b8e85cf14ca4767ed990d
-MD = 9a49265fc641c59f1a91872cdae490d3da73c0c60fd59648e1d17dba1a647a5b95629392bb4ff5163d1a3cb45427c1437a3b2e1d9f030c0a8bcc5ed22da9e2ed
-
-Len = 696
-Msg = 70900618b1e9e9db62296fb6c6590c9f10b0a632765c489c887f1ab7c07791765a62e38465e1be281b1d396c6e080b7ee3e6fa56a30b9799d0e629be153ee76f81bc6a3295aa61489bfa87d53a8ad24248a6ede0dfcfe9
-MD = 1c8c3357ff1f8d6ac4defb3af462a73e09159e3a20c6506edd8cd3052df941c81f68c5fbb893912619e28640977fe8eaae8e9d5d4e7d5f132552cefab4540bac
-
-Len = 704
-Msg = 4e6ddae0d805afcd10a055bce584c848d050fb29fe8f1c64b18e1abfe46b65782e6ff536e89d8d40928b41ed7371365c8080a9647f7532ce6c6d4ac21cfb0c8020783851ec9a7dbc3948f8fca7adf8b2a78c04d898d31ff6
-MD = 5c2f996c779b91b3c4639311f54fabbdde7e2212b53dbae4828c8399588fc00d3b2ae60918aaaf6bb48bc757e52b2bcea84f5d15bf4ec25d5519fb54f6f26e1b
-
-Len = 712
-Msg = 696825f6d6ea8173ec47d0959a401c4ddf69f8f08ddd678a4d2ff976e3a4372bb39f4159845cb63585e1d4108d32e12fa7c5c9d7ce3508a7f53aca2b4bd951adbcd8984ebb7536563f5884c90bc5023b3316f7e4dc6958f743
-MD = 3ce940ca96b00011375daa95c65f66907d69b3eb3b8d779e6fc971afcc05e990bc4c541f434590f6b18b68c080d0f24475a3e764e9cb85343301314ee2fb661e
-
-Len = 720
-Msg = 79ecdfd47a29a74220a52819ce4589747f2b30b364d0852cce52f91e4f0f48e61c72fa76b60d3002cae89dfc5519d3430b95c098fa4678516b5e355109ea9b3745aa41d6f8206ee64ae720f8d44653b001057f2eba7f63cd42f9
-MD = ba3d0fe04470f4cf8f08c46d82ae3afd1caea8c13bebbe026b5c1777aa59860af2e3da7751844e0be24072af48bc8a6fd77678aaee04e08f63395f5c8a465763
-
-Len = 728
-Msg = 9263fe75e8f6c7d5d642e2ca6a6eea4f44e9a0f249513ed79c9409ffca5526ca4491aebb1382057cc7c36722b0b6c3b15123cde312214f25353abfe30bca170568a8e1ba5408917403a01834080ab607c56a10d0265082498fe0b6
-MD = 7736d7a7fc1eb05857ce7d88abfffa87f58c670bfdfc0a8031f60f379e4b6ad94ac8f13ffe28c697809b5cfac7f13be01e7496a85237c4025539051fb2e32fb6
-
-Len = 736
-Msg = 78c17bfe0e02eb526d1a44a1ac127be082181452b625394bd6dc093a2cb432e6ee59c2f8b5503aba30dae41e1a1c6702697c99b2c94e94af48b00caf53b2e0e4e1bbee81ee282c7b2b35f58cf421a07e828d57a6622626af25835399
-MD = b56b6e343166328523e0d1693e5174da643ae83cf69c85a7b3c3bee247b77b84702069d9e6b4cab03bf17fe612009bf4239683ca78ca7e876aca7d07603ba714
-
-Len = 744
-Msg = 298bb304a920f960447d8fd38b061bf8fe4ac1f871d8a0feb4549feb72ca694a5a41b6867d94cd5af77d468ad2f315d127b6c41a862800f3985e573e037740298e2c5c6186a9fb83609be2d49f8b4c31f96a2e49b56dbf09571b38587f
-MD = 34e3878627904ffbbbd85266cc973c34f931e3cab5d4c31f841c553dd69f84838206067df4f9f3b9102001be19267151e673f5c2d4c2f8438a6999a0a325487d
-
-Len = 752
-Msg = a3cf714bf112647e727e8cfd46499acd35a640dd393ddd263cd85cf6225f59890a0686dad1c54eb8d809b81c08a98dba131bbdd6fce8ff59d95db824d8831ea480529da739227a6e0f62b603b38c35cdc2581f614a31879b8be54aeefaa0
-MD = 6f230ae4903ddbef0ba384c2e3506eab318bfd1a46ea76099f65a3fd529c91bc2865b9fd943e346de64626b8529f9db1377bf2c5e0129c66b50c6a5cfb364b3a
-
-Len = 760
-Msg = 0a427ae55ef3a7e6044a08cf6128cbaaabfd776c4e9374708f2ece246fd73603d2f54ac3e01d16cfac2bdaf713920d66e8f0a3d54ee68cff64267d5528cdf2f295f474d10f81173e0143488ac53fc503c444ed23dec63a080ce90c2443dba8
-MD = f6bbe5d0cf13ddf41c1436748a5d1ccae2948547b452c2171c7c8e8b66c6ae4de3c0e8b2962bcb60d3de3608479f80e455c9024d9716c38f6f1206861ab1eaac
-
-Len = 768
-Msg = 2cbbb87511f4948efec3a61b511ededb1dda8b6ecfc0210c11e43a77ee32dc2e374afae4268e3d30427804868232a966b56006d3214037076bf6a265b72135af0fb2ef7909fea2dea412f7717446b276ff153753662b4d4148c02347e3259169
-MD = 76897b87a8a1cf835c434f6d391c9e5227351af9d3e20a3389c796b98b424281a59068d9c8d567ec2bebc435b0126b059e2d86394a9854d6611e1c922f385496
-
-Len = 776
-Msg = 2b23324c9992f60a7fc010159a03cb9a2b290df4fa6a82359b9af602f0a403a5ef33ed5da5b2caf87b77e6a4b93b650348ce2a7dbc08f8da9203d710b587ba5947c65e899f4a759f8e2b049ae7850a8e3e2962f6ef93ea4c631de5d78e729ec5bc
-MD = 3beea0b373ed09cf1c919c51d86d642c9125e0ee81698dc4cbadf02e9e6925efb562fd9b87301a6377ca192be79c4118deabc450b54639000c2e312945451fb5
-
-Len = 784
-Msg = 4022f930c7033b00d986c65ff6bbbdf9ebd0e58c52844ff658df3893c3202dc533f873d4a7f5a5f944419fb5528c9b6788479a1e891306acae7995fc06db70a59baa95bef7da79f5e793f2db7f2a55825e4fdb4a34884af881ded1089fd5334502a2
-MD = 0358775bbb733ccc49e78f544aeee512370d480d0e13c7e8d5c444c423e592146b45fdb91a1b694d35e36b60e4bc8397fca8bb9790e619339778b9cd1abe3fe9
-
-Len = 792
-Msg = 1cb77ba43ce77e236b9fc925f589b1c070780a84f99e8f50c1ff846ac92599cfe91612c8178325bee642a34f4dffdba2aa2ebcf7064339829b26f27993e1106c139c70d578cc05f0e1a777cceddb10a2c67fd9675e4a009df8037d6eeb38f5fba233df
-MD = 6502f46551a3fab3a96428fb97801d7a4aa2f17fef6603238df84e17c74309ed3d9489c8b16a9384ee634a3f86d0b3ba9a4dbc9c51ec8bd4bf8d61de6d3d87d7
-
-Len = 800
-Msg = 52167de2d6c502d99fa10c27b2ab6203bdebc2cafbbfdef15872a43dd610c2362f796ad9bcb5528d95870058fa454453f1e6065b315d410a3f2650e5d71e69d78d9767dfb4accc057fd2069266b0f180cb319e30ded7535bbe52d24be151de4bb598fc5c
-MD = 25cb3ed3983a91b4cf37a65193916c5e3e211b63e943e2f7b50a85d349a463b941aad33eff16561bdfdc92fda06a4e1d94b162de48f06d3c626940b31020925f
-
-Len = 808
-Msg = cede6697d422ddaa78e2d55ae080b8b9e9356c69bc558201a2d4b0b3190a812c27b34bbcee3a62b781378b1bf636b372bcbae1fa2f816a046a0a649a5c555c641fea4ccd841cc761f38f777972f8c91b0324e71c333ce787f04741439bf087ef5e895011c0
-MD = 0be42a25d77ac6ad995c6be48e783380bad25a61732f87cefb0cce1a769cd69081f494a1a12d657664ef2b4d9c41f2ee83f6e9a84327d8756af9f985595e7d3b
-
-Len = 816
-Msg = 56d18d3e2e496440d0a5c9e1bcb464faf5bc70a8b562124f5fc9e9deb5fee6544b945e833b8b5d131b773ecb2cdd780cd4e1bb9e4f1e3cb0a1d64d19cf4b30e44e6c2d0cbcb4e284ce50db7a8a8062ddb63f981d9026c532bf8eeddf8af5a43848a32262178c
-MD = 982dc61c91a93770582eee8025aa55da8e9edb966bf5cf70d4a6534c0d53a2789a8c4fb65b7fed478cda02ed1e0d198d85c5c735b2417c5fab5d34e969fc8e7e
-
-Len = 824
-Msg = 25a7320dfaec5af65da4d0f8688e29e8e95532ecc16679ea8aff0f407d898db6922855b0e8901aa9681aa3dca617cb440764cdc7293fbeaf7f585b593c2b0531738e0ade7c8626b9995f4a84d9fc9b593d6bbee01abc53c5be14bf6956fd2fd81000dafc7c7686
-MD = 749c928c3d5510925bfe98659025b0ed7c01acd4d59a9bf1c54863a088091771dc9d407bdbf83b0f44b0902e10349ba79c84d0981d5e8c4f5c733a117fed0790
-
-Len = 832
-Msg = 3d7177b28ffd916e7e0634895833ba0bd9e0653df2cc4202c811536a005aec853a505e75db55d3c7107579041099e382a1feac80dde65d72368e909ab85f56d88e68d7c3c80c38f85bf8c2b36959409cc34ba8e3ad94fe8ee1927612d672d92141a329c4dd8a88a9
-MD = 14a331508cd7d94fcce56a66bf65f20870a281c8442f8dbd4c2371454a2b66f8d0994a0b67692e771efc6a5e0b887acae7d6f4ec7338e1aa89f2abc7034c4e4c
-
-Len = 840
-Msg = c033e4a512297caecdbead892b11a9f7007af9a74bcab89e0bd4ffdd542ca03ea12e17a06c42bd43fc5f3f757fce4f6f5831997abac3f95676e1ebdb11ca43e11aa31e5ebabe18ce8d1bbfd8b02f482e1ce581b532e307e6960eb97441506c2ed299e1282523f41527
-MD = 95ac9b7d22aa458921874c4b4331e7d64761853217c3f83c601abcbccd7e2eaa6ca6ce9a22ebcfe5046d52f8a09097f043ab8bc59243fd770090bb432c3155e9
-
-Len = 848
-Msg = 69fff0f1a3dbfb36e32f025819fa99ea9a0edaef73145bf7fcd05d8bb0a646cb3b5d5256d524856acfd2e44d6b72e4ebf1ff23c0ff6c56f821e782d5a15f7052a1445b06668eeb4af700679ee7ae26496fbd4640c06aa149964dfd6011df835ac13b73c8ff21151e8440
-MD = 45d4daa652558d1c12beb0f5662c712f325b4c802fc6eb9ee039c949d002bb786f1a732712be941f9c5c79b3e5c43064d63a38578e5a54ee526acb735b9ad45f
-
-Len = 856
-Msg = b2c439c97ab7c63736b3796324d68eeb7a471ed142bd9622684167d61234fff82f93f907537a909bc2e75a4bcbc133cf57197662c1af746ae8b81e5b83de05d9b589851de25d3c99c004c1dfb12d93bf50d450af49c428716f5b90ef088e3b6a6b2c46d3ce67b379599018
-MD = c48ec83be5fa669e6ec8db90aca9676cfe2ec0d5e8e7a2431687bb953c0a300be3db4075cca3bac4dfa4d971baf0fa1aff46639db4b238856ff36d1dfcd520f1
-
-Len = 864
-Msg = c016f522f26b7470e922b9a287e6d45f6c28813b68c1457e36d9ba266708272f9cbc5411f8db9d8bd5a9449fb6eb0cde7d4d03e5df019f2814a90ceed377c59d7d92623899bcb0268033073559d4d8de488686cbe3d67796e6df6ad4276d0b52cc62c49ebb58d7c95287aa6c
-MD = 7402f1a99b47e102b3b73140c6771b07ee6c33b3715e9c4027c441bee40511b735d95e508baea78da26fded9b7038e9a53defa58448aba40dc1e62d7ec592107
-
-Len = 872
-Msg = a766b2a7ef916721f4677b67dbc65ef9b4d1bda1ad4e53fc854b0236440822152a111939e5ab2ba207719472b63fd4f4a54f4bde44a205d334a2d72cfe05abf804f41841b86d36920be6b0b529331ac163a985556c84511ec986439f83e1d7311f57d848cfa02df9ea0cf6b99a
-MD = ddd60f93a3babc78299cf763e7919d45ac6f479700e1adb05ab137acdf89c1521ecb9dfeacd091e58ca57a1db964a9c3cd1fa39192cc1e9f734caa1c5fa62975
-
-Len = 880
-Msg = 10f2be77a4055771a67007cd8630e3230e38288499cb160380290174d66da57455b6baaa9785c84c8a663de41ed3bd544055b9170cec43cb3eb120eceaba1fe36e3eaa3fa4f99b425cd2519f09bc0282bada52d14ce625b1ded3b24d86b1dad342d2b7be322b775b04fc6b86afb4
-MD = a872fa33d463b3343cec57c20c66979c33e1ad067bfc703454696aab5dd0003bc194318f4a8ebbc74503feb7211a472dadee991efe3e38f21a1310f8a76eac80
-
-Len = 888
-Msg = 324533e685f1852e358eea8ea8b81c288b3f3beb1f2bc2b8d3fdbac318382e3d7120de30c9c237aa0a34831deb1e5e060a7969cd3a9742ec1e64b354f7eb290cba1c681c66cc7ea994fdf5614f604d1a2718aab581c1c94931b1387e4b7dc73635bf3a7301174075fa70a9227d85d3
-MD = 3b26c5170729d0814153becb95f1b65cd42f9a6d0649d914e4f69d938b5e9dc041cd0f5c8da0b484d7c7bc7b1bdefb08fe8b1bfedc81109345bc9e9a399feedf
-
-Len = 896
-Msg = 518985977ee21d2bf622a20567124fcbf11c72df805365835ab3c041f4a9cd8a0ad63c9dee1018aa21a9fa3720f47dc48006f1aa3dba544950f87e627f369bc2793ede21223274492cceb77be7eea50e5a509059929a16d33a9f54796cde5770c74bd3ecc25318503f1a41976407aff2
-MD = c00926a374cde55b8fbd77f50da1363da19744d3f464e07ce31794c5a61b6f9c85689fa1cfe136553527fd876be91673c2cac2dd157b2defea360851b6d92cf4
-
-Len = 904
-Msg = 9159767275ba6f79cbb3d58c0108339d8c6a41138991ab7aa58b14793b545b04bda61dd255127b12cc501d5aaad476e09fa14aec21626e8d57b7d08c36cdb79eea314bdd77e65779a0b54eab08c48ceb976adf631f4246a33f7ef896887ea8b5dfa2087a225c8c180f8970696101fc283b
-MD = 3cd3380a90868de17dee4bd4d7f90d7512696f0a92b2d089240d61a9d20cd3af094c78bf466c2d404dd2f662ec5f4a299be2adeadf627b98e50e1c072b769d62
-
-Len = 912
-Msg = fe2d8ae200e6657fdc7494af5a12b2ae940348f1f983f0ba98febbe99c80d115126d57dbf37296765ebb5990256696588b3851d54c8fbe7ade98a6faf7c20b5e4f730f54a7f912ca0ac31bbb53d17949ef69aa0de40c7bab12a871a9b90f68813ca87af4256422a268f4a1d8ec3aa1a947fd
-MD = 8025a8608df0f6a01c34cdec012d4cb25852e1b100b68172fc4e86ac8b7126b64859cb9e767a7e59060989cedbd925afc475ca7369bd43f85ae590e224e036dd
-
-Len = 920
-Msg = dc28484ebfd293d62ac759d5754bdf502423e4d419fa79020805134b2ce3dff738c7556c91d810adbad8dd210f041296b73c2185d4646c97fc0a5b69ed49ac8c7ced0bd1cfd7e3c3cca47374d189247da6811a40b0ab097067ed4ad40ade2e4791e39204e398b3204971445822a1be0dd93af8
-MD = 615115d2e8b62e345adaa4bdb95395a3b4fe27d71c4a111b86c1841463c5f03d6b20d164a39948ab08ae060720d05c10f6022e5c8caf2fa3bca2e04d9c539ded
-
-Len = 928
-Msg = 5af8c0f26db4e99b47ec2e4a01a786e77899e46d464ac337f175027b61aef3149848af849d76ac39b9b0910fe6594817859e55974fa167518ed72d088dae6b414d744d477974fb719c626da792f981233de24b7579d8acca510a266d73c0ee8ee1424343eaf6ffcc59c86c1becce5894072c6c11
-MD = 09da284d5b6556508be54c8ab6c97bbd472995c6bbd585917ecdb54ea9167208daaa070a7b2b7d8e93ce1315f0d1ef8d69667429c44dc5ee1499de57b229a398
-
-Len = 936
-Msg = 49cd0ba0df5bb3f43f68464e3e83e9cbd5d5ee077ffa5591e30f939cb30c93f7d454fb3fbf8bb05327a89c08dc4baf1eef50237317a405775357f1e0d1f31d9f0f0d98124019d47bf18363b1ecfbfe155c10cbc83300e01bc9ce0347c596b35f411e6d8229ad2855e42022b0373ade98663c6d6e9c
-MD = 30cbf0679a97c871574d2fc05d7aa760c6bc8a864b7d246c39b9e812f9b7ff7b4ef5197dd5b69493306688b8564de1ad47d75505c913ba6a78788f8caf5788bd
-
-Len = 944
-Msg = a8a37dfc083ad2f47fff468738bf8b728eb7f1907e427fa15cb4424bc685e55ed7b2825c9c60b839ccc2fe5fb33e36f570cb8661609e630bda05ee641d938428867d90e00744a4aad494c93c5f6d1327878078590cdce1e647c9820818f467641fcd508e2f2ebfd0ff3d4f272393478f3b9e6f806b43
-MD = 8e1c91729be8eb40226f6c58a029380ef7edb9dc166a5c3cdbcefe90bd30d85cb7c4b248e66abf0a3a4c842281299bef6db88858d9e5ab5244f70b7969e1c072
-
-Len = 952
-Msg = 36af17595494ef793c42f48410246df07d05936a918afe74cd005e537c586b2843701f5df8952242b74586f83339b48f4ba3a66bdeb457ecdf61784eac6765cd9b8c570dd628dbba6ae5836b9ac3dbcd795f9efdb8742a35bca232abf36eb3b6698b2933965802277ba953a6edcacaf330c1e4e8c7d45f
-MD = 158bfc348a30b4fabbe355a7d44bdc2122a4c850444c03f289003ce01bfc1ebf3ecc0febb6a8ff523d25db7681b05bdce048d11943ab476c1967cf6556c4a120
-
-Len = 960
-Msg = 42d66edc5f22e0c13c25504c5101a5d172d2db7209e461efa323c0bfaed27e5f808042ea9c3838ea31f9b76de465225ccfbd0c09ca0d9f07e9a43e3e46c7693e00a7e1d483900ddb0a629d5563456dbbf299ac91f92c3d3c17b05d180e6c87c6c93194c39d90273fcf4a482c56084f95e34c04311fa80438
-MD = 061afb119a3c60876e04c10f12ad0f4b977593dc5a2d21096a57e7d3f7d4d44fdef934b2c17d7530674e4f4a1c176dbdcc54811a22e1b8712e4192fc2d4bf8e8
-
-Len = 968
-Msg = f91bb2e1a9c4cd96bf250426b3a6afd9b87ac51e93254d2dae3b16ec686ba80fb0bd7a84d218660e9007593075bc4f4c66567f0c7a5fd2010c999a8a0efa81f89ff5bfefe0fb910f0442e6d4a7c55bbb618c69a79a2ddd82a0938927f6fe3a80f04beaeb7c7636e3435d12dcf1c6bb6ed0a4edb69c9657fa93
-MD = 6e692c8c694ee0a3565f37a299e0006b85ab4a821b20e76798220229f656efc6a20211a4e7e4ed77facde0d70e4d5d95bc8ed1d7a56d8df1446d562f044b344c
-
-Len = 976
-Msg = d1eb961ca6a8f67c49b61e4d3ceaa2a1de6f0ea927b132bf987abdaa725b0e1e274e46830e99a2f75af608964df0dff9a99024fc6839bac5acd10202f921ac71a27fcda681aa3109ebf5f21ee3a849098ea3a551e844fae4b48b5c5bb97ccc802bc5520d68a14cb7e5fc056b67d889d876efb82d0e9a9a2499f1
-MD = 39b2c76ec207120de4b320c7fe069e602c9c38f257596da7369395e87eb64b3acff988c1839ac269d5012c093f9edd4b7cabf13bdea7d42e969ab108269c6ab0
-
-Len = 984
-Msg = adf2263200f376886ba7b6f5e4411d5f07f7d9d101590c73ace114bafbcb0fdc99269e87cd2cead2a1cfe5744394d333aba408a07e21f30233b65b907472e9e3c7d6e7aa6d2c47a08a1be7bb877913a6b5604c723384478911c339e3b5fe527c7e288705a89c95d970b443347897e79f6c522bafe62b11ef8f3135
-MD = 3c23d2d8cf4db6ac6a42e27208180f37668bef5ee0a3f879483c8e604e7f42583f202037b8d242c04a87345b8be6dc8b121d6484b9edad0d73c894c1288f5cae
-
-Len = 992
-Msg = 18e75b47d898ac629c48e80dbfb75dae1e1700b771165eccdb18d628bfc4063dd6c3839a7ec4cd1255c4821b078cd174647b320bb685541d517c579f6b8e3cdd2e109a610c7a921653b204ad018d0340d9938735b60262662016767e1d8824a64954086229c0e3b5bd9ad88c54c1dc5aa4e768ff1a9470ee6f6e998f
-MD = 01c756b7c20b5f95fd2b079ab6a50f28b946fb16266b07c6060945dc4fe9e0d279c5b1505b9ec7d8f8f3c9ebf0c5ee9365aec08cf278d65b64daeccc19d3cbf4
-
-Len = 1000
-Msg = c2963342cfaa88ccd102a258e6d629f6b0d367dd55116502ca4451ea523623bc4175819a0648df3168e8ea8f10ed27354807d76e02ee1fdf1c9c655ee2b9fd08d557058dabdf8dcf964bfcacc996ae173971e26ea038d407c824260d06c2848a04a488c4c456dbcde2939e561ab908c4097b508638d6cda556465c9cc5
-MD = a4d2f59393a5fea612c3c745f4bb9f41aaf3a3ce1679aa8afc1a62baa4ed452819418c8ae1a1e658757976692390fc43d4decf7d855cd8b498b6dc60cae05a90
-
-Len = 1008
-Msg = 85360c3d4257d9878e2f5c16d3cd7d0747df3d231e1a8f63fddc69b3b1101af72153de4c8154b090c9815f2466e0e4f02f3af3a89a7fd04e306664f93e5490d4ce7fc169d553c520ae15dd02c7c613c39b4acd00e0c9a3c501566e52cecea11f7303dd1da61abf3f2532fd396047b1887255f4b256c0afcf58f3ae48c947
-MD = e8352ddcac59e377ea0f9c32bbb43dfd1b6c829fad1954240c41b7c45b0b09db11064b64e2442a96f6530aac2c4abf3beb1eae77f2bce4efe88fee1a70cf5423
-
-Len = 1016
-Msg = c13e6ca3abb893aa5f82c4a8ef754460628af6b75af02168f45b72f8f09e45ed127c203bc7bb80ff0c7bd96f8cc6d8110868eb2cfc01037d8058992a6cf2effcbfe498c842e53a2e68a793867968ba18efc4a78b21cdf6a11e5de821dcabab14921ddb33625d48a13baffad6fe8272dbdf4433bd0f7b813c981269c388f001
-MD = 6e56f77f6883d0bd4face8b8d557f144661989f66d51b1fe4b8fc7124d66d9d20218616fea1bcf86c08d63bf8f2f21845a3e519083b937e70aa7c358310b5a7c
-
-Len = 1024
-Msg = fd2203e467574e834ab07c9097ae164532f24be1eb5d88f1af7748ceff0d2c67a21f4e4097f9d3bb4e9fbf97186e0db6db0100230a52b453d421f8ab9c9a6043aa3295ea20d2f06a2f37470d8a99075f1b8a8336f6228cf08b5942fc1fb4299c7d2480e8e82bce175540bdfad7752bc95b577f229515394f3ae5cec870a4b2f8
-MD = a21b1077d52b27ac545af63b32746c6e3c51cb0cb9f281eb9f3580a6d4996d5c9917d2a6e484627a9d5a06fa1b25327a9d710e027387fc3e07d7c4d14c6086cc
-
+#  CAVS 11.0
+#  "SHA-512 ShortMsg" information 
+#  SHA-512 tests are configured for BYTE oriented implementations
+#  Generated on Tue Mar 15 08:23:49 2011
+
+[L = 64]
+
+Len = 0
+Msg = 00
+MD = cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
+
+Len = 8
+Msg = 21
+MD = 3831a6a6155e509dee59a7f451eb35324d8f8f2df6e3708894740f98fdee23889f4de5adb0c5010dfb555cda77c8ab5dc902094c52de3278f35a75ebc25f093a
+
+Len = 16
+Msg = 9083
+MD = 55586ebba48768aeb323655ab6f4298fc9f670964fc2e5f2731e34dfa4b0c09e6e1e12e3d7286b3145c61c2047fb1a2a1297f36da64160b31fa4c8c2cddd2fb4
+
+Len = 24
+Msg = 0a55db
+MD = 7952585e5330cb247d72bae696fc8a6b0f7d0804577e347d99bc1b11e52f384985a428449382306a89261ae143c2f3fb613804ab20b42dc097e5bf4a96ef919b
+
+Len = 32
+Msg = 23be86d5
+MD = 76d42c8eadea35a69990c63a762f330614a4699977f058adb988f406fb0be8f2ea3dce3a2bbd1d827b70b9b299ae6f9e5058ee97b50bd4922d6d37ddc761f8eb
+
+Len = 40
+Msg = eb0ca946c1
+MD = d39ecedfe6e705a821aee4f58bfc489c3d9433eb4ac1b03a97e321a2586b40dd0522f40fa5aef36afff591a78c916bfc6d1ca515c4983dd8695b1ec7951d723e
+
+Len = 48
+Msg = 38667f39277b
+MD = 85708b8ff05d974d6af0801c152b95f5fa5c06af9a35230c5bea2752f031f9bd84bd844717b3add308a70dc777f90813c20b47b16385664eefc88449f04f2131
+
+Len = 56
+Msg = b39f71aaa8a108
+MD = 258b8efa05b4a06b1e63c7a3f925c5ef11fa03e3d47d631bf4d474983783d8c0b09449009e842fc9fa15de586c67cf8955a17d790b20f41dadf67ee8cdcdfce6
+
+Len = 64
+Msg = 6f8d58b7cab1888c
+MD = a3941def2803c8dfc08f20c06ba7e9a332ae0c67e47ae57365c243ef40059b11be22c91da6a80c2cff0742a8f4bcd941bdee0b861ec872b215433ce8dcf3c031
+
+Len = 72
+Msg = 162b0cf9b3750f9438
+MD = ade217305dc34392aa4b8e57f64f5a3afdd27f1fa969a9a2608353f82b95cfb4ae84598d01575a578a1068a59b34b5045ff6d5299c5cb7ee17180701b2d1d695
+
+Len = 80
+Msg = bad7c618f45be207975e
+MD = 5886828959d1f82254068be0bd14b6a88f59f534061fb20376a0541052dd3635edf3c6f0ca3d08775e13525df9333a2113c0b2af76515887529910b6c793c8a5
+
+Len = 88
+Msg = 6213e10a4420e0d9b77037
+MD = 9982dc2a04dff165567f276fd463efef2b369fa2fbca8cee31ce0de8a79a2eb0b53e437f7d9d1f41c71d725cabb949b513075bad1740c9eefbf6a5c6633400c7
+
+Len = 96
+Msg = 6332c3c2a0a625a61df71858
+MD = 9d60375d9858d9f2416fb86fa0a2189ee4213e8710314fd1ebed0fd158b043e6e7c9a76d62c6ba1e1d411a730902309ec676dd491433c6ef66c8f116233d6ce7
+
+Len = 104
+Msg = f47be3a2b019d1beededf5b80c
+MD = b94292625caa28c7be24a0997eb7328062a76d9b529c0f1d568f850df6d569b5e84df07e9e246be232033ffac3adf2d18f92ab9dacfc0ecf08aff7145f0b833b
+
+Len = 112
+Msg = b1715f782ff02c6b88937f054116
+MD = ee1a56ee78182ec41d2c3ab33d4c41871d437c5c1ca060ee9e219cb83689b4e5a4174dfdab5d1d1096a31a7c8d3abda75c1b5e6da97e1814901c505b0bc07f25
+
+Len = 120
+Msg = 9bcd5262868cd9c8a96c9e82987f03
+MD = 2e07662a001b9755ae922c8e8a95756db5341dc0f2e62ae1cf827038f33ce055f63ad5c00b65391428434ddc01e5535e7fecbf53db66d93099b8e0b7e44e4b25
+
+Len = 128
+Msg = cd67bd4054aaa3baa0db178ce232fd5a
+MD = 0d8521f8f2f3900332d1a1a55c60ba81d04d28dfe8c504b6328ae787925fe0188f2ba91c3a9f0c1653c4bf0ada356455ea36fd31f8e73e3951cad4ebba8c6e04
+
+Len = 136
+Msg = 6ba004fd176791efb381b862e298c67b08
+MD = 112e19144a9c51a223a002b977459920e38afd4ca610bd1c532349e9fa7c0d503215c01ad70e1b2ac5133cf2d10c9e8c1a4c9405f291da2dc45f706761c5e8fe
+
+Len = 144
+Msg = c6a170936568651020edfe15df8012acda8d
+MD = c36c100cdb6c8c45b072f18256d63a66c9843acb4d07de62e0600711d4fbe64c8cf314ec3457c90308147cb7ac7e4d073ba10f0ced78ea724a474b32dae71231
+
+Len = 152
+Msg = 61be0c9f5cf62745c7da47c104597194db245c
+MD = b379249a3ca5f14c29456710114ba6f6136b34c3fc9f6fb91b59d491af782d6b237eb71aaffdd38079461cf690a46d9a4ddd602d19808ab6235d1d8aa01e8200
+
+Len = 160
+Msg = e07056d4f7277bc548099577720a581eec94141d
+MD = 59f1856303ff165e2ab5683dddeb6e8ad81f15bb578579b999eb5746680f22cfec6dba741e591ca4d9e53904837701b374be74bbc0847a92179ac2b67496d807
+
+Len = 168
+Msg = 67ebda0a3573a9a58751d4169e10c7e8663febb3a8
+MD = 13963f81cfabfca71de4739fd24a10ce3897bba1d716907fc0a28490c192a7fc3ccb8db1f91af7a2d250d6617f0dfd1519d221d618a02e3e3fa9041cf35ed1ea
+
+Len = 176
+Msg = 63e09db99eb4cd6238677859a567df313c8520d845b4
+MD = 9083e5348b08eb9810b2d15781d8265845410de54fe61750d4b93853690649adc6e72490bc2b7c365e2390573d9414becc0939719e0cb78eca6b2c80c2fda920
+
+Len = 184
+Msg = f3e06b4bd79e380a65cb679a98ccd732563cc5ebe892e2
+MD = 6b315f106b07c59eedc5ab1df813b3c0b903060e7217cc010e9070278512a885008dac8b2472a521e77835a7f4deadc1d591aa23b624b69948a99bb60121c54e
+
+Len = 192
+Msg = 16b17074d3e3d97557f9ed77d920b4b1bff4e845b345a922
+MD = 6884134582a760046433abcbd53db8ff1a89995862f305b887020f6da6c7b903a314721e972bf438483f452a8b09596298a576c903c91df4a414c7bd20fd1d07
+
+Len = 200
+Msg = 3edf93251349d22806bed25345fd5c190aac96d6cdb2d758b8
+MD = 299e0daf6605e5b0c30e1ec8bb98e7a3bd7b33b388bdb457452dab509594406c8e7b841e6f4e75c8d6fbd614d5eb9e56c359bfafb4285754787ab72b46dd33f0
+
+Len = 208
+Msg = b2d5a14f01e6b778888c562a059ec819ad89992d16a09f7a54b4
+MD = ab2e7d745d8ad393439af2a3fbc9cdc25510d4a04e78b526e12b1c0be3b22966872ebe652e2f46ed5c5acecd2f233a9175dd295ebeb3a0706fc66fa1b137042b
+
+Len = 216
+Msg = 844b66f12ba0c5f9e92731f571539d1eef332e1549a49dbfa4c6de
+MD = c3f9c5781925774783ae9d839772d7513dfcea8c5af8da262c196f9fe80135b2b0c8c6ca0a1604e0a3460247620de20b299f2db7871982d27c2176ae5fa7ad65
+
+Len = 224
+Msg = 6b6cc692d39860b1f30203653e25d09c01e6a8043c1a9cb8b249a41e
+MD = 2e5263d9a4f21b210e0e161ed39df44102864325788647261a6e70ea4b1ee0abb57b57499bc82158d82336dd53f1ef4464c6a08126e138b2cc0892f765f6af85
+
+Len = 232
+Msg = ab1fc9ee845eeb205ec13725daf1fb1f5d50629b14ea9a2235a9350a88
+MD = 72d188a9df5f3b00057bca22c92c0f8228422d974302d22d4b322e7a6c8fc3b2b50ec74c6842781f29f7075c3d4bd065878648846c39bb3e4e2692c0f053f7ed
+
+Len = 240
+Msg = 594ed82acfc03c0e359cc560b8e4b85f6ee77ee59a70023c2b3d5b3285b2
+MD = 5ef322cb4014ecbb713a13659612a222225984d31c187debc4459ba7901f03dac775400acfe3510b306b79894fb0e8437b412150c9193ee5a2164306ebb78301
+
+Len = 248
+Msg = f2c66efbf2a76c5b041860ea576103cd8c6b25e50eca9ff6a2fa88083fe9ac
+MD = 7978f93ef7ed02c4a24abecba124d14dd214e1492ff1e168304c0eab89637da0f7a569c43dc4562bdb9404a018b6314fe0eebaccfb25ba76506aa7e9dcd956a7
+
+Len = 256
+Msg = 8ccb08d2a1a282aa8cc99902ecaf0f67a9f21cffe28005cb27fcf129e963f99d
+MD = 4551def2f9127386eea8d4dae1ea8d8e49b2add0509f27ccbce7d9e950ac7db01d5bca579c271b9f2d806730d88f58252fd0c2587851c3ac8a0e72b4e1dc0da6
+
+Len = 264
+Msg = 9f8c49320af9370cd3db20e9b50d3eaa59a6232d7a86fb7d472f124508d7968b05
+MD = 81b002f15c4d48be8517f7ed89df302fb1435c9435efefed58f3eb8ea11910623f1eb9028a66e02121a7f08a7c604226f2324f483e91548dbbd2c441ab704ce5
+
+Len = 272
+Msg = 4ab9aa069475e54b25e5688a52dd4acd134169c858105f01a0a1b134c72d4af51f8e
+MD = 48ba5a63aba7e7bd8e420475331125a947928c67fdb00f65c4080d9a0b99c0672424e76a1ba6bd76dfe492c730f6f9adccaee7bb11571aadb31f6bb628cfa933
+
+Len = 280
+Msg = f0c1d3407de92ef7421e42df5c9ab31d2ec0a750a9522869cbe4cabd66908d5823ec04
+MD = 9e75c5bca2c2af1d7739787f46e1d981c4f98e493d0724b5252c2fbae3c526719f1d27e6ccd0d705240281e8fbf3db75b9b3205c1413436d3b5d140004b8cca1
+
+Len = 288
+Msg = ae8c9f8fb41b519b6d943833fe1c32d1c4292fb1ddf1dbe2eb227d9e14d31ed74ebaef12
+MD = 042f9fd0a4ed3d9fec3655ae11011c6f2bc7e457e8812b6d8be2cd45fc6c432a94558c88f22c01439618865e8e49e509c448b342ca914b120344aaf7bcbdca18
+
+Len = 296
+Msg = da39fb86237f00303844e61fc6cfe779e42af53349839590bcd2f0e4cbbc279ec0b7e885d1
+MD = ecb43de8c233a731b38e30c5696f8876761b7ea72efe283fd07bedf20029f47c6d2a4427823e100fb087abaf22d7eff42a951c97c3dd05f48a20163fa4367cba
+
+Len = 304
+Msg = 3e7271d2070ef095394620c4b016576c150f34bea60784613a0f660d7fa5ae56872b88c58398
+MD = 8154d0da634ab2266061acc123acb407650ffe9164a22de3fe29bf05393b2aece92cf4db00ea5b4341c31ddb7de151683c8a71b5a44d5c3175790feac67d18ee
+
+Len = 312
+Msg = 311fb67f6a0784bb01a2d5a3f3092c407a9d3322319dff9a79f894291c5fac37319fb408402e18
+MD = 1870fe913abb0a4b4f53b6581ae18322cd05328514556607f3f4d7b6a2ac8e9185d94d947d8b9c88e0efa66d89b59f7439c75fdadd1816f7412306ab2b59d664
+
+Len = 320
+Msg = 7651ab491b8fa86f969d42977d09df5f8bee3e5899180b52c968b0db057a6f02a886ad617a84915a
+MD = f35e50e2e02b8781345f8ceb2198f068ba103476f715cfb487a452882c9f0de0c720b2a088a39d06a8a6b64ce4d6470dfeadc4f65ae06672c057e29f14c4daf9
+
+Len = 328
+Msg = dbe5db685ed7cb848c094524c1723519d49dc66ef9fe6d57e6862a6435750bfa0a70f104f5d396e61a
+MD = 2fa6e5b2c443a68050f093e7fb713bd6b18f6274c061ed61d79bf0688a61dba1940bcc30998276860943ab038902896d0fbf59b88b07c80de927037097150c40
+
+Len = 336
+Msg = 9fa83e96b2a6df23fb372895015678e0b2c9cd18a8542c3eaa2c435a76ae4dc9bd5136d970daff933acf
+MD = 3a2c0ec88a3e5347cf0ea9c078838300ef7356f9a6c342063277c106b880a00ed2be205c13064097bd372fde38007bc306561eb4e74bba2bb20bd354aa690ca6
+
+Len = 344
+Msg = 8a5a45e398bac1d9b896b5a2b4e3566b91d80ad20c977ea7450ff2efb521d82f65019ee762e0c85c6cc841
+MD = 3c704620f4066d79c1ff67752980f39ef3d9c1023fa5a213a5265376b14a15166ffe069b51df7710d8907fef9406bf375d502ce086ac82aff17229aaa7a5a334
+
+Len = 352
+Msg = 49cfffdaf4d031e33b1d28a447450545f6c4293b38d5afbcb9883976c014f080576ec691ac1bff70b742efab
+MD = 8bcc4f1ea2b7862ef1591bfa73916665de8faf65439ddf5cc1be43cebfd5f60f205e835a2b186b675b041258c5cff42669316ce25b46a2f4d4218e102f0f5d6f
+
+Len = 360
+Msg = 2ff845d85efbc4fa5637e9448d950496f19d8d57da99b7bd3df7474822f0a790586736416714e364c6e1fae04e
+MD = 236f6f4ed6e858c02d51787e60c578f731f694f8e52b5df4ecd5b04dff14c78e56bad1028d6f626c29d85aeee151a2a2846d3eed5cfafa9854a69fea8af6d04a
+
+Len = 368
+Msg = cfca05fd893c0f005f5ff796f4da19ba27a1e729956b8b715e67ce4b2d2a382a72ec7814f2f507b1825209a20fcc
+MD = d80969284a4565add4dad6ab9b3bdf53446142f84aaf92d4b23dd22ee7241e6c81489ac8b246edcb6df9bd7b23d91a0c517f546feba4ed5790a2be6e165c1709
+
+Len = 376
+Msg = cfc425759a9c36bb9f4b32eed7767af6566f68ded0adeae25c7a70ca78ec09774d16c8bc357f6d6f7bd441bf62d942
+MD = b587a785cdf455cc9c544e756c1e306300aa3c59f8725012e68ab4d54020b6d227a164d9f83c905e86f8cebeef708a69f976d6e7b18b9bf78e9b98cc4a5cd1b6
+
+Len = 384
+Msg = 097c9db919515242c99d973acb1dc4ed482768f974eb83b465f9f6c82503372006e4490835e2ec8f92301130bfb790b2
+MD = ff5a376f938e73014caef7fe3962944a7230d020b7087869ebe7ec70302721cd06fcdc981c893a425d05e2f99fe198e4db50a088aee2bf1263212110efed422c
+
+Len = 392
+Msg = 77e73d387e7bc80419ebf5482b61d5255caf819fb59251ff6a384e75f601ea026d83ef950ed0b67518fb99dee0d8aaef1f
+MD = c4c89cd882ec945cc888fb9a0127d35e585ecc14a75e4b5b3d8330538d22da28cf6af1ebec96dc247f109cd2aaab9756e6946a3d80db8363a4da3e6ddbb510a1
+
+Len = 400
+Msg = 317e5d9ac73ed0633fa18ebebbca7909ec3a5ef790478f9c38cacec44f196d895835b425774483043341381e7af2d383e51a
+MD = b10bb04491b9c0c334709b407cda1d503efb6b63ee944f2d366b6855e6e63e5b80115be4be7ff63edecdfb5923792e68123976d79212b3884dec2179d1fcf382
+
+Len = 408
+Msg = 209461f20666a346fedf4a530f41a6fa280c43665767be923bc1d80bbcb8c9f8f93ad75782ea2689c8c5d211d2053b993145a0
+MD = 67b7a328d9444056a52ca2f695c5d3f3baafb625a14fb32eee8ff26a40ccb296bec1771a826b55f7ddb6170d4caf7795b612448e66a0f19356fe505927149b47
+
+Len = 416
+Msg = 5d61aa45c446f3bf93604b0511313b4e2f306d6b046fbd94797b926746836f2e1dbdc56124060c6ca9c911b1122192d112420827
+MD = d3931bde2bde8271ed18ca0b9148b12f6f16161e637e376fc961f65bc33bcacf2f6addf26a3eaa81b196653cc37e8a739ec5b3df870d8c38c8f28691c22a39bb
+
+Len = 424
+Msg = 9288c795bb0b86c0419d9c5637dcc37b39bfa18d441e3fbfca75bc0306e5432e8e7b3a5627b5bc7fdc424a77520abdff566e7f2bb8
+MD = e363d0e95d8cd18c384016ebeed6d99c4fa2768e2bd58fca019c5108b9cde1cb46f3f884028a55ce282ec310a10037faa1b16b4a6a669957f0b00f350bbd63d0
+
+Len = 432
+Msg = 780427dc164b2f69b8c7d569266f461e2d30c88c4cd6057fb030a6cf636f24e3c0d0db742a7b6193fdaa15eec50dfb4fae6ec7653c91
+MD = 2964b009fb1bf996de12e030b9d6e0608ae8b9dbf2acfb9beb76fc5361cc104ee85c2a46fb7b4cee90848312da302de49afe61c546477e2b25d223d5e3d33560
+
+Len = 440
+Msg = ec2a92e47f692b53c1355475c71ceff0b0952a8b3541b2938270247d44e7c5cc04e17236b353da028674eab4047d89ec5dad868cfd91ce
+MD = c83aca6147bfcbbc72c377efa8d53654ba0830c5a6a89e1d2a19b713e68fb534640deb833ca512247166dd273b5897e57d526f88eef58f6ff97baee0b4ee5644
+
+Len = 448
+Msg = c99e31ad4e23ac68e15e605d0b02437f8147c44f5445a55b68a10905276cce8676481c33e8cd3efe322bb13fe0107bb546ccbec7b8b38d10
+MD = 52992d45a88221d972958e9f2854adaa9a21d2bf7051e1f1019ae78004da50c5b55c144a02afffe539d753949a2b056534f5b4c21f248a05baa52a6c38c7f5dd
+
+Len = 456
+Msg = 9aa3e8ad92777dfeb121a646ce2e918d1e12b30754bc09470d6da4af6cc9642b012f041ff046569d4fd8d0dccfe448e59feefc908d9ad5af6f
+MD = 994d1cda4de40aff4713237cf9f78f7033af83369ac9c64e504091ea2f1caff6c5152d6a0c5608f82886c0093b3d7fbadd49dfd1f9e0f85accf23bc7dad48904
+
+Len = 464
+Msg = 5842512c37312511a3d8ae41f5801df60cd682d58b4a997342b6e717e94006c214813e6c63e75591f957a7ec301779838bec8ae3ed7febad0805
+MD = 9763c43331ad0eb279d704c5f6e97e02da8724115026827f889e9fcda21f60fd230894ab35abb719890f3afa51afd31bc6852183b9c51059910af460abd2474d
+
+Len = 472
+Msg = ca14e2ea2f37c78f78ef280f58707ec549a31a94361073e37701bfe503e4c01ee1f2e123e00e81a188f08fa050825709128a9b66bb8ae6ea47e41d
+MD = 4600e022a02258739f67fdd367cc1e662631fb087918768352062b9b3c8de8dbca0e9ec751b91f284694fbddb8d325c0637bccb21dd2efa92e48dbab2e5e9c26
+
+Len = 480
+Msg = 647629c779b24c1e76f41744aba17159487532a0156a7d8264db50d645e9595ff81e0c96a850f2aa56c844c613a4b892727a9bfc3d3e20386766f805
+MD = 5bc842fc2d3b7eb31d2d3044df3ec32af114feaa7cfc27ebc8630f46ab6f0c543f59b812e776e5303861d17da3f1f16097641f3b808d4d5cb3e483946409746c
+
+Len = 488
+Msg = 1c5dc0d1dd2e4c717635ff3e9b67caf957aec0f8f63c1b1e221e800a4c14848f4ea06e644e5d3e1de592ef5a8007fa3f07171b24bd07578d68963e5cb1
+MD = cbf1ea86fa5b3dbf67be82fac41e84cccd0d296c757169b37837d273ccc015eecd102b9ce1cff68fdc7f05d22f2b774734f62ded54c8ee0bf57a5a82010d74f5
+
+Len = 496
+Msg = 8a555e75477d065b3af7e615475f37c0a667f73a4c7af5e4a69f28a68d9f4434776a8f90eab7f1d137eb4b22643c0a0d6a16fcfaa1bd62f2783546a9695f
+MD = c088e4a3d7da2f6f99a8f3f717361108872b8ffef921b383c24b8061d4e7c27fc56f4f20dc8f952a14043c5650b5a9e777c49c41cfeb3f2de97ee2e16b2c3924
+
+Len = 504
+Msg = ebb3e2ad7803508ba46e81e220b1cff33ea8381504110e9f8092ef085afef84db0d436931d085d0e1b06bd218cf571c79338da31a83b4cb1ec6c06d6b98768
+MD = f33428d8fc67aa2cc1adcb2822f37f29cbd72abff68190483e415824f0bcecd447cb4f05a9c47031b9c50e0411c552f31cd04c30cea2bc64bcf825a5f8a66028
+
+Len = 512
+Msg = c1ca70ae1279ba0b918157558b4920d6b7fba8a06be515170f202fafd36fb7f79d69fad745dba6150568db1e2b728504113eeac34f527fc82f2200b462ecbf5d
+MD = 046e46623912b3932b8d662ab42583423843206301b58bf20ab6d76fd47f1cbbcf421df536ecd7e56db5354e7e0f98822d2129c197f6f0f222b8ec5231f3967d
+
+Len = 520
+Msg = d3ddddf805b1678a02e39200f6440047acbb062e4a2f046a3ca7f1dd6eb03a18be00cd1eb158706a64af5834c68cf7f105b415194605222c99a2cbf72c50cb14bf
+MD = bae7c5d590bf25a493d8f48b8b4638ccb10541c67996e47287b984322009d27d1348f3ef2999f5ee0d38e112cd5a807a57830cdc318a1181e6c4653cdb8cf122
+
+Len = 528
+Msg = 8e8ef8aa336b3b98894c3126c71878910618838c00ac8590173c91749972ff3d42a61137029ad74501684f75e1b8d1d74336aa908c44082ae9eb162e901867f54905
+MD = 41672931558a93762522b1d55389ecf1b8c0feb8b88f4587fbd417ca809055b0cb630d8bea133ab7f6cf1f21c6b35e2e25c0d19583258808e6c23e1a75336103
+
+Len = 536
+Msg = 52761e1dac0eaea898e0b07cd24f4b2e6bb7bc200ea4b0528842f17b87154559a2ea94459a0e480ae0bdf9f757dd4a335aed0e510138b024a04ed1d591b4323234dbd5
+MD = b826fe80494e19c51b42f2582b2d080ba6b90512f35f2db67dd7fd5ee532eaa16498afba08b4996cbcfdf8d1a2df6b1da939e8265115a48aefa42f38205db436
+
+Len = 544
+Msg = 3804ebc43cbea80c2bd7e4fda5c5515500cd2d2b846a1378dbf218d5c377138606eb3cb8ac88f9076f6ff4436f90717427c9df1ba052acbbe4585e98b6e8e0bf800f1946
+MD = 17dd6d87bc6773051e52047fd444996afa8124b0483fe121877f98553448772bd0e7751fc655e9cc2d29830211015d310f191474ca6adc0477a187c03b8fe252
+
+Len = 552
+Msg = 2249d698c4d807a8e7b4de21c485738959a0d67e5d2ca6f77983dfccb5dbf47931261e1f1537f3cbca253afb6bf4fe5e7672e1dcc860b3d6c8d243afe2d9758b375e955692
+MD = 6af44563fc468d51182f6c3be58d45932af1d985c6f283976c91a9ff421f383fe21dc7322f397ccead583e26b3e3fda067976a7f34665df25a2ced7b4b09cdec
+
+Len = 560
+Msg = 32a9c17033658c54f22c7135ddfc879de94d79593ef2dc7d3041bfa872738389864eeda27801794ccc4ff1fcb5ef3fc48833801d6fe959e3627f8ea1536ad00fa9c7d7d9f043
+MD = 6a47699dd3ada2f11bc4ea42072b06cc20857bf164497df1285400c250f5848b6f71957dbdc845f5daeab913036661f69387893fc2d61c25fa59b9d85b19f401
+
+Len = 568
+Msg = 3d65f69a590a5baaabcd274fe3ef9e88920ffc7adf05c16d7b0f4d18d72bac1e94c3b3d83b8f4c552eb80e9fde3911403f8b000579816f02e1716fd627946031d0af0793e7f3e1
+MD = ffb2d9450943c24b5933c24812459b75d3d9f380344c9bc06fa3e17ee448eca2f98ff79f7e2235ccd9f9a8176f68a2254bbc9b834d6ac8d2bfdbc1597c432c9f
+
+Len = 576
+Msg = 76ff8b20a18cf104f6cdb65e2ba8f66ecf844af7e85e8ef2da19e8848a16052ec405a644dafb5ca08ec48f97327ac52c0e56218402c72a9a6dc1cf344d58a716a78d7d7529680bae
+MD = f8858144c6d709dd0689a526a548a43f17494950ba2ac20544799e8ea27201d78bce5b921e29a7b4029278e68341ef2a0ca4ba3894566b3c8f8950e3e545a689
+
+Len = 584
+Msg = ca88dddfc876a12f45f19562bc9ca250f43267ab251a7f345c3c022e20144e135604078762ef5c8a8f038cf1b1d6a91709b59dd068396a9e971ab628f74886e765384a23607c1a1e6e
+MD = 4f3d9eeef349ca51a7e419af1686f42795abde58a85335ce68d496e81e4436a80a61dc143a4300008c23a3e71f4ba98743195a3694a8d02fee11bd314569abc0
+
+Len = 592
+Msg = 0a78b16b4026f7ec063db4e7b77c42a298e524e268093c5038853e217dcd65f66428650165fca06a1b4c9cf1537fb5d463630ff3bd71cf32c3538b1fdda3fed5c9f601203319b7e1869a
+MD = 6095c3df5b9db7ce524d76123f77421ce888b86a477ae8c6db1d0be8d326d22c852915ab03c0c81a5b7ac71e2c14e74bda17a78d2b10585fa214f6546eb710a0
+
+Len = 600
+Msg = 20f10ef9a0e6128675340171cd248df30b586557620b615ca39a00db534315a9012dbdbfd6a994986eb829dbe6cdaf3a37d4f59ac27298742c8f777b6b12677f21eb289129579868705f27
+MD = b4ead3f860eabbd36c770d66c7356f8107acd1485c7c94178c2eaabd50266d7645d009972586ef83ed43ed92882137df5117b88f35231b894ec1741ae7501145
+
+Len = 608
+Msg = 995c8f747ea418f7d63aba2260b34ac3c7dceebb78438ca4b1f982b7db9798ec1a7f32622264cb024c0d9e60e955a6e1d677c923518851990a459b767d0f13cd803460f61870db3391b44693
+MD = a00a601edeaca83041dc452d438a8de549594e25d843c2cf60a0e009fb92d87abe28a72690ab657c8d35b43cd02d22ec0755de229d1f922fa6ca18a6d6c2aaae
+
+Len = 616
+Msg = 0feb23c7e4a19bcbd70bd300d76ec9045d696f8c9687f49ec4154400e231d2f0862495150cf250b6f12f172a7d130f8fa5d175bf2f25e280172ccdfb327951701165302728a619aa2f242631c9
+MD = eeb6dee30c119fb1e1eb5c15ff2b32d8b9c7464a4e4cc6815cd251a6bae29b49961dd5c2fa9c44a9b142ca062c7072cbf3db04299b767789040196bf0c06aa76
+
+Len = 624
+Msg = ac59a110623f1a64666f160ed32926676cb5be25dd9d962f441951b0efcb5d6a67ac1a4eae473e49c6257860728853ff415c5e8ec76a8a462ecfd343eeac22dad820722c597332fbfd94ebbd32c6
+MD = f65ea942ae0a47e73b02b1442e5b26083db79307f64dd34a039c476faf18d5c514bb77a2c412a6074a7afc326ea66c74e5705fe2abbabf274333325a15b61fd9
+
+Len = 632
+Msg = 9e3e1077e1333a1fb1aa633ccf2f746588ad426489ea08dff5511438b5f4c0b110d1a4d47b540a12b21ea2aa070578ccfa5c22fe0b743ec0cc621c6b3a03b75f4d3eea5dce89e03269afcd9603d0db
+MD = 4b5c5df80c344c12388c723856cd06965b2190af652480476747dc2195ea3716f87c1762359583a5f31522f83f7833bec30f1f47d14540417dd463f5d258cd4a
+
+Len = 640
+Msg = e881e3284c79d8f5237e699e4fbca84090c664bb53229f58cb0842b0436710c9b329d98191b8f030e9c1df89b03858c1569c6ff49a7c07c4a23a8a434b0fde13be4f94cb44ee629d5b44d336090d3de6
+MD = 147d8071c7871ef9256cff32aa63ea031404fa5ee4ec09c56afdd5da919b0cc84a9d35d142c417715203316011cc620cd6855bb117063a5e52867facc680d5f4
+
+Len = 648
+Msg = e58521098911503de84311387d375c25929e6e55076eb6934fd8f2b1bb7b9667fbd76d5ee204828769a341b1f716da5bdfece6c62a9f4d4f988267fce1f5615540dbe375324eef607c910d976b45a5ea5f
+MD = f97ba056fa41f43b8e1987072a09e828c71c5ff6ad4e37f9ab6b89e2a078933dd23052fa72c6615b613904259e9ff9b55ef7b923b89bc8752f6babddd256e117
+
+Len = 656
+Msg = 3796cf51b8726652a4204733b8fbb047cf00fb91a9837e22ec22b1a268f88e2c9f133e5f8527f1b184830e07c3458c83a8ca9f9d9c6998760e610668ba0f22e22b656a737e978b246a17840b7dc4091da85f
+MD = c8a466199acbcbc93f2ce042968508c046901631e3118a2d0bf39a9b42b4197a379b3a86cdeca9df2de1a3eb71b79ae9bf2d6575eadf1878029c4093133f54d3
+
+Len = 664
+Msg = 9af608d031ccf309d7273c607a8e5e36840d449b55db5b13f03aeb9af49fa7e7cf1383ee2ed9c5a8b7515f16fb1c7c84a681590bf90f56597b844db5ebee223d78109b72350772f7c72ea996603e1e84f2ba5f
+MD = f0ded9495b4f64cac585be8a737cfa14247a4a81cdf7f01ebcb134ace71f5a83df2cd72e7773fea1e82beae17e13857372792c8231e2ab9fbeb633e399d5f0ae
+
+Len = 672
+Msg = d0df1bdf1df6203241722fb9c9c1cf7405017497ae154538ccf9224ad752e6ce1d4ae948639aca70cfe86b2b06543cb9914ebd3085aa3e2963f6e9b93d0b03a31ae26fcb9ca974eee016c091a6fcac37b21cc1d7
+MD = c2da3ea3c8a3fd88a5bc5dea2bc076f861abedefae5a5fbd941ddfd1c41cc3312eb2dc826c2c0f65414fe72ebee447d2f9b1a6a56302660d1f86632ee80a175f
+
+Len = 680
+Msg = 8cbc9480553acef7bcdba9716ea8d66b4131780917de2b0b048045fcb32b5cac054808e1fce6e94ad851ecb47fe6cb802225d3551e08ea122093d0078dada564212eacf1d6394e0007cc62a1d595ab14ca08a284bc
+MD = 63b39b88ceb848188b37316e04560e75a5340ab8d417932d231c997e892b41daa69d9fe3e9a14dd19ccfbbfa01488c208e7b946cfaf16ca2b1bf7c8d8da4e6b2
+
+Len = 688
+Msg = 38f184448f3cf82a54cafc556aff336f23f9149e612134b3fc00c8a56455653d88640b12f69062b8432c4335ad8f7ab4ff66cb7eb54f332561a36f024d92c3e26276f4fd48619628cff88e4b8e85cf14ca4767ed990d
+MD = 9a49265fc641c59f1a91872cdae490d3da73c0c60fd59648e1d17dba1a647a5b95629392bb4ff5163d1a3cb45427c1437a3b2e1d9f030c0a8bcc5ed22da9e2ed
+
+Len = 696
+Msg = 70900618b1e9e9db62296fb6c6590c9f10b0a632765c489c887f1ab7c07791765a62e38465e1be281b1d396c6e080b7ee3e6fa56a30b9799d0e629be153ee76f81bc6a3295aa61489bfa87d53a8ad24248a6ede0dfcfe9
+MD = 1c8c3357ff1f8d6ac4defb3af462a73e09159e3a20c6506edd8cd3052df941c81f68c5fbb893912619e28640977fe8eaae8e9d5d4e7d5f132552cefab4540bac
+
+Len = 704
+Msg = 4e6ddae0d805afcd10a055bce584c848d050fb29fe8f1c64b18e1abfe46b65782e6ff536e89d8d40928b41ed7371365c8080a9647f7532ce6c6d4ac21cfb0c8020783851ec9a7dbc3948f8fca7adf8b2a78c04d898d31ff6
+MD = 5c2f996c779b91b3c4639311f54fabbdde7e2212b53dbae4828c8399588fc00d3b2ae60918aaaf6bb48bc757e52b2bcea84f5d15bf4ec25d5519fb54f6f26e1b
+
+Len = 712
+Msg = 696825f6d6ea8173ec47d0959a401c4ddf69f8f08ddd678a4d2ff976e3a4372bb39f4159845cb63585e1d4108d32e12fa7c5c9d7ce3508a7f53aca2b4bd951adbcd8984ebb7536563f5884c90bc5023b3316f7e4dc6958f743
+MD = 3ce940ca96b00011375daa95c65f66907d69b3eb3b8d779e6fc971afcc05e990bc4c541f434590f6b18b68c080d0f24475a3e764e9cb85343301314ee2fb661e
+
+Len = 720
+Msg = 79ecdfd47a29a74220a52819ce4589747f2b30b364d0852cce52f91e4f0f48e61c72fa76b60d3002cae89dfc5519d3430b95c098fa4678516b5e355109ea9b3745aa41d6f8206ee64ae720f8d44653b001057f2eba7f63cd42f9
+MD = ba3d0fe04470f4cf8f08c46d82ae3afd1caea8c13bebbe026b5c1777aa59860af2e3da7751844e0be24072af48bc8a6fd77678aaee04e08f63395f5c8a465763
+
+Len = 728
+Msg = 9263fe75e8f6c7d5d642e2ca6a6eea4f44e9a0f249513ed79c9409ffca5526ca4491aebb1382057cc7c36722b0b6c3b15123cde312214f25353abfe30bca170568a8e1ba5408917403a01834080ab607c56a10d0265082498fe0b6
+MD = 7736d7a7fc1eb05857ce7d88abfffa87f58c670bfdfc0a8031f60f379e4b6ad94ac8f13ffe28c697809b5cfac7f13be01e7496a85237c4025539051fb2e32fb6
+
+Len = 736
+Msg = 78c17bfe0e02eb526d1a44a1ac127be082181452b625394bd6dc093a2cb432e6ee59c2f8b5503aba30dae41e1a1c6702697c99b2c94e94af48b00caf53b2e0e4e1bbee81ee282c7b2b35f58cf421a07e828d57a6622626af25835399
+MD = b56b6e343166328523e0d1693e5174da643ae83cf69c85a7b3c3bee247b77b84702069d9e6b4cab03bf17fe612009bf4239683ca78ca7e876aca7d07603ba714
+
+Len = 744
+Msg = 298bb304a920f960447d8fd38b061bf8fe4ac1f871d8a0feb4549feb72ca694a5a41b6867d94cd5af77d468ad2f315d127b6c41a862800f3985e573e037740298e2c5c6186a9fb83609be2d49f8b4c31f96a2e49b56dbf09571b38587f
+MD = 34e3878627904ffbbbd85266cc973c34f931e3cab5d4c31f841c553dd69f84838206067df4f9f3b9102001be19267151e673f5c2d4c2f8438a6999a0a325487d
+
+Len = 752
+Msg = a3cf714bf112647e727e8cfd46499acd35a640dd393ddd263cd85cf6225f59890a0686dad1c54eb8d809b81c08a98dba131bbdd6fce8ff59d95db824d8831ea480529da739227a6e0f62b603b38c35cdc2581f614a31879b8be54aeefaa0
+MD = 6f230ae4903ddbef0ba384c2e3506eab318bfd1a46ea76099f65a3fd529c91bc2865b9fd943e346de64626b8529f9db1377bf2c5e0129c66b50c6a5cfb364b3a
+
+Len = 760
+Msg = 0a427ae55ef3a7e6044a08cf6128cbaaabfd776c4e9374708f2ece246fd73603d2f54ac3e01d16cfac2bdaf713920d66e8f0a3d54ee68cff64267d5528cdf2f295f474d10f81173e0143488ac53fc503c444ed23dec63a080ce90c2443dba8
+MD = f6bbe5d0cf13ddf41c1436748a5d1ccae2948547b452c2171c7c8e8b66c6ae4de3c0e8b2962bcb60d3de3608479f80e455c9024d9716c38f6f1206861ab1eaac
+
+Len = 768
+Msg = 2cbbb87511f4948efec3a61b511ededb1dda8b6ecfc0210c11e43a77ee32dc2e374afae4268e3d30427804868232a966b56006d3214037076bf6a265b72135af0fb2ef7909fea2dea412f7717446b276ff153753662b4d4148c02347e3259169
+MD = 76897b87a8a1cf835c434f6d391c9e5227351af9d3e20a3389c796b98b424281a59068d9c8d567ec2bebc435b0126b059e2d86394a9854d6611e1c922f385496
+
+Len = 776
+Msg = 2b23324c9992f60a7fc010159a03cb9a2b290df4fa6a82359b9af602f0a403a5ef33ed5da5b2caf87b77e6a4b93b650348ce2a7dbc08f8da9203d710b587ba5947c65e899f4a759f8e2b049ae7850a8e3e2962f6ef93ea4c631de5d78e729ec5bc
+MD = 3beea0b373ed09cf1c919c51d86d642c9125e0ee81698dc4cbadf02e9e6925efb562fd9b87301a6377ca192be79c4118deabc450b54639000c2e312945451fb5
+
+Len = 784
+Msg = 4022f930c7033b00d986c65ff6bbbdf9ebd0e58c52844ff658df3893c3202dc533f873d4a7f5a5f944419fb5528c9b6788479a1e891306acae7995fc06db70a59baa95bef7da79f5e793f2db7f2a55825e4fdb4a34884af881ded1089fd5334502a2
+MD = 0358775bbb733ccc49e78f544aeee512370d480d0e13c7e8d5c444c423e592146b45fdb91a1b694d35e36b60e4bc8397fca8bb9790e619339778b9cd1abe3fe9
+
+Len = 792
+Msg = 1cb77ba43ce77e236b9fc925f589b1c070780a84f99e8f50c1ff846ac92599cfe91612c8178325bee642a34f4dffdba2aa2ebcf7064339829b26f27993e1106c139c70d578cc05f0e1a777cceddb10a2c67fd9675e4a009df8037d6eeb38f5fba233df
+MD = 6502f46551a3fab3a96428fb97801d7a4aa2f17fef6603238df84e17c74309ed3d9489c8b16a9384ee634a3f86d0b3ba9a4dbc9c51ec8bd4bf8d61de6d3d87d7
+
+Len = 800
+Msg = 52167de2d6c502d99fa10c27b2ab6203bdebc2cafbbfdef15872a43dd610c2362f796ad9bcb5528d95870058fa454453f1e6065b315d410a3f2650e5d71e69d78d9767dfb4accc057fd2069266b0f180cb319e30ded7535bbe52d24be151de4bb598fc5c
+MD = 25cb3ed3983a91b4cf37a65193916c5e3e211b63e943e2f7b50a85d349a463b941aad33eff16561bdfdc92fda06a4e1d94b162de48f06d3c626940b31020925f
+
+Len = 808
+Msg = cede6697d422ddaa78e2d55ae080b8b9e9356c69bc558201a2d4b0b3190a812c27b34bbcee3a62b781378b1bf636b372bcbae1fa2f816a046a0a649a5c555c641fea4ccd841cc761f38f777972f8c91b0324e71c333ce787f04741439bf087ef5e895011c0
+MD = 0be42a25d77ac6ad995c6be48e783380bad25a61732f87cefb0cce1a769cd69081f494a1a12d657664ef2b4d9c41f2ee83f6e9a84327d8756af9f985595e7d3b
+
+Len = 816
+Msg = 56d18d3e2e496440d0a5c9e1bcb464faf5bc70a8b562124f5fc9e9deb5fee6544b945e833b8b5d131b773ecb2cdd780cd4e1bb9e4f1e3cb0a1d64d19cf4b30e44e6c2d0cbcb4e284ce50db7a8a8062ddb63f981d9026c532bf8eeddf8af5a43848a32262178c
+MD = 982dc61c91a93770582eee8025aa55da8e9edb966bf5cf70d4a6534c0d53a2789a8c4fb65b7fed478cda02ed1e0d198d85c5c735b2417c5fab5d34e969fc8e7e
+
+Len = 824
+Msg = 25a7320dfaec5af65da4d0f8688e29e8e95532ecc16679ea8aff0f407d898db6922855b0e8901aa9681aa3dca617cb440764cdc7293fbeaf7f585b593c2b0531738e0ade7c8626b9995f4a84d9fc9b593d6bbee01abc53c5be14bf6956fd2fd81000dafc7c7686
+MD = 749c928c3d5510925bfe98659025b0ed7c01acd4d59a9bf1c54863a088091771dc9d407bdbf83b0f44b0902e10349ba79c84d0981d5e8c4f5c733a117fed0790
+
+Len = 832
+Msg = 3d7177b28ffd916e7e0634895833ba0bd9e0653df2cc4202c811536a005aec853a505e75db55d3c7107579041099e382a1feac80dde65d72368e909ab85f56d88e68d7c3c80c38f85bf8c2b36959409cc34ba8e3ad94fe8ee1927612d672d92141a329c4dd8a88a9
+MD = 14a331508cd7d94fcce56a66bf65f20870a281c8442f8dbd4c2371454a2b66f8d0994a0b67692e771efc6a5e0b887acae7d6f4ec7338e1aa89f2abc7034c4e4c
+
+Len = 840
+Msg = c033e4a512297caecdbead892b11a9f7007af9a74bcab89e0bd4ffdd542ca03ea12e17a06c42bd43fc5f3f757fce4f6f5831997abac3f95676e1ebdb11ca43e11aa31e5ebabe18ce8d1bbfd8b02f482e1ce581b532e307e6960eb97441506c2ed299e1282523f41527
+MD = 95ac9b7d22aa458921874c4b4331e7d64761853217c3f83c601abcbccd7e2eaa6ca6ce9a22ebcfe5046d52f8a09097f043ab8bc59243fd770090bb432c3155e9
+
+Len = 848
+Msg = 69fff0f1a3dbfb36e32f025819fa99ea9a0edaef73145bf7fcd05d8bb0a646cb3b5d5256d524856acfd2e44d6b72e4ebf1ff23c0ff6c56f821e782d5a15f7052a1445b06668eeb4af700679ee7ae26496fbd4640c06aa149964dfd6011df835ac13b73c8ff21151e8440
+MD = 45d4daa652558d1c12beb0f5662c712f325b4c802fc6eb9ee039c949d002bb786f1a732712be941f9c5c79b3e5c43064d63a38578e5a54ee526acb735b9ad45f
+
+Len = 856
+Msg = b2c439c97ab7c63736b3796324d68eeb7a471ed142bd9622684167d61234fff82f93f907537a909bc2e75a4bcbc133cf57197662c1af746ae8b81e5b83de05d9b589851de25d3c99c004c1dfb12d93bf50d450af49c428716f5b90ef088e3b6a6b2c46d3ce67b379599018
+MD = c48ec83be5fa669e6ec8db90aca9676cfe2ec0d5e8e7a2431687bb953c0a300be3db4075cca3bac4dfa4d971baf0fa1aff46639db4b238856ff36d1dfcd520f1
+
+Len = 864
+Msg = c016f522f26b7470e922b9a287e6d45f6c28813b68c1457e36d9ba266708272f9cbc5411f8db9d8bd5a9449fb6eb0cde7d4d03e5df019f2814a90ceed377c59d7d92623899bcb0268033073559d4d8de488686cbe3d67796e6df6ad4276d0b52cc62c49ebb58d7c95287aa6c
+MD = 7402f1a99b47e102b3b73140c6771b07ee6c33b3715e9c4027c441bee40511b735d95e508baea78da26fded9b7038e9a53defa58448aba40dc1e62d7ec592107
+
+Len = 872
+Msg = a766b2a7ef916721f4677b67dbc65ef9b4d1bda1ad4e53fc854b0236440822152a111939e5ab2ba207719472b63fd4f4a54f4bde44a205d334a2d72cfe05abf804f41841b86d36920be6b0b529331ac163a985556c84511ec986439f83e1d7311f57d848cfa02df9ea0cf6b99a
+MD = ddd60f93a3babc78299cf763e7919d45ac6f479700e1adb05ab137acdf89c1521ecb9dfeacd091e58ca57a1db964a9c3cd1fa39192cc1e9f734caa1c5fa62975
+
+Len = 880
+Msg = 10f2be77a4055771a67007cd8630e3230e38288499cb160380290174d66da57455b6baaa9785c84c8a663de41ed3bd544055b9170cec43cb3eb120eceaba1fe36e3eaa3fa4f99b425cd2519f09bc0282bada52d14ce625b1ded3b24d86b1dad342d2b7be322b775b04fc6b86afb4
+MD = a872fa33d463b3343cec57c20c66979c33e1ad067bfc703454696aab5dd0003bc194318f4a8ebbc74503feb7211a472dadee991efe3e38f21a1310f8a76eac80
+
+Len = 888
+Msg = 324533e685f1852e358eea8ea8b81c288b3f3beb1f2bc2b8d3fdbac318382e3d7120de30c9c237aa0a34831deb1e5e060a7969cd3a9742ec1e64b354f7eb290cba1c681c66cc7ea994fdf5614f604d1a2718aab581c1c94931b1387e4b7dc73635bf3a7301174075fa70a9227d85d3
+MD = 3b26c5170729d0814153becb95f1b65cd42f9a6d0649d914e4f69d938b5e9dc041cd0f5c8da0b484d7c7bc7b1bdefb08fe8b1bfedc81109345bc9e9a399feedf
+
+Len = 896
+Msg = 518985977ee21d2bf622a20567124fcbf11c72df805365835ab3c041f4a9cd8a0ad63c9dee1018aa21a9fa3720f47dc48006f1aa3dba544950f87e627f369bc2793ede21223274492cceb77be7eea50e5a509059929a16d33a9f54796cde5770c74bd3ecc25318503f1a41976407aff2
+MD = c00926a374cde55b8fbd77f50da1363da19744d3f464e07ce31794c5a61b6f9c85689fa1cfe136553527fd876be91673c2cac2dd157b2defea360851b6d92cf4
+
+Len = 904
+Msg = 9159767275ba6f79cbb3d58c0108339d8c6a41138991ab7aa58b14793b545b04bda61dd255127b12cc501d5aaad476e09fa14aec21626e8d57b7d08c36cdb79eea314bdd77e65779a0b54eab08c48ceb976adf631f4246a33f7ef896887ea8b5dfa2087a225c8c180f8970696101fc283b
+MD = 3cd3380a90868de17dee4bd4d7f90d7512696f0a92b2d089240d61a9d20cd3af094c78bf466c2d404dd2f662ec5f4a299be2adeadf627b98e50e1c072b769d62
+
+Len = 912
+Msg = fe2d8ae200e6657fdc7494af5a12b2ae940348f1f983f0ba98febbe99c80d115126d57dbf37296765ebb5990256696588b3851d54c8fbe7ade98a6faf7c20b5e4f730f54a7f912ca0ac31bbb53d17949ef69aa0de40c7bab12a871a9b90f68813ca87af4256422a268f4a1d8ec3aa1a947fd
+MD = 8025a8608df0f6a01c34cdec012d4cb25852e1b100b68172fc4e86ac8b7126b64859cb9e767a7e59060989cedbd925afc475ca7369bd43f85ae590e224e036dd
+
+Len = 920
+Msg = dc28484ebfd293d62ac759d5754bdf502423e4d419fa79020805134b2ce3dff738c7556c91d810adbad8dd210f041296b73c2185d4646c97fc0a5b69ed49ac8c7ced0bd1cfd7e3c3cca47374d189247da6811a40b0ab097067ed4ad40ade2e4791e39204e398b3204971445822a1be0dd93af8
+MD = 615115d2e8b62e345adaa4bdb95395a3b4fe27d71c4a111b86c1841463c5f03d6b20d164a39948ab08ae060720d05c10f6022e5c8caf2fa3bca2e04d9c539ded
+
+Len = 928
+Msg = 5af8c0f26db4e99b47ec2e4a01a786e77899e46d464ac337f175027b61aef3149848af849d76ac39b9b0910fe6594817859e55974fa167518ed72d088dae6b414d744d477974fb719c626da792f981233de24b7579d8acca510a266d73c0ee8ee1424343eaf6ffcc59c86c1becce5894072c6c11
+MD = 09da284d5b6556508be54c8ab6c97bbd472995c6bbd585917ecdb54ea9167208daaa070a7b2b7d8e93ce1315f0d1ef8d69667429c44dc5ee1499de57b229a398
+
+Len = 936
+Msg = 49cd0ba0df5bb3f43f68464e3e83e9cbd5d5ee077ffa5591e30f939cb30c93f7d454fb3fbf8bb05327a89c08dc4baf1eef50237317a405775357f1e0d1f31d9f0f0d98124019d47bf18363b1ecfbfe155c10cbc83300e01bc9ce0347c596b35f411e6d8229ad2855e42022b0373ade98663c6d6e9c
+MD = 30cbf0679a97c871574d2fc05d7aa760c6bc8a864b7d246c39b9e812f9b7ff7b4ef5197dd5b69493306688b8564de1ad47d75505c913ba6a78788f8caf5788bd
+
+Len = 944
+Msg = a8a37dfc083ad2f47fff468738bf8b728eb7f1907e427fa15cb4424bc685e55ed7b2825c9c60b839ccc2fe5fb33e36f570cb8661609e630bda05ee641d938428867d90e00744a4aad494c93c5f6d1327878078590cdce1e647c9820818f467641fcd508e2f2ebfd0ff3d4f272393478f3b9e6f806b43
+MD = 8e1c91729be8eb40226f6c58a029380ef7edb9dc166a5c3cdbcefe90bd30d85cb7c4b248e66abf0a3a4c842281299bef6db88858d9e5ab5244f70b7969e1c072
+
+Len = 952
+Msg = 36af17595494ef793c42f48410246df07d05936a918afe74cd005e537c586b2843701f5df8952242b74586f83339b48f4ba3a66bdeb457ecdf61784eac6765cd9b8c570dd628dbba6ae5836b9ac3dbcd795f9efdb8742a35bca232abf36eb3b6698b2933965802277ba953a6edcacaf330c1e4e8c7d45f
+MD = 158bfc348a30b4fabbe355a7d44bdc2122a4c850444c03f289003ce01bfc1ebf3ecc0febb6a8ff523d25db7681b05bdce048d11943ab476c1967cf6556c4a120
+
+Len = 960
+Msg = 42d66edc5f22e0c13c25504c5101a5d172d2db7209e461efa323c0bfaed27e5f808042ea9c3838ea31f9b76de465225ccfbd0c09ca0d9f07e9a43e3e46c7693e00a7e1d483900ddb0a629d5563456dbbf299ac91f92c3d3c17b05d180e6c87c6c93194c39d90273fcf4a482c56084f95e34c04311fa80438
+MD = 061afb119a3c60876e04c10f12ad0f4b977593dc5a2d21096a57e7d3f7d4d44fdef934b2c17d7530674e4f4a1c176dbdcc54811a22e1b8712e4192fc2d4bf8e8
+
+Len = 968
+Msg = f91bb2e1a9c4cd96bf250426b3a6afd9b87ac51e93254d2dae3b16ec686ba80fb0bd7a84d218660e9007593075bc4f4c66567f0c7a5fd2010c999a8a0efa81f89ff5bfefe0fb910f0442e6d4a7c55bbb618c69a79a2ddd82a0938927f6fe3a80f04beaeb7c7636e3435d12dcf1c6bb6ed0a4edb69c9657fa93
+MD = 6e692c8c694ee0a3565f37a299e0006b85ab4a821b20e76798220229f656efc6a20211a4e7e4ed77facde0d70e4d5d95bc8ed1d7a56d8df1446d562f044b344c
+
+Len = 976
+Msg = d1eb961ca6a8f67c49b61e4d3ceaa2a1de6f0ea927b132bf987abdaa725b0e1e274e46830e99a2f75af608964df0dff9a99024fc6839bac5acd10202f921ac71a27fcda681aa3109ebf5f21ee3a849098ea3a551e844fae4b48b5c5bb97ccc802bc5520d68a14cb7e5fc056b67d889d876efb82d0e9a9a2499f1
+MD = 39b2c76ec207120de4b320c7fe069e602c9c38f257596da7369395e87eb64b3acff988c1839ac269d5012c093f9edd4b7cabf13bdea7d42e969ab108269c6ab0
+
+Len = 984
+Msg = adf2263200f376886ba7b6f5e4411d5f07f7d9d101590c73ace114bafbcb0fdc99269e87cd2cead2a1cfe5744394d333aba408a07e21f30233b65b907472e9e3c7d6e7aa6d2c47a08a1be7bb877913a6b5604c723384478911c339e3b5fe527c7e288705a89c95d970b443347897e79f6c522bafe62b11ef8f3135
+MD = 3c23d2d8cf4db6ac6a42e27208180f37668bef5ee0a3f879483c8e604e7f42583f202037b8d242c04a87345b8be6dc8b121d6484b9edad0d73c894c1288f5cae
+
+Len = 992
+Msg = 18e75b47d898ac629c48e80dbfb75dae1e1700b771165eccdb18d628bfc4063dd6c3839a7ec4cd1255c4821b078cd174647b320bb685541d517c579f6b8e3cdd2e109a610c7a921653b204ad018d0340d9938735b60262662016767e1d8824a64954086229c0e3b5bd9ad88c54c1dc5aa4e768ff1a9470ee6f6e998f
+MD = 01c756b7c20b5f95fd2b079ab6a50f28b946fb16266b07c6060945dc4fe9e0d279c5b1505b9ec7d8f8f3c9ebf0c5ee9365aec08cf278d65b64daeccc19d3cbf4
+
+Len = 1000
+Msg = c2963342cfaa88ccd102a258e6d629f6b0d367dd55116502ca4451ea523623bc4175819a0648df3168e8ea8f10ed27354807d76e02ee1fdf1c9c655ee2b9fd08d557058dabdf8dcf964bfcacc996ae173971e26ea038d407c824260d06c2848a04a488c4c456dbcde2939e561ab908c4097b508638d6cda556465c9cc5
+MD = a4d2f59393a5fea612c3c745f4bb9f41aaf3a3ce1679aa8afc1a62baa4ed452819418c8ae1a1e658757976692390fc43d4decf7d855cd8b498b6dc60cae05a90
+
+Len = 1008
+Msg = 85360c3d4257d9878e2f5c16d3cd7d0747df3d231e1a8f63fddc69b3b1101af72153de4c8154b090c9815f2466e0e4f02f3af3a89a7fd04e306664f93e5490d4ce7fc169d553c520ae15dd02c7c613c39b4acd00e0c9a3c501566e52cecea11f7303dd1da61abf3f2532fd396047b1887255f4b256c0afcf58f3ae48c947
+MD = e8352ddcac59e377ea0f9c32bbb43dfd1b6c829fad1954240c41b7c45b0b09db11064b64e2442a96f6530aac2c4abf3beb1eae77f2bce4efe88fee1a70cf5423
+
+Len = 1016
+Msg = c13e6ca3abb893aa5f82c4a8ef754460628af6b75af02168f45b72f8f09e45ed127c203bc7bb80ff0c7bd96f8cc6d8110868eb2cfc01037d8058992a6cf2effcbfe498c842e53a2e68a793867968ba18efc4a78b21cdf6a11e5de821dcabab14921ddb33625d48a13baffad6fe8272dbdf4433bd0f7b813c981269c388f001
+MD = 6e56f77f6883d0bd4face8b8d557f144661989f66d51b1fe4b8fc7124d66d9d20218616fea1bcf86c08d63bf8f2f21845a3e519083b937e70aa7c358310b5a7c
+
+Len = 1024
+Msg = fd2203e467574e834ab07c9097ae164532f24be1eb5d88f1af7748ceff0d2c67a21f4e4097f9d3bb4e9fbf97186e0db6db0100230a52b453d421f8ab9c9a6043aa3295ea20d2f06a2f37470d8a99075f1b8a8336f6228cf08b5942fc1fb4299c7d2480e8e82bce175540bdfad7752bc95b577f229515394f3ae5cec870a4b2f8
+MD = a21b1077d52b27ac545af63b32746c6e3c51cb0cb9f281eb9f3580a6d4996d5c9917d2a6e484627a9d5a06fa1b25327a9d710e027387fc3e07d7c4d14c6086cc
+

zeroidc/vendor/schannel/appveyor.yml

@@ -1,26 +1,26 @@
-environment:
-  matrix:
-  - TARGET: x86_64-pc-windows-msvc
-    VERSION: nightly
-  - TARGET: i686-pc-windows-msvc
-    VERSION: nightly
-  - TARGET: x86_64-pc-windows-gnu
-    VERSION: nightly
-  - TARGET: i686-pc-windows-gnu
-    VERSION: 1.40.0
-  access_token:
-    secure: ZxcrtxQXwszRYNN6c1ZIagczEqzmQQZeYHY58izcmF0jdq/cptxJvFUoVxDmnoqj
-install:
-  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-${env:VERSION}-${env:TARGET}.exe" -FileName "rust-nightly.exe"
-  - ps: .\rust-nightly.exe /VERYSILENT /NORESTART /DIR="C:\rust" | Out-Null
-  - ps: $env:PATH="$env:PATH;C:\rust\bin"
-  - rustc -vV
-  - cargo -vV
-  - echo install
-
-build: off
-
-test_script:
-  # TODO remove this loop when server 2016 lands on appveyor; related to https://github.com/steffengy/schannel-rs/issues/8
-  - set RUST_BACKTRACE=1
-  - ps: for($i=1; $i -le 3; $i++) { cmd /c "cargo test 2>&1"; if ($?) { break } }
+environment:
+  matrix:
+  - TARGET: x86_64-pc-windows-msvc
+    VERSION: nightly
+  - TARGET: i686-pc-windows-msvc
+    VERSION: nightly
+  - TARGET: x86_64-pc-windows-gnu
+    VERSION: nightly
+  - TARGET: i686-pc-windows-gnu
+    VERSION: 1.40.0
+  access_token:
+    secure: ZxcrtxQXwszRYNN6c1ZIagczEqzmQQZeYHY58izcmF0jdq/cptxJvFUoVxDmnoqj
+install:
+  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-${env:VERSION}-${env:TARGET}.exe" -FileName "rust-nightly.exe"
+  - ps: .\rust-nightly.exe /VERYSILENT /NORESTART /DIR="C:\rust" | Out-Null
+  - ps: $env:PATH="$env:PATH;C:\rust\bin"
+  - rustc -vV
+  - cargo -vV
+  - echo install
+
+build: off
+
+test_script:
+  # TODO remove this loop when server 2016 lands on appveyor; related to https://github.com/steffengy/schannel-rs/issues/8
+  - set RUST_BACKTRACE=1
+  - ps: for($i=1; $i -le 3; $i++) { cmd /c "cargo test 2>&1"; if ($?) { break } }

zeroidc/vendor/schannel/src/key_handle.rs

@@ -1,3 +1,3 @@
-//! Deprecated.
-#[deprecated(note = "use cert_context::PrivateKey", since = "0.1.5")]
-pub use crate::cert_context::PrivateKey as KeyHandle;
+//! Deprecated.
+#[deprecated(note = "use cert_context::PrivateKey", since = "0.1.5")]
+pub use crate::cert_context::PrivateKey as KeyHandle;

zeroidc/vendor/tinyvec/CHANGELOG.md

@@ -1,73 +1,73 @@
-# Changelog
-
-## 1.6.0
-
-* [i509VCB](https://github.com/i509VCB) added the `try_` functions for fallable reallocation.
-  [pr 158](https://github.com/Lokathor/tinyvec/pull/158)
-* [ajtribick](https://github.com/ajtribick) added more error impls to `TryFromSliceError`.
-  [pr 160](https://github.com/Lokathor/tinyvec/pull/160)
-* The `std` feature now automatically enables the `alloc` feature as well.
-
-## 1.5.1
-
-* [madsmtm](https://github.com/madsmtm) fixed an error with the `alloc` feature on very old rustc versions.
-  [pr 154](https://github.com/Lokathor/tinyvec/pull/154)
-
-## 1.5.0
-
-* [eeeebbbbrrrr](https://github.com/eeeebbbbrrrr) added an impl for [std::io::Write](https://doc.rust-lang.org/std/io/trait.Write.html) to `TinyVec` when the element type is `u8`.
-  This is gated behind the new `std` feature.
-  [pr 152](https://github.com/Lokathor/tinyvec/pull/152)
-
-## 1.4.0
-
-* [saethlin](https://github.com/saethlin) stabilized the usage of const generics and array map with the `rustc_1_55` feature.
-  [pr 149](https://github.com/Lokathor/tinyvec/pull/149)
-
-## 1.3.1
-
-* Improved the performance of the `clone_from` method [pr 144](https://github.com/Lokathor/tinyvec/pull/144)
-
-## 1.3.0
-
-* [jeffa5](https://github.com/jeffa5) added arbitrary implementations for `TinyVec` and `ArrayVec` [pr 146](https://github.com/Lokathor/tinyvec/pull/146).
-* [elomatreb](https://github.com/elomatreb) implemented `DoubleEndedIterator` for `TinyVecIterator` [pr 145](https://github.com/Lokathor/tinyvec/pull/145).
-
-## 1.2.0
-
-* [Cryptjar](https://github.com/Cryptjar) removed the `A:Array` bound on the struct of `ArrayVec<A:Array>`,
-  and added the `from_array_empty` method, which is a `const fn` constructor
-  [pr 141](https://github.com/Lokathor/tinyvec/pull/141).
-
-## 1.1.1
-
-* [saethlin](https://github.com/saethlin) contributed many PRs (
-  [127](https://github.com/Lokathor/tinyvec/pull/127),
-  [128](https://github.com/Lokathor/tinyvec/pull/128),
-  [129](https://github.com/Lokathor/tinyvec/pull/129),
-  [131](https://github.com/Lokathor/tinyvec/pull/131),
-  [132](https://github.com/Lokathor/tinyvec/pull/132)
-  ) to help in several benchmarks.
-
-## 1.1.0
-
-* [slightlyoutofphase](https://github.com/slightlyoutofphase)
-added "array splat" style syntax to the `array_vec!` and `tiny_vec!` macros.
-You can now write `array_vec![true; 5]` and get a length 5 array vec full of `true`,
-just like normal array initialization allows. Same goes for `tiny_vec!`.
-([pr 118](https://github.com/Lokathor/tinyvec/pull/118))
-* [not-a-seagull](https://github.com/not-a-seagull)
-added `ArrayVec::into_inner` so that you can get the array out of an `ArrayVec`.
-([pr 124](https://github.com/Lokathor/tinyvec/pull/124))
-
-## 1.0.2
-
-* Added license files for the MIT and Apache-2.0 license options.
-
-## 1.0.1
-
-* Display additional features in the [docs.rs/tinyvec](https://docs.rs/tinyvec) documentation.
-
-## 1.0.0
-
-Initial Stable Release.
+# Changelog
+
+## 1.6.0
+
+* [i509VCB](https://github.com/i509VCB) added the `try_` functions for fallable reallocation.
+  [pr 158](https://github.com/Lokathor/tinyvec/pull/158)
+* [ajtribick](https://github.com/ajtribick) added more error impls to `TryFromSliceError`.
+  [pr 160](https://github.com/Lokathor/tinyvec/pull/160)
+* The `std` feature now automatically enables the `alloc` feature as well.
+
+## 1.5.1
+
+* [madsmtm](https://github.com/madsmtm) fixed an error with the `alloc` feature on very old rustc versions.
+  [pr 154](https://github.com/Lokathor/tinyvec/pull/154)
+
+## 1.5.0
+
+* [eeeebbbbrrrr](https://github.com/eeeebbbbrrrr) added an impl for [std::io::Write](https://doc.rust-lang.org/std/io/trait.Write.html) to `TinyVec` when the element type is `u8`.
+  This is gated behind the new `std` feature.
+  [pr 152](https://github.com/Lokathor/tinyvec/pull/152)
+
+## 1.4.0
+
+* [saethlin](https://github.com/saethlin) stabilized the usage of const generics and array map with the `rustc_1_55` feature.
+  [pr 149](https://github.com/Lokathor/tinyvec/pull/149)
+
+## 1.3.1
+
+* Improved the performance of the `clone_from` method [pr 144](https://github.com/Lokathor/tinyvec/pull/144)
+
+## 1.3.0
+
+* [jeffa5](https://github.com/jeffa5) added arbitrary implementations for `TinyVec` and `ArrayVec` [pr 146](https://github.com/Lokathor/tinyvec/pull/146).
+* [elomatreb](https://github.com/elomatreb) implemented `DoubleEndedIterator` for `TinyVecIterator` [pr 145](https://github.com/Lokathor/tinyvec/pull/145).
+
+## 1.2.0
+
+* [Cryptjar](https://github.com/Cryptjar) removed the `A:Array` bound on the struct of `ArrayVec<A:Array>`,
+  and added the `from_array_empty` method, which is a `const fn` constructor
+  [pr 141](https://github.com/Lokathor/tinyvec/pull/141).
+
+## 1.1.1
+
+* [saethlin](https://github.com/saethlin) contributed many PRs (
+  [127](https://github.com/Lokathor/tinyvec/pull/127),
+  [128](https://github.com/Lokathor/tinyvec/pull/128),
+  [129](https://github.com/Lokathor/tinyvec/pull/129),
+  [131](https://github.com/Lokathor/tinyvec/pull/131),
+  [132](https://github.com/Lokathor/tinyvec/pull/132)
+  ) to help in several benchmarks.
+
+## 1.1.0
+
+* [slightlyoutofphase](https://github.com/slightlyoutofphase)
+added "array splat" style syntax to the `array_vec!` and `tiny_vec!` macros.
+You can now write `array_vec![true; 5]` and get a length 5 array vec full of `true`,
+just like normal array initialization allows. Same goes for `tiny_vec!`.
+([pr 118](https://github.com/Lokathor/tinyvec/pull/118))
+* [not-a-seagull](https://github.com/not-a-seagull)
+added `ArrayVec::into_inner` so that you can get the array out of an `ArrayVec`.
+([pr 124](https://github.com/Lokathor/tinyvec/pull/124))
+
+## 1.0.2
+
+* Added license files for the MIT and Apache-2.0 license options.
+
+## 1.0.1
+
+* Display additional features in the [docs.rs/tinyvec](https://docs.rs/tinyvec) documentation.
+
+## 1.0.0
+
+Initial Stable Release.

zeroidc/vendor/tinyvec/LICENSE-APACHE.md

@@ -1,202 +1,202 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

zeroidc/vendor/tinyvec/LICENSE-MIT.md

@@ -1,5 +1,5 @@
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

zeroidc/vendor/tinyvec/LICENSE-ZLIB.md

@@ -1,11 +1,11 @@
-Copyright (c) 2019 Daniel "Lokathor" Gee.
-
-This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source distribution.
+Copyright (c) 2019 Daniel "Lokathor" Gee.
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.

zeroidc/vendor/tinyvec/README.md

@@ -1,19 +1,19 @@
-[![License:Zlib](https://img.shields.io/badge/License-Zlib-brightgreen.svg)](https://opensource.org/licenses/Zlib)
-![Minimum Rust Version](https://img.shields.io/badge/Min%20Rust-1.34-green.svg)
-[![crates.io](https://img.shields.io/crates/v/tinyvec.svg)](https://crates.io/crates/tinyvec)
-[![docs.rs](https://docs.rs/tinyvec/badge.svg)](https://docs.rs/tinyvec/)
-
-![Unsafe-Zero-Percent](https://img.shields.io/badge/Unsafety-0%25-brightgreen.svg)
-
-# tinyvec
-
-A 100% safe crate of vec-like types. `#![forbid(unsafe_code)]`
-
-Main types are as follows:
-* `ArrayVec` is an array-backed vec-like data structure. It panics on overflow.
-* `SliceVec` is the same deal, but using a `&mut [T]`.
-* `TinyVec` (`alloc` feature) is an enum that's either an `Inline(ArrayVec)` or a `Heap(Vec)`. If a `TinyVec` is `Inline` and would overflow it automatically transitions to `Heap` and continues whatever it was doing.
-
-To attain this "100% safe code" status there is one compromise: the element type of the vecs must implement `Default`.
-
-For more details, please see [the docs.rs documentation](https://docs.rs/tinyvec/)
+[![License:Zlib](https://img.shields.io/badge/License-Zlib-brightgreen.svg)](https://opensource.org/licenses/Zlib)
+![Minimum Rust Version](https://img.shields.io/badge/Min%20Rust-1.34-green.svg)
+[![crates.io](https://img.shields.io/crates/v/tinyvec.svg)](https://crates.io/crates/tinyvec)
+[![docs.rs](https://docs.rs/tinyvec/badge.svg)](https://docs.rs/tinyvec/)
+
+![Unsafe-Zero-Percent](https://img.shields.io/badge/Unsafety-0%25-brightgreen.svg)
+
+# tinyvec
+
+A 100% safe crate of vec-like types. `#![forbid(unsafe_code)]`
+
+Main types are as follows:
+* `ArrayVec` is an array-backed vec-like data structure. It panics on overflow.
+* `SliceVec` is the same deal, but using a `&mut [T]`.
+* `TinyVec` (`alloc` feature) is an enum that's either an `Inline(ArrayVec)` or a `Heap(Vec)`. If a `TinyVec` is `Inline` and would overflow it automatically transitions to `Heap` and continues whatever it was doing.
+
+To attain this "100% safe code" status there is one compromise: the element type of the vecs must implement `Default`.
+
+For more details, please see [the docs.rs documentation](https://docs.rs/tinyvec/)

zeroidc/vendor/tinyvec/benches/macros.rs

@@ -1,52 +1,52 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-
-use tinyvec::tiny_vec;
-
-fn bench_tinyvec_macro(c: &mut Criterion) {
-  let mut g = c.benchmark_group("tinyvec_macro");
-
-  g.bench_function("0 of 32", |b| {
-    b.iter(|| tiny_vec!([u8; 32]));
-  });
-
-  g.bench_function("16 of 32", |b| {
-    b.iter(|| {
-      tiny_vec!([u8; 32]=>
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-      )
-    });
-  });
-
-  g.bench_function("32 of 32", |b| {
-    b.iter(|| {
-      tiny_vec!([u8; 32]=>
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
-      )
-    });
-  });
-
-  g.bench_function("33 of 32", |b| {
-    b.iter(|| {
-      tiny_vec!([u8; 32]=>
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
-        33,
-      )
-    });
-  });
-
-  g.bench_function("64 of 32", |b| {
-    b.iter(|| {
-      tiny_vec!([u8; 32]=>
-        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
-        33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
-        49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
-      )
-    });
-  });
-}
-
-criterion_group!(benches, bench_tinyvec_macro);
-criterion_main!(benches);
+use criterion::{criterion_group, criterion_main, Criterion};
+
+use tinyvec::tiny_vec;
+
+fn bench_tinyvec_macro(c: &mut Criterion) {
+  let mut g = c.benchmark_group("tinyvec_macro");
+
+  g.bench_function("0 of 32", |b| {
+    b.iter(|| tiny_vec!([u8; 32]));
+  });
+
+  g.bench_function("16 of 32", |b| {
+    b.iter(|| {
+      tiny_vec!([u8; 32]=>
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+      )
+    });
+  });
+
+  g.bench_function("32 of 32", |b| {
+    b.iter(|| {
+      tiny_vec!([u8; 32]=>
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+      )
+    });
+  });
+
+  g.bench_function("33 of 32", |b| {
+    b.iter(|| {
+      tiny_vec!([u8; 32]=>
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+        33,
+      )
+    });
+  });
+
+  g.bench_function("64 of 32", |b| {
+    b.iter(|| {
+      tiny_vec!([u8; 32]=>
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+        33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+        49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+      )
+    });
+  });
+}
+
+criterion_group!(benches, bench_tinyvec_macro);
+criterion_main!(benches);

zeroidc/vendor/tinyvec/benches/smallvec.rs

@@ -1,500 +1,500 @@
-//! Benchmarks that compare TinyVec to SmallVec
-//!
-//! All the following commentary is based on the latest nightly at the time:
-//! rustc 1.55.0 (c8dfcfe04 2021-09-06).
-//!
-//! Some of these benchmarks are just a few instructions, so we put our own for loop inside
-//! the criterion::Bencher::iter call. This seems to improve the stability of measurements, and it
-//! has the wonderful side effect of making the emitted assembly easier to follow. Some of these
-//! benchmarks are totally inlined so that there are no calls at all in the hot path, so finding
-//! this for loop is an easy way to find your way around the emitted assembly.
-//!
-//! The clear method is cheaper to call for arrays of elements without a Drop impl, so wherever
-//! possible we reuse a single object in the benchmark loop, with a clear + black_box on each
-//! iteration in an attempt to not make that visible to the optimizer.
-//!
-//! We always call black_box(&v), instead of v = black_box(v) because the latter does a move of the
-//! inline array, which is linear in the size of the array and thus varies based on the array type
-//! being benchmarked, and this move can be more expensive than the function we're trying to
-//! benchmark.
-//!
-//! We also black_box the input to each method call. This has a significant effect on the assembly
-//! emitted, for example if we do not black_box the range we iterate over in the ::push benchmarks,
-//! the loop is unrolled. It's not entirely clear if it's better to black_box the iterator that
-//! yields the items being pushed, or to black_box at a deeper level: v.push(black_box(i)) for
-//! example. Anecdotally, it seems like the latter approach produces unreasonably bad assembly.
-//!
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use smallvec::SmallVec;
-use std::iter::FromIterator;
-use tinyvec::TinyVec;
-
-const ITERS: usize = 10_000;
-
-macro_rules! tinyvec_benches {
-  ($c:expr, $type:ty ; $len:expr) => {{
-    let mut g = $c.benchmark_group(concat!(
-      "TinyVec_",
-      stringify!($type),
-      "_",
-      stringify!($len)
-    ));
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::default"
-      ),
-      |b| {
-        b.iter(|| {
-          for _ in 0..ITERS {
-            let v: TinyVec<[$type; $len]> = TinyVec::default();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::clone"
-      ),
-      |b| {
-        b.iter(|| {
-          let outer: TinyVec<[$type; $len]> =
-            black_box(TinyVec::from_iter(0..=($len as usize - 1) as _));
-          for _ in 0..ITERS {
-            let v = outer.clone();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::clear"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::push"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            for i in black_box(0..=($len as usize - 1) as _) {
-              v.push(i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::from_iter"
-      ),
-      |b| {
-        b.iter(|| {
-          for _ in 0..ITERS {
-            let v: TinyVec<[$type; $len]> =
-              TinyVec::from_iter(black_box(0..=($len as usize - 1) as _));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::from_slice"
-      ),
-      |b| {
-        b.iter(|| {
-          let data: &[$type] = &[0, 1, 2, 3, 4, 5, 6, 7];
-          for _ in 0..ITERS {
-            let v: TinyVec<[$type; $len]> = TinyVec::from(black_box(data));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::extend"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: TinyVec<[$type; $len]> = black_box(TinyVec::default());
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            v.extend(black_box(0..=($len as usize - 1) as _));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::extend_from_slice"
-      ),
-      |b| {
-        b.iter(|| {
-          let data: &[$type] = black_box(&[0, 1, 2, 3, 4, 5, 6, 7]);
-          let mut v: TinyVec<[$type; $len]> = black_box(TinyVec::default());
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            v.extend_from_slice(data);
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::insert"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            for i in black_box(0..=($len as usize - 1) as _) {
-              v.insert(i as usize, i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "TinyVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::remove"
-      ),
-      |b| {
-        b.iter(|| {
-          let outer: TinyVec<[$type; $len]> =
-            black_box(TinyVec::from_iter(0..=($len as usize - 1) as _));
-          for _ in 0..ITERS {
-            let mut v = outer.clone();
-            for i in black_box((0..=($len as usize - 1) as _).rev()) {
-              v.remove(i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-  }};
-}
-
-fn tinyvec_benches(c: &mut Criterion) {
-  tinyvec_benches!(c, u8; 8);
-  tinyvec_benches!(c, u8; 16);
-  tinyvec_benches!(c, u8; 32);
-  tinyvec_benches!(c, u8; 64);
-  tinyvec_benches!(c, u8; 128);
-  tinyvec_benches!(c, u8; 256);
-  tinyvec_benches!(c, u64; 2);
-  tinyvec_benches!(c, u64; 4);
-  tinyvec_benches!(c, u64; 8);
-  tinyvec_benches!(c, u64; 16);
-  tinyvec_benches!(c, u64; 32);
-}
-
-macro_rules! smallvec_benches {
-  ($c:expr, $type:ty ; $len:expr) => {{
-    let mut g = $c.benchmark_group(concat!(
-      "SmallVec_",
-      stringify!($type),
-      "_",
-      stringify!($len)
-    ));
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::default"
-      ),
-      |b| {
-        b.iter(|| {
-          for _ in 0..ITERS {
-            let v: SmallVec<[$type; $len]> = SmallVec::default();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::clone"
-      ),
-      |b| {
-        b.iter(|| {
-          let outer: SmallVec<[$type; $len]> =
-            black_box(SmallVec::from_iter(0..=($len as usize - 1) as _));
-          for _ in 0..ITERS {
-            let v = outer.clone();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::clear"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::push"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            for i in black_box(0..=($len as usize - 1) as _) {
-              v.push(i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::from_iter"
-      ),
-      |b| {
-        b.iter(|| {
-          for _ in 0..ITERS {
-            let v: SmallVec<[$type; $len]> =
-              SmallVec::from_iter(black_box(0..=($len as usize - 1) as _));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::from_slice"
-      ),
-      |b| {
-        b.iter(|| {
-          let data: &[$type] = &[0, 1, 2, 3, 4, 5, 6, 7];
-          for _ in 0..ITERS {
-            let v: SmallVec<[$type; $len]> = SmallVec::from(black_box(data));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::extend"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: SmallVec<[$type; $len]> = black_box(SmallVec::default());
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            v.extend(black_box(0..=($len as usize - 1) as _));
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::extend_from_slice"
-      ),
-      |b| {
-        b.iter(|| {
-          let data: &[$type] = black_box(&[0, 1, 2, 3, 4, 5, 6, 7]);
-          let mut v: SmallVec<[$type; $len]> = black_box(SmallVec::default());
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            v.extend_from_slice(data);
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::insert"
-      ),
-      |b| {
-        b.iter(|| {
-          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
-          for _ in 0..ITERS {
-            v.clear();
-            black_box(&v);
-            for i in black_box(0..=($len as usize - 1) as _) {
-              v.insert(i as usize, i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-
-    g.bench_function(
-      concat!(
-        "SmallVec<[",
-        stringify!($type),
-        "; ",
-        stringify!($len),
-        "]>::remove"
-      ),
-      |b| {
-        b.iter(|| {
-          let outer: SmallVec<[$type; $len]> =
-            black_box(SmallVec::from_iter(0..=($len as usize - 1) as _));
-          for _ in 0..ITERS {
-            let mut v = outer.clone();
-            for i in black_box((0..=($len as usize - 1) as _).rev()) {
-              v.remove(i);
-            }
-            black_box(&v);
-          }
-        });
-      },
-    );
-  }};
-}
-
-fn smallvec_benches(c: &mut Criterion) {
-  smallvec_benches!(c, u8; 8);
-  smallvec_benches!(c, u8; 16);
-  smallvec_benches!(c, u8; 32);
-  smallvec_benches!(c, u8; 64);
-  smallvec_benches!(c, u8; 128);
-  smallvec_benches!(c, u8; 256);
-  smallvec_benches!(c, u64; 2);
-  smallvec_benches!(c, u64; 4);
-  smallvec_benches!(c, u64; 8);
-  smallvec_benches!(c, u64; 16);
-  smallvec_benches!(c, u64; 32);
-}
-
-criterion_group!(benches, tinyvec_benches, smallvec_benches);
-criterion_main!(benches);
+//! Benchmarks that compare TinyVec to SmallVec
+//!
+//! All the following commentary is based on the latest nightly at the time:
+//! rustc 1.55.0 (c8dfcfe04 2021-09-06).
+//!
+//! Some of these benchmarks are just a few instructions, so we put our own for loop inside
+//! the criterion::Bencher::iter call. This seems to improve the stability of measurements, and it
+//! has the wonderful side effect of making the emitted assembly easier to follow. Some of these
+//! benchmarks are totally inlined so that there are no calls at all in the hot path, so finding
+//! this for loop is an easy way to find your way around the emitted assembly.
+//!
+//! The clear method is cheaper to call for arrays of elements without a Drop impl, so wherever
+//! possible we reuse a single object in the benchmark loop, with a clear + black_box on each
+//! iteration in an attempt to not make that visible to the optimizer.
+//!
+//! We always call black_box(&v), instead of v = black_box(v) because the latter does a move of the
+//! inline array, which is linear in the size of the array and thus varies based on the array type
+//! being benchmarked, and this move can be more expensive than the function we're trying to
+//! benchmark.
+//!
+//! We also black_box the input to each method call. This has a significant effect on the assembly
+//! emitted, for example if we do not black_box the range we iterate over in the ::push benchmarks,
+//! the loop is unrolled. It's not entirely clear if it's better to black_box the iterator that
+//! yields the items being pushed, or to black_box at a deeper level: v.push(black_box(i)) for
+//! example. Anecdotally, it seems like the latter approach produces unreasonably bad assembly.
+//!
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use smallvec::SmallVec;
+use std::iter::FromIterator;
+use tinyvec::TinyVec;
+
+const ITERS: usize = 10_000;
+
+macro_rules! tinyvec_benches {
+  ($c:expr, $type:ty ; $len:expr) => {{
+    let mut g = $c.benchmark_group(concat!(
+      "TinyVec_",
+      stringify!($type),
+      "_",
+      stringify!($len)
+    ));
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::default"
+      ),
+      |b| {
+        b.iter(|| {
+          for _ in 0..ITERS {
+            let v: TinyVec<[$type; $len]> = TinyVec::default();
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::clone"
+      ),
+      |b| {
+        b.iter(|| {
+          let outer: TinyVec<[$type; $len]> =
+            black_box(TinyVec::from_iter(0..=($len as usize - 1) as _));
+          for _ in 0..ITERS {
+            let v = outer.clone();
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::clear"
+      ),
+      |b| {
+        b.iter(|| {
+          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::push"
+      ),
+      |b| {
+        b.iter(|| {
+          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+            for i in black_box(0..=($len as usize - 1) as _) {
+              v.push(i);
+            }
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::from_iter"
+      ),
+      |b| {
+        b.iter(|| {
+          for _ in 0..ITERS {
+            let v: TinyVec<[$type; $len]> =
+              TinyVec::from_iter(black_box(0..=($len as usize - 1) as _));
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::from_slice"
+      ),
+      |b| {
+        b.iter(|| {
+          let data: &[$type] = &[0, 1, 2, 3, 4, 5, 6, 7];
+          for _ in 0..ITERS {
+            let v: TinyVec<[$type; $len]> = TinyVec::from(black_box(data));
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::extend"
+      ),
+      |b| {
+        b.iter(|| {
+          let mut v: TinyVec<[$type; $len]> = black_box(TinyVec::default());
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+            v.extend(black_box(0..=($len as usize - 1) as _));
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::extend_from_slice"
+      ),
+      |b| {
+        b.iter(|| {
+          let data: &[$type] = black_box(&[0, 1, 2, 3, 4, 5, 6, 7]);
+          let mut v: TinyVec<[$type; $len]> = black_box(TinyVec::default());
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+            v.extend_from_slice(data);
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::insert"
+      ),
+      |b| {
+        b.iter(|| {
+          let mut v: TinyVec<[$type; $len]> = TinyVec::default();
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+            for i in black_box(0..=($len as usize - 1) as _) {
+              v.insert(i as usize, i);
+            }
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "TinyVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::remove"
+      ),
+      |b| {
+        b.iter(|| {
+          let outer: TinyVec<[$type; $len]> =
+            black_box(TinyVec::from_iter(0..=($len as usize - 1) as _));
+          for _ in 0..ITERS {
+            let mut v = outer.clone();
+            for i in black_box((0..=($len as usize - 1) as _).rev()) {
+              v.remove(i);
+            }
+            black_box(&v);
+          }
+        });
+      },
+    );
+  }};
+}
+
+fn tinyvec_benches(c: &mut Criterion) {
+  tinyvec_benches!(c, u8; 8);
+  tinyvec_benches!(c, u8; 16);
+  tinyvec_benches!(c, u8; 32);
+  tinyvec_benches!(c, u8; 64);
+  tinyvec_benches!(c, u8; 128);
+  tinyvec_benches!(c, u8; 256);
+  tinyvec_benches!(c, u64; 2);
+  tinyvec_benches!(c, u64; 4);
+  tinyvec_benches!(c, u64; 8);
+  tinyvec_benches!(c, u64; 16);
+  tinyvec_benches!(c, u64; 32);
+}
+
+macro_rules! smallvec_benches {
+  ($c:expr, $type:ty ; $len:expr) => {{
+    let mut g = $c.benchmark_group(concat!(
+      "SmallVec_",
+      stringify!($type),
+      "_",
+      stringify!($len)
+    ));
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::default"
+      ),
+      |b| {
+        b.iter(|| {
+          for _ in 0..ITERS {
+            let v: SmallVec<[$type; $len]> = SmallVec::default();
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::clone"
+      ),
+      |b| {
+        b.iter(|| {
+          let outer: SmallVec<[$type; $len]> =
+            black_box(SmallVec::from_iter(0..=($len as usize - 1) as _));
+          for _ in 0..ITERS {
+            let v = outer.clone();
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::clear"
+      ),
+      |b| {
+        b.iter(|| {
+          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::push"
+      ),
+      |b| {
+        b.iter(|| {
+          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+            for i in black_box(0..=($len as usize - 1) as _) {
+              v.push(i);
+            }
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::from_iter"
+      ),
+      |b| {
+        b.iter(|| {
+          for _ in 0..ITERS {
+            let v: SmallVec<[$type; $len]> =
+              SmallVec::from_iter(black_box(0..=($len as usize - 1) as _));
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::from_slice"
+      ),
+      |b| {
+        b.iter(|| {
+          let data: &[$type] = &[0, 1, 2, 3, 4, 5, 6, 7];
+          for _ in 0..ITERS {
+            let v: SmallVec<[$type; $len]> = SmallVec::from(black_box(data));
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::extend"
+      ),
+      |b| {
+        b.iter(|| {
+          let mut v: SmallVec<[$type; $len]> = black_box(SmallVec::default());
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+            v.extend(black_box(0..=($len as usize - 1) as _));
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::extend_from_slice"
+      ),
+      |b| {
+        b.iter(|| {
+          let data: &[$type] = black_box(&[0, 1, 2, 3, 4, 5, 6, 7]);
+          let mut v: SmallVec<[$type; $len]> = black_box(SmallVec::default());
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+            v.extend_from_slice(data);
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::insert"
+      ),
+      |b| {
+        b.iter(|| {
+          let mut v: SmallVec<[$type; $len]> = SmallVec::default();
+          for _ in 0..ITERS {
+            v.clear();
+            black_box(&v);
+            for i in black_box(0..=($len as usize - 1) as _) {
+              v.insert(i as usize, i);
+            }
+            black_box(&v);
+          }
+        });
+      },
+    );
+
+    g.bench_function(
+      concat!(
+        "SmallVec<[",
+        stringify!($type),
+        "; ",
+        stringify!($len),
+        "]>::remove"
+      ),
+      |b| {
+        b.iter(|| {
+          let outer: SmallVec<[$type; $len]> =
+            black_box(SmallVec::from_iter(0..=($len as usize - 1) as _));
+          for _ in 0..ITERS {
+            let mut v = outer.clone();
+            for i in black_box((0..=($len as usize - 1) as _).rev()) {
+              v.remove(i);
+            }
+            black_box(&v);
+          }
+        });
+      },
+    );
+  }};
+}
+
+fn smallvec_benches(c: &mut Criterion) {
+  smallvec_benches!(c, u8; 8);
+  smallvec_benches!(c, u8; 16);
+  smallvec_benches!(c, u8; 32);
+  smallvec_benches!(c, u8; 64);
+  smallvec_benches!(c, u8; 128);
+  smallvec_benches!(c, u8; 256);
+  smallvec_benches!(c, u64; 2);
+  smallvec_benches!(c, u64; 4);
+  smallvec_benches!(c, u64; 8);
+  smallvec_benches!(c, u64; 16);
+  smallvec_benches!(c, u64; 32);
+}
+
+criterion_group!(benches, tinyvec_benches, smallvec_benches);
+criterion_main!(benches);

zeroidc/vendor/tinyvec/compare_benchmarks.py

@@ -1,30 +1,30 @@
-import os
-import os.path
-import json
-
-comparisons = []
-
-for (root, _dirs, files) in os.walk('target/criterion'):
-    for file in files:
-        if file == 'estimates.json' and root.endswith(
-                'new') and 'TinyVec' in root:
-            path = os.path.join(root, file)
-
-            bench_name = path.split('/')[3]
-            tinyvec_time = json.load(open(path))['mean']['point_estimate']
-
-            path = path.replace('TinyVec', 'SmallVec')
-
-            smallvec_time = json.load(open(path))['mean']['point_estimate']
-
-            comparisons.append((bench_name, tinyvec_time / smallvec_time))
-
-comparisons.sort(key=lambda x: x[1])
-longest_name = max(len(c[0]) for c in comparisons)
-for (name, ratio) in comparisons:
-    # Undo the criterion name mangling
-    name = name.replace('_[', '<[')
-    name = name.replace(']___', ']>::')
-
-    name = name.ljust(longest_name)
-    print(f"{name} {ratio:.2f}")
+import os
+import os.path
+import json
+
+comparisons = []
+
+for (root, _dirs, files) in os.walk('target/criterion'):
+    for file in files:
+        if file == 'estimates.json' and root.endswith(
+                'new') and 'TinyVec' in root:
+            path = os.path.join(root, file)
+
+            bench_name = path.split('/')[3]
+            tinyvec_time = json.load(open(path))['mean']['point_estimate']
+
+            path = path.replace('TinyVec', 'SmallVec')
+
+            smallvec_time = json.load(open(path))['mean']['point_estimate']
+
+            comparisons.append((bench_name, tinyvec_time / smallvec_time))
+
+comparisons.sort(key=lambda x: x[1])
+longest_name = max(len(c[0]) for c in comparisons)
+for (name, ratio) in comparisons:
+    # Undo the criterion name mangling
+    name = name.replace('_[', '<[')
+    name = name.replace(']___', ']>::')
+
+    name = name.ljust(longest_name)
+    print(f"{name} {ratio:.2f}")

zeroidc/vendor/tinyvec/gen-array-impls.sh

@@ -1,53 +1,53 @@
-#!/usr/bin/env bash
-
-gen_impl() {
-	local len=$1
-	cat <<-END
-		impl<T: Default> Array for [T; $len] {
-		  type Item = T;
-		  const CAPACITY: usize = $len;
-
-		  #[inline(always)]
-		  #[must_use]
-		  fn as_slice(&self) -> &[T] {
-		    &*self
-		  }
-
-		  #[inline(always)]
-		  #[must_use]
-		  fn as_slice_mut(&mut self) -> &mut [T] {
-		    &mut *self
-		  }
-
-		  #[inline(always)]
-		  fn default() -> Self {
-		    [
-		$(for ((i = 0; i < $len; i += 6))
-		do
-			echo -n '     '
-			for ((j = 0; j < 6 && j + i < $len; j++))
-			do
-				echo -n ' T::default(),'
-			done
-			echo
-		done)
-		    ]
-		  }
-		}
-
-		END
-}
-
-cat <<-END
-	// Generated file, to regenerate run
-	//     ./gen-array-impls.sh > src/array/generated_impl.rs
-	// from the repo root
-
-	use super::Array;
-
-	$(for ((i = 0; i <= 33; i++)); do gen_impl $i; done)
-
-	$(for ((i = 64; i <= 4096; i *= 2)); do gen_impl $i; done)
-END
-
-# vim: noet
+#!/usr/bin/env bash
+
+gen_impl() {
+	local len=$1
+	cat <<-END
+		impl<T: Default> Array for [T; $len] {
+		  type Item = T;
+		  const CAPACITY: usize = $len;
+
+		  #[inline(always)]
+		  #[must_use]
+		  fn as_slice(&self) -> &[T] {
+		    &*self
+		  }
+
+		  #[inline(always)]
+		  #[must_use]
+		  fn as_slice_mut(&mut self) -> &mut [T] {
+		    &mut *self
+		  }
+
+		  #[inline(always)]
+		  fn default() -> Self {
+		    [
+		$(for ((i = 0; i < $len; i += 6))
+		do
+			echo -n '     '
+			for ((j = 0; j < 6 && j + i < $len; j++))
+			do
+				echo -n ' T::default(),'
+			done
+			echo
+		done)
+		    ]
+		  }
+		}
+
+		END
+}
+
+cat <<-END
+	// Generated file, to regenerate run
+	//     ./gen-array-impls.sh > src/array/generated_impl.rs
+	// from the repo root
+
+	use super::Array;
+
+	$(for ((i = 0; i <= 33; i++)); do gen_impl $i; done)
+
+	$(for ((i = 64; i <= 4096; i *= 2)); do gen_impl $i; done)
+END
+
+# vim: noet

zeroidc/vendor/tinyvec/rustfmt.toml

@@ -1,14 +1,14 @@
-
-# Stable
-edition = "2018"
-fn_args_layout = "Compressed"
-max_width = 80
-tab_spaces = 2
-use_field_init_shorthand = true
-use_try_shorthand = true
-use_small_heuristics = "Max"
-
-# Unstable
-format_code_in_doc_comments = true
-wrap_comments = true
-imports_granularity="Crate"
+
+# Stable
+edition = "2018"
+fn_args_layout = "Compressed"
+max_width = 80
+tab_spaces = 2
+use_field_init_shorthand = true
+use_try_shorthand = true
+use_small_heuristics = "Max"
+
+# Unstable
+format_code_in_doc_comments = true
+wrap_comments = true
+imports_granularity="Crate"

zeroidc/vendor/tinyvec/src-backup/arrayset.rs

@@ -1,303 +1,303 @@
-#![cfg(feature = "experimental_array_set")]
-
-// This was contributed by user `dhardy`! Big thanks.
-
-use super::{take, Array};
-use core::{
-  borrow::Borrow,
-  fmt,
-  mem::swap,
-  ops::{AddAssign, SubAssign},
-};
-
-/// Error resulting from attempting to insert into a full array
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct InsertError;
-
-// TODO(when std): impl std::error::Error for InsertError {}
-
-impl fmt::Display for InsertError {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(f, "ArraySet: insertion failed")
-  }
-}
-
-/// An array-backed set
-///
-/// This set supports `O(n)` operations and has a fixed size, thus may fail to
-/// insert items. The potential advantage is a *really* small size.
-///
-/// The set is backed by an array of type `A` and indexed by type `L`.
-/// The item type must support `Default`.
-/// Due to restrictions, `L` may be only `u8` or `u16`.
-#[derive(Clone, Debug, Default)]
-pub struct ArraySet<A: Array, L> {
-  arr: A,
-  len: L,
-}
-
-impl<A: Array + Default, L: From<u8>> ArraySet<A, L> {
-  /// Constructs a new, empty, set
-  #[inline]
-  pub fn new() -> Self {
-    ArraySet { arr: Default::default(), len: 0.into() }
-  }
-}
-
-impl<A: Array, L: Copy + Into<usize>> ArraySet<A, L> {
-  /// Constructs a new set from given inputs
-  ///
-  /// Panics if `len> arr.len()`.
-  #[inline]
-  pub fn from(arr: A, len: L) -> Self {
-    if len.into() > A::CAPACITY {
-      panic!("ArraySet::from(array, len): len > array.len()");
-    }
-    ArraySet { arr, len }
-  }
-}
-
-impl<A: Array, L> ArraySet<A, L>
-where
-  L: Copy + PartialEq + From<u8> + Into<usize>,
-{
-  /// Returns the fixed capacity of the set
-  #[inline]
-  pub fn capacity(&self) -> usize {
-    A::CAPACITY
-  }
-
-  /// Returns the number of elements in the set
-  #[inline]
-  pub fn len(&self) -> usize {
-    self.len.into()
-  }
-
-  /// Returns true when the set contains no elements
-  #[inline]
-  pub fn is_empty(&self) -> bool {
-    self.len == 0.into()
-  }
-
-  /// Removes all elements
-  #[inline]
-  pub fn clear(&mut self) {
-    self.len = 0.into();
-  }
-
-  /// Iterate over all contents
-  #[inline]
-  pub fn iter(&self) -> Iter<A::Item> {
-    Iter { a: self.arr.as_slice(), i: 0 }
-  }
-}
-
-impl<A: Array, L> ArraySet<A, L>
-where
-  L: Copy + PartialOrd + AddAssign + SubAssign + From<u8> + Into<usize>,
-{
-  /// Check whether the set contains `elt`
-  #[inline]
-  pub fn contains<Q: Eq + ?Sized>(&self, elt: &Q) -> bool
-  where
-    A::Item: Borrow<Q>,
-  {
-    self.get(elt).is_some()
-  }
-
-  /// Get a reference to a contained item matching `elt`
-  pub fn get<Q: Eq + ?Sized>(&self, elt: &Q) -> Option<&A::Item>
-  where
-    A::Item: Borrow<Q>,
-  {
-    let len: usize = self.len.into();
-    let arr = self.arr.as_slice();
-    for i in 0..len {
-      if arr[i].borrow() == elt {
-        return Some(&arr[i]);
-      }
-    }
-    None
-  }
-
-  /// Remove an item matching `elt`, if any
-  pub fn remove<Q: Eq + ?Sized>(&mut self, elt: &Q) -> Option<A::Item>
-  where
-    A::Item: Borrow<Q>,
-  {
-    let len: usize = self.len.into();
-    let arr = self.arr.as_slice_mut();
-    for i in 0..len {
-      if arr[i].borrow() == elt {
-        let l1 = len - 1;
-        if i < l1 {
-          arr.swap(i, l1);
-        }
-        self.len -= L::from(1);
-        return Some(take(&mut arr[l1]));
-      }
-    }
-    None
-  }
-
-  /// Remove any items for which `f(item) == false`
-  pub fn retain<F>(&mut self, mut f: F)
-  where
-    F: FnMut(&A::Item) -> bool,
-  {
-    let mut len = self.len;
-    let arr = self.arr.as_slice_mut();
-    let mut i = 0;
-    while i < len.into() {
-      if !f(&arr[i]) {
-        len -= L::from(1);
-        if i < len.into() {
-          arr.swap(i, len.into());
-        }
-      } else {
-        i += 1;
-      }
-    }
-    self.len = len;
-  }
-}
-
-impl<A: Array, L> ArraySet<A, L>
-where
-  A::Item: Eq,
-  L: Copy + PartialOrd + AddAssign + SubAssign + From<u8> + Into<usize>,
-{
-  /// Insert an item
-  ///
-  /// Due to the fixed size of the backing array, insertion may fail.
-  #[inline]
-  pub fn insert(&mut self, elt: A::Item) -> Result<bool, InsertError> {
-    if self.contains(&elt) {
-      return Ok(false);
-    }
-
-    let len = self.len.into();
-    let arr = self.arr.as_slice_mut();
-    if len >= arr.len() {
-      return Err(InsertError);
-    }
-    arr[len] = elt;
-    self.len += L::from(1);
-    Ok(true)
-  }
-
-  /* Hits borrow checker
-  pub fn get_or_insert(&mut self, elt: A::Item) -> Result<&A::Item, InsertError> {
-      if let Some(r) = self.get(&elt) {
-          return Ok(r);
-      }
-      self.insert(elt)?;
-      let len: usize = self.len.into();
-      Ok(&self.arr.as_slice()[len - 1])
-  }
-  */
-
-  /// Replace an item matching `elt` with `elt`, or insert `elt`
-  ///
-  /// Returns the replaced item, if any. Fails when there is no matching item
-  /// and the backing array is full, preventing insertion.
-  pub fn replace(
-    &mut self,
-    mut elt: A::Item,
-  ) -> Result<Option<A::Item>, InsertError> {
-    let len: usize = self.len.into();
-    let arr = self.arr.as_slice_mut();
-    for i in 0..len {
-      if arr[i] == elt {
-        swap(&mut arr[i], &mut elt);
-        return Ok(Some(elt));
-      }
-    }
-
-    if len >= arr.len() {
-      return Err(InsertError);
-    }
-    arr[len] = elt;
-    self.len += L::from(1);
-    Ok(None)
-  }
-}
-
-/// Type returned by [`ArraySet::iter`]
-pub struct Iter<'a, T> {
-  a: &'a [T],
-  i: usize,
-}
-
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {
-  #[inline]
-  fn len(&self) -> usize {
-    self.a.len() - self.i
-  }
-}
-
-impl<'a, T> Iterator for Iter<'a, T> {
-  type Item = &'a T;
-
-  #[inline]
-  fn next(&mut self) -> Option<Self::Item> {
-    if self.i < self.a.len() {
-      let i = self.i;
-      self.i += 1;
-      Some(&self.a[i])
-    } else {
-      None
-    }
-  }
-
-  #[inline]
-  fn size_hint(&self) -> (usize, Option<usize>) {
-    let len = self.len();
-    (len, Some(len))
-  }
-}
-
-#[cfg(test)]
-mod test {
-  use super::*;
-  use core::mem::size_of;
-
-  #[test]
-  fn test_size() {
-    assert_eq!(size_of::<ArraySet<[i8; 7], u8>>(), 8);
-  }
-
-  #[test]
-  fn test() {
-    let mut set: ArraySet<[i8; 7], u8> = ArraySet::new();
-    assert_eq!(set.capacity(), 7);
-
-    assert_eq!(set.insert(1), Ok(true));
-    assert_eq!(set.insert(5), Ok(true));
-    assert_eq!(set.insert(6), Ok(true));
-    assert_eq!(set.len(), 3);
-
-    assert_eq!(set.insert(5), Ok(false));
-    assert_eq!(set.len(), 3);
-
-    assert_eq!(set.replace(1), Ok(Some(1)));
-    assert_eq!(set.replace(2), Ok(None));
-    assert_eq!(set.len(), 4);
-
-    assert_eq!(set.insert(3), Ok(true));
-    assert_eq!(set.insert(4), Ok(true));
-    assert_eq!(set.insert(7), Ok(true));
-    assert_eq!(set.insert(8), Err(InsertError));
-    assert_eq!(set.len(), 7);
-
-    assert_eq!(set.replace(9), Err(InsertError));
-
-    assert_eq!(set.remove(&3), Some(3));
-    assert_eq!(set.len(), 6);
-
-    set.retain(|x| *x == 3 || *x == 6);
-    assert_eq!(set.len(), 1);
-    assert!(!set.contains(&3));
-    assert!(set.contains(&6));
-  }
-}
+#![cfg(feature = "experimental_array_set")]
+
+// This was contributed by user `dhardy`! Big thanks.
+
+use super::{take, Array};
+use core::{
+  borrow::Borrow,
+  fmt,
+  mem::swap,
+  ops::{AddAssign, SubAssign},
+};
+
+/// Error resulting from attempting to insert into a full array
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct InsertError;
+
+// TODO(when std): impl std::error::Error for InsertError {}
+
+impl fmt::Display for InsertError {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    write!(f, "ArraySet: insertion failed")
+  }
+}
+
+/// An array-backed set
+///
+/// This set supports `O(n)` operations and has a fixed size, thus may fail to
+/// insert items. The potential advantage is a *really* small size.
+///
+/// The set is backed by an array of type `A` and indexed by type `L`.
+/// The item type must support `Default`.
+/// Due to restrictions, `L` may be only `u8` or `u16`.
+#[derive(Clone, Debug, Default)]
+pub struct ArraySet<A: Array, L> {
+  arr: A,
+  len: L,
+}
+
+impl<A: Array + Default, L: From<u8>> ArraySet<A, L> {
+  /// Constructs a new, empty, set
+  #[inline]
+  pub fn new() -> Self {
+    ArraySet { arr: Default::default(), len: 0.into() }
+  }
+}
+
+impl<A: Array, L: Copy + Into<usize>> ArraySet<A, L> {
+  /// Constructs a new set from given inputs
+  ///
+  /// Panics if `len> arr.len()`.
+  #[inline]
+  pub fn from(arr: A, len: L) -> Self {
+    if len.into() > A::CAPACITY {
+      panic!("ArraySet::from(array, len): len > array.len()");
+    }
+    ArraySet { arr, len }
+  }
+}
+
+impl<A: Array, L> ArraySet<A, L>
+where
+  L: Copy + PartialEq + From<u8> + Into<usize>,
+{
+  /// Returns the fixed capacity of the set
+  #[inline]
+  pub fn capacity(&self) -> usize {
+    A::CAPACITY
+  }
+
+  /// Returns the number of elements in the set
+  #[inline]
+  pub fn len(&self) -> usize {
+    self.len.into()
+  }
+
+  /// Returns true when the set contains no elements
+  #[inline]
+  pub fn is_empty(&self) -> bool {
+    self.len == 0.into()
+  }
+
+  /// Removes all elements
+  #[inline]
+  pub fn clear(&mut self) {
+    self.len = 0.into();
+  }
+
+  /// Iterate over all contents
+  #[inline]
+  pub fn iter(&self) -> Iter<A::Item> {
+    Iter { a: self.arr.as_slice(), i: 0 }
+  }
+}
+
+impl<A: Array, L> ArraySet<A, L>
+where
+  L: Copy + PartialOrd + AddAssign + SubAssign + From<u8> + Into<usize>,
+{
+  /// Check whether the set contains `elt`
+  #[inline]
+  pub fn contains<Q: Eq + ?Sized>(&self, elt: &Q) -> bool
+  where
+    A::Item: Borrow<Q>,
+  {
+    self.get(elt).is_some()
+  }
+
+  /// Get a reference to a contained item matching `elt`
+  pub fn get<Q: Eq + ?Sized>(&self, elt: &Q) -> Option<&A::Item>
+  where
+    A::Item: Borrow<Q>,
+  {
+    let len: usize = self.len.into();
+    let arr = self.arr.as_slice();
+    for i in 0..len {
+      if arr[i].borrow() == elt {
+        return Some(&arr[i]);
+      }
+    }
+    None
+  }
+
+  /// Remove an item matching `elt`, if any
+  pub fn remove<Q: Eq + ?Sized>(&mut self, elt: &Q) -> Option<A::Item>
+  where
+    A::Item: Borrow<Q>,
+  {
+    let len: usize = self.len.into();
+    let arr = self.arr.as_slice_mut();
+    for i in 0..len {
+      if arr[i].borrow() == elt {
+        let l1 = len - 1;
+        if i < l1 {
+          arr.swap(i, l1);
+        }
+        self.len -= L::from(1);
+        return Some(take(&mut arr[l1]));
+      }
+    }
+    None
+  }
+
+  /// Remove any items for which `f(item) == false`
+  pub fn retain<F>(&mut self, mut f: F)
+  where
+    F: FnMut(&A::Item) -> bool,
+  {
+    let mut len = self.len;
+    let arr = self.arr.as_slice_mut();
+    let mut i = 0;
+    while i < len.into() {
+      if !f(&arr[i]) {
+        len -= L::from(1);
+        if i < len.into() {
+          arr.swap(i, len.into());
+        }
+      } else {
+        i += 1;
+      }
+    }
+    self.len = len;
+  }
+}
+
+impl<A: Array, L> ArraySet<A, L>
+where
+  A::Item: Eq,
+  L: Copy + PartialOrd + AddAssign + SubAssign + From<u8> + Into<usize>,
+{
+  /// Insert an item
+  ///
+  /// Due to the fixed size of the backing array, insertion may fail.
+  #[inline]
+  pub fn insert(&mut self, elt: A::Item) -> Result<bool, InsertError> {
+    if self.contains(&elt) {
+      return Ok(false);
+    }
+
+    let len = self.len.into();
+    let arr = self.arr.as_slice_mut();
+    if len >= arr.len() {
+      return Err(InsertError);
+    }
+    arr[len] = elt;
+    self.len += L::from(1);
+    Ok(true)
+  }
+
+  /* Hits borrow checker
+  pub fn get_or_insert(&mut self, elt: A::Item) -> Result<&A::Item, InsertError> {
+      if let Some(r) = self.get(&elt) {
+          return Ok(r);
+      }
+      self.insert(elt)?;
+      let len: usize = self.len.into();
+      Ok(&self.arr.as_slice()[len - 1])
+  }
+  */
+
+  /// Replace an item matching `elt` with `elt`, or insert `elt`
+  ///
+  /// Returns the replaced item, if any. Fails when there is no matching item
+  /// and the backing array is full, preventing insertion.
+  pub fn replace(
+    &mut self,
+    mut elt: A::Item,
+  ) -> Result<Option<A::Item>, InsertError> {
+    let len: usize = self.len.into();
+    let arr = self.arr.as_slice_mut();
+    for i in 0..len {
+      if arr[i] == elt {
+        swap(&mut arr[i], &mut elt);
+        return Ok(Some(elt));
+      }
+    }
+
+    if len >= arr.len() {
+      return Err(InsertError);
+    }
+    arr[len] = elt;
+    self.len += L::from(1);
+    Ok(None)
+  }
+}
+
+/// Type returned by [`ArraySet::iter`]
+pub struct Iter<'a, T> {
+  a: &'a [T],
+  i: usize,
+}
+
+impl<'a, T> ExactSizeIterator for Iter<'a, T> {
+  #[inline]
+  fn len(&self) -> usize {
+    self.a.len() - self.i
+  }
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+  type Item = &'a T;
+
+  #[inline]
+  fn next(&mut self) -> Option<Self::Item> {
+    if self.i < self.a.len() {
+      let i = self.i;
+      self.i += 1;
+      Some(&self.a[i])
+    } else {
+      None
+    }
+  }
+
+  #[inline]
+  fn size_hint(&self) -> (usize, Option<usize>) {
+    let len = self.len();
+    (len, Some(len))
+  }
+}
+
+#[cfg(test)]
+mod test {
+  use super::*;
+  use core::mem::size_of;
+
+  #[test]
+  fn test_size() {
+    assert_eq!(size_of::<ArraySet<[i8; 7], u8>>(), 8);
+  }
+
+  #[test]
+  fn test() {
+    let mut set: ArraySet<[i8; 7], u8> = ArraySet::new();
+    assert_eq!(set.capacity(), 7);
+
+    assert_eq!(set.insert(1), Ok(true));
+    assert_eq!(set.insert(5), Ok(true));
+    assert_eq!(set.insert(6), Ok(true));
+    assert_eq!(set.len(), 3);
+
+    assert_eq!(set.insert(5), Ok(false));
+    assert_eq!(set.len(), 3);
+
+    assert_eq!(set.replace(1), Ok(Some(1)));
+    assert_eq!(set.replace(2), Ok(None));
+    assert_eq!(set.len(), 4);
+
+    assert_eq!(set.insert(3), Ok(true));
+    assert_eq!(set.insert(4), Ok(true));
+    assert_eq!(set.insert(7), Ok(true));
+    assert_eq!(set.insert(8), Err(InsertError));
+    assert_eq!(set.len(), 7);
+
+    assert_eq!(set.replace(9), Err(InsertError));
+
+    assert_eq!(set.remove(&3), Some(3));
+    assert_eq!(set.len(), 6);
+
+    set.retain(|x| *x == 3 || *x == 6);
+    assert_eq!(set.len(), 1);
+    assert!(!set.contains(&3));
+    assert!(set.contains(&6));
+  }
+}

zeroidc/vendor/tinyvec/src/array.rs

@@ -1,48 +1,48 @@
-/// A trait for types that are an array.
-///
-/// An "array", for our purposes, has the following properties:
-/// * Owns some number of elements.
-/// * The element type can be generic, but must implement [`Default`].
-/// * The capacity is fixed at compile time, based on the implementing type.
-/// * You can get a shared or mutable slice to the elements.
-///
-/// You are generally **not** expected to need to implement this yourself. It is
-/// already implemented for all the major array lengths (`0..=32` and the powers
-/// of 2 up to 4,096), or for all array lengths with the feature `rustc_1_55`.
-///
-/// **Additional lengths can easily be added upon request.**
-///
-/// ## Safety Reminder
-///
-/// Just a reminder: this trait is 100% safe, which means that `unsafe` code
-/// **must not** rely on an instance of this trait being correct.
-pub trait Array {
-  /// The type of the items in the thing.
-  type Item: Default;
-
-  /// The number of slots in the thing.
-  const CAPACITY: usize;
-
-  /// Gives a shared slice over the whole thing.
-  ///
-  /// A correct implementation will return a slice with a length equal to the
-  /// `CAPACITY` value.
-  fn as_slice(&self) -> &[Self::Item];
-
-  /// Gives a unique slice over the whole thing.
-  ///
-  /// A correct implementation will return a slice with a length equal to the
-  /// `CAPACITY` value.
-  fn as_slice_mut(&mut self) -> &mut [Self::Item];
-
-  /// Create a default-initialized instance of ourself, similar to the
-  /// [`Default`] trait, but implemented for the same range of sizes as
-  /// [`Array`].
-  fn default() -> Self;
-}
-
-#[cfg(feature = "rustc_1_55")]
-mod const_generic_impl;
-
-#[cfg(not(feature = "rustc_1_55"))]
-mod generated_impl;
+/// A trait for types that are an array.
+///
+/// An "array", for our purposes, has the following properties:
+/// * Owns some number of elements.
+/// * The element type can be generic, but must implement [`Default`].
+/// * The capacity is fixed at compile time, based on the implementing type.
+/// * You can get a shared or mutable slice to the elements.
+///
+/// You are generally **not** expected to need to implement this yourself. It is
+/// already implemented for all the major array lengths (`0..=32` and the powers
+/// of 2 up to 4,096), or for all array lengths with the feature `rustc_1_55`.
+///
+/// **Additional lengths can easily be added upon request.**
+///
+/// ## Safety Reminder
+///
+/// Just a reminder: this trait is 100% safe, which means that `unsafe` code
+/// **must not** rely on an instance of this trait being correct.
+pub trait Array {
+  /// The type of the items in the thing.
+  type Item: Default;
+
+  /// The number of slots in the thing.
+  const CAPACITY: usize;
+
+  /// Gives a shared slice over the whole thing.
+  ///
+  /// A correct implementation will return a slice with a length equal to the
+  /// `CAPACITY` value.
+  fn as_slice(&self) -> &[Self::Item];
+
+  /// Gives a unique slice over the whole thing.
+  ///
+  /// A correct implementation will return a slice with a length equal to the
+  /// `CAPACITY` value.
+  fn as_slice_mut(&mut self) -> &mut [Self::Item];
+
+  /// Create a default-initialized instance of ourself, similar to the
+  /// [`Default`] trait, but implemented for the same range of sizes as
+  /// [`Array`].
+  fn default() -> Self;
+}
+
+#[cfg(feature = "rustc_1_55")]
+mod const_generic_impl;
+
+#[cfg(not(feature = "rustc_1_55"))]
+mod generated_impl;