[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [tor-rust-dependencies/master] Add digest-0.7.2 dependency for #24659.



commit e92c124a41535bd2131b9506a7d95c68c9d8feda
Author: Isis Lovecruft <isis@xxxxxxxxxxxxxx>
Date:   Tue May 8 21:28:03 2018 +0000

    Add digest-0.7.2 dependency for #24659.
---
 crates/digest-0.7.2/.cargo-checksum.json           |    1 +
 crates/digest-0.7.2/Cargo.toml                     |   30 +
 crates/digest-0.7.2/LICENSE-APACHE                 |  201 +++
 crates/digest-0.7.2/LICENSE-MIT                    |   25 +
 crates/digest-0.7.2/src/dev.rs                     |  171 +++
 crates/digest-0.7.2/src/digest.rs                  |   85 ++
 crates/digest-0.7.2/src/lib.rs                     |   96 ++
 crates/generic-array-0.9.0/.cargo-checksum.json    |    1 +
 crates/generic-array-0.9.0/.travis.yml             |   18 +
 crates/generic-array-0.9.0/Cargo.toml              |   32 +
 crates/generic-array-0.9.0/LICENSE                 |   21 +
 crates/generic-array-0.9.0/README.md               |   34 +
 crates/generic-array-0.9.0/rustfmt.toml            |    3 +
 crates/generic-array-0.9.0/src/arr.rs              |   57 +
 crates/generic-array-0.9.0/src/hex.rs              |  101 ++
 crates/generic-array-0.9.0/src/impl_serde.rs       |   68 +
 crates/generic-array-0.9.0/src/impls.rs            |  171 +++
 crates/generic-array-0.9.0/src/iter.rs             |  117 ++
 crates/generic-array-0.9.0/src/lib.rs              |  464 ++++++
 crates/generic-array-0.9.0/tests/hex.rs            |   44 +
 crates/generic-array-0.9.0/tests/import_name.rs    |   10 +
 crates/generic-array-0.9.0/tests/mod.rs            |  169 +++
 crates/typenum-1.9.0/.cargo-checksum.json          |    1 +
 crates/typenum-1.9.0/.travis.yml                   |   42 +
 crates/typenum-1.9.0/CHANGELOG.md                  |   52 +
 crates/typenum-1.9.0/Cargo.toml                    |   24 +
 crates/typenum-1.9.0/LICENSE                       |   21 +
 crates/typenum-1.9.0/README.md                     |   42 +
 crates/typenum-1.9.0/build/main.rs                 |  177 +++
 crates/typenum-1.9.0/build/op.rs                   |  483 +++++++
 crates/typenum-1.9.0/build/tests.rs                |  293 ++++
 crates/typenum-1.9.0/ghp-import/LICENSE            |   11 +
 crates/typenum-1.9.0/ghp-import/MANIFEST.in        |    2 +
 crates/typenum-1.9.0/ghp-import/Makefile           |    8 +
 crates/typenum-1.9.0/ghp-import/README.md          |   78 +
 crates/typenum-1.9.0/ghp-import/docs/build.py      |   22 +
 .../typenum-1.9.0/ghp-import/docs/images/bg_hr.png |  Bin 0 -> 943 bytes
 .../ghp-import/docs/images/blacktocat.png          |  Bin 0 -> 1428 bytes
 .../ghp-import/docs/images/icon_download.png       |  Bin 0 -> 1162 bytes
 .../ghp-import/docs/images/sprite_download.png     |  Bin 0 -> 16799 bytes
 .../typenum-1.9.0/ghp-import/docs/index.html.tmpl  |   42 +
 crates/typenum-1.9.0/ghp-import/docs/style.css     |  431 ++++++
 crates/typenum-1.9.0/ghp-import/ghp_import.py      |  248 ++++
 crates/typenum-1.9.0/ghp-import/requirements.txt   |    2 +
 crates/typenum-1.9.0/ghp-import/setup.py           |   41 +
 crates/typenum-1.9.0/src/array.rs                  |  269 ++++
 crates/typenum-1.9.0/src/bit.rs                    |  263 ++++
 crates/typenum-1.9.0/src/int.rs                    |  910 ++++++++++++
 crates/typenum-1.9.0/src/lib.rs                    |  143 ++
 crates/typenum-1.9.0/src/marker_traits.rs          |  112 ++
 crates/typenum-1.9.0/src/operator_aliases.rs       |  102 ++
 crates/typenum-1.9.0/src/private.rs                |  371 +++++
 crates/typenum-1.9.0/src/type_operators.rs         |  499 +++++++
 crates/typenum-1.9.0/src/uint.rs                   | 1499 ++++++++++++++++++++
 crates/typenum-1.9.0/tests/test.rs                 |    1 +
 55 files changed, 8108 insertions(+)

diff --git a/crates/digest-0.7.2/.cargo-checksum.json b/crates/digest-0.7.2/.cargo-checksum.json
new file mode 100644
index 0000000..9208e04
--- /dev/null
+++ b/crates/digest-0.7.2/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"ed88be5d30abfcaec2cb19506924dc34ccb835a18132ac4e2ada488d6fb5edfe","LICENSE-APACHE":"a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5","LICENSE-MIT":"9e0dfd2dd4173a530e238cb6adb37aa78c34c6bc7444e0e10c1ab5d8881f63ba","src/dev.rs":"c824f834fa8b8c729024e4ec61138e89c26a56bfb6b50295600dddb5ff8fff62","src/digest.rs":"1e090459cd5775fa08cf973b717753992150b3dce92f17f854fb5bf4d705fef2","src/lib.rs":"b34d844aa0aedfeb6cfddff1504f43f86182c92384da30457fdc278571cafff3"},"package":"00a49051fef47a72c9623101b19bd71924a45cca838826caae3eaa4d00772603"}
\ No newline at end of file
diff --git a/crates/digest-0.7.2/Cargo.toml b/crates/digest-0.7.2/Cargo.toml
new file mode 100644
index 0000000..90c4ee3
--- /dev/null
+++ b/crates/digest-0.7.2/Cargo.toml
@@ -0,0 +1,30 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g. crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "digest"
+version = "0.7.2"
+authors = ["RustCrypto Developers"]
+description = "Traits for cryptographic hash functions"
+documentation = "https://docs.rs/digest";
+keywords = ["digest", "crypto", "hash"]
+categories = ["cryptography", "no-std"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/RustCrypto/traits";
+[dependencies.generic-array]
+version = "0.9"
+
+[features]
+dev = []
+std = []
+[badges.travis-ci]
+repository = "RustCrypto/traits"
diff --git a/crates/digest-0.7.2/LICENSE-APACHE b/crates/digest-0.7.2/LICENSE-APACHE
new file mode 100644
index 0000000..78173fa
--- /dev/null
+++ b/crates/digest-0.7.2/LICENSE-APACHE
@@ -0,0 +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.
diff --git a/crates/digest-0.7.2/LICENSE-MIT b/crates/digest-0.7.2/LICENSE-MIT
new file mode 100644
index 0000000..8dcb85b
--- /dev/null
+++ b/crates/digest-0.7.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2017 Artyom Pavlov
+
+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.
diff --git a/crates/digest-0.7.2/src/dev.rs b/crates/digest-0.7.2/src/dev.rs
new file mode 100644
index 0000000..35778cd
--- /dev/null
+++ b/crates/digest-0.7.2/src/dev.rs
@@ -0,0 +1,171 @@
+use super::{Digest, Input, VariableOutput, ExtendableOutput, XofReader};
+use core::fmt::Debug;
+
+pub struct Test {
+    pub name: &'static str,
+    pub input: &'static [u8],
+    pub output: &'static [u8],
+}
+
+#[macro_export]
+macro_rules! new_tests {
+    ( $( $name:expr ),*  ) => {
+        [$(
+            Test {
+                name: $name,
+                input: include_bytes!(concat!("data/", $name, ".input.bin")),
+                output: include_bytes!(concat!("data/", $name, ".output.bin")),
+            },
+        )*]
+    };
+    ( $( $name:expr ),+, ) => (new_tests!($($name),+))
+}
+
+pub fn main_test<D: Digest + Debug + Clone>(tests: &[Test]) {
+    // Test that it works when accepting the message all at once
+    for t in tests.iter() {
+        let mut sh = D::default();
+        sh.input(t.input);
+
+        let out = sh.result();
+
+        assert_eq!(out[..], t.output[..]);
+    }
+
+    // Test that it works when accepting the message in pieces
+    for t in tests.iter() {
+        let mut sh = D::default();
+        let len = t.input.len();
+        let mut left = len;
+        while left > 0 {
+            let take = (left + 1) / 2;
+            sh.input(&t.input[len - left..take + len - left]);
+            left = left - take;
+        }
+
+        let out = sh.result();
+
+        assert_eq!(out[..], t.output[..]);
+    }
+}
+
+pub fn variable_test<D>(tests: &[Test])
+    where D: Input + VariableOutput + Clone + Debug
+{
+    let mut buf = [0u8; 1024];
+    // Test that it works when accepting the message all at once
+    for t in tests.iter() {
+        let mut sh = D::new(t.output.len()).unwrap();
+        sh.process(t.input);
+
+        let out = sh.variable_result(&mut buf[..t.output.len()]).unwrap();
+
+        assert_eq!(out[..], t.output[..]);
+    }
+
+    // Test that it works when accepting the message in pieces
+    for t in tests.iter() {
+        let mut sh = D::new(t.output.len()).unwrap();
+        let len = t.input.len();
+        let mut left = len;
+        while left > 0 {
+            let take = (left + 1) / 2;
+            sh.process(&t.input[len - left..take + len - left]);
+            left = left - take;
+        }
+
+        let out = sh.variable_result(&mut buf[..t.output.len()]).unwrap();
+
+        assert_eq!(out[..], t.output[..]);
+    }
+}
+
+
+pub fn xof_test<D>(tests: &[Test])
+    where D: Input + ExtendableOutput + Default + Debug + Clone
+{
+    let mut buf = [0u8; 1024];
+    // Test that it works when accepting the message all at once
+    for t in tests.iter() {
+        let mut sh = D::default();
+        sh.process(t.input);
+
+        let out = &mut buf[..t.output.len()];
+        sh.xof_result().read(out);
+
+        assert_eq!(out[..], t.output[..]);
+    }
+
+    // Test that it works when accepting the message in pieces
+    for t in tests.iter() {
+        let mut sh = D::default();
+        let len = t.input.len();
+        let mut left = len;
+        while left > 0 {
+            let take = (left + 1) / 2;
+            sh.process(&t.input[len - left..take + len - left]);
+            left = left - take;
+        }
+
+        let out = &mut buf[..t.output.len()];
+        sh.xof_result().read(out);
+
+        assert_eq!(out[..], t.output[..]);
+    }
+
+    // Test reeading from reader byte by byte
+    for t in tests.iter() {
+        let mut sh = D::default();
+        sh.process(t.input);
+
+        let mut reader = sh.xof_result();
+        let out = &mut buf[..t.output.len()];
+        for chunk in out.chunks_mut(1) {
+            reader.read(chunk);
+        }
+
+        assert_eq!(out[..], t.output[..]);
+    }
+}
+
+pub fn one_million_a<D: Digest + Default + Debug + Clone>(expected: &[u8]) {
+    let mut sh = D::default();
+    for _ in 0..50000 {
+        sh.input(&[b'a'; 10]);
+    }
+    sh.input(&[b'a'; 500000]);
+    let out = sh.result();
+    assert_eq!(out[..], expected[..]);
+}
+
+
+#[macro_export]
+macro_rules! bench_digest {
+    ($name:ident, $engine:path, $bs:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let mut d = <$engine>::default();
+            let data = [0; $bs];
+
+            b.iter(|| {
+                d.input(&data);
+            });
+
+            b.bytes = $bs;
+        }
+    };
+
+    ($engine:path) => {
+        extern crate test;
+
+        use test::Bencher;
+        use digest::Digest;
+
+        bench_digest!(bench1_16, $engine, 1<<4);
+        bench_digest!(bench2_64, $engine, 1<<6);
+        bench_digest!(bench3_256, $engine, 1<<8);
+        bench_digest!(bench4_1k, $engine, 1<<10);
+        bench_digest!(bench5_4k, $engine, 1<<12);
+        bench_digest!(bench6_16k, $engine, 1<<14);
+    }
+}
diff --git a/crates/digest-0.7.2/src/digest.rs b/crates/digest-0.7.2/src/digest.rs
new file mode 100644
index 0000000..8439718
--- /dev/null
+++ b/crates/digest-0.7.2/src/digest.rs
@@ -0,0 +1,85 @@
+use super::{Input, BlockInput, FixedOutput};
+use generic_array::GenericArray;
+#[cfg(feature = "std")]
+use std::io;
+
+type Output<N> = GenericArray<u8, N>;
+
+/// The `Digest` trait specifies an interface common for digest functions.
+///
+/// It's a convinience wrapper around `Input`, `FixedOutput`, `BlockInput` and
+/// `Default` traits. It also provides additional convinience methods.
+pub trait Digest: Input + BlockInput + FixedOutput + Default {
+    /// Create new hasher instance
+    fn new() -> Self {
+        Self::default()
+    }
+
+    /// Digest input data. This method can be called repeatedly
+    /// for use with streaming messages.
+    fn input(&mut self, input: &[u8]) {
+        self.process(input);
+    }
+
+    /// Retrieve the digest result. This method consumes digest instance.
+    fn result(self) -> Output<Self::OutputSize> {
+        self.fixed_result()
+    }
+
+    /// Convinience function to compute hash of the `data`. It will handle
+    /// hasher creation, data feeding and finalization.
+    ///
+    /// Example:
+    ///
+    /// ```rust,ignore
+    /// println!("{:x}", sha2::Sha256::digest(b"Hello world"));
+    /// ```
+    #[inline]
+    fn digest(data: &[u8]) -> Output<Self::OutputSize> {
+        let mut hasher = Self::default();
+        hasher.process(data);
+        hasher.fixed_result()
+    }
+
+    /// Convinience function to compute hash of the string. It's equivalent to
+    /// `digest(input_string.as_bytes())`.
+    #[inline]
+    fn digest_str(str: &str) -> Output<Self::OutputSize> {
+        Self::digest(str.as_bytes())
+    }
+
+    /// Convinience function which takes `std::io::Read` as a source and computes
+    /// value of digest function `D`, e.g. SHA-2, SHA-3, BLAKE2, etc. using 1 KB
+    /// blocks.
+    ///
+    /// Usage example:
+    ///
+    /// ```rust,ignore
+    /// use std::fs;
+    /// use sha2::{Sha256, Digest};
+    ///
+    /// let mut file = fs::File::open("Cargo.toml")?;
+    /// let result = Sha256::digest_reader(&mut file)?;
+    /// println!("{:x}", result);
+    /// ```
+    #[cfg(feature = "std")]
+    #[inline]
+    fn digest_reader(source: &mut io::Read)
+        -> io::Result<Output<Self::OutputSize>>
+    {
+        let mut hasher = Self::default();
+
+        let mut buffer = [0u8; 1024];
+        loop {
+            let bytes_read = source.read(&mut buffer)?;
+            hasher.input(&buffer[..bytes_read]);
+            if bytes_read == 0 {
+                break;
+            }
+        }
+
+        Ok(hasher.result())
+    }
+}
+
+impl<D: Input + FixedOutput + BlockInput + Default> Digest for D {}
diff --git a/crates/digest-0.7.2/src/lib.rs b/crates/digest-0.7.2/src/lib.rs
new file mode 100644
index 0000000..f1a91cf
--- /dev/null
+++ b/crates/digest-0.7.2/src/lib.rs
@@ -0,0 +1,96 @@
+//! This crate provides traits for describing funcionality of cryptographic hash
+//! functions.
+//!
+//! By default std functionality in this crate disabled. (e.g. method for
+//! hashing `Read`ers) To enable it turn on `std` feature in your `Cargo.toml`
+//! for this crate.
+#![cfg_attr(not(feature = "std"), no_std)]
+pub extern crate generic_array;
+
+#[cfg(feature = "std")]
+use std as core;
+use generic_array::{GenericArray, ArrayLength};
+
+mod digest;
+#[cfg(feature = "dev")]
+pub mod dev;
+
+pub use digest::Digest;
+
+// `process` is choosen to not overlap with `input` method in the digest trait
+// change it on trait alias stabilization
+
+/// Trait for processing input data
+pub trait Input {
+    /// Digest input data. This method can be called repeatedly
+    /// for use with streaming messages.
+    fn process(&mut self, input: &[u8]);
+}
+
+/// Trait to indicate that digest function processes data in blocks of size
+/// `BlockSize`. Main usage of this trait is for implementing HMAC generically.
+pub trait BlockInput {
+    type BlockSize: ArrayLength<u8>;
+}
+
+/// Trait for returning digest result with the fixed size
+pub trait FixedOutput {
+    type OutputSize: ArrayLength<u8>;
+
+    /// Retrieve the digest result. This method consumes digest instance.
+    fn fixed_result(self) -> GenericArray<u8, Self::OutputSize>;
+}
+
+/// The error type for variable digest output
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct InvalidLength;
+
+/// Trait for returning digest result with the varaible size
+pub trait VariableOutput: core::marker::Sized {
+    /// Create new hasher instance with given output size. Will return
+    /// `Err(InvalidLength)` in case if hasher can not work with the given
+    /// output size. Will always return an error if output size equals to zero.
+    fn new(output_size: usize) -> Result<Self, InvalidLength>;
+
+    /// Get output size of the hasher instance provided to the `new` method
+    fn output_size(&self) -> usize;
+
+    /// Retrieve the digest result into provided buffer. Length of the buffer
+    /// must be equal to output size provided to the `new` method, otherwise
+    /// `Err(InvalidLength)` will be returned
+    fn variable_result(self, buffer: &mut [u8]) -> Result<&[u8], InvalidLength>;
+}
+
+/// Trait for decribing readers which are used to extract extendable output
+/// from the resulting state of hash function.
+pub trait XofReader {
+    /// Read output into the `buffer`. Can be called unlimited number of times.
+    fn read(&mut self, buffer: &mut [u8]);
+}
+
+/// Trait which describes extendable output (XOF) of hash functions. Using this
+/// trait you first need to get structure which implements `XofReader`, using
+/// which you can read extendable output.
+pub trait ExtendableOutput {
+    type Reader: XofReader;
+
+    /// Finalize hash function and return XOF reader
+    fn xof_result(self) -> Self::Reader;
+}
+
+/// Macro for defining opaque `Debug` implementation. It will use the following
+/// format: "HasherName { ... }". While it's convinient to have it
+/// (e.g. for including in other structs), it could be undesirable to leak
+/// internall state, which can happen for example through uncareful logging.
+#[macro_export]
+macro_rules! impl_opaque_debug {
+    ($state:ty) => {
+        impl ::core::fmt::Debug for $state {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter)
+                -> Result<(), ::core::fmt::Error>
+            {
+                write!(f, concat!(stringify!($state), " {{ ... }}"))
+            }
+        }
+    }
+}
diff --git a/crates/generic-array-0.9.0/.cargo-checksum.json b/crates/generic-array-0.9.0/.cargo-checksum.json
new file mode 100644
index 0000000..b6789fd
--- /dev/null
+++ b/crates/generic-array-0.9.0/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{".travis.yml":"e54c4d5b57dd91d875a36d2d57d68fef9c14bb0c31481f2e18877edf040f8676","Cargo.toml":"87ff65d640c137c26d338f96e21e769af1e1b2e7fa615b40a1bcc755448bb118","LICENSE":"ad4fcfaf8d5b12b97409c137a03d4a4e4b21024c65c54f976cc3b609c1bd5b0f","README.md":"9a1a45416eac57050036b13df6ec84d21d555e820726af3c782896bd9d37d94b","rustfmt.toml":"2a298b4ce1fe6e16b8f281a0035567b8eb15042ed3062729fd28224f29c2f75a","src/arr.rs":"cc1ea0a9ef6a524b90767cc8a89f6b939394a2948a645ed313c0bf5ce5a258a4","src/hex.rs":"bfbf304fb4dea6f7edc0569b38bf2ac7657ce089c5761891321722509e3b5076","src/impl_serde.rs":"805885478728b3c205b842d46deb377b7dd6dd4c4c50254064431f49f0981a2a","src/impls.rs":"8c54e294a82a2bf344bdcb9949b8a84903fb65698d6b1b1e0ab9f5e7847be64f","src/iter.rs":"e52217f04d0dc046f13ef2e3539b90eabd4d55bb85cf40f76ba0bf86d5e55ef0","src/lib.rs":"da93fa505eee94b40fce0fe98e26ed3bb4d2bc4d4869af01598b6e54fc9c0f8d","tests/hex.rs":"e909bc0564e7d52c5fcf172dfc0fac7085010c6a21d38581bf73a54ab2e256e1","tests/import_na
 me.rs":"1235729ecbde47fc9a38b3bf35c750a53ed55e3cf967c9d2b24fd759dc9e9e0c","tests/mod.rs":"f4100c5338906c038636f98f4d2b3d272f59580662afa89d915eafb96d7bbcf9"},"package":"ef25c5683767570c2bbd7deba372926a55eaae9982d7726ee2a1050239d45b9d"}
\ No newline at end of file
diff --git a/crates/generic-array-0.9.0/.travis.yml b/crates/generic-array-0.9.0/.travis.yml
new file mode 100644
index 0000000..e7432fa
--- /dev/null
+++ b/crates/generic-array-0.9.0/.travis.yml
@@ -0,0 +1,18 @@
+language: rust
+script:
+  - cd $TRAVIS_BUILD_DIR
+  - cargo build
+  - cargo test
+  - cargo build --features serde
+  - cargo test --features serde
+after_success: |-
+  [ $TRAVIS_BRANCH = master ] &&
+  [ $TRAVIS_PULL_REQUEST = false ] &&
+  cargo doc &&
+  echo "<meta http-equiv=refresh content=0;url=`echo $TRAVIS_REPO_SLUG | cut -d '/' -f 2`/index.html>" > target/doc/index.html &&
+  sudo pip install ghp-import &&
+  ghp-import -n target/doc &&
+  git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
+env:
+  global:
+    secure: te+DVowxg7YWHJHKRE2eEKEg5lK8IwK4aeKZ6rsDMaTcQFzP+jzSYJiodVuDMXy45sfDMCnkWmVmpfXFI5tCLBSqTDXXOZ0UpE2f4fI0d3inH6McEoXNM43HNZqvEWj6Uc4PzTSzkywcAhg39I08PRbp5zzdj+UhB0Ty++Twwjpipr2KQMNmu9RZEwPtbyjqE69yXkDWy1oM3o51uPnpK0RUH+ZE+B0StTG6CMzVY3gW+kQX96Ow+LYkhgn/YjfubVvKO7QHz8Nd1hOxg78tn1ZTHIazN7p3bJejpsZoU92cNCcx1xM0vV/rXNN1pLxzJOBxNC9tU9FNJAaLsg5kAVGZi8Xvu62nUmkpzki71/nilHBAUxJHGIyv0H52p4DyITEN8NzR5WkqN4qBv814Dpvna1Ua3TPqiYWP/LBb+xM27DuPHKuOifePNWehE84qhQMPgArQyiNCgfKaKbaiFO+J4jiUfEV/1aztuEFyHftLoRYstmHfMkhwYHfSf683QGjlqqoL3SFClp1sKAp8WO5b5ZasT9fOGaqPWi8g28/ZGIu67wocT/hJvXxwozAycsXV36JVHs1ab/ujRYMUbcnObx8E5taKLKhWn2jYWsrJ99bUag7F6wTz1erG0eboScTD8QgVY7Zfvz0Eh1MfePOhEJGZfETR80BypC9fZhY=
diff --git a/crates/generic-array-0.9.0/Cargo.toml b/crates/generic-array-0.9.0/Cargo.toml
new file mode 100644
index 0000000..07c6064
--- /dev/null
+++ b/crates/generic-array-0.9.0/Cargo.toml
@@ -0,0 +1,32 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g. crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "generic-array"
+version = "0.9.0"
+authors = ["BartÅ?omiej KamiÅ?ski <fizyk20@xxxxxxxxx>"]
+description = "Generic types implementing functionality of arrays"
+documentation = "http://fizyk20.github.io/generic-array/generic_array/";
+license = "MIT"
+repository = "https://github.com/fizyk20/generic-array.git";
+
+[lib]
+name = "generic_array"
+[dependencies.typenum]
+version = "1.9"
+
+[dependencies.serde]
+version = "1.0"
+optional = true
+default-features = false
+[dev-dependencies.serde_json]
+version = "1.0"
diff --git a/crates/generic-array-0.9.0/LICENSE b/crates/generic-array-0.9.0/LICENSE
new file mode 100644
index 0000000..5968bcc
--- /dev/null
+++ b/crates/generic-array-0.9.0/LICENSE
@@ -0,0 +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
+SOFTWARE.
\ No newline at end of file
diff --git a/crates/generic-array-0.9.0/README.md b/crates/generic-array-0.9.0/README.md
new file mode 100644
index 0000000..0864ed6
--- /dev/null
+++ b/crates/generic-array-0.9.0/README.md
@@ -0,0 +1,34 @@
+[![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.
+
+[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>
+}
+```
+
+To actually define a type implementing `ArrayLength`, you can use unsigned integer types defined in [typenum](https://github.com/paholg/typenum) crate - for example, `GenericArray<T, U5>` would work almost like `[T; 5]` :)
+
+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);
+```
diff --git a/crates/generic-array-0.9.0/rustfmt.toml b/crates/generic-array-0.9.0/rustfmt.toml
new file mode 100644
index 0000000..3dc0db2
--- /dev/null
+++ b/crates/generic-array-0.9.0/rustfmt.toml
@@ -0,0 +1,3 @@
+reorder_imports = true
+reorder_imported_names = true
+use_try_shorthand = true
diff --git a/crates/generic-array-0.9.0/src/arr.rs b/crates/generic-array-0.9.0/src/arr.rs
new file mode 100644
index 0000000..51d87f6
--- /dev/null
+++ b/crates/generic-array-0.9.0/src/arr.rs
@@ -0,0 +1,57 @@
+//! 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 {
+    ($T:ty; $N:ty, [$($x:expr),*], []) => ({
+	unsafe { $crate::transmute::<_, $crate::GenericArray<$T, $N>>([$($x),*]) }
+    });
+    ($T:ty; $N:ty, [], [$x1:expr]) => (
+        arr_impl!($T; $crate::arr::Inc<$T, $N>, [$x1 as $T], [])
+    );
+    ($T:ty; $N:ty, [], [$x1:expr, $($x:expr),+]) => (
+        arr_impl!($T; $crate::arr::Inc<$T, $N>, [$x1 as $T], [$($x),*])
+    );
+    ($T:ty; $N:ty, [$($y:expr),+], [$x1:expr]) => (
+        arr_impl!($T; $crate::arr::Inc<$T, $N>, [$($y),*, $x1 as $T], [])
+    );
+    ($T:ty; $N:ty, [$($y:expr),+], [$x1:expr, $($x:expr),+]) => (
+        arr_impl!($T; $crate::arr::Inc<$T, $N>, [$($y),*, $x1 as $T], [$($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),*) => (
+        arr_impl!($T; $crate::typenum::U0, [], [$($x),*])
+    );
+    ($($x:expr,)+) => (arr![$($x),*]);
+    () => ("""Macro requires a type, e.g. `let array = arr![u32; 1, 2, 3];`")
+}
diff --git a/crates/generic-array-0.9.0/src/hex.rs b/crates/generic-array-0.9.0/src/hex.rs
new file mode 100644
index 0000000..1ce5332
--- /dev/null
+++ b/crates/generic-array-0.9.0/src/hex.rs
@@ -0,0 +1,101 @@
+//! 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 {ArrayLength, GenericArray};
+use core::fmt;
+use core::ops::Add;
+use core::str;
+use typenum::*;
+
+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());
+
+        if T::to_usize() < 1024 {
+            // For small arrays use a stack allocated
+            // buffer of 2x number of bytes
+            let mut res = GenericArray::<u8, Sum<T, T>>::default();
+
+            for (i, c) in self.iter().take(max_digits).enumerate() {
+                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 * 2]) },
+            )?;
+        } else {
+            // For large array use chunks of up to 1024 bytes (2048 hex chars)
+            let mut buf = [0u8; 2048];
+
+            for chunk in self[..max_digits].chunks(1024) {
+                for (i, c) in chunk.iter().enumerate() {
+                    buf[i * 2] = LOWER_CHARS[(c >> 4) as usize];
+                    buf[i * 2 + 1] = LOWER_CHARS[(c & 0xF) as usize];
+                }
+                f.write_str(unsafe {
+                    str::from_utf8_unchecked(&buf[..chunk.len() * 2])
+                })?;
+            }
+        }
+        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());
+
+        if T::to_usize() < 1024 {
+            // For small arrays use a stack allocated
+            // buffer of 2x number of bytes
+            let mut res = GenericArray::<u8, Sum<T, T>>::default();
+
+            for (i, c) in self.iter().take(max_digits).enumerate() {
+                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 * 2]) },
+            )?;
+        } else {
+            // For large array use chunks of up to 1024 bytes (2048 hex chars)
+            let mut buf = [0u8; 2048];
+
+            for chunk in self[..max_digits].chunks(1024) {
+                for (i, c) in chunk.iter().enumerate() {
+                    buf[i * 2] = UPPER_CHARS[(c >> 4) as usize];
+                    buf[i * 2 + 1] = UPPER_CHARS[(c & 0xF) as usize];
+                }
+                f.write_str(unsafe {
+                    str::from_utf8_unchecked(&buf[..chunk.len() * 2])
+                })?;
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/crates/generic-array-0.9.0/src/impl_serde.rs b/crates/generic-array-0.9.0/src/impl_serde.rs
new file mode 100644
index 0000000..fd7f490
--- /dev/null
+++ b/crates/generic-array-0.9.0/src/impl_serde.rs
@@ -0,0 +1,68 @@
+//! Serde serialization/deserialization implementation
+
+use {ArrayLength, GenericArray};
+use core::fmt;
+use core::marker::PhantomData;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::de::{self, SeqAccess, Visitor};
+
+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,
+    {
+        serializer.collect_seq(self.iter())
+    }
+}
+
+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::to_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_seq(visitor)
+    }
+}
diff --git a/crates/generic-array-0.9.0/src/impls.rs b/crates/generic-array-0.9.0/src/impls.rs
new file mode 100644
index 0000000..3055876
--- /dev/null
+++ b/crates/generic-array-0.9.0/src/impls.rs
@@ -0,0 +1,171 @@
+use super::{ArrayLength, GenericArray};
+use core::borrow::{Borrow, BorrowMut};
+use core::cmp::Ordering;
+use core::fmt::{self, Debug};
+use core::hash::{Hash, Hasher};
+
+impl<T: Default, N> Default for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    #[inline]
+    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_ref(|x| x.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>,
+{
+    fn borrow(&self) -> &[T] {
+        &self[..]
+    }
+}
+
+impl<T, N> BorrowMut<[T]> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn borrow_mut(&mut self) -> &mut [T] {
+        &mut self[..]
+    }
+}
+
+impl<T, N> AsRef<[T]> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn as_ref(&self) -> &[T] {
+        &self[..]
+    }
+}
+
+impl<T, N> AsMut<[T]> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    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> {
+                fn from(arr: [T; $n]) -> Self {
+                    use core::mem::{forget, transmute_copy};
+                    let x = unsafe { transmute_copy(&arr) };
+                    forget(arr);
+                    x
+                }
+            }
+        )*
+
+    }
+}
+
+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
+}
\ No newline at end of file
diff --git a/crates/generic-array-0.9.0/src/iter.rs b/crates/generic-array-0.9.0/src/iter.rs
new file mode 100644
index 0000000..b928276
--- /dev/null
+++ b/crates/generic-array-0.9.0/src/iter.rs
@@ -0,0 +1,117 @@
+//! `GenericArray` iterator implementation.
+
+use super::{ArrayLength, GenericArray};
+use core::{cmp, ptr};
+use core::mem::ManuallyDrop;
+
+/// 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,
+}
+
+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::to_usize(),
+        }
+    }
+}
+
+impl<T, N> Drop for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn drop(&mut self) {
+        // Drop values that are still alive.
+        for p in &mut self.array[self.index..self.index_back] {
+            unsafe {
+                ptr::drop_in_place(p);
+            }
+        }
+    }
+}
+
+impl<T, N> Iterator for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        if self.len() > 0 {
+            unsafe {
+                let p = self.array.get_unchecked(self.index);
+                self.index += 1;
+                Some(ptr::read(p))
+            }
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+
+    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()
+    }
+
+    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.len() > 0 {
+            self.index_back -= 1;
+            unsafe {
+                let p = self.array.get_unchecked(self.index_back);
+                Some(ptr::read(p))
+            }
+        } else {
+            None
+        }
+    }
+}
+
+impl<T, N> ExactSizeIterator for GenericArrayIter<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn len(&self) -> usize {
+        self.index_back - self.index
+    }
+}
diff --git a/crates/generic-array-0.9.0/src/lib.rs b/crates/generic-array-0.9.0/src/lib.rs
new file mode 100644
index 0000000..ce478e5
--- /dev/null
+++ b/crates/generic-array-0.9.0/src/lib.rs
@@ -0,0 +1,464 @@
+//! This crate implements a structure that can be used as a generic array type.use
+//! Core Rust array types `[T; N]` can't be used generically with
+//! respect to `N`, so for example this:
+//!
+//! ```{should_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:
+//!
+//! ```
+//! # 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).
+//!
+//! 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)]
+#![no_std]
+
+pub extern crate typenum;
+#[cfg(feature = "serde")]
+extern crate serde;
+
+mod hex;
+mod impls;
+
+#[cfg(feature = "serde")]
+pub mod impl_serde;
+
+use core::{mem, ptr, slice};
+
+use core::marker::PhantomData;
+use core::mem::ManuallyDrop;
+pub use core::mem::transmute;
+use core::ops::{Deref, DerefMut};
+
+use typenum::bit::{B0, B1};
+use typenum::uint::{UInt, UTerm, Unsigned};
+
+#[cfg_attr(test, macro_use)]
+pub mod arr;
+pub mod iter;
+pub use iter::GenericArrayIter;
+
+/// 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 = ();
+}
+
+/// 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)]
+pub struct GenericArray<T, U: ArrayLength<T>> {
+    data: U::ArrayType,
+}
+
+impl<T, N> Deref for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    type Target = [T];
+
+    fn deref(&self) -> &[T] {
+        unsafe { slice::from_raw_parts(self as *const Self as *const T, N::to_usize()) }
+    }
+}
+
+impl<T, N> DerefMut for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    fn deref_mut(&mut self) -> &mut [T] {
+        unsafe { slice::from_raw_parts_mut(self as *mut Self as *mut T, N::to_usize()) }
+    }
+}
+
+struct ArrayBuilder<T, N: ArrayLength<T>> {
+    array: ManuallyDrop<GenericArray<T, N>>,
+    position: usize,
+}
+
+impl<T, N: ArrayLength<T>> ArrayBuilder<T, N> {
+    fn new() -> ArrayBuilder<T, N> {
+        ArrayBuilder {
+            array: ManuallyDrop::new(unsafe { mem::uninitialized() }),
+            position: 0,
+        }
+    }
+
+    fn into_inner(self) -> GenericArray<T, N> {
+        let array = unsafe { ptr::read(&self.array) };
+
+        mem::forget(self);
+
+        ManuallyDrop::into_inner(array)
+    }
+}
+
+impl<T, N: ArrayLength<T>> Drop for ArrayBuilder<T, N> {
+    fn drop(&mut self) {
+        for value in self.array.iter_mut().take(self.position) {
+            unsafe {
+                ptr::drop_in_place(value);
+            }
+        }
+    }
+}
+
+struct ArrayConsumer<T, N: ArrayLength<T>> {
+    array: ManuallyDrop<GenericArray<T, N>>,
+    position: usize,
+}
+
+impl<T, N: ArrayLength<T>> ArrayConsumer<T, N> {
+    fn new(array: GenericArray<T, N>) -> ArrayConsumer<T, N> {
+        ArrayConsumer {
+            array: ManuallyDrop::new(array),
+            position: 0,
+        }
+    }
+}
+
+impl<T, N: ArrayLength<T>> Drop for ArrayConsumer<T, N> {
+    fn drop(&mut self) {
+        for i in self.position..N::to_usize() {
+            unsafe {
+                ptr::drop_in_place(self.array.get_unchecked_mut(i));
+            }
+        }
+    }
+}
+
+impl<T, N> GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+{
+    /// Initializes a new `GenericArray` instance using the given function.
+    ///
+    /// If the generator function panics while initializing the array,
+    /// any already initialized elements will be dropped.
+    pub fn generate<F>(f: F) -> GenericArray<T, N>
+    where
+        F: Fn(usize) -> T,
+    {
+        let mut destination = ArrayBuilder::new();
+
+        for (i, dst) in destination.array.iter_mut().enumerate() {
+            unsafe {
+                ptr::write(dst, f(i));
+            }
+
+            destination.position += 1;
+        }
+
+        destination.into_inner()
+    }
+
+    /// Map a function over a slice to a `GenericArray`.
+    ///
+    /// The length of the slice *must* be equal to the length of the array.
+    #[inline]
+    pub fn map_slice<S, F: Fn(&S) -> T>(s: &[S], f: F) -> GenericArray<T, N> {
+        assert_eq!(s.len(), N::to_usize());
+
+        Self::generate(|i| f(unsafe { s.get_unchecked(i) }))
+    }
+
+    /// Maps a `GenericArray` to another `GenericArray`.
+    ///
+    /// If the mapping function panics, any already initialized elements in the new array
+    /// will be dropped, AND any unused elements in the source array will also be dropped.
+    pub fn map<U, F>(self, f: F) -> GenericArray<U, N>
+    where
+        F: Fn(T) -> U,
+        N: ArrayLength<U>,
+    {
+        let mut source = ArrayConsumer::new(self);
+        let mut destination = ArrayBuilder::new();
+
+        for (dst, src) in destination.array.iter_mut().zip(source.array.iter()) {
+            unsafe {
+                ptr::write(dst, f(ptr::read(src)));
+            }
+
+            source.position += 1;
+            destination.position += 1;
+        }
+
+        destination.into_inner()
+    }
+
+    /// Maps a `GenericArray` to another `GenericArray` by reference.
+    ///
+    /// If the mapping function panics, any already initialized elements will be dropped.
+    #[inline]
+    pub fn map_ref<U, F>(&self, f: F) -> GenericArray<U, N>
+    where
+        F: Fn(&T) -> U,
+        N: ArrayLength<U>,
+    {
+        GenericArray::generate(|i| f(unsafe { self.get_unchecked(i) }))
+    }
+
+    /// Combines two `GenericArray` instances and iterates through both of them,
+    /// initializing a new `GenericArray` with the result of the zipped mapping function.
+    ///
+    /// If the mapping function panics, any already initialized elements in the new array
+    /// will be dropped, AND any unused elements in the source arrays will also be dropped.
+    pub fn zip<B, U, F>(self, rhs: GenericArray<B, N>, f: F) -> GenericArray<U, N>
+    where
+        F: Fn(T, B) -> U,
+        N: ArrayLength<B> + ArrayLength<U>,
+    {
+        let mut left = ArrayConsumer::new(self);
+        let mut right = ArrayConsumer::new(rhs);
+
+        let mut destination = ArrayBuilder::new();
+
+        for (dst, (lhs, rhs)) in
+            destination.array.iter_mut().zip(left.array.iter().zip(
+                right.array.iter(),
+            ))
+        {
+            unsafe {
+                ptr::write(dst, f(ptr::read(lhs), ptr::read(rhs)));
+            }
+
+            destination.position += 1;
+            left.position += 1;
+            right.position += 1;
+        }
+
+        destination.into_inner()
+    }
+
+    /// Combines two `GenericArray` instances and iterates through both of them by reference,
+    /// initializing a new `GenericArray` with the result of the zipped mapping function.
+    ///
+    /// If the mapping function panics, any already initialized elements will be dropped.
+    pub fn zip_ref<B, U, F>(&self, rhs: &GenericArray<B, N>, f: F) -> GenericArray<U, N>
+    where
+        F: Fn(&T, &B) -> U,
+        N: ArrayLength<B> + ArrayLength<U>,
+    {
+        GenericArray::generate(|i| unsafe {
+            f(self.get_unchecked(i), rhs.get_unchecked(i))
+        })
+    }
+
+    /// 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> {
+        assert_eq!(slice.len(), N::to_usize());
+
+        unsafe { &*(slice.as_ptr() as *const 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]
+    pub fn from_mut_slice(slice: &mut [T]) -> &mut GenericArray<T, N> {
+        assert_eq!(slice.len(), N::to_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>,
+{
+    pub fn from_exact_iter<I>(iter: I) -> Option<Self>
+    where
+        I: IntoIterator<Item = T>,
+        <I as IntoIterator>::IntoIter: ExactSizeIterator,
+    {
+        let iter = iter.into_iter();
+
+        if iter.len() == N::to_usize() {
+            let mut destination = ArrayBuilder::new();
+
+            for (dst, src) in destination.array.iter_mut().zip(iter.into_iter()) {
+                unsafe {
+                    ptr::write(dst, src);
+                }
+
+                destination.position += 1;
+            }
+
+            let array = unsafe { ptr::read(&destination.array) };
+
+            mem::forget(destination);
+
+            Some(ManuallyDrop::into_inner(array))
+        } else {
+            None
+        }
+    }
+}
+
+impl<T, N> ::core::iter::FromIterator<T> for GenericArray<T, N>
+where
+    N: ArrayLength<T>,
+    T: Default,
+{
+    fn from_iter<I>(iter: I) -> GenericArray<T, N>
+    where
+        I: IntoIterator<Item = T>,
+    {
+        let mut destination = ArrayBuilder::new();
+
+        let defaults = ::core::iter::repeat(()).map(|_| T::default());
+
+        for (dst, src) in destination.array.iter_mut().zip(
+            iter.into_iter().chain(defaults),
+        )
+        {
+            unsafe {
+                ptr::write(dst, src);
+            }
+        }
+
+        destination.into_inner()
+    }
+}
+
+#[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() {
+        let a = black_box(arr![i32; 1, 3, 5, 7]);
+        let b = black_box(arr![i32; 2, 4, 6, 8]);
+
+        let c = a.zip_ref(&b, |l, r| l + r);
+
+        assert_eq!(c, arr![i32; 3, 7, 11, 15]);
+    }
+}
diff --git a/crates/generic-array-0.9.0/tests/hex.rs b/crates/generic-array-0.9.0/tests/hex.rs
new file mode 100644
index 0000000..aed69e4
--- /dev/null
+++ b/crates/generic-array-0.9.0/tests/hex.rs
@@ -0,0 +1,44 @@
+#[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_upper_hex() {
+    let ar = GenericArray::<u8, U2048>::default();
+    assert_eq!(format!("{:X}", ar), from_utf8(&[b'0'; 4096]).unwrap());
+}
+
+#[test]
+fn truncated_lower_hex() {
+    let ar = arr![u8; 10, 20, 30, 40, 50];
+    assert_eq!(format!("{:.2x}", ar), "0a14");
+}
+
+#[test]
+fn truncated_upper_hex() {
+    let ar = arr![u8; 30, 20, 10, 17, 0];
+    assert_eq!(format!("{:.4X}", ar), "1E140A11");
+}
diff --git a/crates/generic-array-0.9.0/tests/import_name.rs b/crates/generic-array-0.9.0/tests/import_name.rs
new file mode 100644
index 0000000..27653c9
--- /dev/null
+++ b/crates/generic-array-0.9.0/tests/import_name.rs
@@ -0,0 +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;];
+}
diff --git a/crates/generic-array-0.9.0/tests/mod.rs b/crates/generic-array-0.9.0/tests/mod.rs
new file mode 100644
index 0000000..2a2f2e1
--- /dev/null
+++ b/crates/generic-array-0.9.0/tests/mod.rs
@@ -0,0 +1,169 @@
+#![recursion_limit="128"]
+#![no_std]
+#[macro_use]
+extern crate generic_array;
+use core::cell::Cell;
+use core::ops::Drop;
+use generic_array::GenericArray;
+use generic_array::typenum::{U1, U3, U4, U97};
+
+#[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);
+}
+
+#[test]
+fn test_iter_flat_map() {
+    assert!((0..5).flat_map(|i| arr![i32; 2 * i, 2 * i + 1]).eq(0..10));
+}
+
+#[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, U1>::default();
+    assert_eq!(arr[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() {
+    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::GenericArray;
+    use generic_array::typenum::U6;
+
+    #[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);
+
+    let c = a.zip(b, |r, l| r as i32 + l);
+
+    assert_eq!(c, arr![i32; 1, 6, 11, 16]);
+}
+
+#[test]
+fn test_from_iter() {
+    use core::iter::repeat;
+
+    let a: GenericArray<_, U4> = repeat(11).take(3).collect();
+
+    assert_eq!(a, arr![i32; 11, 11, 11, 0]);
+}
diff --git a/crates/typenum-1.9.0/.cargo-checksum.json b/crates/typenum-1.9.0/.cargo-checksum.json
new file mode 100644
index 0000000..a20d55e
--- /dev/null
+++ b/crates/typenum-1.9.0/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{".travis.yml":"978a9c6fe23dd921b9fef8aaaa51f2f9213a09ea4550799624437e3cfbe83fae","CHANGELOG.md":"67dfcd0f0210a552334aaa02cb2e2980a756e18104113aa6c5caf090f02ec100","Cargo.toml":"9ff5180d11639e7b77b6be3c791c19b8f742d52ad29a964b2106fc995fc39a58","LICENSE":"a825bd853ab71619a4923d7b4311221427848070ff44d990da39b0b274c1683f","README.md":"068cae213e6858db4fa1afd8ddb50c10867d0a812c6339bb6eccacc23c54895f","build/main.rs":"69d1cf7e903a07f325a207c7a032ca674844456b5618d0f2285e01f0b29f7e30","build/op.rs":"2a4c77bb83b2230afa5e141f693222732919eeba9fa00f2e165339411e58cffe","build/tests.rs":"ad13e2566a1b7d26d4864797a8eea864810c3b6f52e62791956d42640ea06846","ghp-import/LICENSE":"4cad12a37ce2df808fa1f2ceb356207fd0a007e441f769e43d76b1ff200468e9","ghp-import/MANIFEST.in":"014edf15a68a5ddc0cf29523154d988535979b16e244069e6c9bfd5809a36d7b","ghp-import/Makefile":"66948f41286a924305a77902f16fbba66d9ab6b7be0516e110341b4d3fb80441","ghp-import/README.md":"860b0df1e5710aaead9d958afadbacfe73a28990f5752f5
 9e3e992d3e974565e","ghp-import/docs/build.py":"cc34d0b0bbf4f80d324c06ace177ae8c5117fa7544d306aa8831876ad9e132ae","ghp-import/docs/images/bg_hr.png":"8d8593f4f2eade62591d25e184e5cb6a0d0c6bd18a7cae862b11f1c03aa69489","ghp-import/docs/images/blacktocat.png":"01609f52c83c1bf92878bcc87a15656205dcacbea51d198c72e252a87e256c11","ghp-import/docs/images/icon_download.png":"9e47c3a9c659a46c6eacce7e474ce663aec9baa2d0f0fe08ad895321b7299bab","ghp-import/docs/images/sprite_download.png":"cd25181e43c38322cb01b0a90ba98e7252538939a327c3f22e09f27f01a3a710","ghp-import/docs/index.html.tmpl":"d811ce4dde58cec6ee4bd5ad36836099a4d437b9a82b3a2f73aa3ef2fdfcf8c9","ghp-import/docs/style.css":"492e8ff0f5601af383fe02a1011291e36804bc9a5e41cf5fce66a431081f5789","ghp-import/ghp_import.py":"97e6d4314deb206d63f6a28cfc4e5cf1812429ba53930fc2e844dece7a9e2af3","ghp-import/requirements.txt":"55c0e950d7d4ec76f5d5997efb989906b32f432ba1fc4cb8a3696fcefb3a919a","ghp-import/setup.py":"36d8a3a84ae4ddd1ee70da55719e13e4d4f129d026a
 df70a98dc7f7cac03388c","src/array.rs":"65fa2b482d3025c5d4e827278b8ab85dba45f72f56a30e42f622b0d8e76a15db","src/bit.rs":"6a5c04ee206c982d556c742499e06100d464fd3e9aec1dde091febb740311ff5","src/int.rs":"0e00004a029d96b40931b942bc3b13e91bbd5f1c3fcaf3b58af010eff38ebccc","src/lib.rs":"1a4d13a7557bc09e0340cc87ef702e40badfea492b3cd9cbd36d0dde41b6658d","src/marker_traits.rs":"b118437d58f6bf96d196c09320f39ec2b52c94b31aac9d23ab530bd88c097f43","src/operator_aliases.rs":"ef7b53fafad39e1320f3999da9f241955d11f774dab513db3990ac317e556475","src/private.rs":"bba45b391a7b6c5e2a90460f26ba42549cf575626bb38f1f6df7550565b646c8","src/type_operators.rs":"ae7a9f5950a079010cb0a97588ca027eb67514a15e488be4689a71997c427cf8","src/uint.rs":"3e98ef7de23e8c0dbb48ff997a2974b1afdc25ca097655e35b3b7db0e3b8deed","tests/test.rs":"ed6fa25e8c0850ad3c02f576341754348adc29234a11e9c6dac119405485d73d"},"package":"13a99dc6780ef33c78780b826cf9d2a78840b72cae9474de4bcaf9051e60ebbd"}
\ No newline at end of file
diff --git a/crates/typenum-1.9.0/.travis.yml b/crates/typenum-1.9.0/.travis.yml
new file mode 100644
index 0000000..f6b411b
--- /dev/null
+++ b/crates/typenum-1.9.0/.travis.yml
@@ -0,0 +1,42 @@
+language: rust
+sudo: false
+rust:
+  - stable
+  - nightly
+  - beta
+cache: cargo
+
+notifications:
+  email:
+    recipients: paho@xxxxxxxxxx
+
+before_script:
+  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
+  - export TRAVIS_CARGO_NIGHTLY_FEATURE=""
+  - test -x $HOME/.cargo/bin/rustfmt || cargo install rustfmt # Only install rustfmt if it's not there
+
+script:
+  - |
+    PATH=$PATH:~/.cargo/bin cargo fmt -- --write-mode=diff &&
+    travis-cargo build &&
+    travis-cargo test &&
+    # Note: The "no_std" flag is deprecated and this test remains to make sure we don't break compatibility.
+    travis-cargo --only stable test -- --features "no_std" &&
+    travis-cargo --only nightly test -- --features "clippy" &&
+    travis-cargo --only nightly test -- --features "i128" &&
+    travis-cargo --only stable doc
+
+after_success:
+  - travis-cargo --only stable doc-upload
+  - test $TRAVIS_PULL_REQUEST == "false" &&
+    test $TRAVIS_BRANCH == "master" &&
+    cargo publish --token ${CRATESIO_TOKEN}
+
+env:
+  global:
+    # GitHub SSH stuff
+    - COMMIT_AUTHOR_EMAIL: "paho@xxxxxxxxxx"
+    # GH_TOKEN
+    - secure: "jEnVq9nswc2mm2A77SEI5C9ytubHrAGpMu9mqF+wr7GoaGee48LjA5OkawY3VHzreB+3djy3LO6h+JUTkKN699KRZt+RvyIBR+yY1C5O+5IwY3k5pZn/Bm4xJZfeGfRwnZ9UYl1iNEAy+yHverMcQC+Lv5wzCSRCmTa18FQpKBeYKsdXfPP1wa+PWbei3bBrO0tBxuiIA5BZUuK8QqYXluUPxKETvJxtdKgFOUbMbf4DDJ4igOrt9OZQQxKrTZWDy+5Hwv4wMh2cir3ExYuM/8dfBewxxGOty1dlZWAUAFsIJ6Ww/mhEAGtsPYjqh3tB5G5JEss2FSvLuYJcKpA9p/mf+K4tagRVF68AydjQISWVBjOarwln2+HzK9tcykfyO8fGIUNgf0ptuZETA95g3BxwKF3O0LvhGJG2QOas8Bjqpdrg3iDoT5QGy2j8DnQLL7HgM31oCvzu1BOqDn3EvRSjwWpmBpXFz/FeUoRdIX1fOZpgw3cYWTpsT/mqW+mUfO98wTHKn3QBOnskLwf9AteTmJwsdx9Kdc4e1a3BqJE/UGNZv16SnVNtun+zMQ3P84HplvCIXL5k2pUDAUpDQne9nxmZ5ADpQJQluDosA5ydtbl+Z6x2o+zGrBOlo1vxoL/x4uuAFYyiwh1DUGyNgN9x2m1A3WtqqzXX5H4XwZ0="
+    # CRATESIO_TOKEN
+    - secure: "cchJKaN5hM2ceBpLqDokhUWFUyFubTlrUxj8d/5JjDXOxVvpZQWQuPxihnSyz0U+GSY4HwUh8C9+jRe2i8UBmhS6pPMG4Bl0Xo2T1HU9ilWb43vSqsbg77UgQ2SELNd+7g1xSI/UTsaFH0YlTOw7DsF6plruVduyOy8C44Ox1nAo4hIgN1ThRs9nhKTWydREr2zRQ/7n4c99RnPQz54ITnrHx/Ks2bvy3zgTOP7CeiQQJKh521U5tuH23r48eljje7776UA4Jbs2j1LsnMaBsraadIzNMopEwaSE1oNLOobfWG9YzvyTZ2i4yElDX4A7tscwo631Ig5AUH2+QbvN2k0q2EKETQJ9Mov5OSmK3aeMSW1GA3hQ44Uvz0F7SZru8D84sKgfSXNbfck1hTVfBPPOpmUIKDb+rSthulYq2SW2XG9cpVXrJmhYD2WTNKEuSmw7imVbTCPS03dbbMoLchpmOBkcgLtcMNDyC94xdZYSkyz9+RCG0bEfwIu9oG7o6gv+8a42pgVSP8mfOOq0+MELHntIqumlmTO0jGGH10Prs4Pgs8eVn6S84w+oz8yrbYroVaqrI2TZl73KnOmvAlnYZdCSIBGV5XsTukzochfwgaTKWI2h2iK1yt6k5I5ZgOoVlTUPB4ElwhIDfgYhc7fltHd53EO81GHGDPSI49M="
diff --git a/crates/typenum-1.9.0/CHANGELOG.md b/crates/typenum-1.9.0/CHANGELOG.md
new file mode 100644
index 0000000..3040713
--- /dev/null
+++ b/crates/typenum-1.9.0/CHANGELOG.md
@@ -0,0 +1,52 @@
+# Changelog
+
+This project follows semantic versioning.
+
+### 1.9.0 (2017-05-14)
+- [added] The `Abs` type operater and corresponding `AbsVal` alias.
+- [added] The feature `i128` that enables creating 128-bit integers from typenums.
+- [added] The `assert_type!` and `assert_type_eq!` macros.
+- [added] Operators to the `op!` macro, including those performed by `cmp!`.
+- [fixed] Bug in `op!` macro involving functions and convoluted expressions.
+- [deprecated] The `cmp!` macro.
+
+### 1.8.0 (2017-04-12)
+- [added] The `op!` macro for conveniently performing type-level operations.
+- [added] The `cmp!` macro for conveniently performing type-level comparisons.
+- [added] Some comparison type-operators that are used by the `cmp!` macro.
+
+### 1.7.0 (2017-03-24)
+- [added] Type operators `Min` and `Max` with accompanying aliases `Minimum` and `Maximum`
+
+### 1.6.0 (2017-02-24)
+- [fixed] Bug in `Array` division.
+- [fixed] Bug where `Rem` would sometimes exit early with the wrong answer.
+- [added] `PartialDiv` operator that performs division as a partial function -- it's defined only
+  when there is no remainder.
+
+### 1.5.2 (2017-02-04)
+- [fixed] Bug between `Div` implementation and type system.
+
+### 1.5.1 (2016-11-08)
+- [fixed] Expanded implementation of `Pow` for primitives.
+
+### 1.5.0 (2016-11-03)
+- [added] Functions to the `Pow` and `Len` traits. This is *technically* a breaking change, but it
+  would only break someone's code if they have a custom impl for `Pow`. I would be very surprised
+  if that is anyone other than me.
+
+### 1.4.0 (2016-10-29)
+- [added] Type-level arrays of type-level integers. (PR #66)
+- [added] The types in this crate are now instantiable. (Issue #67, PR #68)
+
+### 1.3.1 (2016-03-31)
+- [fixed] Bug with recent nightlies.
+
+### 1.3.0 (2016-02-07)
+- [changed] Removed dependency on libstd. (Issue #53, PR #55)
+- [changed] Reorganized module structure. (PR #57)
+
+### 1.2.0 (2016-01-03)
+- [added] This change log!
+- [added] Convenience type aliases for operators. (Issue #48, PR #50)
+- [added] Types in this crate now derive all possible traits. (Issue #42, PR #51)
diff --git a/crates/typenum-1.9.0/Cargo.toml b/crates/typenum-1.9.0/Cargo.toml
new file mode 100644
index 0000000..589901b
--- /dev/null
+++ b/crates/typenum-1.9.0/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+  name = "typenum"
+  build = "build/main.rs"
+  version = "1.9.0"
+  authors = [
+    "Paho Lurie-Gregg <paho@xxxxxxxxxx>",
+    "Andre Bogus <bogusandre@xxxxxxxxx>"
+  ]
+  documentation = "http://paholg.com/typenum";
+  repository = "https://github.com/paholg/typenum";
+  readme = "README.md"
+  license = "MIT/Apache-2.0"
+  description = "Typenum is a Rust library for type-level numbers evaluated at compile time. It currently supports bits, unsigned integers, and signed integers. It also provides a type-level array of type-level numbers, but its implementation is incomplete."
+  categories = ["no-std"]
+
+[lib]
+  name = "typenum"
+
+[features]
+  no_std = []
+  i128 = []
+
+[dependencies]
+  clippy = { version = "0.0.133", optional = true }
diff --git a/crates/typenum-1.9.0/LICENSE b/crates/typenum-1.9.0/LICENSE
new file mode 100644
index 0000000..e567a4d
--- /dev/null
+++ b/crates/typenum-1.9.0/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Paho Lurie-Gregg
+
+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.
diff --git a/crates/typenum-1.9.0/README.md b/crates/typenum-1.9.0/README.md
new file mode 100644
index 0000000..6c66154
--- /dev/null
+++ b/crates/typenum-1.9.0/README.md
@@ -0,0 +1,42 @@
+[![crates.io](https://img.shields.io/crates/v/typenum.svg)](https://crates.io/crates/typenum)
+[![Build Status](https://travis-ci.org/paholg/typenum.svg?branch=master)](https://travis-ci.org/paholg/typenum)
+
+Typenum
+=====
+
+Typenum is a Rust library for type-level numbers evaluated at compile time. It currently
+supports bits, unsigned integers, and signed integers.
+
+Typenum depends only on libcore, and so is suitable for use on any platform!
+
+For the full documentation, go [here](http://paholg.com/typenum).
+
+### Importing
+
+While `typenum` is divided into several modules, they are all re-exported through the crate root,
+so you can import anything contained herein with `use typenum::whatever;`, ignoring the
+crate structure.
+
+You may also find it useful to treat the `consts` module as a prelude, perfoming a glob import.
+
+### Example
+
+Here is a trivial example of `typenum`'s use:
+
+```rust
+use typenum::{Sum, Exp, Integer, N2, P3, P4};
+
+type X = Sum<P3, P4>;
+assert_eq!(<X as Integer>::to_i32(), 7);
+
+type Y = Exp<N2, P3>;
+assert_eq!(<Y as Integer>::to_i32(), -8);
+```
+
+For a non-trivial example of its use, see one of the crates that depends on it. The full
+list is [here](https://crates.io/crates/typenum/reverse_dependencies). Of note are
+[dimensioned](https://crates.io/crates/dimensioned/) which does compile-time type
+checking for arbitrary unit systems and
+[generic-array](https://crates.io/crates/generic-array/) which provides arrays whose
+length you can generically refer to.
+
diff --git a/crates/typenum-1.9.0/build/main.rs b/crates/typenum-1.9.0/build/main.rs
new file mode 100644
index 0000000..8e86e4b
--- /dev/null
+++ b/crates/typenum-1.9.0/build/main.rs
@@ -0,0 +1,177 @@
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
+use std::fmt;
+
+mod tests;
+mod op;
+
+pub enum UIntCode {
+    Term,
+    Zero(Box<UIntCode>),
+    One(Box<UIntCode>),
+}
+
+pub enum IntCode {
+    Zero,
+    Pos(Box<UIntCode>),
+    Neg(Box<UIntCode>),
+}
+
+impl fmt::Display for UIntCode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            UIntCode::Term => write!(f, "UTerm"),
+            UIntCode::Zero(ref inner) => write!(f, "UInt<{}, B0>", inner),
+            UIntCode::One(ref inner) => write!(f, "UInt<{}, B1>", inner),
+        }
+    }
+}
+
+impl fmt::Display for IntCode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            IntCode::Zero => write!(f, "Z0"),
+            IntCode::Pos(ref inner) => write!(f, "PInt<{}>", inner),
+            IntCode::Neg(ref inner) => write!(f, "NInt<{}>", inner),
+        }
+    }
+}
+
+pub fn gen_uint(u: u64) -> UIntCode {
+    let mut result = UIntCode::Term;
+    let mut x = 1u64 << 63;
+    while x > u {
+        x >>= 1
+    }
+    while x > 0 {
+        result = if x & u > 0 {
+            UIntCode::One(Box::new(result))
+        } else {
+            UIntCode::Zero(Box::new(result))
+        };
+        x >>= 1;
+    }
+    result
+}
+
+pub fn gen_int(i: i64) -> IntCode {
+    if i > 0 {
+        IntCode::Pos(Box::new(gen_uint(i as u64)))
+    } else if i < 0 {
+        IntCode::Neg(Box::new(gen_uint(i.abs() as u64)))
+    } else {
+        IntCode::Zero
+    }
+}
+
+#[cfg_attr(feature="no_std", deprecated(
+    since="1.3.0",
+    note="the `no_std` flag is no longer necessary and will be removed in the future"))]
+pub fn no_std() {}
+
+// fixme: get a warning when testing without this
+#[allow(dead_code)]
+fn main() {
+    let highest: u64 = 1024;
+
+
+    let first2: u32 = (highest as f64).log(2.0) as u32 + 1;
+    let first10: u32 = (highest as f64).log(10.0) as u32 + 1;
+    let uints = (0..(highest + 1))
+        .chain((first2..64).map(|i| 2u64.pow(i)))
+        .chain((first10..20).map(|i| 10u64.pow(i)));
+
+
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let dest = Path::new(&out_dir).join("consts.rs");
+
+    let mut f = File::create(&dest).unwrap();
+
+    no_std();
+
+    // Header stuff here!
+    write!(f,
+           "
+/**
+Type aliases for many constants.
+
+This file is generated by typenum's build script.
+
+For unsigned integers, the format is `U` followed by the number. We define aliases for
+
+- Numbers 0 through {highest}
+- Powers of 2 below `u64::MAX`
+- Powers of 10 below `u64::MAX`
+
+These alias definitions look like this:
+
+```rust
+use typenum::{{B0, B1, UInt, UTerm}};
+
+# #[allow(dead_code)]
+type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
+```
+
+For positive signed integers, the format is `P` followed by the number and for negative
+signed integers it is `N` followed by the number. For the signed integer zero, we use
+`Z0`. We define aliases for
+
+- Numbers -{highest} through {highest}
+- Powers of 2 between `i64::MIN` and `i64::MAX`
+- Powers of 10 between `i64::MIN` and `i64::MAX`
+
+These alias definitions look like this:
+
+```rust
+use typenum::{{B0, B1, UInt, UTerm, PInt, NInt}};
+
+# #[allow(dead_code)]
+type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
+# #[allow(dead_code)]
+type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
+```
+
+# Example
+```rust
+# #[allow(unused_imports)]
+use typenum::{{U0, U1, U2, U3, U4, U5, U6}};
+# #[allow(unused_imports)]
+use typenum::{{N3, N2, N1, Z0, P1, P2, P3}};
+# #[allow(unused_imports)]
+use typenum::{{U774, N17, N10000, P1024, P4096}};
+```
+
+We also define the aliases `False` and `True` for `B0` and `B1`, respectively.
+*/
+#[allow(missing_docs)]
+pub mod consts {{
+    use uint::{{UInt, UTerm}};
+    use int::{{PInt, NInt}};
+
+    pub use bit::{{B0, B1}};
+    pub use int::Z0;
+
+    pub type True = B1;
+    pub type False = B0;
+",
+           highest = highest)
+            .unwrap();
+
+    for u in uints {
+        write!(f, "    pub type U{} = {};\n", u, gen_uint(u)).unwrap();
+        if u <= ::std::i64::MAX as u64 && u != 0 {
+            let i = u as i64;
+            write!(f,
+                   "    pub type P{i} = PInt<U{i}>; pub type N{i} = NInt<U{i}>;\n",
+                   i = i)
+                    .unwrap();
+        }
+    }
+    write!(f, "}}").unwrap();
+
+    tests::build_tests().unwrap();
+
+    op::write_op_macro().unwrap();
+}
diff --git a/crates/typenum-1.9.0/build/op.rs b/crates/typenum-1.9.0/build/op.rs
new file mode 100644
index 0000000..6fbef9b
--- /dev/null
+++ b/crates/typenum-1.9.0/build/op.rs
@@ -0,0 +1,483 @@
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+enum OpType {
+    Operator,
+    Function,
+}
+
+use self::OpType::*;
+
+struct Op {
+    token: &'static str,
+    operator: &'static str,
+    example: (&'static str, &'static str),
+    precedence: u8,
+    n_args: u8,
+    op_type: OpType,
+}
+
+pub fn write_op_macro() -> ::std::io::Result<()> {
+    let out_dir = ::std::env::var("OUT_DIR").unwrap();
+    let dest = ::std::path::Path::new(&out_dir).join("op.rs");
+    let mut f = ::std::fs::File::create(&dest).unwrap();
+
+    // Operator precedence is taken from
+    // https://doc.rust-lang.org/reference.html#operator-precedence
+    //
+    // We choose 16 as the highest precedence (functions are set to 255 but it doesn't matter
+    // for them).  We also only use operators that are left associative so we don't have to worry
+    // about that.
+    let ops = &[Op {
+                    token: "*",
+                    operator: "Prod",
+                    example: ("P2 * P3", "P6"),
+                    precedence: 16,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "/",
+                    operator: "Quot",
+                    example: ("P6 / P2", "P3"),
+                    precedence: 16,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "%",
+                    operator: "Mod",
+                    example: ("P5 % P3", "P2"),
+                    precedence: 16,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "+",
+                    operator: "Sum",
+                    example: ("P2 + P3", "P5"),
+                    precedence: 15,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "-",
+                    operator: "Diff",
+                    example: ("P2 - P3", "N1"),
+                    precedence: 15,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "<<",
+                    operator: "Shleft",
+                    example: ("U1 << U5", "U32"),
+                    precedence: 14,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: ">>",
+                    operator: "Shright",
+                    example: ("U32 >> U5", "U1"),
+                    precedence: 14,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "&",
+                    operator: "And",
+                    example: ("U5 & U3", "U1"),
+                    precedence: 13,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "^",
+                    operator: "Xor",
+                    example: ("U5 ^ U3", "U6"),
+                    precedence: 12,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "|",
+                    operator: "Or",
+                    example: ("U5 | U3", "U7"),
+                    precedence: 11,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "==",
+                    operator: "Eq",
+                    example: ("P5 == P3 + P2", "True"),
+                    precedence: 10,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "!=",
+                    operator: "NotEq",
+                    example: ("P5 != P3 + P2", "False"),
+                    precedence: 10,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "<=",
+                    operator: "LeEq",
+                    example: ("P6 <= P3 + P2", "False"),
+                    precedence: 10,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: ">=",
+                    operator: "GrEq",
+                    example: ("P6 >= P3 + P2", "True"),
+                    precedence: 10,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "<",
+                    operator: "Le",
+                    example: ("P4 < P3 + P2", "True"),
+                    precedence: 10,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: ">",
+                    operator: "Gr",
+                    example: ("P5 < P3 + P2", "False"),
+                    precedence: 10,
+                    n_args: 2,
+                    op_type: Operator,
+                },
+                Op {
+                    token: "cmp",
+                    operator: "Compare",
+                    example: ("cmp(P2, P3)", "Less"),
+                    precedence: !0,
+                    n_args: 2,
+                    op_type: Function,
+                },
+                Op {
+                    token: "sqr",
+                    operator: "Square",
+                    example: ("sqr(P2)", "P4"),
+                    precedence: !0,
+                    n_args: 1,
+                    op_type: Function,
+                },
+                Op {
+                    token: "abs",
+                    operator: "AbsVal",
+                    example: ("abs(N2)", "P2"),
+                    precedence: !0,
+                    n_args: 1,
+                    op_type: Function,
+                },
+                Op {
+                    token: "cube",
+                    operator: "Cube",
+                    example: ("cube(P2)", "P8"),
+                    precedence: !0,
+                    n_args: 1,
+                    op_type: Function,
+                },
+                Op {
+                    token: "pow",
+                    operator: "Exp",
+                    example: ("pow(P2, P3)", "P8"),
+                    precedence: !0,
+                    n_args: 2,
+                    op_type: Function,
+                },
+                Op {
+                    token: "min",
+                    operator: "Minimum",
+                    example: ("min(P2, P3)", "P2"),
+                    precedence: !0,
+                    n_args: 2,
+                    op_type: Function,
+                },
+                Op {
+                    token: "max",
+                    operator: "Maximum",
+                    example: ("max(P2, P3)", "P3"),
+                    precedence: !0,
+                    n_args: 2,
+                    op_type: Function,
+                }];
+
+    use std::io::Write;
+    write!(f,
+           "
+/**
+Convenient type operations.
+
+Any types representing values must be able to be expressed as `ident`s. That means they need to be
+in scope.
+
+For example, `P5` is okay, but `typenum::P5` is not.
+
+You may combine operators arbitrarily, although doing so excessively may require raising the
+recursion limit.
+
+# Example
+```rust
+#![recursion_limit=\"128\"]
+#[macro_use] extern crate typenum;
+use typenum::consts::*;
+
+fn main() {{
+    assert_type!(
+        op!(min((P1 - P2) * (N3 + N7), P5 * (P3 + P4)) == P10)
+    );
+}}
+```
+Operators are evaluated based on the operator precedence outlined
+[here](https://doc.rust-lang.org/reference.html#operator-precedence).
+
+The full list of supported operators and functions is as follows:
+
+{}
+
+They all expand to type aliases defined in the `operator_aliases` module. Here is an expanded list,
+including examples:
+
+",
+           ops.iter()
+               .map(|op| format!("`{}`", op.token))
+               .collect::<Vec<_>>()
+               .join(", "))?;
+
+    //write!(f, "Token | Alias | Example\n ===|===|===\n")?;
+
+    for op in ops.iter() {
+        write!(f,
+               "---\nOperator `{token}`. Expands to `{operator}`.
+
+```rust
+# #[macro_use] extern crate typenum;
+# use typenum::*;
+# fn main() {{
+assert_type_eq!(op!({ex0}), {ex1});
+# }}
+```\n
+",
+               token = op.token,
+               operator = op.operator,
+               ex0 = op.example.0,
+               ex1 = op.example.1)?;
+    }
+
+    write!(f,
+           "*/
+#[macro_export]
+macro_rules! op {{
+    ($($tail:tt)*) => ( __op_internal__!($($tail)*) );
+}}
+
+    #[doc(hidden)]
+    #[macro_export]
+    macro_rules! __op_internal__ {{
+")?;
+
+    // We first us the shunting-yard algorithm to produce our tokens in Polish notation.
+    // See: https://en.wikipedia.org/wiki/Shunting-yard_algorithm
+
+    // Note: Due to macro asymmetry, "the top of the stack" refers to the first element, not the
+    // last
+
+    // -----------------------------------------------------------------------------------------
+    // Stage 1: There are tokens to be read:
+
+    // -------
+    // Case 1: Token is a function => Push it onto the stack:
+    for fun in ops.iter().filter(|f| f.op_type == Function) {
+        write!(f,
+               "
+(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: {f_token} $($tail:tt)*) => (
+    __op_internal__!(@stack[{f_op}, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*)
+);",
+               f_token = fun.token,
+               f_op = fun.operator)?;
+    }
+
+    // -------
+    // Case 2: Token is a comma => Until the top of the stack is a LParen,
+    //                             Pop operators from stack to queue
+
+    // Base case: Top of stack is LParen, ditch comma and continue
+    write!(f,
+           "
+(@stack[LParen, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: , $($tail:tt)*) => (
+    __op_internal__!(@stack[LParen, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*)
+);")?;
+    // Recursive case: Not LParen, pop from stack to queue
+    write!(f,
+           "
+(@stack[$stack_top:ident, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: , $($tail:tt)*) => (
+    __op_internal__!(@stack[$($stack,)*] @queue[$stack_top, $($queue,)*] @tail: , $($tail)*)
+);")?;
+
+    // -------
+    // Case 3: Token is an operator, o1:
+    for o1 in ops.iter().filter(|op| op.op_type == Operator) {
+        // If top of stack is operator o2 with o1.precedence <= o2.precedence,
+        // Then pop o2 off stack onto queue:
+        for o2 in ops.iter()
+                .filter(|op| op.op_type == Operator)
+                .filter(|o2| o1.precedence <= o2.precedence) {
+            write!(f,
+                   "
+(@stack[{o2_op}, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: {o1_token} $($tail:tt)*) => (
+    __op_internal__!(@stack[$($stack,)*] @queue[{o2_op}, $($queue,)*] @tail: {o1_token} $($tail)*)
+);",
+                   o2_op = o2.operator,
+                   o1_token = o1.token)?;
+        }
+        // Base case: push o1 onto stack
+        write!(f,
+               "
+(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: {o1_token} $($tail:tt)*) => (
+    __op_internal__!(@stack[{o1_op}, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*)
+);",
+               o1_op = o1.operator,
+               o1_token = o1.token)?;
+    }
+
+    // -------
+    // Case 4: Token is "(": push it onto stack as "LParen". Also convert the ")" to "RParen" to
+    // appease the macro gods:
+    write!(f,
+           "
+(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ( $($stuff:tt)* ) $($tail:tt)* )
+ => (
+    __op_internal__!(@stack[LParen, $($stack,)*] @queue[$($queue,)*]
+                     @tail: $($stuff)* RParen $($tail)*)
+);")?;
+
+    // -------
+    // Case 5: Token is "RParen":
+    //     1. Pop from stack to queue until we see an "LParen",
+    //     2. Kill the "LParen",
+    //     3. If the top of the stack is a function, pop it onto the queue
+    // 2. Base case:
+    write!(f,
+           "
+(@stack[LParen, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: RParen $($tail:tt)*) => (
+    __op_internal__!(@rp3 @stack[$($stack,)*] @queue[$($queue,)*] @tail: $($tail)*)
+);")?;
+    // 1. Recursive case:
+    write!(f,
+           "
+(@stack[$stack_top:ident, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: RParen $($tail:tt)*)
+ => (
+    __op_internal__!(@stack[$($stack,)*] @queue[$stack_top, $($queue,)*] @tail: RParen $($tail)*)
+);")?;
+    // 3. Check for function:
+    for fun in ops.iter().filter(|f| f.op_type == Function) {
+        write!(f,
+               "
+(@rp3 @stack[{fun_op}, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => (
+    __op_internal__!(@stack[$($stack,)*] @queue[{fun_op}, $($queue,)*] @tail: $($tail)*)
+);",
+               fun_op = fun.operator)?;
+    }
+    // 3. If no function found:
+    write!(f,
+           "
+(@rp3 @stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => (
+    __op_internal__!(@stack[$($stack,)*] @queue[$($queue,)*] @tail: $($tail)*)
+);")?;
+
+    // -------
+    // Case 6: Token is a number: Push it onto the queue
+    write!(f,
+           "
+(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $num:ident $($tail:tt)*) => (
+    __op_internal__!(@stack[$($stack,)*] @queue[$num, $($queue,)*] @tail: $($tail)*)
+);")?;
+
+    // -------
+    // Case 7: Out of tokens:
+    // Base case: Stack empty: Start evaluating
+    write!(f,
+           "
+(@stack[] @queue[$($queue:ident,)*] @tail: ) => (
+    __op_internal__!(@reverse[] @input: $($queue,)*)
+);")?;
+    // Recursive case: Pop stack to queue
+    write!(f,
+           "
+(@stack[$stack_top:ident, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail:) => (
+    __op_internal__!(@stack[$($stack,)*] @queue[$stack_top, $($queue,)*] @tail: )
+);")?;
+
+    // -----------------------------------------------------------------------------------------
+    // Stage 2: Reverse so we have RPN
+    write!(f,
+           "
+(@reverse[$($revved:ident,)*] @input: $head:ident, $($tail:ident,)* ) => (
+    __op_internal__!(@reverse[$head, $($revved,)*] @input: $($tail,)*)
+);")?;
+    write!(f,
+           "
+(@reverse[$($revved:ident,)*] @input: ) => (
+    __op_internal__!(@eval @stack[] @input[$($revved,)*])
+);")?;
+
+    // -----------------------------------------------------------------------------------------
+    // Stage 3: Evaluate in Reverse Polish Notation
+    // Operators / Operators with 2 args:
+    for op in ops.iter().filter(|op| op.n_args == 2) {
+        // Note: We have to switch $a and $b here, otherwise non-commutative functions are backwards
+        write!(f,
+               "
+(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[{op}, $($tail:ident,)*]) => (
+    __op_internal__!(@eval @stack[$crate::{op}<$b, $a>, $($stack,)*] @input[$($tail,)*])
+);",
+               op = op.operator)?;
+    }
+    // Operators with 1 arg:
+    for op in ops.iter().filter(|op| op.n_args == 1) {
+        write!(f,
+               "
+(@eval @stack[$a:ty, $($stack:ty,)*] @input[{op}, $($tail:ident,)*]) => (
+    __op_internal__!(@eval @stack[$crate::{op}<$a>, $($stack,)*] @input[$($tail,)*])
+);",
+               op = op.operator)?;
+    }
+
+    // Wasn't a function or operator, so must be a value => push onto stack
+    write!(f,
+           "
+(@eval @stack[$($stack:ty,)*] @input[$head:ident, $($tail:ident,)*]) => (
+    __op_internal__!(@eval @stack[$head, $($stack,)*] @input[$($tail,)*])
+);")?;
+
+    // No input left:
+    write!(f,
+           "
+(@eval @stack[$stack:ty,] @input[]) => (
+    $stack
+);")?;
+
+    // -----------------------------------------------------------------------------------------
+    // Stage 0: Get it started
+    write!(f,
+           "
+($($tail:tt)* ) => (
+    __op_internal__!(@stack[] @queue[] @tail: $($tail)*)
+);")?;
+
+
+    write!(f,
+           "
+}}")?;
+
+    Ok(())
+}
diff --git a/crates/typenum-1.9.0/build/tests.rs b/crates/typenum-1.9.0/build/tests.rs
new file mode 100644
index 0000000..7c46037
--- /dev/null
+++ b/crates/typenum-1.9.0/build/tests.rs
@@ -0,0 +1,293 @@
+use std::{env, fs, io, fmt, path};
+
+use super::{gen_int, gen_uint};
+
+fn sign(i: i64) -> char {
+    if i > 0 {
+        'P'
+    } else if i < 0 {
+        'N'
+    } else {
+        '_'
+    }
+}
+
+struct UIntTest {
+    a: u64,
+    op: &'static str,
+    b: Option<u64>,
+    r: u64,
+}
+
+impl fmt::Display for UIntTest {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.b {
+            Some(b) => {
+                write!(f,
+                       "
+#[test]
+#[allow(non_snake_case)]
+fn test_{a}_{op}_{b}() {{
+    type A = {gen_a};
+    type B = {gen_b};
+    type U{r} = {result};
+
+    #[allow(non_camel_case_types)]
+    type U{a}{op}U{b} = <<A as {op}<B>>::Output as Same<U{r}>>::Output;
+
+    assert_eq!(<U{a}{op}U{b} as Unsigned>::to_u64(), <U{r} as Unsigned>::to_u64());
+}}",
+                       gen_a = gen_uint(self.a),
+                       gen_b = gen_uint(b),
+                       r = self.r,
+                       result = gen_uint(self.r),
+                       a = self.a,
+                       b = b,
+                       op = self.op)
+            }
+            None => {
+                write!(f,
+                       "
+#[test]
+#[allow(non_snake_case)]
+fn test_{a}_{op}() {{
+    type A = {gen_a};
+    type U{r} = {result};
+
+    #[allow(non_camel_case_types)]
+    type {op}U{a} = <<A as {op}>::Output as Same<U{r}>>::Output;
+    assert_eq!(<{op}U{a} as Unsigned>::to_u64(), <U{r} as Unsigned>::to_u64());
+}}",
+                       gen_a = gen_uint(self.a),
+                       r = self.r,
+                       result = gen_uint(self.r),
+                       a = self.a,
+                       op = self.op)
+            }
+        }
+    }
+}
+
+fn uint_binary_test(a: u64, op: &'static str, b: u64, result: u64) -> UIntTest {
+    UIntTest {
+        a: a,
+        op: op,
+        b: Option::Some(b),
+        r: result,
+    }
+}
+
+// fn uint_unary_test(op: &'static str, a: u64, result: u64) -> UIntTest {
+//     UIntTest { a: a, op: op, b: Option::None, r: result }
+// }
+
+struct IntBinaryTest {
+    a: i64,
+    op: &'static str,
+    b: i64,
+    r: i64,
+}
+
+impl fmt::Display for IntBinaryTest {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f,
+               "
+#[test]
+#[allow(non_snake_case)]
+fn test_{sa}{a}_{op}_{sb}{b}() {{
+    type A = {gen_a};
+    type B = {gen_b};
+    type {sr}{r} = {result};
+
+    #[allow(non_camel_case_types)]
+    type {sa}{a}{op}{sb}{b} = <<A as {op}<B>>::Output as Same<{sr}{r}>>::Output;
+
+    assert_eq!(<{sa}{a}{op}{sb}{b} as Integer>::to_i64(), <{sr}{r} as Integer>::to_i64());
+}}",
+               gen_a = gen_int(self.a),
+               gen_b = gen_int(self.b),
+               r = self.r.abs(),
+               sr = sign(self.r),
+               result = gen_int(self.r),
+               a = self.a.abs(),
+               b = self.b.abs(),
+               sa = sign(self.a),
+               sb = sign(self.b),
+               op = self.op)
+    }
+}
+
+fn int_binary_test(a: i64, op: &'static str, b: i64, result: i64) -> IntBinaryTest {
+    IntBinaryTest {
+        a: a,
+        op: op,
+        b: b,
+        r: result,
+    }
+}
+
+struct IntUnaryTest {
+    op: &'static str,
+    a: i64,
+    r: i64,
+}
+
+impl fmt::Display for IntUnaryTest {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f,
+               "
+#[test]
+#[allow(non_snake_case)]
+fn test_{sa}{a}_{op}() {{
+    type A = {gen_a};
+    type {sr}{r} = {result};
+
+    #[allow(non_camel_case_types)]
+    type {op}{sa}{a} = <<A as {op}>::Output as Same<{sr}{r}>>::Output;
+    assert_eq!(<{op}{sa}{a} as Integer>::to_i64(), <{sr}{r} as Integer>::to_i64());
+}}",
+               gen_a = gen_int(self.a),
+               r = self.r.abs(),
+               sr = sign(self.r),
+               result = gen_int(self.r),
+               a = self.a.abs(),
+               sa = sign(self.a),
+               op = self.op)
+    }
+}
+
+fn int_unary_test(op: &'static str, a: i64, result: i64) -> IntUnaryTest {
+    IntUnaryTest {
+        op: op,
+        a: a,
+        r: result,
+    }
+}
+
+fn uint_cmp_test(a: u64, b: u64) -> String {
+    format!("
+#[test]
+#[allow(non_snake_case)]
+fn test_{a}_cmp_{b}() {{
+    type A = {gen_a};
+    type B = {gen_b};
+
+    #[allow(non_camel_case_types)]
+    type U{a}CmpU{b} = <A as Cmp<B>>::Output;
+    assert_eq!(<U{a}CmpU{b} as Ord>::to_ordering(), Ordering::{result:?});
+}}",
+            a = a,
+            b = b,
+            gen_a = gen_uint(a),
+            gen_b = gen_uint(b),
+            result = a.cmp(&b))
+}
+
+fn int_cmp_test(a: i64, b: i64) -> String {
+    format!("
+#[test]
+#[allow(non_snake_case)]
+fn test_{sa}{a}_cmp_{sb}{b}() {{
+    type A = {gen_a};
+    type B = {gen_b};
+
+    #[allow(non_camel_case_types)]
+    type {sa}{a}Cmp{sb}{b} = <A as Cmp<B>>::Output;
+    assert_eq!(<{sa}{a}Cmp{sb}{b} as Ord>::to_ordering(), Ordering::{result:?});
+}}",
+            a = a.abs(),
+            b = b.abs(),
+            sa = sign(a),
+            sb = sign(b),
+            gen_a = gen_int(a),
+            gen_b = gen_int(b),
+            result = a.cmp(&b))
+}
+
+pub fn build_tests() -> Result<(), Box<::std::error::Error>> {
+    // will test all permutations of number pairs up to this (and down to its opposite for ints)
+    let high: i64 = 5;
+
+    let uints = (0u64..high as u64 + 1).flat_map(|a| (a..a + 1).cycle().zip((0..high as u64 + 1)));
+    let ints = (-high..high + 1).flat_map(|a| (a..a + 1).cycle().zip((-high..high + 1)));
+
+
+    let out_dir = env::var("OUT_DIR")?;
+    let dest = path::Path::new(&out_dir).join("tests.rs");
+    let f = fs::File::create(&dest)?;
+    let mut writer = io::BufWriter::new(&f);
+    use std::io::Write;
+    writer
+        .write(b"
+extern crate typenum;
+
+use std::ops::*;
+use std::cmp::Ordering;
+use typenum::*;
+")?;
+    use std::cmp;
+    // uint operators:
+    for (a, b) in uints {
+        write!(writer, "{}", uint_binary_test(a, "BitAnd", b, a & b))?;
+        write!(writer, "{}", uint_binary_test(a, "BitOr", b, a | b))?;
+        write!(writer, "{}", uint_binary_test(a, "BitXor", b, a ^ b))?;
+        write!(writer, "{}", uint_binary_test(a, "Shl", b, a << b))?;
+        write!(writer, "{}", uint_binary_test(a, "Shr", b, a >> b))?;
+        write!(writer, "{}", uint_binary_test(a, "Add", b, a + b))?;
+        write!(writer, "{}", uint_binary_test(a, "Min", b, cmp::min(a, b)))?;
+        write!(writer, "{}", uint_binary_test(a, "Max", b, cmp::max(a, b)))?;
+        if a >= b {
+            write!(writer, "{}", uint_binary_test(a, "Sub", b, a - b))?;
+        }
+        write!(writer, "{}", uint_binary_test(a, "Mul", b, a * b))?;
+        if b != 0 {
+            write!(writer, "{}", uint_binary_test(a, "Div", b, a / b))?;
+            write!(writer, "{}", uint_binary_test(a, "Rem", b, a % b))?;
+            if a % b == 0 {
+                write!(writer, "{}", uint_binary_test(a, "PartialDiv", b, a / b))?;
+            }
+        }
+        write!(writer, "{}", uint_binary_test(a, "Pow", b, a.pow(b as u32)))?;
+        write!(writer, "{}", uint_cmp_test(a, b))?;
+    }
+    // int operators:
+    for (a, b) in ints {
+        write!(writer, "{}", int_binary_test(a, "Add", b, a + b))?;
+        write!(writer, "{}", int_binary_test(a, "Sub", b, a - b))?;
+        write!(writer, "{}", int_binary_test(a, "Mul", b, a * b))?;
+        write!(writer, "{}", int_binary_test(a, "Min", b, cmp::min(a, b)))?;
+        write!(writer, "{}", int_binary_test(a, "Max", b, cmp::max(a, b)))?;
+        if b != 0 {
+            write!(writer, "{}", int_binary_test(a, "Div", b, a / b))?;
+            write!(writer, "{}", int_binary_test(a, "Rem", b, a % b))?;
+            if a % b == 0 {
+                write!(writer, "{}", int_binary_test(a, "PartialDiv", b, a / b))?;
+            }
+        }
+        if b >= 0 || a.abs() == 1 {
+            let result = if b < 0 {
+                if a == 1 {
+                    a
+                } else if a == -1 {
+                    a.pow((-b) as u32)
+                } else {
+                    unreachable!()
+                }
+            } else {
+                a.pow(b as u32)
+            };
+            write!(writer, "{}", int_binary_test(a, "Pow", b, result))?;
+        }
+        write!(writer, "{}", int_cmp_test(a, b))?;
+    }
+
+    // int unary operators:
+    for n in -high..high + 1 {
+        write!(writer, "{}", int_unary_test("Neg", n, -n))?;
+        write!(writer, "{}", int_unary_test("Abs", n, n.abs()))?;
+    }
+
+    writer.flush()?;
+
+    Ok(())
+}
diff --git a/crates/typenum-1.9.0/ghp-import/LICENSE b/crates/typenum-1.9.0/ghp-import/LICENSE
new file mode 100644
index 0000000..e7f63f0
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/LICENSE
@@ -0,0 +1,11 @@
+                           Tumbolia Public License
+
+Copyright 2013, Paul Davis <paul.joseph.davis@xxxxxxxxx>
+
+Copying and distribution of this file, with or without modification, are
+permitted in any medium without royalty provided the copyright notice and this
+notice are preserved.
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. opan saurce LOL
diff --git a/crates/typenum-1.9.0/ghp-import/MANIFEST.in b/crates/typenum-1.9.0/ghp-import/MANIFEST.in
new file mode 100644
index 0000000..c1a7121
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/MANIFEST.in
@@ -0,0 +1,2 @@
+include LICENSE
+include README.md
diff --git a/crates/typenum-1.9.0/ghp-import/Makefile b/crates/typenum-1.9.0/ghp-import/Makefile
new file mode 100644
index 0000000..9e035e0
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/Makefile
@@ -0,0 +1,8 @@
+
+docs:
+	pyflakes ./ghp_import.py
+	./docs/build.py > docs/index.html
+	./ghp_import.py -p docs/
+
+
+.PHONY: docs
diff --git a/crates/typenum-1.9.0/ghp-import/README.md b/crates/typenum-1.9.0/ghp-import/README.md
new file mode 100644
index 0000000..c1f0f31
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/README.md
@@ -0,0 +1,78 @@
+GitHub Pages Import
+===================
+
+As part of [gunicorn][gunicorn], [Benoit Chesneau][benoit] and I have been
+starting to look at how to host documentation. There's the obvious method of
+using [GitHub's post-receive hook][github-post] to trigger doc builds and rsync
+to a webserver, but we ended up wanting to try out github's hosting to make the
+whole interface a bit more robust.
+
+[GitHub Pages][gh-pages] is a pretty awesome service that GitHub provides for
+hosting project documentation. The only thing is that it requires a
+`gh-pages` branch that is the site's document root. This means that keeping
+documentation sources in the branch with code is a bit difficult. And it really
+turns into a head scratcher for things like [Sphinx][sphinx] that want to
+access documentation sources and code sources at the same time.
+
+Then I stumbled across an interesting looking package called
+[github-tools][github-tools] that looked almost like what I wanted. It was a tad
+complicated and more involved than I wanted but it gave me an idear. Why not
+just write a script that can copy a directory to the `gh-pages` branch of the
+repository. This saves me from even having to think about the branch and
+everything becomes magical.
+
+This is what `ghp-import` was written for.
+
+[gunicorn]: http://www.gunicorn.com/ "Gunicorn"
+[benoit]: http://github.com/benoitc "Benoît Chesneau"
+[github-post]: https://help.github.com/articles/post-receive-hooks "GitHub Post-Receive Hook"
+[gh-pages]: http://pages.github.com/ "GitHub Pages"
+[sphinx]: http://sphinx.pocoo.org/ "Sphinx Documentation"
+[github-tools]: http://dinoboff.github.com/github-tools/ "github-tools"
+
+
+Big Fat Warning
+---------------
+
+This will **DESTROY** your `gh-pages` branch. If you love it, you'll want to
+take backups before playing with this. This script assumes that `gh-pages` is
+100% derivative. You should never edit files in your `gh-pages` branch by hand
+if you're using this script because you will lose your work.
+
+Usage
+-----
+
+    Usage: ghp-import [OPTIONS] DIRECTORY
+
+	Options:
+	  -n          Include a .nojekyll file in the branch.
+	  -c CNAME    Write a CNAME file with the given CNAME.
+	  -m MESG     The commit message to use on the target branch.
+	  -p          Push the branch to origin/{branch} after committing.
+	  -f          Force the push to the repository
+	  -r REMOTE   The name of the remote to push to. [origin]
+	  -b BRANCH   Name of the branch to write to. [gh-pages]
+	  -s          Use the shell when invoking Git. [False]
+	  -l          Follow symlinks when adding files. [False]
+	  -h, --help  show this help message and exit
+
+Its pretty simple. Inside your repository just run `ghp-import $DOCS_DIR`
+where `$DOCS_DIR` is the path to the **built** documentation. This will write a
+commit to your `gh-pages` branch with the current documents in it.
+
+If you specify `-p` it will also attempt to push the `gh-pages` branch to
+GitHub. By default it'll just run `git push origin gh-pages`. You can specify
+a different remote using the `-r` flag.
+
+You can specify a different branch with `-b`. This is useful for user and
+organization page, which are served from the `master` branch.
+
+Some Windows users report needing to pass Git commands through the shell which can be accomplished by passing `-s`.
+
+The `-l` option will cause the import to follow symlinks for users that have odd configurations that include symlinking outside of their documentation directory.
+
+License
+-------
+
+`ghp-import` is distributed under the Tumbolia Public License. See the LICENSE
+file for more information.
diff --git a/crates/typenum-1.9.0/ghp-import/docs/build.py b/crates/typenum-1.9.0/ghp-import/docs/build.py
new file mode 100755
index 0000000..ab0bbb7
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/docs/build.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+
+import os
+import StringIO
+
+import markdown
+
+
+def main():
+    base = os.path.abspath(os.path.dirname(__file__))
+    index = os.path.join(base, "index.html.tmpl")
+    readme = os.path.join(os.path.dirname(base), "README.md")
+
+    templ = open(index).read()
+
+    buf = StringIO.StringIO("rw")
+    markdown.markdownFromFile(input=readme, output=buf)
+
+    print templ.format(body=buf.getvalue())
+
+if __name__ == '__main__':
+    main()
diff --git a/crates/typenum-1.9.0/ghp-import/docs/images/bg_hr.png b/crates/typenum-1.9.0/ghp-import/docs/images/bg_hr.png
new file mode 100644
index 0000000..7973bd6
Binary files /dev/null and b/crates/typenum-1.9.0/ghp-import/docs/images/bg_hr.png differ
diff --git a/crates/typenum-1.9.0/ghp-import/docs/images/blacktocat.png b/crates/typenum-1.9.0/ghp-import/docs/images/blacktocat.png
new file mode 100644
index 0000000..6e264fe
Binary files /dev/null and b/crates/typenum-1.9.0/ghp-import/docs/images/blacktocat.png differ
diff --git a/crates/typenum-1.9.0/ghp-import/docs/images/icon_download.png b/crates/typenum-1.9.0/ghp-import/docs/images/icon_download.png
new file mode 100644
index 0000000..a2a287f
Binary files /dev/null and b/crates/typenum-1.9.0/ghp-import/docs/images/icon_download.png differ
diff --git a/crates/typenum-1.9.0/ghp-import/docs/images/sprite_download.png b/crates/typenum-1.9.0/ghp-import/docs/images/sprite_download.png
new file mode 100644
index 0000000..f2babd5
Binary files /dev/null and b/crates/typenum-1.9.0/ghp-import/docs/images/sprite_download.png differ
diff --git a/crates/typenum-1.9.0/ghp-import/docs/index.html.tmpl b/crates/typenum-1.9.0/ghp-import/docs/index.html.tmpl
new file mode 100644
index 0000000..0027767
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/docs/index.html.tmpl
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset='utf-8' />
+    <meta http-equiv="X-UA-Compatible" content="chrome=1" />
+    <meta name="description" content="ghp-import : Easily import docs to your gh-pages branch." />
+    <link rel="stylesheet" type="text/css" media="screen" href="style.css">
+
+    <title>ghp-import - GitHub Pages import tool</title>
+  </head>
+  <body>
+
+    <!-- HEADER -->
+    <div id="header_wrap" class="outer">
+        <header class="inner">
+          <a id="forkme_banner" href="https://github.com/davisp/ghp-import";>View on GitHub</a>
+
+          <h1 id="project_title">ghp-import</h1>
+          <h2 id="project_tagline">Easily import docs to your gh-pages branch.</h2>
+            <section id="downloads">
+              <a class="zip_download_link" href="https://github.com/davisp/ghp-import/zipball/master";>Download this project as a .zip file</a>
+              <a class="tar_download_link" href="https://github.com/davisp/ghp-import/tarball/master";>Download this project as a tar.gz file</a>
+            </section>
+        </header>
+    </div>
+
+    <!-- MAIN CONTENT -->
+    <div id="main_content_wrap" class="outer">
+      <section id="main_content" class="inner">
+      {body}
+      </section>
+    </div>
+
+    <!-- FOOTER  -->
+    <div id="footer_wrap" class="outer">
+      <footer class="inner">
+        <p class="copyright">ghp-import maintained by <a href="https://github.com/davisp";>davisp</a></p>
+        <p>Published with <a href="http://pages.github.com";>GitHub Pages</a></p>
+      </footer>
+    </div>
+  </body>
+</html>
diff --git a/crates/typenum-1.9.0/ghp-import/docs/style.css b/crates/typenum-1.9.0/ghp-import/docs/style.css
new file mode 100644
index 0000000..2bd468a
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/docs/style.css
@@ -0,0 +1,431 @@
+/*******************************************************************************
+Slate Theme for GitHub Pages
+by Jason Costello, @jsncostello
+*******************************************************************************/
+
+@import url(pygment_trac.css);
+
+/*******************************************************************************
+MeyerWeb Reset
+*******************************************************************************/
+
+html, body, div, span, applet, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, big, cite, code,
+del, dfn, em, img, ins, kbd, q, s, samp,
+small, strike, strong, sub, sup, tt, var,
+b, u, i, center,
+dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, embed,
+figure, figcaption, footer, header, hgroup,
+menu, nav, output, ruby, section, summary,
+time, mark, audio, video {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  font: inherit;
+  vertical-align: baseline;
+}
+
+/* HTML5 display-role reset for older browsers */
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+  display: block;
+}
+
+ol, ul {
+  list-style: none;
+}
+
+blockquote, q {
+}
+
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+a:focus {
+  outline: none;
+}
+
+/*******************************************************************************
+Theme Styles
+*******************************************************************************/
+
+body {
+  box-sizing: border-box;
+  color:#373737;
+  background: #212121;
+  font-size: 16px;
+  font-family: 'Myriad Pro', Calibri, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 10px 0;
+  font-weight: 700;
+  color:#222222;
+  font-family: 'Lucida Grande', 'Calibri', Helvetica, Arial, sans-serif;
+  letter-spacing: -1px;
+}
+
+h1 {
+  font-size: 36px;
+  font-weight: 700;
+}
+
+h2 {
+  padding-bottom: 10px;
+  font-size: 32px;
+  background: url('../images/bg_hr.png') repeat-x bottom;
+}
+
+h3 {
+  font-size: 24px;
+}
+
+h4 {
+  font-size: 21px;
+}
+
+h5 {
+  font-size: 18px;
+}
+
+h6 {
+  font-size: 16px;
+}
+
+p {
+  margin: 10px 0 15px 0;
+}
+
+footer p {
+  color: #f2f2f2;
+}
+
+a {
+  text-decoration: none;
+  color: #007edf;
+  text-shadow: none;
+
+  transition: color 0.5s ease;
+  transition: text-shadow 0.5s ease;
+  -webkit-transition: color 0.5s ease;
+  -webkit-transition: text-shadow 0.5s ease;
+  -moz-transition: color 0.5s ease;
+  -moz-transition: text-shadow 0.5s ease;
+  -o-transition: color 0.5s ease;
+  -o-transition: text-shadow 0.5s ease;
+  -ms-transition: color 0.5s ease;
+  -ms-transition: text-shadow 0.5s ease;
+}
+
+#main_content a:hover {
+  color: #0069ba;
+  text-shadow: #0090ff 0px 0px 2px;
+}
+
+footer a:hover {
+  color: #43adff;
+  text-shadow: #0090ff 0px 0px 2px;
+}
+
+em {
+  font-style: italic;
+}
+
+strong {
+  font-weight: bold;
+}
+
+img {
+  position: relative;
+  margin: 0 auto;
+  max-width: 739px;
+  padding: 5px;
+  margin: 10px 0 10px 0;
+  border: 1px solid #ebebeb;
+
+  box-shadow: 0 0 5px #ebebeb;
+  -webkit-box-shadow: 0 0 5px #ebebeb;
+  -moz-box-shadow: 0 0 5px #ebebeb;
+  -o-box-shadow: 0 0 5px #ebebeb;
+  -ms-box-shadow: 0 0 5px #ebebeb;
+}
+
+pre, code {
+  width: 100%;
+  color: #222;
+  background-color: #fff;
+
+  font-family: Monaco, "Bitstream Vera Sans Mono", "Lucida Console", Terminal, monospace;
+  font-size: 14px;
+
+  border-radius: 2px;
+  -moz-border-radius: 2px;
+  -webkit-border-radius: 2px;
+
+
+
+}
+
+pre {
+  width: 100%;
+  padding: 10px;
+  box-shadow: 0 0 10px rgba(0,0,0,.1);
+  overflow: auto;
+}
+
+code {
+  padding: 3px;
+  margin: 0 3px;
+  box-shadow: 0 0 10px rgba(0,0,0,.1);
+}
+
+pre code {
+  display: block;
+  box-shadow: none;
+}
+
+blockquote {
+  color: #666;
+  margin-bottom: 20px;
+  padding: 0 0 0 20px;
+  border-left: 3px solid #bbb;
+}
+
+ul, ol, dl {
+  margin-bottom: 15px
+}
+
+ul li {
+  list-style: inside;
+  padding-left: 20px;
+}
+
+ol li {
+  list-style: decimal inside;
+  padding-left: 20px;
+}
+
+dl dt {
+  font-weight: bold;
+}
+
+dl dd {
+  padding-left: 20px;
+  font-style: italic;
+}
+
+dl p {
+  padding-left: 20px;
+  font-style: italic;
+}
+
+hr {
+  height: 1px;
+  margin-bottom: 5px;
+  border: none;
+  background: url('../images/bg_hr.png') repeat-x center;
+}
+
+table {
+  border: 1px solid #373737;
+  margin-bottom: 20px;
+  text-align: left;
+ }
+
+th {
+  font-family: 'Lucida Grande', 'Helvetica Neue', Helvetica, Arial, sans-serif;
+  padding: 10px;
+  background: #373737;
+  color: #fff;
+ }
+
+td {
+  padding: 10px;
+  border: 1px solid #373737;
+ }
+
+form {
+  background: #f2f2f2;
+  padding: 20px;
+}
+
+img {
+  width: 100%;
+  max-width: 100%;
+}
+
+/*******************************************************************************
+Full-Width Styles
+*******************************************************************************/
+
+.outer {
+  width: 100%;
+}
+
+.inner {
+  position: relative;
+  max-width: 640px;
+  padding: 20px 10px;
+  margin: 0 auto;
+}
+
+#forkme_banner {
+  display: block;
+  position: absolute;
+  top:0;
+  right: 10px;
+  z-index: 10;
+  padding: 10px 50px 10px 10px;
+  color: #fff;
+  background: url('../images/blacktocat.png') #0090ff no-repeat 95% 50%;
+  font-weight: 700;
+  box-shadow: 0 0 10px rgba(0,0,0,.5);
+  border-bottom-left-radius: 2px;
+  border-bottom-right-radius: 2px;
+}
+
+#header_wrap {
+  background: #212121;
+  background: -moz-linear-gradient(top, #373737, #212121);
+  background: -webkit-linear-gradient(top, #373737, #212121);
+  background: -ms-linear-gradient(top, #373737, #212121);
+  background: -o-linear-gradient(top, #373737, #212121);
+  background: linear-gradient(top, #373737, #212121);
+}
+
+#header_wrap .inner {
+  padding: 50px 10px 30px 10px;
+}
+
+#project_title {
+  margin: 0;
+  color: #fff;
+  font-size: 42px;
+  font-weight: 700;
+  text-shadow: #111 0px 0px 10px;
+}
+
+#project_tagline {
+  color: #fff;
+  font-size: 24px;
+  font-weight: 300;
+  background: none;
+  text-shadow: #111 0px 0px 10px;
+}
+
+#downloads {
+  position: absolute;
+  width: 210px;
+  z-index: 10;
+  bottom: -40px;
+  right: 0;
+  height: 70px;
+  background: url('../images/icon_download.png') no-repeat 0% 90%;
+}
+
+.zip_download_link {
+  display: block;
+  float: right;
+  width: 90px;
+  height:70px;
+  text-indent: -5000px;
+  overflow: hidden;
+  background: url(../images/sprite_download.png) no-repeat bottom left;
+}
+
+.tar_download_link {
+  display: block;
+  float: right;
+  width: 90px;
+  height:70px;
+  text-indent: -5000px;
+  overflow: hidden;
+  background: url(../images/sprite_download.png) no-repeat bottom right;
+  margin-left: 10px;
+}
+
+.zip_download_link:hover {
+  background: url(../images/sprite_download.png) no-repeat top left;
+}
+
+.tar_download_link:hover {
+  background: url(../images/sprite_download.png) no-repeat top right;
+}
+
+#main_content_wrap {
+  background: #f2f2f2;
+  border-top: 1px solid #111;
+  border-bottom: 1px solid #111;
+}
+
+#main_content {
+  padding-top: 40px;
+}
+
+#footer_wrap {
+  background: #212121;
+}
+
+
+
+/*******************************************************************************
+Small Device Styles
+*******************************************************************************/
+
+@media screen and (max-width: 480px) {
+  body {
+    font-size:14px;
+  }
+
+  #downloads {
+    display: none;
+  }
+
+  .inner {
+    min-width: 320px;
+    max-width: 480px;
+  }
+
+  #project_title {
+  font-size: 32px;
+  }
+
+  h1 {
+    font-size: 28px;
+  }
+
+  h2 {
+    font-size: 24px;
+  }
+
+  h3 {
+    font-size: 21px;
+  }
+
+  h4 {
+    font-size: 18px;
+  }
+
+  h5 {
+    font-size: 14px;
+  }
+
+  h6 {
+    font-size: 12px;
+  }
+
+  code, pre {
+    min-width: 320px;
+    max-width: 480px;
+    font-size: 11px;
+  }
+
+}
diff --git a/crates/typenum-1.9.0/ghp-import/ghp_import.py b/crates/typenum-1.9.0/ghp-import/ghp_import.py
new file mode 100755
index 0000000..41f4376
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/ghp_import.py
@@ -0,0 +1,248 @@
+#! /usr/bin/env python
+#
+# This file is part of the ghp-import package released under
+# the Tumbolia Public License. See the LICENSE file for more
+# information.
+
+import errno
+import optparse as op
+import os
+import subprocess as sp
+import sys
+import time
+import unicodedata
+
+__usage__ = "%prog [OPTIONS] DIRECTORY"
+
+
+if sys.version_info[0] == 3:
+    def enc(text):
+        if isinstance(text, bytes):
+            return text
+        return text.encode()
+
+    def dec(text):
+        if isinstance(text, bytes):
+            return text.decode('utf-8')
+        return text
+
+    def write(pipe, data):
+        try:
+            pipe.stdin.write(data)
+        except IOError as e:
+            if e.errno != errno.EPIPE:
+                raise
+else:
+    def enc(text):
+        if isinstance(text, unicode):
+            return text.encode('utf-8')
+        return text
+
+    def dec(text):
+        if isinstance(text, unicode):
+            return text
+        return text.decode('utf-8')
+
+    def write(pipe, data):
+        pipe.stdin.write(data)
+
+
+class Git(object):
+    def __init__(self, use_shell=False):
+        self.use_shell = use_shell
+
+        self.cmd = None
+        self.pipe = None
+        self.stderr = None
+        self.stdout = None
+
+    def check_repo(self, parser):
+        if self.call('rev-parse') != 0:
+            error = self.stderr
+            if not error:
+                error = "Unknown Git error"
+            error = dec(error)
+            if error.startswith("fatal: "):
+                error = error[len("fatal: "):]
+            parser.error(error)
+
+    def try_rebase(self, remote, branch):
+        rc = self.call('rev-list', '--max-count=1', '%s/%s' % (remote, branch))
+        if rc != 0:
+            return True
+        rev = dec(self.stdout.strip())
+        rc = self.call('update-ref', 'refs/heads/%s' % branch, rev)
+        if rc != 0:
+            return False
+        return True
+
+    def get_config(self, key):
+        self.call('config', key)
+        return self.stdout.strip()
+
+    def get_prev_commit(self, branch):
+        rc = self.call('rev-list', '--max-count=1', branch, '--')
+        if rc != 0:
+            return None
+        return dec(self.stdout).strip()
+
+    def open(self, *args, **kwargs):
+        self.cmd = ['git'] + list(args)
+        if sys.version_info >= (3, 2, 0):
+            kwargs['universal_newlines'] = False
+        for k in 'stdin stdout stderr'.split():
+            kwargs[k] = sp.PIPE
+        kwargs['shell'] = self.use_shell
+        self.pipe = sp.Popen(self.cmd, **kwargs)
+        return self.pipe
+
+    def call(self, *args, **kwargs):
+        self.open(*args, **kwargs)
+        (self.stdout, self.stderr) = self.pipe.communicate()
+        return self.pipe.wait()
+
+    def check_call(self, *args, **kwargs):
+        kwargs["shell"] = self.use_shell
+        sp.check_call(['git'] + list(args), **kwargs)
+
+
+def normalize_path(path):
+    # Fix unicode pathnames on OS X
+    # See: http://stackoverflow.com/a/5582439/44289
+    if sys.platform == "darwin":
+        return unicodedata.normalize("NFKC", dec(path))
+    return path
+
+
+def mk_when(timestamp=None):
+    if timestamp is None:
+        timestamp = int(time.time())
+    currtz = time.strftime('%z')
+    return "%s %s" % (timestamp, currtz)
+
+
+def start_commit(pipe, git, branch, message):
+    uname = dec(git.get_config("user.name"))
+    email = dec(git.get_config("user.email"))
+    write(pipe, enc('commit refs/heads/%s\n' % branch))
+    write(pipe, enc('committer %s <%s> %s\n' % (uname, email, mk_when())))
+    write(pipe, enc('data %d\n%s\n' % (len(enc(message)), message)))
+    head = git.get_prev_commit(branch)
+    if head:
+        write(pipe, enc('from %s\n' % head))
+    write(pipe, enc('deleteall\n'))
+
+
+def add_file(pipe, srcpath, tgtpath):
+    with open(srcpath, "rb") as handle:
+        if os.access(srcpath, os.X_OK):
+            write(pipe, enc('M 100755 inline %s\n' % tgtpath))
+        else:
+            write(pipe, enc('M 100644 inline %s\n' % tgtpath))
+        data = handle.read()
+        write(pipe, enc('data %d\n' % len(data)))
+        write(pipe, enc(data))
+        write(pipe, enc('\n'))
+
+
+def add_nojekyll(pipe):
+    write(pipe, enc('M 100644 inline .nojekyll\n'))
+    write(pipe, enc('data 0\n'))
+    write(pipe, enc('\n'))
+
+
+def add_cname(pipe, cname):
+    write(pipe, enc('M 100644 inline CNAME\n'))
+    write(pipe, enc('data %d\n%s\n' % (len(enc(cname)), cname)))
+
+
+def gitpath(fname):
+    norm = os.path.normpath(fname)
+    return "/".join(norm.split(os.path.sep))
+
+
+def run_import(git, srcdir, opts):
+    cmd = ['git', 'fast-import', '--date-format=raw', '--quiet']
+    kwargs = {
+        "stdin": sp.PIPE,
+        "shell": opts.use_shell
+    }
+    if sys.version_info >= (3, 2, 0):
+        kwargs["universal_newlines"] = False
+    pipe = sp.Popen(cmd, **kwargs)
+    start_commit(pipe, git, opts.branch, opts.mesg)
+    for path, dnames, fnames in os.walk(srcdir, followlinks=opts.followlinks):
+        for fn in fnames:
+            fpath = os.path.join(path, fn)
+            fpath = normalize_path(fpath)
+            gpath = gitpath(os.path.relpath(fpath, start=srcdir))
+            add_file(pipe, fpath, gpath)
+    if opts.nojekyll:
+        add_nojekyll(pipe)
+    if opts.cname is not None:
+        add_cname(pipe, opts.cname)
+    write(pipe, enc('\n'))
+    pipe.stdin.close()
+    if pipe.wait() != 0:
+        sys.stdout.write(enc("Failed to process commit.\n"))
+
+
+def options():
+    return [
+        op.make_option('-n', '--no-jekyll', dest='nojekyll', default=False,
+            action="store_true",
+            help='Include a .nojekyll file in the branch.'),
+        op.make_option('-c', '--cname', dest='cname', default=None,
+            help='Write a CNAME file with the given CNAME.'),
+        op.make_option('-m', '--message', dest='mesg',
+            default='Update documentation',
+            help='The commit message to use on the target branch.'),
+        op.make_option('-p', '--push', dest='push', default=False,
+            action='store_true',
+            help='Push the branch to origin/{branch} after committing.'),
+        op.make_option('-f', '--force', dest='force',
+            default=False, action='store_true',
+            help='Force the push to the repository'),
+        op.make_option('-r', '--remote', dest='remote', default='origin',
+            help='The name of the remote to push to. [%default]'),
+        op.make_option('-b', '--branch', dest='branch', default='gh-pages',
+            help='Name of the branch to write to. [%default]'),
+        op.make_option('-s', '--shell', dest='use_shell', default=False,
+            action='store_true',
+            help='Use the shell when invoking Git. [%default]'),
+        op.make_option('-l', '--follow-links', dest='followlinks',
+            default=False, action='store_true',
+            help='Follow symlinks when adding files. [%default]')
+    ]
+
+
+def main():
+    parser = op.OptionParser(usage=__usage__, option_list=options())
+    opts, args = parser.parse_args()
+
+    if len(args) == 0:
+        parser.error("No import directory specified.")
+
+    if len(args) > 1:
+        parser.error("Unknown arguments specified: %s" % ', '.join(args[1:]))
+
+    if not os.path.isdir(args[0]):
+        parser.error("Not a directory: %s" % args[0])
+
+    git = Git(use_shell=opts.use_shell)
+    git.check_repo(parser)
+
+    if not git.try_rebase(opts.remote, opts.branch):
+        parser.error("Failed to rebase %s branch." % opts.branch)
+
+    run_import(git, args[0], opts)
+
+    if opts.push:
+        if opts.force:
+            git.check_call('push', opts.remote, opts.branch, '--force')
+        else:
+            git.check_call('push', opts.remote, opts.branch)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/crates/typenum-1.9.0/ghp-import/requirements.txt b/crates/typenum-1.9.0/ghp-import/requirements.txt
new file mode 100644
index 0000000..a07c43d
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/requirements.txt
@@ -0,0 +1,2 @@
+markdown
+pyflakes
diff --git a/crates/typenum-1.9.0/ghp-import/setup.py b/crates/typenum-1.9.0/ghp-import/setup.py
new file mode 100644
index 0000000..32cae4c
--- /dev/null
+++ b/crates/typenum-1.9.0/ghp-import/setup.py
@@ -0,0 +1,41 @@
+import io
+import os
+import sys
+
+try:
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
+
+LONG_DESC_PATH = os.path.join(os.path.dirname(__file__), "README.md")
+LONG_DESC = io.open(LONG_DESC_PATH, encoding = "utf-8").read()
+
+setup(
+    name = "ghp-import",
+    version = "0.5.5",
+    description = "Copy your docs directly to the gh-pages branch.",
+    long_description = LONG_DESC,
+    author = "Paul Joseph Davis",
+    author_email = "paul.joseph.davis@xxxxxxxxx",
+    license = "Tumbolia Public License",
+    url = "http://github.com/davisp/ghp-import";,
+    zip_safe = False,
+
+    classifiers = [
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        'Natural Language :: English',
+        "Operating System :: OS Independent",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 3",
+    ],
+
+    py_modules = ["ghp_import"],
+
+    entry_points = {
+        "console_scripts": [
+            "ghp-import = ghp_import:main",
+        ],
+    }
+)
diff --git a/crates/typenum-1.9.0/src/array.rs b/crates/typenum-1.9.0/src/array.rs
new file mode 100644
index 0000000..075decd
--- /dev/null
+++ b/crates/typenum-1.9.0/src/array.rs
@@ -0,0 +1,269 @@
+//! A type-level array of type-level numbers.
+//!
+//! It is not very featureful right now, and should be considered a work in progress.
+
+use core::marker::PhantomData;
+use core::ops::{Add, Sub, Mul, Div};
+
+use super::*;
+
+/// The terminating type for type arrays.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug)]
+pub struct ATerm;
+
+impl TypeArray for ATerm {}
+
+/// `TArr` is a type that acts as an array of types. It is defined similarly to `UInt`, only its
+/// values can be more than bits, and it is designed to act as an array. So you can only add two if
+/// they have the same number of elements, for example.
+///
+/// This array is only really designed to contain `Integer` types. If you use it with others, you
+/// may find it lacking functionality.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug)]
+pub struct TArr<V, A> {
+    _marker: PhantomData<(V, A)>,
+}
+
+impl<V, A> TypeArray for TArr<V, A> {}
+
+/// Create a new type-level arrray. Only usable on Rust 1.13.0 or newer.
+///
+/// There's not a whole lot you can do with it right now.
+///
+/// # Example
+/// ```rust
+/// #[macro_use]
+/// extern crate typenum;
+/// use typenum::consts::*;
+///
+/// type Array = tarr![P3, N4, Z0, P38];
+/// # fn main() { let _: Array; }
+#[macro_export]
+macro_rules! tarr {
+    () => ( $crate::ATerm );
+    ($n:ty) => ( $crate::TArr<$n, $crate::ATerm> );
+    ($n:ty,) => ( $crate::TArr<$n, $crate::ATerm> );
+    ($n:ty, $($tail:ty),+) => ( $crate::TArr<$n, tarr![$($tail),+]> );
+    ($n:ty, $($tail:ty),+,) => ( $crate::TArr<$n, tarr![$($tail),+]> );
+}
+
+// ---------------------------------------------------------------------------------------
+// Length
+
+/// Length of `ATerm` by itself is 0
+impl Len for ATerm {
+    type Output = U0;
+    fn len(&self) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Size of a `TypeArray`
+impl<V, A> Len for TArr<V, A>
+    where A: Len,
+          Length<A>: Add<B1>,
+          Sum<Length<A>, B1>: Unsigned
+{
+    type Output = Add1<Length<A>>;
+    fn len(&self) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Add arrays
+// Note that two arrays are only addable if they are the same length.
+
+impl Add<ATerm> for ATerm {
+    type Output = ATerm;
+    fn add(self, _: ATerm) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<Al, Vl, Ar, Vr> Add<TArr<Vr, Ar>> for TArr<Vl, Al>
+    where Al: Add<Ar>,
+          Vl: Add<Vr>
+{
+    type Output = TArr<Sum<Vl, Vr>, Sum<Al, Ar>>;
+    fn add(self, _: TArr<Vr, Ar>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Subtract arrays
+// Note that two arrays are only subtractable if they are the same length.
+
+impl Sub<ATerm> for ATerm {
+    type Output = ATerm;
+    fn sub(self, _: ATerm) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<Vl, Al, Vr, Ar> Sub<TArr<Vr, Ar>> for TArr<Vl, Al>
+    where Vl: Sub<Vr>,
+          Al: Sub<Ar>
+{
+    type Output = TArr<Diff<Vl, Vr>, Diff<Al, Ar>>;
+    fn sub(self, _: TArr<Vr, Ar>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Multiply an array by a scalar
+
+impl<Rhs> Mul<Rhs> for ATerm {
+    type Output = ATerm;
+    fn mul(self, _: Rhs) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<V, A, Rhs> Mul<Rhs> for TArr<V, A>
+    where V: Mul<Rhs>,
+          A: Mul<Rhs>
+{
+    type Output = TArr<Prod<V, Rhs>, Prod<A, Rhs>>;
+    fn mul(self, _: Rhs) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+impl Mul<ATerm> for Z0 {
+    type Output = ATerm;
+    fn mul(self, _: ATerm) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<U> Mul<ATerm> for PInt<U>
+    where U: Unsigned + NonZero
+{
+    type Output = ATerm;
+    fn mul(self, _: ATerm) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<U> Mul<ATerm> for NInt<U>
+    where U: Unsigned + NonZero
+{
+    type Output = ATerm;
+    fn mul(self, _: ATerm) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<V, A> Mul<TArr<V, A>> for Z0
+    where Z0: Mul<A>
+{
+    type Output = TArr<Z0, Prod<Z0, A>>;
+    fn mul(self, _: TArr<V, A>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+impl<V, A, U> Mul<TArr<V, A>> for PInt<U>
+    where U: Unsigned + NonZero,
+          PInt<U>: Mul<A> + Mul<V>
+{
+    type Output = TArr<Prod<PInt<U>, V>, Prod<PInt<U>, A>>;
+    fn mul(self, _: TArr<V, A>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+impl<V, A, U> Mul<TArr<V, A>> for NInt<U>
+    where U: Unsigned + NonZero,
+          NInt<U>: Mul<A> + Mul<V>
+{
+    type Output = TArr<Prod<NInt<U>, V>, Prod<NInt<U>, A>>;
+    fn mul(self, _: TArr<V, A>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Divide an array by a scalar
+
+impl<Rhs> Div<Rhs> for ATerm {
+    type Output = ATerm;
+    fn div(self, _: Rhs) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<V, A, Rhs> Div<Rhs> for TArr<V, A>
+    where V: Div<Rhs>,
+          A: Div<Rhs>
+{
+    type Output = TArr<Quot<V, Rhs>, Quot<A, Rhs>>;
+    fn div(self, _: Rhs) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Partial Divide an array by a scalar
+
+impl<Rhs> PartialDiv<Rhs> for ATerm {
+    type Output = ATerm;
+    fn partial_div(self, _: Rhs) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<V, A, Rhs> PartialDiv<Rhs> for TArr<V, A>
+    where V: PartialDiv<Rhs>,
+          A: PartialDiv<Rhs>
+{
+    type Output = TArr<PartialQuot<V, Rhs>, PartialQuot<A, Rhs>>;
+    fn partial_div(self, _: Rhs) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Modulo an array by a scalar
+use core::ops::Rem;
+
+impl<Rhs> Rem<Rhs> for ATerm {
+    type Output = ATerm;
+    fn rem(self, _: Rhs) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<V, A, Rhs> Rem<Rhs> for TArr<V, A>
+    where V: Rem<Rhs>,
+          A: Rem<Rhs>
+{
+    type Output = TArr<Mod<V, Rhs>, Mod<A, Rhs>>;
+    fn rem(self, _: Rhs) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Negate an array
+use core::ops::Neg;
+
+impl Neg for ATerm {
+    type Output = ATerm;
+    fn neg(self) -> Self::Output {
+        ATerm
+    }
+}
+
+impl<V, A> Neg for TArr<V, A>
+    where V: Neg,
+          A: Neg
+{
+    type Output = TArr<Negate<V>, Negate<A>>;
+    fn neg(self) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
diff --git a/crates/typenum-1.9.0/src/bit.rs b/crates/typenum-1.9.0/src/bit.rs
new file mode 100644
index 0000000..96d75d4
--- /dev/null
+++ b/crates/typenum-1.9.0/src/bit.rs
@@ -0,0 +1,263 @@
+//! Type-level bits.
+//!
+//! These are rather simple and are used as the building blocks of the
+//! other number types in this crate.
+//!
+//!
+//! **Type operators** implemented:
+//!
+//! - From `core::ops`: `BitAnd`, `BitOr`, `BitXor`, and `Not`.
+//! - From `typenum`: `Same` and `Cmp`.
+//!
+
+use core::ops::{BitAnd, BitOr, BitXor, Not};
+use {NonZero, Cmp, Greater, Less, Equal};
+
+pub use marker_traits::Bit;
+
+/// The type-level bit 0.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct B0;
+
+impl B0 {
+    /// Instantiates a singleton representing this bit.
+    #[inline]
+    pub fn new() -> B0 {
+        B0
+    }
+}
+
+/// The type-level bit 1.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct B1;
+
+impl B1 {
+    /// Instantiates a singleton representing this bit.
+    #[inline]
+    pub fn new() -> B1 {
+        B1
+    }
+}
+
+impl Bit for B0 {
+    #[inline]
+    fn to_u8() -> u8 {
+        0
+    }
+    #[inline]
+    fn to_bool() -> bool {
+        false
+    }
+}
+
+impl Bit for B1 {
+    #[inline]
+    fn to_u8() -> u8 {
+        1
+    }
+    #[inline]
+    fn to_bool() -> bool {
+        true
+    }
+}
+
+impl NonZero for B1 {}
+
+// macro for testing operation results. Uses `Same` to ensure the types are equal and
+// not just the values they evaluate to.
+macro_rules! test_bit_op {
+    ($op:ident $Lhs:ident = $Answer:ident) => (
+        {
+            type Test = <<$Lhs as $op>::Output as ::Same<$Answer>>::Output;
+            assert_eq!(<$Answer as Bit>::to_u8(), <Test as Bit>::to_u8());
+        }
+        );
+    ($Lhs:ident $op:ident $Rhs:ident = $Answer:ident) => (
+        {
+            type Test = <<$Lhs as $op<$Rhs>>::Output as ::Same<$Answer>>::Output;
+            assert_eq!(<$Answer as Bit>::to_u8(), <Test as Bit>::to_u8());
+        }
+        );
+}
+
+/// Not of 0 (!0 = 1)
+impl Not for B0 {
+    type Output = B1;
+    fn not(self) -> Self::Output {
+        B1
+    }
+}
+/// Not of 1 (!1 = 0)
+impl Not for B1 {
+    type Output = B0;
+    fn not(self) -> Self::Output {
+        B0
+    }
+}
+
+/// And with 0 ( 0 & B = 0)
+impl<Rhs: Bit> BitAnd<Rhs> for B0 {
+    type Output = B0;
+    fn bitand(self, _: Rhs) -> Self::Output {
+        B0
+    }
+}
+
+/// And with 1 ( 1 & 0 = 0)
+impl BitAnd<B0> for B1 {
+    type Output = B0;
+    fn bitand(self, _: B0) -> Self::Output {
+        B0
+    }
+}
+
+/// And with 1 ( 1 & 1 = 1)
+impl BitAnd<B1> for B1 {
+    type Output = B1;
+    fn bitand(self, _: B1) -> Self::Output {
+        B1
+    }
+}
+
+/// Or with 0 ( 0 | 0 = 0)
+impl BitOr<B0> for B0 {
+    type Output = B0;
+    fn bitor(self, _: B0) -> Self::Output {
+        B0
+    }
+}
+
+/// Or with 0 ( 0 | 1 = 1)
+impl BitOr<B1> for B0 {
+    type Output = B1;
+    fn bitor(self, _: B1) -> Self::Output {
+        B1
+    }
+}
+
+/// Or with 1 ( 1 | B = 1)
+impl<Rhs: Bit> BitOr<Rhs> for B1 {
+    type Output = B1;
+    fn bitor(self, _: Rhs) -> Self::Output {
+        B1
+    }
+}
+
+/// Xor between 0 and 0 ( 0 ^ 0 = 0)
+impl BitXor<B0> for B0 {
+    type Output = B0;
+    fn bitxor(self, _: B0) -> Self::Output {
+        B0
+    }
+}
+/// Xor between 1 and 0 ( 1 ^ 0 = 1)
+impl BitXor<B0> for B1 {
+    type Output = B1;
+    fn bitxor(self, _: B0) -> Self::Output {
+        B1
+    }
+}
+/// Xor between 0 and 1 ( 0 ^ 1 = 1)
+impl BitXor<B1> for B0 {
+    type Output = B1;
+    fn bitxor(self, _: B1) -> Self::Output {
+        B1
+    }
+}
+/// Xor between 1 and 1 ( 1 ^ 1 = 0)
+impl BitXor<B1> for B1 {
+    type Output = B0;
+    fn bitxor(self, _: B1) -> Self::Output {
+        B0
+    }
+}
+
+#[test]
+fn bit_operations() {
+    test_bit_op!(Not B0 = B1);
+    test_bit_op!(Not B1 = B0);
+
+    test_bit_op!(B0 BitAnd B0 = B0);
+    test_bit_op!(B0 BitAnd B1 = B0);
+    test_bit_op!(B1 BitAnd B0 = B0);
+    test_bit_op!(B1 BitAnd B1 = B1);
+
+    test_bit_op!(B0 BitOr B0 = B0);
+    test_bit_op!(B0 BitOr B1 = B1);
+    test_bit_op!(B1 BitOr B0 = B1);
+    test_bit_op!(B1 BitOr B1 = B1);
+
+    test_bit_op!(B0 BitXor B0 = B0);
+    test_bit_op!(B0 BitXor B1 = B1);
+    test_bit_op!(B1 BitXor B0 = B1);
+    test_bit_op!(B1 BitXor B1 = B0);
+}
+
+impl Cmp<B0> for B0 {
+    type Output = Equal;
+}
+
+impl Cmp<B1> for B0 {
+    type Output = Less;
+}
+
+impl Cmp<B0> for B1 {
+    type Output = Greater;
+}
+
+impl Cmp<B1> for B1 {
+    type Output = Equal;
+}
+
+
+use Min;
+impl Min<B0> for B0 {
+    type Output = B0;
+    fn min(self, _: B0) -> B0 {
+        self
+    }
+}
+impl Min<B1> for B0 {
+    type Output = B0;
+    fn min(self, _: B1) -> B0 {
+        self
+    }
+}
+impl Min<B0> for B1 {
+    type Output = B0;
+    fn min(self, rhs: B0) -> B0 {
+        rhs
+    }
+}
+impl Min<B1> for B1 {
+    type Output = B1;
+    fn min(self, _: B1) -> B1 {
+        self
+    }
+}
+
+use Max;
+impl Max<B0> for B0 {
+    type Output = B0;
+    fn max(self, _: B0) -> B0 {
+        self
+    }
+}
+impl Max<B1> for B0 {
+    type Output = B1;
+    fn max(self, rhs: B1) -> B1 {
+        rhs
+    }
+}
+impl Max<B0> for B1 {
+    type Output = B1;
+    fn max(self, _: B0) -> B1 {
+        self
+    }
+}
+impl Max<B1> for B1 {
+    type Output = B1;
+    fn max(self, _: B1) -> B1 {
+        self
+    }
+}
diff --git a/crates/typenum-1.9.0/src/int.rs b/crates/typenum-1.9.0/src/int.rs
new file mode 100644
index 0000000..2d1c0f7
--- /dev/null
+++ b/crates/typenum-1.9.0/src/int.rs
@@ -0,0 +1,910 @@
+//! Type-level signed integers.
+//!
+//!
+//! Type **operators** implemented:
+//!
+//! From `core::ops`: `Add`, `Sub`, `Mul`, `Div`, and `Rem`.
+//! From `typenum`: `Same`, `Cmp`, and `Pow`.
+//!
+//! Rather than directly using the structs defined in this module, it is recommended that
+//! you import and use the relevant aliases from the [consts](../consts/index.html) module.
+//!
+//! Note that operators that work on the underlying structure of the number are
+//! intentionally not implemented. This is because this implementation of signed integers
+//! does *not* use twos-complement, and implementing them would require making arbitrary
+//! choices, causing the results of such operators to be difficult to reason about.
+//!
+//! # Example
+//! ```rust
+//! use std::ops::{Add, Sub, Mul, Div, Rem};
+//! use typenum::{Integer, N3, P2};
+//!
+//! assert_eq!(<N3 as Add<P2>>::Output::to_i32(), -1);
+//! assert_eq!(<N3 as Sub<P2>>::Output::to_i32(), -5);
+//! assert_eq!(<N3 as Mul<P2>>::Output::to_i32(), -6);
+//! assert_eq!(<N3 as Div<P2>>::Output::to_i32(), -1);
+//! assert_eq!(<N3 as Rem<P2>>::Output::to_i32(), -1);
+//! ```
+//!
+
+use core::ops::{Neg, Add, Sub, Mul, Div, Rem};
+use core::marker::PhantomData;
+
+use {NonZero, Pow, Cmp, Greater, Equal, Less};
+use uint::{Unsigned, UInt};
+use bit::{Bit, B0, B1};
+use private::{PrivateIntegerAdd, PrivateDivInt, PrivateRem};
+use consts::{U0, U1, P1, N1};
+
+pub use marker_traits::Integer;
+
+/// Type-level signed integers with positive sign.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct PInt<U: Unsigned + NonZero> {
+    _marker: PhantomData<U>,
+}
+
+/// Type-level signed integers with negative sign.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct NInt<U: Unsigned + NonZero> {
+    _marker: PhantomData<U>,
+}
+
+impl<U: Unsigned + NonZero> PInt<U> {
+    /// Instantiates a singleton representing this strictly positive integer.
+    #[inline]
+    pub fn new() -> PInt<U> {
+        PInt { _marker: PhantomData }
+    }
+}
+
+impl<U: Unsigned + NonZero> NInt<U> {
+    /// Instantiates a singleton representing this strictly negative integer.
+    #[inline]
+    pub fn new() -> NInt<U> {
+        NInt { _marker: PhantomData }
+    }
+}
+
+
+/// The type-level signed integer 0.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct Z0;
+
+impl Z0 {
+    /// Instantiates a singleton representing the integer 0.
+    #[inline]
+    pub fn new() -> Z0 {
+        Z0
+    }
+}
+
+impl<U: Unsigned + NonZero> NonZero for PInt<U> {}
+impl<U: Unsigned + NonZero> NonZero for NInt<U> {}
+
+impl Integer for Z0 {
+    #[inline]
+    fn to_i8() -> i8 {
+        0
+    }
+    #[inline]
+    fn to_i16() -> i16 {
+        0
+    }
+    #[inline]
+    fn to_i32() -> i32 {
+        0
+    }
+    #[inline]
+    fn to_i64() -> i64 {
+        0
+    }
+    #[cfg(feature="i128")]
+    #[inline]
+    fn to_i128() -> i128 {
+        0
+    }
+    #[inline]
+    fn to_isize() -> isize {
+        0
+    }
+}
+
+impl<U: Unsigned + NonZero> Integer for PInt<U> {
+    #[inline]
+    fn to_i8() -> i8 {
+        <U as Unsigned>::to_i8()
+    }
+    #[inline]
+    fn to_i16() -> i16 {
+        <U as Unsigned>::to_i16()
+    }
+    #[inline]
+    fn to_i32() -> i32 {
+        <U as Unsigned>::to_i32()
+    }
+    #[inline]
+    fn to_i64() -> i64 {
+        <U as Unsigned>::to_i64()
+    }
+    #[cfg(feature="i128")]
+    #[inline]
+    fn to_i128() -> i128 {
+        <U as Unsigned>::to_i128()
+    }
+    #[inline]
+    fn to_isize() -> isize {
+        <U as Unsigned>::to_isize()
+    }
+}
+
+impl<U: Unsigned + NonZero> Integer for NInt<U> {
+    #[inline]
+    fn to_i8() -> i8 {
+        -<U as Unsigned>::to_i8()
+    }
+    #[inline]
+    fn to_i16() -> i16 {
+        -<U as Unsigned>::to_i16()
+    }
+    #[inline]
+    fn to_i32() -> i32 {
+        -<U as Unsigned>::to_i32()
+    }
+    #[inline]
+    fn to_i64() -> i64 {
+        -<U as Unsigned>::to_i64()
+    }
+    #[cfg(feature="i128")]
+    #[inline]
+    fn to_i128() -> i128 {
+        -<U as Unsigned>::to_i128()
+    }
+    #[inline]
+    fn to_isize() -> isize {
+        -<U as Unsigned>::to_isize()
+    }
+}
+
+// macro for testing operation results. Uses `Same` to ensure the types are equal and
+// not just the values they evaluate to.
+macro_rules! test_int_op {
+    ($op:ident $Lhs:ident = $Answer:ident) => (
+        {
+            type Test = <<$Lhs as $op>::Output as ::Same<$Answer>>::Output;
+            assert_eq!(<$Answer as Integer>::to_i64(), <Test as Integer>::to_i64());
+        }
+        );
+    ($Lhs:ident $op:ident $Rhs:ident = $Answer:ident) => (
+        {
+            type Test = <<$Lhs as $op<$Rhs>>::Output as ::Same<$Answer>>::Output;
+            assert_eq!(<$Answer as Integer>::to_i64(), <Test as Integer>::to_i64());
+        }
+        );
+}
+
+// ---------------------------------------------------------------------------------------
+// Neg
+
+/// `-Z0 = Z0`
+impl Neg for Z0 {
+    type Output = Z0;
+    fn neg(self) -> Self::Output {
+        Z0
+    }
+}
+
+/// `-PInt = NInt`
+impl<U: Unsigned + NonZero> Neg for PInt<U> {
+    type Output = NInt<U>;
+    fn neg(self) -> Self::Output {
+        NInt::new()
+    }
+}
+
+/// `-NInt = PInt`
+impl<U: Unsigned + NonZero> Neg for NInt<U> {
+    type Output = PInt<U>;
+    fn neg(self) -> Self::Output {
+        PInt::new()
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Add
+
+/// `Z0 + I = I`
+impl<I: Integer> Add<I> for Z0 {
+    type Output = I;
+    fn add(self, _: I) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `PInt + Z0 = PInt`
+impl<U: Unsigned + NonZero> Add<Z0> for PInt<U> {
+    type Output = PInt<U>;
+    fn add(self, _: Z0) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// `NInt + Z0 = NInt`
+impl<U: Unsigned + NonZero> Add<Z0> for NInt<U> {
+    type Output = NInt<U>;
+    fn add(self, _: Z0) -> Self::Output {
+        NInt::new()
+    }
+}
+
+/// `P(Ul) + P(Ur) = P(Ul + Ur)`
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Add<PInt<Ur>> for PInt<Ul>
+    where Ul: Add<Ur>,
+          <Ul as Add<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = PInt<<Ul as Add<Ur>>::Output>;
+    fn add(self, _: PInt<Ur>) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// `N(Ul) + N(Ur) = N(Ul + Ur)`
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Add<NInt<Ur>> for NInt<Ul>
+    where Ul: Add<Ur>,
+          <Ul as Add<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = NInt<<Ul as Add<Ur>>::Output>;
+    fn add(self, _: NInt<Ur>) -> Self::Output {
+        NInt::new()
+    }
+}
+
+/// `P(Ul) + N(Ur)`: We resolve this with our `PrivateAdd`
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Add<NInt<Ur>> for PInt<Ul>
+    where Ul: Cmp<Ur> + PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>
+{
+    type Output = <Ul as PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>>::Output;
+    fn add(self, _: NInt<Ur>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `N(Ul) + P(Ur)`: We resolve this with our `PrivateAdd`
+// We just do the same thing as above, swapping Lhs and Rhs
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Add<PInt<Ur>> for NInt<Ul>
+    where Ur: Cmp<Ul> + PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>
+{
+    type Output = <Ur as PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>>::Output;
+    fn add(self, _: PInt<Ur>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `P + N = 0` where `P == N`
+impl<N: Unsigned, P: Unsigned> PrivateIntegerAdd<Equal, N> for P {
+    type Output = Z0;
+}
+
+/// `P + N = Positive` where `P > N`
+impl<N: Unsigned, P: Unsigned> PrivateIntegerAdd<Greater, N> for P
+    where P: Sub<N>,
+          <P as Sub<N>>::Output: Unsigned + NonZero
+{
+    type Output = PInt<<P as Sub<N>>::Output>;
+}
+
+/// `P + N = Negative` where `P < N`
+impl<N: Unsigned, P: Unsigned> PrivateIntegerAdd<Less, N> for P
+    where N: Sub<P>,
+          <N as Sub<P>>::Output: Unsigned + NonZero
+{
+    type Output = NInt<<N as Sub<P>>::Output>;
+}
+
+// ---------------------------------------------------------------------------------------
+// Sub
+
+/// `Z0 - Z0 = Z0`
+impl Sub<Z0> for Z0 {
+    type Output = Z0;
+    fn sub(self, _: Z0) -> Self::Output {
+        Z0
+    }
+}
+
+/// `Z0 - P = N`
+impl<U: Unsigned + NonZero> Sub<PInt<U>> for Z0 {
+    type Output = NInt<U>;
+    fn sub(self, _: PInt<U>) -> Self::Output {
+        NInt::new()
+    }
+}
+
+/// `Z0 - N = P`
+impl<U: Unsigned + NonZero> Sub<NInt<U>> for Z0 {
+    type Output = PInt<U>;
+    fn sub(self, _: NInt<U>) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// `PInt - Z0 = PInt`
+impl<U: Unsigned + NonZero> Sub<Z0> for PInt<U> {
+    type Output = PInt<U>;
+    fn sub(self, _: Z0) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// `NInt - Z0 = NInt`
+impl<U: Unsigned + NonZero> Sub<Z0> for NInt<U> {
+    type Output = NInt<U>;
+    fn sub(self, _: Z0) -> Self::Output {
+        NInt::new()
+    }
+}
+
+/// `P(Ul) - N(Ur) = P(Ul + Ur)`
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Sub<NInt<Ur>> for PInt<Ul>
+    where Ul: Add<Ur>,
+          <Ul as Add<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = PInt<<Ul as Add<Ur>>::Output>;
+    fn sub(self, _: NInt<Ur>) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// `N(Ul) - P(Ur) = N(Ul + Ur)`
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Sub<PInt<Ur>> for NInt<Ul>
+    where Ul: Add<Ur>,
+          <Ul as Add<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = NInt<<Ul as Add<Ur>>::Output>;
+    fn sub(self, _: PInt<Ur>) -> Self::Output {
+        NInt::new()
+    }
+}
+
+/// `P(Ul) - P(Ur)`: We resolve this with our `PrivateAdd`
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Sub<PInt<Ur>> for PInt<Ul>
+    where Ul: Cmp<Ur> + PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>
+{
+    type Output = <Ul as PrivateIntegerAdd<<Ul as Cmp<Ur>>::Output, Ur>>::Output;
+    fn sub(self, _: PInt<Ur>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `N(Ul) - N(Ur)`: We resolve this with our `PrivateAdd`
+// We just do the same thing as above, swapping Lhs and Rhs
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Sub<NInt<Ur>> for NInt<Ul>
+    where Ur: Cmp<Ul> + PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>
+{
+    type Output = <Ur as PrivateIntegerAdd<<Ur as Cmp<Ul>>::Output, Ul>>::Output;
+    fn sub(self, _: NInt<Ur>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Mul
+
+/// `Z0 * I = Z0`
+impl<I: Integer> Mul<I> for Z0 {
+    type Output = Z0;
+    fn mul(self, _: I) -> Self::Output {
+        Z0
+    }
+}
+
+/// `P * Z0 = Z0`
+impl<U: Unsigned + NonZero> Mul<Z0> for PInt<U> {
+    type Output = Z0;
+    fn mul(self, _: Z0) -> Self::Output {
+        Z0
+    }
+}
+
+/// `N * Z0 = Z0`
+impl<U: Unsigned + NonZero> Mul<Z0> for NInt<U> {
+    type Output = Z0;
+    fn mul(self, _: Z0) -> Self::Output {
+        Z0
+    }
+}
+
+/// P(Ul) * P(Ur) = P(Ul * Ur)
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Mul<PInt<Ur>> for PInt<Ul>
+    where Ul: Mul<Ur>,
+          <Ul as Mul<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = PInt<<Ul as Mul<Ur>>::Output>;
+    fn mul(self, _: PInt<Ur>) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// N(Ul) * N(Ur) = P(Ul * Ur)
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Mul<NInt<Ur>> for NInt<Ul>
+    where Ul: Mul<Ur>,
+          <Ul as Mul<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = PInt<<Ul as Mul<Ur>>::Output>;
+    fn mul(self, _: NInt<Ur>) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// P(Ul) * N(Ur) = N(Ul * Ur)
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Mul<NInt<Ur>> for PInt<Ul>
+    where Ul: Mul<Ur>,
+          <Ul as Mul<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = NInt<<Ul as Mul<Ur>>::Output>;
+    fn mul(self, _: NInt<Ur>) -> Self::Output {
+        NInt::new()
+    }
+}
+
+/// N(Ul) * P(Ur) = N(Ul * Ur)
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Mul<PInt<Ur>> for NInt<Ul>
+    where Ul: Mul<Ur>,
+          <Ul as Mul<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = NInt<<Ul as Mul<Ur>>::Output>;
+    fn mul(self, _: PInt<Ur>) -> Self::Output {
+        NInt::new()
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Div
+
+/// `Z0 / I = Z0` where `I != 0`
+impl<I: Integer + NonZero> Div<I> for Z0 {
+    type Output = Z0;
+    fn div(self, _: I) -> Self::Output {
+        Z0
+    }
+}
+
+macro_rules! impl_int_div {
+    ($A:ident, $B:ident, $R:ident) => (
+        /// `$A<Ul> / $B<Ur> = $R<Ul / Ur>`
+        impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Div<$B<Ur>> for $A<Ul>
+            where Ul: Cmp<Ur>,
+                  $A<Ul>: PrivateDivInt<<Ul as Cmp<Ur>>::Output, $B<Ur>>
+        {
+            type Output = <$A<Ul> as PrivateDivInt<
+                <Ul as Cmp<Ur>>::Output,
+                $B<Ur>>>::Output;
+            fn div(self, _: $B<Ur>) -> Self::Output {
+                unsafe { ::core::mem::uninitialized() }
+            }
+        }
+        impl<Ul, Ur> PrivateDivInt<Less, $B<Ur>> for $A<Ul>
+            where Ul: Unsigned + NonZero, Ur: Unsigned + NonZero,
+        {
+            type Output = Z0;
+        }
+        impl<Ul, Ur> PrivateDivInt<Equal, $B<Ur>> for $A<Ul>
+            where Ul: Unsigned + NonZero, Ur: Unsigned + NonZero,
+        {
+            type Output = $R<U1>;
+        }
+        impl<Ul, Ur> PrivateDivInt<Greater, $B<Ur>> for $A<Ul>
+            where Ul: Unsigned + NonZero + Div<Ur>,
+                  Ur: Unsigned + NonZero,
+                  <Ul as Div<Ur>>::Output: Unsigned + NonZero,
+        {
+            type Output = $R<<Ul as Div<Ur>>::Output>;
+        }
+        );
+}
+
+impl_int_div!(PInt, PInt, PInt);
+impl_int_div!(PInt, NInt, NInt);
+impl_int_div!(NInt, PInt, NInt);
+impl_int_div!(NInt, NInt, PInt);
+
+// ---------------------------------------------------------------------------------------
+// PartialDiv
+
+use {PartialDiv, Quot};
+
+impl<M, N> PartialDiv<N> for M
+    where M: Integer + Div<N> + Rem<N, Output = Z0>
+{
+    type Output = Quot<M, N>;
+    fn partial_div(self, _: N) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Cmp
+
+/// 0 == 0
+impl Cmp<Z0> for Z0 {
+    type Output = Equal;
+}
+
+/// 0 > -X
+impl<U: Unsigned + NonZero> Cmp<NInt<U>> for Z0 {
+    type Output = Greater;
+}
+
+/// 0 < X
+impl<U: Unsigned + NonZero> Cmp<PInt<U>> for Z0 {
+    type Output = Less;
+}
+
+/// X > 0
+impl<U: Unsigned + NonZero> Cmp<Z0> for PInt<U> {
+    type Output = Greater;
+}
+
+/// -X < 0
+impl<U: Unsigned + NonZero> Cmp<Z0> for NInt<U> {
+    type Output = Less;
+}
+
+/// -X < Y
+impl<P: Unsigned + NonZero, N: Unsigned + NonZero> Cmp<PInt<P>> for NInt<N> {
+    type Output = Less;
+}
+
+/// X > - Y
+impl<P: Unsigned + NonZero, N: Unsigned + NonZero> Cmp<NInt<N>> for PInt<P> {
+    type Output = Greater;
+}
+
+/// X <==> Y
+impl<Pl: Cmp<Pr> + Unsigned + NonZero, Pr: Unsigned + NonZero> Cmp<PInt<Pr>> for PInt<Pl> {
+    type Output = <Pl as Cmp<Pr>>::Output;
+}
+
+/// -X <==> -Y
+impl<Nl: Unsigned + NonZero, Nr: Cmp<Nl> + Unsigned + NonZero> Cmp<NInt<Nr>> for NInt<Nl> {
+    type Output = <Nr as Cmp<Nl>>::Output;
+}
+
+macro_rules! test_ord {
+    ($Lhs:ident > $Rhs:ident) => (
+        {
+            type Test = <$Lhs as Cmp<$Rhs>>::Output;
+            assert_eq!(::core::cmp::Ordering::Greater, <Test as Ord>::to_ordering());
+        }
+        );
+    ($Lhs:ident == $Rhs:ident) => (
+        {
+            type Test = <$Lhs as Cmp<$Rhs>>::Output;
+            assert_eq!(::core::cmp::Ordering::Equal, <Test as Ord>::to_ordering());
+        }
+        );
+    ($Lhs:ident < $Rhs:ident) => (
+        {
+            type Test = <$Lhs as Cmp<$Rhs>>::Output;
+            assert_eq!(::core::cmp::Ordering::Less, <Test as Ord>::to_ordering());
+        }
+        );
+}
+
+// ---------------------------------------------------------------------------------------
+// Rem
+
+/// `Z0 % I = Z0` where `I != 0`
+impl<I: Integer + NonZero> Rem<I> for Z0 {
+    type Output = Z0;
+    fn rem(self, _: I) -> Self::Output {
+        Z0
+    }
+}
+
+macro_rules! impl_int_rem {
+    ($A:ident, $B:ident, $R:ident) => (
+        /// `$A<Ul> % $B<Ur> = $R<Ul % Ur>`
+        impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Rem<$B<Ur>> for $A<Ul>
+            where Ul: Rem<Ur>,
+                  $A<Ul>: PrivateRem<<Ul as Rem<Ur>>::Output, $B<Ur>>
+        {
+            type Output = <$A<Ul> as PrivateRem<
+                <Ul as Rem<Ur>>::Output,
+                $B<Ur>>>::Output;
+            fn rem(self, _: $B<Ur>) -> Self::Output {
+                unsafe { ::core::mem::uninitialized() }
+            }
+        }
+        impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> PrivateRem<U0, $B<Ur>> for $A<Ul> {
+            type Output = Z0;
+        }
+        impl<Ul, Ur, U, B> PrivateRem<UInt<U, B>, $B<Ur>> for $A<Ul>
+            where Ul: Unsigned + NonZero, Ur: Unsigned + NonZero, U: Unsigned, B: Bit,
+        {
+            type Output = $R<UInt<U, B>>;
+        }
+        );
+}
+
+impl_int_rem!(PInt, PInt, PInt);
+impl_int_rem!(PInt, NInt, PInt);
+impl_int_rem!(NInt, PInt, NInt);
+impl_int_rem!(NInt, NInt, NInt);
+
+// ---------------------------------------------------------------------------------------
+// Pow
+
+/// 0^0 = 1
+impl Pow<Z0> for Z0 {
+    type Output = P1;
+    fn powi(self, _: Z0) -> Self::Output {
+        P1::new()
+    }
+}
+
+/// 0^P = 0
+impl<U: Unsigned + NonZero> Pow<PInt<U>> for Z0 {
+    type Output = Z0;
+    fn powi(self, _: PInt<U>) -> Self::Output {
+        Z0
+    }
+}
+
+/// 0^N = 0
+impl<U: Unsigned + NonZero> Pow<NInt<U>> for Z0 {
+    type Output = Z0;
+    fn powi(self, _: NInt<U>) -> Self::Output {
+        Z0
+    }
+}
+
+/// 1^N = 1
+impl<U: Unsigned + NonZero> Pow<NInt<U>> for P1 {
+    type Output = P1;
+    fn powi(self, _: NInt<U>) -> Self::Output {
+        P1::new()
+    }
+}
+
+/// (-1)^N = 1 if N is even
+impl<U: Unsigned> Pow<NInt<UInt<U, B0>>> for N1 {
+    type Output = P1;
+    fn powi(self, _: NInt<UInt<U, B0>>) -> Self::Output {
+        P1::new()
+    }
+}
+
+/// (-1)^N = -1 if N is odd
+impl<U: Unsigned> Pow<NInt<UInt<U, B1>>> for N1 {
+    type Output = N1;
+    fn powi(self, _: NInt<UInt<U, B1>>) -> Self::Output {
+        N1::new()
+    }
+}
+
+/// P^0 = 1
+impl<U: Unsigned + NonZero> Pow<Z0> for PInt<U> {
+    type Output = P1;
+    fn powi(self, _: Z0) -> Self::Output {
+        P1::new()
+    }
+}
+
+/// N^0 = 1
+impl<U: Unsigned + NonZero> Pow<Z0> for NInt<U> {
+    type Output = P1;
+    fn powi(self, _: Z0) -> Self::Output {
+        P1::new()
+    }
+}
+
+/// P(Ul)^P(Ur) = P(Ul^Ur)
+impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Pow<PInt<Ur>> for PInt<Ul>
+    where Ul: Pow<Ur>,
+          <Ul as Pow<Ur>>::Output: Unsigned + NonZero
+{
+    type Output = PInt<<Ul as Pow<Ur>>::Output>;
+    fn powi(self, _: PInt<Ur>) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// N(Ul)^P(Ur) = P(Ul^Ur) if Ur is even
+impl<Ul: Unsigned + NonZero, Ur: Unsigned> Pow<PInt<UInt<Ur, B0>>> for NInt<Ul>
+    where Ul: Pow<UInt<Ur, B0>>,
+          <Ul as Pow<UInt<Ur, B0>>>::Output: Unsigned + NonZero
+{
+    type Output = PInt<<Ul as Pow<UInt<Ur, B0>>>::Output>;
+    fn powi(self, _: PInt<UInt<Ur, B0>>) -> Self::Output {
+        PInt::new()
+    }
+}
+
+/// N(Ul)^P(Ur) = N(Ul^Ur) if Ur is odd
+impl<Ul: Unsigned + NonZero, Ur: Unsigned> Pow<PInt<UInt<Ur, B1>>> for NInt<Ul>
+    where Ul: Pow<UInt<Ur, B1>>,
+          <Ul as Pow<UInt<Ur, B1>>>::Output: Unsigned + NonZero
+{
+    type Output = NInt<<Ul as Pow<UInt<Ur, B1>>>::Output>;
+    fn powi(self, _: PInt<UInt<Ur, B1>>) -> Self::Output {
+        NInt::new()
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Min
+use {Min, Minimum, Max, Maximum};
+
+impl Min<Z0> for Z0 {
+    type Output = Z0;
+    fn min(self, _: Z0) -> Self::Output {
+        self
+    }
+}
+
+impl<U> Min<PInt<U>> for Z0
+    where U: Unsigned + NonZero
+{
+    type Output = Z0;
+    fn min(self, _: PInt<U>) -> Self::Output {
+        self
+    }
+}
+
+impl<U> Min<NInt<U>> for Z0
+    where U: Unsigned + NonZero
+{
+    type Output = NInt<U>;
+    fn min(self, rhs: NInt<U>) -> Self::Output {
+        rhs
+    }
+}
+
+impl<U> Min<Z0> for PInt<U>
+    where U: Unsigned + NonZero
+{
+    type Output = Z0;
+    fn min(self, rhs: Z0) -> Self::Output {
+        rhs
+    }
+}
+
+impl<U> Min<Z0> for NInt<U>
+    where U: Unsigned + NonZero
+{
+    type Output = NInt<U>;
+    fn min(self, _: Z0) -> Self::Output {
+        self
+    }
+}
+
+impl<Ul, Ur> Min<PInt<Ur>> for PInt<Ul>
+    where Ul: Unsigned + NonZero + Min<Ur>,
+          Ur: Unsigned + NonZero,
+          Minimum<Ul, Ur>: Unsigned + NonZero
+{
+    type Output = PInt<Minimum<Ul, Ur>>;
+    fn min(self, _: PInt<Ur>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+impl<Ul, Ur> Min<PInt<Ur>> for NInt<Ul>
+    where Ul: Unsigned + NonZero,
+          Ur: Unsigned + NonZero
+{
+    type Output = NInt<Ul>;
+    fn min(self, _: PInt<Ur>) -> Self::Output {
+        self
+    }
+}
+
+impl<Ul, Ur> Min<NInt<Ur>> for PInt<Ul>
+    where Ul: Unsigned + NonZero,
+          Ur: Unsigned + NonZero
+{
+    type Output = NInt<Ur>;
+    fn min(self, rhs: NInt<Ur>) -> Self::Output {
+        rhs
+    }
+}
+
+impl<Ul, Ur> Min<NInt<Ur>> for NInt<Ul>
+    where Ul: Unsigned + NonZero + Max<Ur>,
+          Ur: Unsigned + NonZero,
+          Maximum<Ul, Ur>: Unsigned + NonZero
+{
+    type Output = NInt<Maximum<Ul, Ur>>;
+    fn min(self, _: NInt<Ur>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Max
+
+impl Max<Z0> for Z0 {
+    type Output = Z0;
+    fn max(self, _: Z0) -> Self::Output {
+        self
+    }
+}
+
+impl<U> Max<PInt<U>> for Z0
+    where U: Unsigned + NonZero
+{
+    type Output = PInt<U>;
+    fn max(self, rhs: PInt<U>) -> Self::Output {
+        rhs
+    }
+}
+
+impl<U> Max<NInt<U>> for Z0
+    where U: Unsigned + NonZero
+{
+    type Output = Z0;
+    fn max(self, _: NInt<U>) -> Self::Output {
+        self
+    }
+}
+
+impl<U> Max<Z0> for PInt<U>
+    where U: Unsigned + NonZero
+{
+    type Output = PInt<U>;
+    fn max(self, _: Z0) -> Self::Output {
+        self
+    }
+}
+
+impl<U> Max<Z0> for NInt<U>
+    where U: Unsigned + NonZero
+{
+    type Output = Z0;
+    fn max(self, rhs: Z0) -> Self::Output {
+        rhs
+    }
+}
+
+impl<Ul, Ur> Max<PInt<Ur>> for PInt<Ul>
+    where Ul: Unsigned + NonZero + Max<Ur>,
+          Ur: Unsigned + NonZero,
+          Maximum<Ul, Ur>: Unsigned + NonZero
+{
+    type Output = PInt<Maximum<Ul, Ur>>;
+    fn max(self, _: PInt<Ur>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+impl<Ul, Ur> Max<PInt<Ur>> for NInt<Ul>
+    where Ul: Unsigned + NonZero,
+          Ur: Unsigned + NonZero
+{
+    type Output = PInt<Ur>;
+    fn max(self, rhs: PInt<Ur>) -> Self::Output {
+        rhs
+    }
+}
+
+impl<Ul, Ur> Max<NInt<Ur>> for PInt<Ul>
+    where Ul: Unsigned + NonZero,
+          Ur: Unsigned + NonZero
+{
+    type Output = PInt<Ul>;
+    fn max(self, _: NInt<Ur>) -> Self::Output {
+        self
+    }
+}
+
+impl<Ul, Ur> Max<NInt<Ur>> for NInt<Ul>
+    where Ul: Unsigned + NonZero + Min<Ur>,
+          Ur: Unsigned + NonZero,
+          Minimum<Ul, Ur>: Unsigned + NonZero
+{
+    type Output = NInt<Minimum<Ul, Ur>>;
+    fn max(self, _: NInt<Ur>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
diff --git a/crates/typenum-1.9.0/src/lib.rs b/crates/typenum-1.9.0/src/lib.rs
new file mode 100644
index 0000000..c2756e3
--- /dev/null
+++ b/crates/typenum-1.9.0/src/lib.rs
@@ -0,0 +1,143 @@
+//! This crate provides type-level numbers evaluated at compile time. It depends only on libcore.
+//!
+//! The traits defined or used in this crate are used in a typical manner. They can be divided into
+//! two categories: **marker traits** and **type operators**.
+//!
+//! Many of the marker traits have functions defined, but they all do essentially the same thing:
+//! convert a type into its runtime counterpart, and are really just there for debugging. For
+//! example,
+//!
+//! ```rust
+//! use typenum::{N4, Integer};
+//!
+//! assert_eq!(N4::to_i32(), -4);
+//! ```
+//!
+//! **Type operators** are traits that behave as functions at the type level. These are the meat of
+//! this library. Where possible, traits defined in libcore have been used, but their attached
+//! functions have not been implemented.
+//!
+//! For example, the `Add` trait is implemented for both unsigned and signed integers, but the
+//! `add` function is not. As there are never any objects of the types defined here, it wouldn't
+//! make sense to implement it. What is important is its associated type `Output`, which is where
+//! the addition happens.
+//!
+//! ```rust
+//! use std::ops::Add;
+//! use typenum::{Integer, P3, P4};
+//!
+//! type X = <P3 as Add<P4>>::Output;
+//! assert_eq!(<X as Integer>::to_i32(), 7);
+//! ```
+//!
+//! In addition, helper aliases are defined for type operators. For example, the above snippet
+//! could be replaced with
+//!
+//! ```rust
+//! use typenum::{Sum, Integer, P3, P4};
+//!
+//! type X = Sum<P3, P4>;
+//! assert_eq!(<X as Integer>::to_i32(), 7);
+//! ```
+//!
+//! Documented in each module is the full list of type operators implemented.
+//!
+
+#![no_std]
+#![warn(missing_docs)]
+
+#![cfg_attr(feature="i128", feature(i128_type))]
+
+// For clippy:
+#![cfg_attr(feature="clippy", feature(plugin))]
+#![cfg_attr(feature="clippy", plugin(clippy))]
+
+#![allow(unknown_lints)]
+#![deny(clippy)]
+#![allow(type_complexity, len_without_is_empty)]
+
+// For debugging macros:
+// #![feature(trace_macros)]
+// trace_macros!(true);
+
+use core::cmp::Ordering;
+
+include!(concat!(env!("OUT_DIR"), "/consts.rs"));
+include!(concat!(env!("OUT_DIR"), "/op.rs"));
+pub mod bit;
+pub mod uint;
+pub mod int;
+pub mod private;
+pub mod marker_traits;
+pub mod type_operators;
+pub mod operator_aliases;
+
+pub mod array;
+
+pub use consts::*;
+pub use marker_traits::*;
+pub use type_operators::*;
+pub use operator_aliases::*;
+
+pub use uint::{UInt, UTerm};
+pub use int::{NInt, PInt};
+pub use array::{TArr, ATerm};
+
+/// A potential output from `Cmp`, this is the type equivalent to the enum variant
+/// `core::cmp::Ordering::Greater`.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct Greater;
+
+/// A potential output from `Cmp`, this is the type equivalent to the enum variant
+/// `core::cmp::Ordering::Less`.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct Less;
+
+/// A potential output from `Cmp`, this is the type equivalent to the enum variant
+/// `core::cmp::Ordering::Equal`.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct Equal;
+
+/// Returns `core::cmp::Ordering::Greater`
+impl Ord for Greater {
+    #[inline]
+    fn to_ordering() -> Ordering {
+        Ordering::Greater
+    }
+}
+
+/// Returns `core::cmp::Ordering::Less`
+impl Ord for Less {
+    #[inline]
+    fn to_ordering() -> Ordering {
+        Ordering::Less
+    }
+}
+
+/// Returns `core::cmp::Ordering::Equal`
+impl Ord for Equal {
+    #[inline]
+    fn to_ordering() -> Ordering {
+        Ordering::Equal
+    }
+}
+
+/**
+Asserts that two types are the same.
+*/
+#[macro_export]
+macro_rules! assert_type_eq {
+    ($a:ty, $b:ty) => (
+        let _: <$a as $crate::Same<$b>>::Output;
+    );
+}
+
+/**
+Asserts that a type is `True`, aka `B1`.
+*/
+#[macro_export]
+macro_rules! assert_type {
+    ($a:ty) => (
+        let _: <$a as $crate::Same<True>>::Output;
+    );
+}
diff --git a/crates/typenum-1.9.0/src/marker_traits.rs b/crates/typenum-1.9.0/src/marker_traits.rs
new file mode 100644
index 0000000..443e83c
--- /dev/null
+++ b/crates/typenum-1.9.0/src/marker_traits.rs
@@ -0,0 +1,112 @@
+//! All of the **marker traits** used in typenum.
+//!
+//! Note that the definition here for marker traits is slightly different than the conventional one
+//! -- we include traits with functions that convert a type to the corresponding value.
+//!
+//! For example, the `Integer` trait includes the function (among others) `fn to_i32() ->
+//! i32` so that one can do this:
+//!
+//! ```
+//! use typenum::{N42, Integer};
+//!
+//! assert_eq!(-42, N42::to_i32());
+//! ```
+//!
+//!
+
+/// A **marker trait** to designate that a type is not zero. All number types in this
+/// crate implement `NonZero` except `B0`, `U0`, and `Z0`.
+pub trait NonZero {}
+
+/// A **Marker trait** for the types `Greater`, `Equal`, and `Less`.
+///
+/// This trait should not be implemented for anything outside this crate.
+pub trait Ord {
+    #[allow(missing_docs)]
+    fn to_ordering() -> ::core::cmp::Ordering;
+}
+
+/// The **marker trait** for compile time bits.
+///
+/// This trait should not be implemented for anything outside this crate.
+pub trait Bit {
+    #[allow(missing_docs)]
+    fn to_u8() -> u8;
+    #[allow(missing_docs)]
+    fn to_bool() -> bool;
+}
+
+/// The **marker trait** for compile time unsigned integers.
+///
+/// This trait should not be implemented for anything outside this crate.
+///
+/// # Example
+/// ```rust
+/// use typenum::{U3, Unsigned};
+///
+/// assert_eq!(U3::to_u32(), 3);
+/// ```
+pub trait Unsigned {
+    #[allow(missing_docs)]
+    fn to_u8() -> u8;
+    #[allow(missing_docs)]
+    fn to_u16() -> u16;
+    #[allow(missing_docs)]
+    fn to_u32() -> u32;
+    #[allow(missing_docs)]
+    fn to_u64() -> u64;
+    #[cfg(feature="i128")]
+    #[allow(missing_docs)]
+    fn to_u128() -> u128;
+    #[allow(missing_docs)]
+    fn to_usize() -> usize;
+
+    #[allow(missing_docs)]
+    fn to_i8() -> i8;
+    #[allow(missing_docs)]
+    fn to_i16() -> i16;
+    #[allow(missing_docs)]
+    fn to_i32() -> i32;
+    #[allow(missing_docs)]
+    fn to_i64() -> i64;
+    #[cfg(feature="i128")]
+    #[allow(missing_docs)]
+    fn to_i128() -> i128;
+    #[allow(missing_docs)]
+    fn to_isize() -> isize;
+}
+
+/// The **marker trait** for compile time signed integers.
+///
+/// This trait should not be implemented for anything outside this crate.
+///
+/// # Example
+/// ```rust
+/// use typenum::{P3, Integer};
+///
+/// assert_eq!(P3::to_i32(), 3);
+/// ```
+pub trait Integer {
+    #[allow(missing_docs)]
+    fn to_i8() -> i8;
+    #[allow(missing_docs)]
+    fn to_i16() -> i16;
+    #[allow(missing_docs)]
+    fn to_i32() -> i32;
+    #[allow(missing_docs)]
+    fn to_i64() -> i64;
+    #[cfg(feature="i128")]
+    #[allow(missing_docs)]
+    fn to_i128() -> i128;
+    #[allow(missing_docs)]
+    fn to_isize() -> isize;
+}
+
+/// The **marker trait** for type-level arrays of type-level numbers.
+///
+/// This trait should not be implemented for anything outside this crate.
+///
+/// Someday, it will contain a function or associated constant to produce a runtime array, like the
+/// other marker traits here. However, that requires stabilization of associated consts or of
+/// const functions.
+pub trait TypeArray {}
diff --git a/crates/typenum-1.9.0/src/operator_aliases.rs b/crates/typenum-1.9.0/src/operator_aliases.rs
new file mode 100644
index 0000000..fe8fb9c
--- /dev/null
+++ b/crates/typenum-1.9.0/src/operator_aliases.rs
@@ -0,0 +1,102 @@
+//! Aliases for the type operators used in this crate.
+
+//! Their purpose is to increase the ergonomics of performing operations on the types defined
+//! here. For even more ergonomics, consider using the `op!` macro instead.
+//!
+//! For example, type `X` and type `Y` are the same here:
+//!
+//! ```rust
+//! # #[macro_use] extern crate typenum;
+//! # fn main() {
+//! use std::ops::Mul;
+//! use typenum::{Prod, P5, P7};
+//!
+//! type X = <P7 as Mul<P5>>::Output;
+//! type Y = Prod<P7, P5>;
+//!
+//! assert_type_eq!(X, Y);
+//! # }
+//! ```
+//!
+//!
+
+// Aliases!!!
+use core::ops::{BitAnd, BitOr, BitXor, Shl, Shr, Add, Sub, Mul, Div, Rem, Neg};
+use type_operators::{Abs, Pow, Cmp, Len, PartialDiv, Min, Max};
+
+/// Alias for the associated type of `BitAnd`: `And<A, B> = <A as BitAnd<B>>::Output`
+pub type And<A, B> = <A as BitAnd<B>>::Output;
+/// Alias for the associated type of `BitOr`: `Or<A, B> = <A as BitOr<B>>::Output`
+pub type Or<A, B> = <A as BitOr<B>>::Output;
+/// Alias for the associated type of `BitXor`: `Xor<A, B> = <A as BitXor<B>>::Output`
+pub type Xor<A, B> = <A as BitXor<B>>::Output;
+
+/// Alias for the associated type of `Shl`: `Shleft<A, B> = <A as Shl<B>>::Output`
+pub type Shleft<A, B> = <A as Shl<B>>::Output;
+/// Alias for the associated type of `Shr`: `Shright<A, B> = <A as Shr<B>>::Output`
+pub type Shright<A, B> = <A as Shr<B>>::Output;
+
+
+/// Alias for the associated type of `Add`: `Sum<A, B> = <A as Add<B>>::Output`
+pub type Sum<A, B> = <A as Add<B>>::Output;
+/// Alias for the associated type of `Sub`: `Diff<A, B> = <A as Sub<B>>::Output`
+pub type Diff<A, B> = <A as Sub<B>>::Output;
+/// Alias for the associated type of `Mul`: `Prod<A, B> = <A as Mul<B>>::Output`
+pub type Prod<A, B> = <A as Mul<B>>::Output;
+/// Alias for the associated type of `Div`: `Quot<A, B> = <A as Div<B>>::Output`
+pub type Quot<A, B> = <A as Div<B>>::Output;
+/// Alias for the associated type of `Rem`: `Mod<A, B> = <A as Rem<B>>::Output`
+pub type Mod<A, B> = <A as Rem<B>>::Output;
+
+/// Alias for the associated type of
+/// `PartialDiv`: `PartialQuot<A, B> = <A as PartialDiv<B>>::Output`
+pub type PartialQuot<A, B> = <A as PartialDiv<B>>::Output;
+
+/// Alias for the associated type of `Neg`: `Negate<A> = <A as Neg>::Output`
+pub type Negate<A> = <A as Neg>::Output;
+
+/// Alias for the associated type of `Abs`: `AbsVal<A> = <A as Abs>::Output`
+pub type AbsVal<A> = <A as Abs>::Output;
+
+/// Alias for the associated type of `Pow`: `Exp<A, B> = <A as Pow<B>>::Output`
+pub type Exp<A, B> = <A as Pow<B>>::Output;
+
+
+/// Alias to make it easy to add 1: `Add1<A> = <A as Add<B1>>::Output`
+pub type Add1<A> = <A as Add<::bit::B1>>::Output;
+/// Alias to make it easy to subtract 1: `Sub1<A> = <A as Sub<B1>>::Output`
+pub type Sub1<A> = <A as Sub<::bit::B1>>::Output;
+
+/// Alias to make it easy to square. `Square<A> = <A as Mul<A>>::Output`
+pub type Square<A> = <A as Mul>::Output;
+/// Alias to make it easy to square. `Cube<A> = <Square<A> as Mul<A>>::Output`
+pub type Cube<A> = <Square<A> as Mul<A>>::Output;
+
+/// Alias for the associated type of `Cmp`: `Compare<A, B> = <A as Cmp<B>>::Output`
+pub type Compare<A, B> = <A as Cmp<B>>::Output;
+
+/// Alias for the associated type of `Len`: `Length<A> = <A as Len>::Output`
+pub type Length<T> = <T as Len>::Output;
+
+
+/// Alias for the associated type of `Min`: `Minimum<A, B> = <A as Min<B>>::Output`
+pub type Minimum<A, B> = <A as Min<B>>::Output;
+
+/// Alias for the associated type of `Max`: `Maximum<A, B> = <A as Max<B>>::Output`
+pub type Maximum<A, B> = <A as Max<B>>::Output;
+
+
+use type_operators::{IsLess, IsEqual, IsGreater, IsGreaterOrEqual, IsLessOrEqual, IsNotEqual};
+/// Alias for the associated type of `IsLess`: `Le<A, B> = <A as IsLess<B>>::Output`
+pub type Le<A, B> = <A as IsLess<B>>::Output;
+/// Alias for the associated type of `IsEqual`: `Eq<A, B> = <A as IsEqual<B>>::Output`
+pub type Eq<A, B> = <A as IsEqual<B>>::Output;
+/// Alias for the associated type of `IsGreater`: `Gr<A, B> = <A as IsGreater<B>>::Output`
+pub type Gr<A, B> = <A as IsGreater<B>>::Output;
+/// Alias for the associated type of `IsGreaterOrEqual`:
+/// `GrEq<A, B> = <A as IsGreaterOrEqual<B>>::Output`
+pub type GrEq<A, B> = <A as IsGreaterOrEqual<B>>::Output;
+/// Alias for the associated type of `IsLessOrEqual`: `LeEq<A, B> = <A as IsLessOrEqual<B>>::Output`
+pub type LeEq<A, B> = <A as IsLessOrEqual<B>>::Output;
+/// Alias for the associated type of `IsNotEqual`: `NotEq<A, B> = <A as IsNotEqual<B>>::Output`
+pub type NotEq<A, B> = <A as IsNotEqual<B>>::Output;
diff --git a/crates/typenum-1.9.0/src/private.rs b/crates/typenum-1.9.0/src/private.rs
new file mode 100644
index 0000000..2eb61dc
--- /dev/null
+++ b/crates/typenum-1.9.0/src/private.rs
@@ -0,0 +1,371 @@
+//! **Ignore me!** This module is for things that are conceptually private but that must
+//! be made public for typenum to work correctly.
+//!
+//! Unless you are working on typenum itself, **there is no need to view anything here**.
+//!
+//! Certainly don't implement any of the traits here for anything.
+//!
+//!
+//! Just look away.
+//!
+//!
+//! Loooooooooooooooooooooooooooooooooook awaaaaaaaaaaaayyyyyyyyyyyyyyyyyyyyyyyyyyyyy...
+//!
+//!
+//! If you do manage to find something of use in here, please let me know. If you can make a
+//! compelling case, it may be moved out of __private.
+//!
+//! Note: Aliases for private type operators will all be named simply that operator followed
+//! by an abbreviated name of its associated type.
+//!
+
+#![doc(hidden)]
+
+// use ::{Sub};
+use bit::{Bit, B1, B0};
+use uint::{Unsigned, UInt, UTerm};
+
+/// Convenience trait. Calls `Invert` -> `TrimTrailingZeros` -> `Invert`
+pub trait Trim {
+    type Output;
+}
+pub type TrimOut<A> = <A as Trim>::Output;
+
+/// Gets rid of all zeros until it hits a one.
+
+// ONLY IMPLEMENT FOR INVERTED NUMBERS!
+pub trait TrimTrailingZeros {
+    type Output;
+}
+pub type TrimTrailingZerosOut<A> = <A as TrimTrailingZeros>::Output;
+
+/// Converts between standard numbers and inverted ones that have the most significant
+/// digit on the outside.
+pub trait Invert {
+    type Output;
+}
+pub type InvertOut<A> = <A as Invert>::Output;
+
+/// Doubly private! Called by invert to make the magic happen once its done the first step.
+/// The Rhs is what we've got so far.
+pub trait PrivateInvert<Rhs> {
+    type Output;
+}
+pub type PrivateInvertOut<A, Rhs> = <A as PrivateInvert<Rhs>>::Output;
+
+/// Terminating character for `InvertedUInt`s
+pub enum InvertedUTerm {}
+
+/// Inverted `UInt` (has most significant digit on the outside)
+pub struct InvertedUInt<IU: InvertedUnsigned, B: Bit> {
+    _marker: (IU, B),
+}
+
+/// Does the real anding for `UInt`s; `And` just calls this and then `Trim`.
+pub trait PrivateAnd<Rhs = Self> {
+    type Output;
+}
+pub type PrivateAndOut<A, Rhs> = <A as PrivateAnd<Rhs>>::Output;
+
+/// Does the real xoring for `UInt`s; `Xor` just calls this and then `Trim`.
+pub trait PrivateXor<Rhs = Self> {
+    type Output;
+}
+pub type PrivateXorOut<A, Rhs> = <A as PrivateXor<Rhs>>::Output;
+
+/// Does the real subtraction for `UInt`s; `Sub` just calls this and then `Trim`.
+pub trait PrivateSub<Rhs = Self> {
+    type Output;
+}
+pub type PrivateSubOut<A, Rhs> = <A as PrivateSub<Rhs>>::Output;
+
+/// Used for addition of signed integers; `C = P.cmp(N)`
+/// Assumes `P = Self` is positive and `N` is negative
+/// where `P` and `N` are both passed as unsigned integers
+pub trait PrivateIntegerAdd<C, N> {
+    type Output;
+}
+pub type PrivateIntegerAddOut<P, C, N> = <P as PrivateIntegerAdd<C, N>>::Output;
+
+pub trait PrivatePow<Y, N> {
+    type Output;
+}
+pub type PrivatePowOut<A, Y, N> = <A as PrivatePow<Y, N>>::Output;
+
+/// Performs `Shl` on `Lhs` so that `SizeOf(Lhs) = SizeOf(Rhs)`
+/// Fails if `SizeOf(Lhs) > SizeOf(Rhs)`
+pub trait ShiftDiff<Rhs> {
+    type Output;
+}
+pub type ShiftDiffOut<A, Rhs> = <A as ShiftDiff<Rhs>>::Output;
+
+/// Gives `SizeOf(Lhs) - SizeOf(Rhs)`
+pub trait BitDiff<Rhs> {
+    type Output;
+}
+pub type BitDiffOut<A, Rhs> = <A as BitDiff<Rhs>>::Output;
+
+/// Inverted unsigned numbers
+pub trait InvertedUnsigned {
+    fn to_u64() -> u64;
+}
+
+impl InvertedUnsigned for InvertedUTerm {
+    fn to_u64() -> u64 {
+        0
+    }
+}
+
+impl<IU: InvertedUnsigned, B: Bit> InvertedUnsigned for InvertedUInt<IU, B> {
+    fn to_u64() -> u64 {
+        B::to_u8() as u64 | IU::to_u64() << 1
+    }
+}
+
+impl Invert for UTerm {
+    type Output = InvertedUTerm;
+}
+
+impl<U: Unsigned, B: Bit> Invert for UInt<U, B>
+    where U: PrivateInvert<InvertedUInt<InvertedUTerm, B>>
+{
+    type Output = PrivateInvertOut<U, InvertedUInt<InvertedUTerm, B>>;
+}
+
+
+impl<IU: InvertedUnsigned> PrivateInvert<IU> for UTerm {
+    type Output = IU;
+}
+
+impl<IU: InvertedUnsigned, U: Unsigned, B: Bit> PrivateInvert<IU> for UInt<U, B>
+    where U: PrivateInvert<InvertedUInt<IU, B>>
+{
+    type Output = PrivateInvertOut<U, InvertedUInt<IU, B>>;
+}
+
+#[test]
+fn test_inversion() {
+    type Test4 = <::consts::U4 as Invert>::Output;
+    type Test5 = <::consts::U5 as Invert>::Output;
+    type Test12 = <::consts::U12 as Invert>::Output;
+    type Test16 = <::consts::U16 as Invert>::Output;
+
+    assert_eq!(1, <Test4 as InvertedUnsigned>::to_u64());
+    assert_eq!(5, <Test5 as InvertedUnsigned>::to_u64());
+    assert_eq!(3, <Test12 as InvertedUnsigned>::to_u64());
+    assert_eq!(1, <Test16 as InvertedUnsigned>::to_u64());
+}
+
+impl Invert for InvertedUTerm {
+    type Output = UTerm;
+}
+
+impl<IU: InvertedUnsigned, B: Bit> Invert for InvertedUInt<IU, B>
+    where IU: PrivateInvert<UInt<UTerm, B>>
+{
+    type Output = <IU as PrivateInvert<UInt<UTerm, B>>>::Output;
+}
+
+impl<U: Unsigned> PrivateInvert<U> for InvertedUTerm {
+    type Output = U;
+}
+
+impl<U: Unsigned, IU: InvertedUnsigned, B: Bit> PrivateInvert<U> for InvertedUInt<IU, B>
+    where IU: PrivateInvert<UInt<U, B>>
+{
+    type Output = <IU as PrivateInvert<UInt<U, B>>>::Output;
+}
+
+#[test]
+fn test_double_inversion() {
+    type Test4 =
+        <<::consts::U4 as Invert>::Output as Invert>::Output;
+    type Test5 =
+        <<::consts::U5 as Invert>::Output as Invert>::Output;
+    type Test12 =
+        <<::consts::U12 as Invert>::Output as Invert>::Output;
+    type Test16 =
+        <<::consts::U16 as Invert>::Output as Invert>::Output;
+
+    assert_eq!(4, <Test4 as Unsigned>::to_u64());
+    assert_eq!(5, <Test5 as Unsigned>::to_u64());
+    assert_eq!(12, <Test12 as Unsigned>::to_u64());
+    assert_eq!(16, <Test16 as Unsigned>::to_u64());
+}
+
+impl TrimTrailingZeros for InvertedUTerm {
+    type Output = InvertedUTerm;
+}
+
+impl<IU: InvertedUnsigned> TrimTrailingZeros for InvertedUInt<IU, B1> {
+    type Output = Self;
+}
+
+impl<IU: InvertedUnsigned> TrimTrailingZeros for InvertedUInt<IU, B0>
+    where IU: TrimTrailingZeros
+{
+    type Output = <IU as TrimTrailingZeros>::Output;
+}
+
+impl<U: Unsigned> Trim for U
+    where U: Invert,
+          <U as Invert>::Output: TrimTrailingZeros,
+          <<U as Invert>::Output as TrimTrailingZeros>::Output: Invert
+{
+    type Output = <<<U as Invert>::Output as TrimTrailingZeros>::Output as Invert>::Output;
+}
+
+// Note: Trimming is tested when we do subtraction.
+
+pub trait PrivateCmp<Rhs, SoFar> {
+    type Output;
+}
+pub type PrivateCmpOut<A, Rhs, SoFar> = <A as PrivateCmp<Rhs, SoFar>>::Output;
+
+
+// Set Bit
+pub trait PrivateSetBit<I, B> {
+    type Output;
+}
+pub type PrivateSetBitOut<N, I, B> = <N as PrivateSetBit<I, B>>::Output;
+
+// Div
+pub trait PrivateDiv<N, D, Q, R, I> {
+    type Quotient;
+    type Remainder;
+}
+
+pub type PrivateDivQuot<N, D, Q, R, I> = <() as PrivateDiv<N, D, Q, R, I>>::Quotient;
+pub type PrivateDivRem<N, D, Q, R, I> = <() as PrivateDiv<N, D, Q, R, I>>::Remainder;
+
+pub trait PrivateDivIf<N, D, Q, R, I, RcmpD> {
+    type Quotient;
+    type Remainder;
+}
+
+pub type PrivateDivIfQuot<N, D, Q, R, I, RcmpD> = <() as PrivateDivIf<N,
+                                                                             D,
+                                                                             Q,
+                                                                             R,
+                                                                             I,
+                                                                             RcmpD>>::Quotient;
+pub type PrivateDivIfRem<N, D, Q, R, I, RcmpD> = <() as PrivateDivIf<N,
+                                                                            D,
+                                                                            Q,
+                                                                            R,
+                                                                            I,
+                                                                            RcmpD>>::Remainder;
+
+// Div for signed ints
+pub trait PrivateDivInt<C, Divisor> {
+    type Output;
+}
+pub type PrivateDivIntOut<A, C, Divisor> = <A as PrivateDivInt<C, Divisor>>::Output;
+
+pub trait PrivateRem<URem, Divisor> {
+    type Output;
+}
+pub type PrivateRemOut<A, URem, Divisor> = <A as PrivateRem<URem, Divisor>>::Output;
+
+
+// min max
+pub trait PrivateMin<Rhs, CmpResult> {
+    type Output;
+    fn private_min(self, rhs: Rhs) -> Self::Output;
+}
+pub type PrivateMinOut<A, B, CmpResult> = <A as PrivateMin<B, CmpResult>>::Output;
+
+pub trait PrivateMax<Rhs, CmpResult> {
+    type Output;
+    fn private_max(self, rhs: Rhs) -> Self::Output;
+}
+pub type PrivateMaxOut<A, B, CmpResult> = <A as PrivateMax<B, CmpResult>>::Output;
+
+
+// Comparisons
+
+use {True, False, Greater, Less, Equal};
+
+pub trait IsLessPrivate<Rhs, Cmp> {
+    type Output: Bit;
+}
+
+impl<A, B> IsLessPrivate<B, Less> for A {
+    type Output = True;
+}
+impl<A, B> IsLessPrivate<B, Equal> for A {
+    type Output = False;
+}
+impl<A, B> IsLessPrivate<B, Greater> for A {
+    type Output = False;
+}
+
+pub trait IsEqualPrivate<Rhs, Cmp> {
+    type Output: Bit;
+}
+
+impl<A, B> IsEqualPrivate<B, Less> for A {
+    type Output = False;
+}
+impl<A, B> IsEqualPrivate<B, Equal> for A {
+    type Output = True;
+}
+impl<A, B> IsEqualPrivate<B, Greater> for A {
+    type Output = False;
+}
+
+pub trait IsGreaterPrivate<Rhs, Cmp> {
+    type Output: Bit;
+}
+
+impl<A, B> IsGreaterPrivate<B, Less> for A {
+    type Output = False;
+}
+impl<A, B> IsGreaterPrivate<B, Equal> for A {
+    type Output = False;
+}
+impl<A, B> IsGreaterPrivate<B, Greater> for A {
+    type Output = True;
+}
+
+pub trait IsLessOrEqualPrivate<Rhs, Cmp> {
+    type Output: Bit;
+}
+
+impl<A, B> IsLessOrEqualPrivate<B, Less> for A {
+    type Output = True;
+}
+impl<A, B> IsLessOrEqualPrivate<B, Equal> for A {
+    type Output = True;
+}
+impl<A, B> IsLessOrEqualPrivate<B, Greater> for A {
+    type Output = False;
+}
+
+pub trait IsNotEqualPrivate<Rhs, Cmp> {
+    type Output: Bit;
+}
+
+impl<A, B> IsNotEqualPrivate<B, Less> for A {
+    type Output = True;
+}
+impl<A, B> IsNotEqualPrivate<B, Equal> for A {
+    type Output = False;
+}
+impl<A, B> IsNotEqualPrivate<B, Greater> for A {
+    type Output = True;
+}
+
+pub trait IsGreaterOrEqualPrivate<Rhs, Cmp> {
+    type Output: Bit;
+}
+
+impl<A, B> IsGreaterOrEqualPrivate<B, Less> for A {
+    type Output = False;
+}
+impl<A, B> IsGreaterOrEqualPrivate<B, Equal> for A {
+    type Output = True;
+}
+impl<A, B> IsGreaterOrEqualPrivate<B, Greater> for A {
+    type Output = True;
+}
diff --git a/crates/typenum-1.9.0/src/type_operators.rs b/crates/typenum-1.9.0/src/type_operators.rs
new file mode 100644
index 0000000..24a528d
--- /dev/null
+++ b/crates/typenum-1.9.0/src/type_operators.rs
@@ -0,0 +1,499 @@
+//! Useful **type operators** that are not defined in `core::ops`.
+//!
+
+use {Unsigned, Bit, UInt, PInt, NInt, NonZero, UTerm, Z0};
+
+/// A **type operator** that ensures that `Rhs` is the same as `Self`, it is mainly useful
+/// for writing macros that can take arbitrary binary or unary operators.
+///
+/// `Same` is implemented generically for all types; it should never need to be implemented
+/// for anything else.
+///
+/// Note that Rust lazily evaluates types, so this will only fail for two different types if
+/// the `Output` is used.
+///
+/// # Example
+/// ```rust
+/// use typenum::{Same, U4, U5, Unsigned};
+///
+/// assert_eq!(<U5 as Same<U5>>::Output::to_u32(), 5);
+///
+/// // Only an error if we use it:
+/// # #[allow(dead_code)]
+/// type Undefined = <U5 as Same<U4>>::Output;
+/// // Compiler error:
+/// // Undefined::to_u32();
+/// ```
+pub trait Same<Rhs = Self> {
+    /// Should always be `Self`
+    type Output;
+}
+
+impl<T> Same<T> for T {
+    type Output = T;
+}
+
+/// A **type operator** that returns the absolute value.
+///
+/// # Example
+/// ```rust
+/// use typenum::{Abs, N5, Integer};
+///
+/// assert_eq!(<N5 as Abs>::Output::to_i32(), 5);
+/// ```
+pub trait Abs {
+    /// The absolute value.
+    type Output;
+}
+
+impl Abs for Z0 {
+    type Output = Z0;
+}
+
+impl<U: Unsigned + NonZero> Abs for PInt<U> {
+    type Output = Self;
+}
+
+impl<U: Unsigned + NonZero> Abs for NInt<U> {
+    type Output = PInt<U>;
+}
+
+/// A **type operator** that provides exponentiation by repeated squaring.
+///
+/// # Example
+/// ```rust
+/// use typenum::{Pow, N3, P3, Integer};
+///
+/// assert_eq!(<N3 as Pow<P3>>::Output::to_i32(), -27);
+/// ```
+pub trait Pow<Exp> {
+    /// The result of the exponentiation.
+    type Output;
+    /// This function isn't used in this crate, but may be useful for others.
+    /// It is implemented for primitives.
+    ///
+    /// # Example
+    /// ```rust
+    /// use typenum::{Pow, U3};
+    ///
+    /// let a = 7u32.powi(U3::new());
+    /// let b = 7u32.pow(3);
+    /// assert_eq!(a, b);
+    ///
+    /// let x = 3.0.powi(U3::new());
+    /// let y = 27.0;
+    /// assert_eq!(x, y);
+    /// ```
+    fn powi(self, exp: Exp) -> Self::Output;
+}
+
+macro_rules! impl_pow_f {
+    ($t: ty) => (
+        impl Pow<UTerm> for $t {
+            type Output = $t;
+            #[inline]
+            fn powi(self, _: UTerm) -> Self::Output {
+                1.0
+            }
+        }
+
+        impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for $t {
+            type Output = $t;
+            // powi is unstable in core, so we have to write this function ourselves.
+            // copied from num::pow::pow
+            #[inline]
+            fn powi(self, _: UInt<U, B>) -> Self::Output {
+                let mut exp = <UInt<U, B> as Unsigned>::to_u32();
+                let mut base = self;
+
+                if exp == 0 { return 1.0 }
+
+                while exp & 1 == 0 {
+                    base *= base;
+                    exp >>= 1;
+                }
+                if exp == 1 { return base }
+
+                let mut acc = base.clone();
+                while exp > 1 {
+                    exp >>= 1;
+                    base *= base;
+                    if exp & 1 == 1 {
+                        acc *= base.clone();
+                    }
+                }
+                acc
+            }
+        }
+
+        impl Pow<Z0> for $t {
+            type Output = $t;
+            #[inline]
+            fn powi(self, _: Z0) -> Self::Output {
+                1.0
+            }
+        }
+
+        impl<U: Unsigned + NonZero> Pow<PInt<U>> for $t {
+            type Output = $t;
+            // powi is unstable in core, so we have to write this function ourselves.
+            // copied from num::pow::pow
+            #[inline]
+            fn powi(self, _: PInt<U>) -> Self::Output {
+                let mut exp = U::to_u32();
+                let mut base = self;
+
+                if exp == 0 { return 1.0 }
+
+                while exp & 1 == 0 {
+                    base *= base;
+                    exp >>= 1;
+                }
+                if exp == 1 { return base }
+
+                let mut acc = base.clone();
+                while exp > 1 {
+                    exp >>= 1;
+                    base *= base;
+                    if exp & 1 == 1 {
+                        acc *= base.clone();
+                    }
+                }
+                acc
+            }
+        }
+    );
+}
+
+impl_pow_f!(f32);
+impl_pow_f!(f64);
+
+
+macro_rules! impl_pow_i {
+    () => ();
+    ($t: ty $(, $tail:tt)*) => (
+        impl Pow<UTerm> for $t {
+            type Output = $t;
+            #[inline]
+            fn powi(self, _: UTerm) -> Self::Output {
+                1
+            }
+        }
+
+        impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for $t {
+            type Output = $t;
+            #[inline]
+            fn powi(self, _: UInt<U, B>) -> Self::Output {
+                self.pow(<UInt<U, B> as Unsigned>::to_u32())
+            }
+        }
+
+        impl Pow<Z0> for $t {
+            type Output = $t;
+            #[inline]
+            fn powi(self, _: Z0) -> Self::Output {
+                1
+            }
+        }
+
+        impl<U: Unsigned + NonZero> Pow<PInt<U>> for $t {
+            type Output = $t;
+            #[inline]
+            fn powi(self, _: PInt<U>) -> Self::Output {
+                self.pow(U::to_u32())
+            }
+        }
+
+        impl_pow_i!($($tail),*);
+    );
+}
+
+impl_pow_i!(u8, u16, u32, u64, usize, i8, i16, i32, i64, isize);
+#[cfg(feature="i128")]
+impl_pow_i!(u128, i128);
+
+#[test]
+fn pow_test() {
+    use consts::*;
+    let z0 = Z0::new();
+    let p3 = P3::new();
+
+    let u0 = U0::new();
+    let u3 = U3::new();
+
+    macro_rules! check {
+        ($x:ident) => (
+            assert_eq!($x.powi(z0), 1);
+            assert_eq!($x.powi(u0), 1);
+
+            assert_eq!($x.powi(p3), $x*$x*$x);
+            assert_eq!($x.powi(u3), $x*$x*$x);
+        );
+        ($x:ident, $f:ident) => (
+            assert!((<$f as Pow<Z0>>::powi(*$x, z0) - 1.0).abs() < ::core::$f::EPSILON);
+            assert!((<$f as Pow<U0>>::powi(*$x, u0) - 1.0).abs() < ::core::$f::EPSILON);
+
+            assert!((<$f as Pow<P3>>::powi(*$x, p3) - $x*$x*$x).abs() < ::core::$f::EPSILON);
+            assert!((<$f as Pow<U3>>::powi(*$x, u3) - $x*$x*$x).abs() < ::core::$f::EPSILON);
+        );
+    }
+
+    for x in &[0i8, -3, 2] {
+        check!(x);
+    }
+    for x in &[0u8, 1, 5] {
+        check!(x);
+    }
+    for x in &[0usize, 1, 5, 40] {
+        check!(x);
+    }
+    for x in &[0isize, 1, 2, -30, -22, 48] {
+        check!(x);
+    }
+    for x in &[0.0f32, 2.2, -3.5, 378.223] {
+        check!(x, f32);
+    }
+    for x in &[0.0f64, 2.2, -3.5, -2387.2, 234.22] {
+        check!(x, f64);
+    }
+}
+
+
+/// A **type operator** for comparing `Self` and `Rhs`. It provides a similar functionality to
+/// the function
+/// [`core::cmp::Ord::cmp`](https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp)
+/// but for types.
+///
+/// # Example
+/// ```rust
+/// use typenum::{Cmp, Ord, N3, P2, P5};
+/// use std::cmp::Ordering;
+///
+/// assert_eq!(<P2 as Cmp<N3>>::Output::to_ordering(), Ordering::Greater);
+/// assert_eq!(<P2 as Cmp<P2>>::Output::to_ordering(), Ordering::Equal);
+/// assert_eq!(<P2 as Cmp<P5>>::Output::to_ordering(), Ordering::Less);
+pub trait Cmp<Rhs = Self> {
+    /// The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`.
+    type Output;
+}
+
+/// A **type operator** that gives the length of an `Array` or the number of bits in a `UInt`.
+pub trait Len {
+    /// The length as a type-level unsigned integer.
+    type Output: ::Unsigned;
+    /// This function isn't used in this crate, but may be useful for others.
+    fn len(&self) -> Self::Output;
+}
+
+/// Division as a partial function. This **type operator** performs division just as `Div`, but is
+/// only defined when the result is an integer (i.e. there is no remainder).
+pub trait PartialDiv<Rhs = Self> {
+    /// The type of the result of the division
+    type Output;
+    /// Method for performing the division
+    fn partial_div(self, _: Rhs) -> Self::Output;
+}
+
+
+/// A **type operator** that returns the minimum of `Self` and `Rhs`.
+pub trait Min<Rhs = Self> {
+    /// The type of the minimum of `Self` and `Rhs`
+    type Output;
+    /// Method returning the minimum
+    fn min(self, rhs: Rhs) -> Self::Output;
+}
+
+/// A **type operator** that returns the maximum of `Self` and `Rhs`.
+pub trait Max<Rhs = Self> {
+    /// The type of the maximum of `Self` and `Rhs`
+    type Output;
+    /// Method returning the maximum
+    fn max(self, rhs: Rhs) -> Self::Output;
+}
+
+use Compare;
+
+/// A **type operator** that returns `True` if `Self < Rhs`, otherwise returns `False`.
+pub trait IsLess<Rhs = Self> {
+    /// The type representing either `True` or `False`
+    type Output: Bit;
+    /// Method returning `True` or `False`.
+    fn is_less(self, rhs: Rhs) -> Self::Output;
+}
+
+use private::IsLessPrivate;
+impl<A, B> IsLess<B> for A
+    where A: Cmp<B> + IsLessPrivate<B, Compare<A, B>>
+{
+    type Output = <A as IsLessPrivate<B, Compare<A, B>>>::Output;
+
+    fn is_less(self, _: B) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// A **type operator** that returns `True` if `Self == Rhs`, otherwise returns `False`.
+pub trait IsEqual<Rhs = Self> {
+    /// The type representing either `True` or `False`
+    type Output: Bit;
+    /// Method returning `True` or `False`.
+    fn is_equal(self, rhs: Rhs) -> Self::Output;
+}
+
+use private::IsEqualPrivate;
+impl<A, B> IsEqual<B> for A
+    where A: Cmp<B> + IsEqualPrivate<B, Compare<A, B>>
+{
+    type Output = <A as IsEqualPrivate<B, Compare<A, B>>>::Output;
+
+    fn is_equal(self, _: B) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+
+/// A **type operator** that returns `True` if `Self > Rhs`, otherwise returns `False`.
+pub trait IsGreater<Rhs = Self> {
+    /// The type representing either `True` or `False`
+    type Output: Bit;
+    /// Method returning `True` or `False`.
+    fn is_greater(self, rhs: Rhs) -> Self::Output;
+}
+
+use private::IsGreaterPrivate;
+impl<A, B> IsGreater<B> for A
+    where A: Cmp<B> + IsGreaterPrivate<B, Compare<A, B>>
+{
+    type Output = <A as IsGreaterPrivate<B, Compare<A, B>>>::Output;
+
+    fn is_greater(self, _: B) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// A **type operator** that returns `True` if `Self <= Rhs`, otherwise returns `False`.
+pub trait IsLessOrEqual<Rhs = Self> {
+    /// The type representing either `True` or `False`
+    type Output: Bit;
+    /// Method returning `True` or `False`.
+    fn is_less_or_equal(self, rhs: Rhs) -> Self::Output;
+}
+
+use private::IsLessOrEqualPrivate;
+impl<A, B> IsLessOrEqual<B> for A
+    where A: Cmp<B> + IsLessOrEqualPrivate<B, Compare<A, B>>
+{
+    type Output = <A as IsLessOrEqualPrivate<B, Compare<A, B>>>::Output;
+
+    fn is_less_or_equal(self, _: B) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// A **type operator** that returns `True` if `Self != Rhs`, otherwise returns `False`.
+pub trait IsNotEqual<Rhs = Self> {
+    /// The type representing either `True` or `False`
+    type Output: Bit;
+    /// Method returning `True` or `False`.
+    fn is_not_equal(self, rhs: Rhs) -> Self::Output;
+}
+
+use private::IsNotEqualPrivate;
+impl<A, B> IsNotEqual<B> for A
+    where A: Cmp<B> + IsNotEqualPrivate<B, Compare<A, B>>
+{
+    type Output = <A as IsNotEqualPrivate<B, Compare<A, B>>>::Output;
+
+    fn is_not_equal(self, _: B) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// A **type operator** that returns `True` if `Self >= Rhs`, otherwise returns `False`.
+pub trait IsGreaterOrEqual<Rhs = Self> {
+    /// The type representing either `True` or `False`
+    type Output: Bit;
+    /// Method returning `True` or `False`.
+    fn is_greater_or_equal(self, rhs: Rhs) -> Self::Output;
+}
+
+use private::IsGreaterOrEqualPrivate;
+impl<A, B> IsGreaterOrEqual<B> for A
+    where A: Cmp<B> + IsGreaterOrEqualPrivate<B, Compare<A, B>>
+{
+    type Output = <A as IsGreaterOrEqualPrivate<B, Compare<A, B>>>::Output;
+
+    fn is_greater_or_equal(self, _: B) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+
+/**
+A convenience macro for comparing type numbers. Use `op!` instead.
+
+Due to the intricacies of the macro system, if the left-hand operand is more complex than a simple
+`ident`, you must place a comma between it and the comparison sign.
+
+For example, you can do `cmp!(P5 > P3)` or `cmp!(typenum::P5, > typenum::P3)` but not
+`cmp!(typenum::P5 > typenum::P3)`.
+
+The result of this comparison will always be one of `True` (aka `B1`) or `False` (aka `B0`).
+
+# Example
+```rust
+#[macro_use] extern crate typenum;
+use typenum::consts::*;
+use typenum::Bit;
+
+fn main() {
+type Result = cmp!(P9 == op!(P1 + P2 * (P2 - N2)));
+assert_eq!(Result::to_bool(), true);
+}
+```
+ */
+#[deprecated(since="1.9.0", note="use the `op!` macro instead")]
+#[macro_export]
+macro_rules! cmp {
+    ($a:ident < $b:ty) => (
+        <$a as $crate::IsLess<$b>>::Output
+    );
+    ($a:ty, < $b:ty) => (
+        <$a as $crate::IsLess<$b>>::Output
+    );
+
+    ($a:ident == $b:ty) => (
+        <$a as $crate::IsEqual<$b>>::Output
+    );
+    ($a:ty, == $b:ty) => (
+        <$a as $crate::IsEqual<$b>>::Output
+    );
+
+    ($a:ident > $b:ty) => (
+        <$a as $crate::IsGreater<$b>>::Output
+    );
+    ($a:ty, > $b:ty) => (
+        <$a as $crate::IsGreater<$b>>::Output
+    );
+
+    ($a:ident <= $b:ty) => (
+        <$a as $crate::IsLessOrEqual<$b>>::Output
+    );
+    ($a:ty, <= $b:ty) => (
+        <$a as $crate::IsLessOrEqual<$b>>::Output
+    );
+
+    ($a:ident != $b:ty) => (
+        <$a as $crate::IsNotEqual<$b>>::Output
+    );
+    ($a:ty, != $b:ty) => (
+        <$a as $crate::IsNotEqual<$b>>::Output
+    );
+
+    ($a:ident >= $b:ty) => (
+        <$a as $crate::IsGreaterOrEqual<$b>>::Output
+    );
+    ($a:ty, >= $b:ty) => (
+        <$a as $crate::IsGreaterOrEqual<$b>>::Output
+    );
+}
diff --git a/crates/typenum-1.9.0/src/uint.rs b/crates/typenum-1.9.0/src/uint.rs
new file mode 100644
index 0000000..973c92d
--- /dev/null
+++ b/crates/typenum-1.9.0/src/uint.rs
@@ -0,0 +1,1499 @@
+//! Type-level unsigned integers.
+//!
+//!
+//! **Type operators** implemented:
+//!
+//! From `core::ops`: `BitAnd`, `BitOr`, `BitXor`, `Shl`, `Shr`, `Add`, `Sub`,
+//!                 `Mul`, `Div`, and `Rem`.
+//! From `typenum`: `Same`, `Cmp`, and `Pow`.
+//!
+//! Rather than directly using the structs defined in this module, it is recommended that
+//! you import and use the relevant aliases from the [consts](../consts/index.html) module.
+//!
+//! # Example
+//! ```rust
+//! use std::ops::{BitAnd, BitOr, BitXor, Shl, Shr, Add, Sub, Mul, Div, Rem};
+//! use typenum::{Unsigned, U1, U2, U3, U4};
+//!
+//! assert_eq!(<U3 as BitAnd<U2>>::Output::to_u32(), 2);
+//! assert_eq!(<U3 as BitOr<U4>>::Output::to_u32(), 7);
+//! assert_eq!(<U3 as BitXor<U2>>::Output::to_u32(), 1);
+//! assert_eq!(<U3 as Shl<U1>>::Output::to_u32(), 6);
+//! assert_eq!(<U3 as Shr<U1>>::Output::to_u32(), 1);
+//! assert_eq!(<U3 as Add<U2>>::Output::to_u32(), 5);
+//! assert_eq!(<U3 as Sub<U2>>::Output::to_u32(), 1);
+//! assert_eq!(<U3 as Mul<U2>>::Output::to_u32(), 6);
+//! assert_eq!(<U3 as Div<U2>>::Output::to_u32(), 1);
+//! assert_eq!(<U3 as Rem<U2>>::Output::to_u32(), 1);
+//! ```
+//!
+
+use core::ops::{BitAnd, BitOr, BitXor, Shl, Shr, Add, Sub, Mul};
+use core::marker::PhantomData;
+use {NonZero, Ord, Greater, Equal, Less, Pow, Cmp, Len};
+
+use bit::{Bit, B0, B1};
+
+use private::{Trim, PrivateAnd, PrivateXor, PrivateSub, PrivateCmp, PrivatePow, BitDiff};
+
+use private::{TrimOut, PrivateAndOut, PrivateXorOut, PrivateSubOut, PrivateCmpOut, PrivatePowOut,
+              BitDiffOut};
+
+use consts::{U0, U1};
+use {Or, Shleft, Shright, Sum, Prod, Add1, Sub1, Square, Length};
+
+pub use marker_traits::Unsigned;
+
+/// The terminating type for `UInt`; it always comes after the most significant
+/// bit. `UTerm` by itself represents zero, which is aliased to `U0`.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct UTerm;
+
+impl UTerm {
+    /// Instantiates a singleton representing this unsigned integer.
+    #[inline]
+    pub fn new() -> UTerm {
+        UTerm
+    }
+}
+
+impl Unsigned for UTerm {
+    #[inline]
+    fn to_u8() -> u8 {
+        0
+    }
+    #[inline]
+    fn to_u16() -> u16 {
+        0
+    }
+    #[inline]
+    fn to_u32() -> u32 {
+        0
+    }
+    #[inline]
+    fn to_u64() -> u64 {
+        0
+    }
+    #[cfg(feature="i128")]
+    #[inline]
+    fn to_u128() -> u128 {
+        0
+    }
+    #[inline]
+    fn to_usize() -> usize {
+        0
+    }
+
+    #[inline]
+    fn to_i8() -> i8 {
+        0
+    }
+    #[inline]
+    fn to_i16() -> i16 {
+        0
+    }
+    #[inline]
+    fn to_i32() -> i32 {
+        0
+    }
+    #[inline]
+    fn to_i64() -> i64 {
+        0
+    }
+    #[cfg(feature="i128")]
+    #[inline]
+    fn to_i128() -> i128 {
+        0
+    }
+    #[inline]
+    fn to_isize() -> isize {
+        0
+    }
+}
+
+/// `UInt` is defined recursively, where `B` is the least significant bit and `U` is the rest
+/// of the number. Conceptually, `U` should be bound by the trait `Unsigned` and `B` should
+/// be bound by the trait `Bit`, but enforcing these bounds causes linear instead of
+/// logrithmic scaling in some places, so they are left off for now. They may be enforced in
+/// future.
+///
+/// In order to keep numbers unique, leading zeros are not allowed, so `UInt<UTerm, B0>` is
+/// forbidden.
+///
+/// # Example
+/// ```rust
+/// use typenum::{B0, B1, UInt, UTerm};
+///
+/// # #[allow(dead_code)]
+/// type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
+/// ```
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
+pub struct UInt<U, B> {
+    _marker: PhantomData<(U, B)>,
+}
+
+impl<U: Unsigned, B: Bit> UInt<U, B> {
+    /// Instantiates a singleton representing this unsigned integer.
+    #[inline]
+    pub fn new() -> UInt<U, B> {
+        UInt { _marker: PhantomData }
+    }
+}
+
+
+impl<U: Unsigned, B: Bit> Unsigned for UInt<U, B> {
+    #[inline]
+    fn to_u8() -> u8 {
+        B::to_u8() | U::to_u8() << 1
+    }
+    #[inline]
+    fn to_u16() -> u16 {
+        B::to_u8() as u16 | U::to_u16() << 1
+    }
+    #[inline]
+    fn to_u32() -> u32 {
+        B::to_u8() as u32 | U::to_u32() << 1
+    }
+    #[inline]
+    fn to_u64() -> u64 {
+        B::to_u8() as u64 | U::to_u64() << 1
+    }
+    #[cfg(feature="i128")]
+    #[inline]
+    fn to_u128() -> u128 {
+        B::to_u8() as u128 | U::to_u128() << 1
+    }
+    #[inline]
+    fn to_usize() -> usize {
+        B::to_u8() as usize | U::to_usize() << 1
+    }
+
+    #[inline]
+    fn to_i8() -> i8 {
+        B::to_u8() as i8 | U::to_i8() << 1
+    }
+    #[inline]
+    fn to_i16() -> i16 {
+        B::to_u8() as i16 | U::to_i16() << 1
+    }
+    #[inline]
+    fn to_i32() -> i32 {
+        B::to_u8() as i32 | U::to_i32() << 1
+    }
+    #[inline]
+    fn to_i64() -> i64 {
+        B::to_u8() as i64 | U::to_i64() << 1
+    }
+    #[cfg(feature="i128")]
+    #[inline]
+    fn to_i128() -> i128 {
+        B::to_u8() as i128 | U::to_i128() << 1
+    }
+    #[inline]
+    fn to_isize() -> isize {
+        B::to_u8() as isize | U::to_isize() << 1
+    }
+}
+
+impl<U: Unsigned, B: Bit> NonZero for UInt<U, B> {}
+
+// macro for testing operation results. Uses `Same` to ensure the types are equal and
+// not just the values they evaluate to.
+macro_rules! test_uint_op {
+    ($op:ident $Lhs:ident = $Answer:ident) => (
+        {
+            type Test = <<$Lhs as $op>::Output as ::Same<$Answer>>::Output;
+            assert_eq!(<$Answer as Unsigned>::to_u64(), <Test as Unsigned>::to_u64());
+        }
+        );
+    ($Lhs:ident $op:ident $Rhs:ident = $Answer:ident) => (
+        {
+            type Test = <<$Lhs as $op<$Rhs>>::Output as ::Same<$Answer>>::Output;
+            assert_eq!(<$Answer as Unsigned>::to_u64(), <Test as Unsigned>::to_u64());
+        }
+        );
+}
+
+// ---------------------------------------------------------------------------------------
+// Getting length of unsigned integers, which is defined as the number of bits before `UTerm`
+
+/// Length of `UTerm` by itself is 0
+impl Len for UTerm {
+    type Output = U0;
+    fn len(&self) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Length of a bit is 1
+impl<U: Unsigned, B: Bit> Len for UInt<U, B>
+    where U: Len,
+          Length<U>: Add<B1>,
+          Add1<Length<U>>: Unsigned
+{
+    type Output = Add1<Length<U>>;
+    fn len(&self) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Adding bits to unsigned integers
+
+/// `UTerm + B0 = UTerm`
+impl Add<B0> for UTerm {
+    type Output = UTerm;
+    fn add(self, _: B0) -> Self::Output {
+        UTerm
+    }
+}
+
+/// `U + B0 = U`
+impl<U: Unsigned, B: Bit> Add<B0> for UInt<U, B> {
+    type Output = UInt<U, B>;
+    fn add(self, _: B0) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// `UTerm + B1 = UInt<UTerm, B1>`
+impl Add<B1> for UTerm {
+    type Output = UInt<UTerm, B1>;
+    fn add(self, _: B1) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// `UInt<U, B0> + B1 = UInt<U + B1>`
+impl<U: Unsigned> Add<B1> for UInt<U, B0> {
+    type Output = UInt<U, B1>;
+    fn add(self, _: B1) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// `UInt<U, B1> + B1 = UInt<U + B1, B0>`
+impl<U: Unsigned> Add<B1> for UInt<U, B1>
+    where U: Add<B1>,
+          Add1<U>: Unsigned
+{
+    type Output = UInt<Add1<U>, B0>;
+    fn add(self, _: B1) -> Self::Output {
+        UInt::new()
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Adding unsigned integers
+
+/// `UTerm + U = U`
+impl<U: Unsigned> Add<U> for UTerm {
+    type Output = U;
+    fn add(self, _: U) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UInt<U, B> + UTerm = UInt<U, B>`
+impl<U: Unsigned, B: Bit> Add<UTerm> for UInt<U, B> {
+    type Output = UInt<U, B>;
+    fn add(self, _: UTerm) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// `UInt<Ul, B0> + UInt<Ur, B0> = UInt<Ul + Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B0>
+    where Ul: Add<Ur>
+{
+    type Output = UInt<Sum<Ul, Ur>, B0>;
+    fn add(self, _: UInt<Ur, B0>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UInt<Ul, B0> + UInt<Ur, B1> = UInt<Ul + Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B0>
+    where Ul: Add<Ur>
+{
+    type Output = UInt<Sum<Ul, Ur>, B1>;
+    fn add(self, _: UInt<Ur, B1>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B1>
+    where Ul: Add<Ur>
+{
+    type Output = UInt<Sum<Ul, Ur>, B1>;
+    fn add(self, _: UInt<Ur, B0>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UInt<Ul, B1> + UInt<Ur, B1> = UInt<(Ul + Ur) + B1, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B1>
+    where Ul: Add<Ur>,
+          Sum<Ul, Ur>: Add<B1>
+{
+    type Output = UInt<Add1<Sum<Ul, Ur>>, B0>;
+    fn add(self, _: UInt<Ur, B1>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Subtracting bits from unsigned integers
+
+/// `UTerm - B0 = Term`
+impl Sub<B0> for UTerm {
+    type Output = UTerm;
+    fn sub(self, _: B0) -> Self::Output {
+        UTerm
+    }
+}
+
+/// `UInt - B0 = UInt`
+impl<U: Unsigned, B: Bit> Sub<B0> for UInt<U, B> {
+    type Output = UInt<U, B>;
+    fn sub(self, _: B0) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// `UInt<U, B1> - B1 = UInt<U, B0>`
+impl<U: Unsigned, B: Bit> Sub<B1> for UInt<UInt<U, B>, B1> {
+    type Output = UInt<UInt<U, B>, B0>;
+    fn sub(self, _: B1) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// `UInt<UTerm, B1> - B1 = UTerm`
+impl Sub<B1> for UInt<UTerm, B1> {
+    type Output = UTerm;
+    fn sub(self, _: B1) -> Self::Output {
+        UTerm
+    }
+}
+
+/// `UInt<U, B0> - B1 = UInt<U - B1, B1>`
+impl<U: Unsigned> Sub<B1> for UInt<U, B0>
+    where U: Sub<B1>,
+          Sub1<U>: Unsigned
+{
+    type Output = UInt<Sub1<U>, B1>;
+    fn sub(self, _: B1) -> Self::Output {
+        UInt::new()
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Subtracting unsigned integers
+
+/// `UTerm - UTerm = UTerm`
+impl Sub<UTerm> for UTerm {
+    type Output = UTerm;
+    fn sub(self, _: UTerm) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Subtracting unsigned integers. We just do our `PrivateSub` and then `Trim` the output.
+impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> Sub<Ur> for UInt<Ul, Bl>
+    where UInt<Ul, Bl>: PrivateSub<Ur>,
+          PrivateSubOut<UInt<Ul, Bl>, Ur>: Trim
+{
+    type Output = TrimOut<PrivateSubOut<UInt<Ul, Bl>, Ur>>;
+    fn sub(self, _: Ur) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `U - UTerm = U`
+impl<U: Unsigned> PrivateSub<UTerm> for U {
+    type Output = U;
+}
+
+/// `UInt<Ul, B0> - UInt<Ur, B0> = UInt<Ul - Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateSub<UInt<Ur, B0>> for UInt<Ul, B0>
+    where Ul: PrivateSub<Ur>
+{
+    type Output = UInt<PrivateSubOut<Ul, Ur>, B0>;
+}
+
+/// `UInt<Ul, B0> - UInt<Ur, B1> = UInt<(Ul - Ur) - B1, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateSub<UInt<Ur, B1>> for UInt<Ul, B0>
+    where Ul: PrivateSub<Ur>,
+          PrivateSubOut<Ul, Ur>: Sub<B1>
+{
+    type Output = UInt<Sub1<PrivateSubOut<Ul, Ur>>, B1>;
+}
+
+/// `UInt<Ul, B1> - UInt<Ur, B0> = UInt<Ul - Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateSub<UInt<Ur, B0>> for UInt<Ul, B1>
+    where Ul: PrivateSub<Ur>
+{
+    type Output = UInt<PrivateSubOut<Ul, Ur>, B1>;
+}
+
+/// `UInt<Ul, B1> - UInt<Ur, B1> = UInt<Ul - Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateSub<UInt<Ur, B1>> for UInt<Ul, B1>
+    where Ul: PrivateSub<Ur>
+{
+    type Output = UInt<PrivateSubOut<Ul, Ur>, B0>;
+}
+
+// ---------------------------------------------------------------------------------------
+// And unsigned integers
+
+/// 0 & X = 0
+impl<Ur: Unsigned> BitAnd<Ur> for UTerm {
+    type Output = UTerm;
+    fn bitand(self, _: Ur) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Anding unsigned integers.
+/// We use our `PrivateAnd` operator and then `Trim` the output.
+impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> BitAnd<Ur> for UInt<Ul, Bl>
+    where UInt<Ul, Bl>: PrivateAnd<Ur>,
+          PrivateAndOut<UInt<Ul, Bl>, Ur>: Trim
+{
+    type Output = TrimOut<PrivateAndOut<UInt<Ul, Bl>, Ur>>;
+    fn bitand(self, _: Ur) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UTerm & X = UTerm`
+impl<U: Unsigned> PrivateAnd<U> for UTerm {
+    type Output = UTerm;
+}
+
+/// `X & UTerm = UTerm`
+impl<B: Bit, U: Unsigned> PrivateAnd<UTerm> for UInt<U, B> {
+    type Output = UTerm;
+}
+
+/// `UInt<Ul, B0> & UInt<Ur, B0> = UInt<Ul & Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateAnd<UInt<Ur, B0>> for UInt<Ul, B0>
+    where Ul: PrivateAnd<Ur>
+{
+    type Output = UInt<PrivateAndOut<Ul, Ur>, B0>;
+}
+
+/// `UInt<Ul, B0> & UInt<Ur, B1> = UInt<Ul & Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateAnd<UInt<Ur, B1>> for UInt<Ul, B0>
+    where Ul: PrivateAnd<Ur>
+{
+    type Output = UInt<PrivateAndOut<Ul, Ur>, B0>;
+}
+
+/// `UInt<Ul, B1> & UInt<Ur, B0> = UInt<Ul & Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateAnd<UInt<Ur, B0>> for UInt<Ul, B1>
+    where Ul: PrivateAnd<Ur>
+{
+    type Output = UInt<PrivateAndOut<Ul, Ur>, B0>;
+}
+
+/// `UInt<Ul, B1> & UInt<Ur, B1> = UInt<Ul & Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateAnd<UInt<Ur, B1>> for UInt<Ul, B1>
+    where Ul: PrivateAnd<Ur>
+{
+    type Output = UInt<PrivateAndOut<Ul, Ur>, B1>;
+}
+
+// ---------------------------------------------------------------------------------------
+// Or unsigned integers
+
+/// `UTerm | X = X`
+impl<U: Unsigned> BitOr<U> for UTerm {
+    type Output = U;
+    fn bitor(self, _: U) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+///  `X | UTerm = X`
+impl<B: Bit, U: Unsigned> BitOr<UTerm> for UInt<U, B> {
+    type Output = Self;
+    fn bitor(self, _: UTerm) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// `UInt<Ul, B0> | UInt<Ur, B0> = UInt<Ul | Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B0>
+    where Ul: BitOr<Ur>
+{
+    type Output = UInt<<Ul as BitOr<Ur>>::Output, B0>;
+    fn bitor(self, _: UInt<Ur, B0>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UInt<Ul, B0> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B0>
+    where Ul: BitOr<Ur>
+{
+    type Output = UInt<Or<Ul, Ur>, B1>;
+    fn bitor(self, _: UInt<Ur, B1>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UInt<Ul, B1> | UInt<Ur, B0> = UInt<Ul | Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B1>
+    where Ul: BitOr<Ur>
+{
+    type Output = UInt<Or<Ul, Ur>, B1>;
+    fn bitor(self, _: UInt<Ur, B0>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UInt<Ul, B1> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B1>
+    where Ul: BitOr<Ur>
+{
+    type Output = UInt<Or<Ul, Ur>, B1>;
+    fn bitor(self, _: UInt<Ur, B1>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Xor unsigned integers
+
+/// 0 ^ X = X
+impl<Ur: Unsigned> BitXor<Ur> for UTerm {
+    type Output = Ur;
+    fn bitxor(self, _: Ur) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// Xoring unsigned integers.
+/// We use our `PrivateXor` operator and then `Trim` the output.
+impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> BitXor<Ur> for UInt<Ul, Bl>
+    where UInt<Ul, Bl>: PrivateXor<Ur>,
+          PrivateXorOut<UInt<Ul, Bl>, Ur>: Trim
+{
+    type Output = TrimOut<PrivateXorOut<UInt<Ul, Bl>, Ur>>;
+    fn bitxor(self, _: Ur) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UTerm ^ X = X`
+impl<U: Unsigned> PrivateXor<U> for UTerm {
+    type Output = U;
+}
+
+/// `X ^ UTerm = X`
+impl<B: Bit, U: Unsigned> PrivateXor<UTerm> for UInt<U, B> {
+    type Output = Self;
+}
+
+/// `UInt<Ul, B0> ^ UInt<Ur, B0> = UInt<Ul ^ Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateXor<UInt<Ur, B0>> for UInt<Ul, B0>
+    where Ul: PrivateXor<Ur>
+{
+    type Output = UInt<PrivateXorOut<Ul, Ur>, B0>;
+}
+
+/// `UInt<Ul, B0> ^ UInt<Ur, B1> = UInt<Ul ^ Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateXor<UInt<Ur, B1>> for UInt<Ul, B0>
+    where Ul: PrivateXor<Ur>
+{
+    type Output = UInt<PrivateXorOut<Ul, Ur>, B1>;
+}
+
+/// `UInt<Ul, B1> ^ UInt<Ur, B0> = UInt<Ul ^ Ur, B1>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateXor<UInt<Ur, B0>> for UInt<Ul, B1>
+    where Ul: PrivateXor<Ur>
+{
+    type Output = UInt<PrivateXorOut<Ul, Ur>, B1>;
+}
+
+/// `UInt<Ul, B1> ^ UInt<Ur, B1> = UInt<Ul ^ Ur, B0>`
+impl<Ul: Unsigned, Ur: Unsigned> PrivateXor<UInt<Ur, B1>> for UInt<Ul, B1>
+    where Ul: PrivateXor<Ur>
+{
+    type Output = UInt<PrivateXorOut<Ul, Ur>, B0>;
+}
+
+// ---------------------------------------------------------------------------------------
+// Shl unsigned integers
+
+/// Shifting `UTerm` by a 0 bit: `UTerm << B0 = UTerm`
+impl Shl<B0> for UTerm {
+    type Output = UTerm;
+    fn shl(self, _: B0) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Shifting `UTerm` by a 1 bit: `UTerm << B1 = UTerm`
+impl Shl<B1> for UTerm {
+    type Output = UTerm;
+    fn shl(self, _: B1) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Shifting left any unsigned by a zero bit: `U << B0 = U`
+impl<U: Unsigned, B: Bit> Shl<B0> for UInt<U, B> {
+    type Output = UInt<U, B>;
+    fn shl(self, _: B0) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// Shifting left a `UInt` by a one bit: `UInt<U, B> << B1 = UInt<UInt<U, B>, B0>`
+impl<U: Unsigned, B: Bit> Shl<B1> for UInt<U, B> {
+    type Output = UInt<UInt<U, B>, B0>;
+    fn shl(self, _: B1) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// Shifting left `UInt` by `UTerm`: `UInt<U, B> << UTerm = UInt<U, B>`
+impl<U: Unsigned, B: Bit> Shl<UTerm> for UInt<U, B> {
+    type Output = UInt<U, B>;
+    fn shl(self, _: UTerm) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// Shifting left `UTerm` by an unsigned integer: `UTerm << U = UTerm`
+impl<U: Unsigned> Shl<U> for UTerm {
+    type Output = UTerm;
+    fn shl(self, _: U) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Shifting left `UInt` by `UInt`: `X << Y` = `UInt(X, B0) << (Y - 1)`
+impl<U: Unsigned, B: Bit, Ur: Unsigned, Br: Bit> Shl<UInt<Ur, Br>> for UInt<U, B>
+    where UInt<Ur, Br>: Sub<B1>,
+          UInt<UInt<U, B>, B0>: Shl<Sub1<UInt<Ur, Br>>>
+{
+    type Output = Shleft<UInt<UInt<U, B>, B0>, Sub1<UInt<Ur, Br>>>;
+    fn shl(self, _: UInt<Ur, Br>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Shr unsigned integers
+
+/// Shifting right a `UTerm` by an unsigned integer: `UTerm >> U = UTerm`
+impl<U: Unsigned> Shr<U> for UTerm {
+    type Output = UTerm;
+    fn shr(self, _: U) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Shifting right `UInt` by `UTerm`: `UInt<U, B> >> UTerm = UInt<U, B>`
+impl<U: Unsigned, B: Bit> Shr<UTerm> for UInt<U, B> {
+    type Output = UInt<U, B>;
+    fn shr(self, _: UTerm) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// Shifting right `UTerm` by a 0 bit: `UTerm >> B0 = UTerm`
+impl Shr<B0> for UTerm {
+    type Output = UTerm;
+    fn shr(self, _: B0) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Shifting right `UTerm` by a 1 bit: `UTerm >> B1 = UTerm`
+impl Shr<B1> for UTerm {
+    type Output = UTerm;
+    fn shr(self, _: B1) -> Self::Output {
+        UTerm
+    }
+}
+
+/// Shifting right any unsigned by a zero bit: `U >> B0 = U`
+impl<U: Unsigned, B: Bit> Shr<B0> for UInt<U, B> {
+    type Output = UInt<U, B>;
+    fn shr(self, _: B0) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// Shifting right a `UInt` by a 1 bit: `UInt<U, B> >> B1 = U`
+impl<U: Unsigned, B: Bit> Shr<B1> for UInt<U, B> {
+    type Output = U;
+    fn shr(self, _: B1) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// Shifting right `UInt` by `UInt`: `UInt(U, B) >> Y` = `U >> (Y - 1)`
+impl<U: Unsigned, B: Bit, Ur: Unsigned, Br: Bit> Shr<UInt<Ur, Br>> for UInt<U, B>
+    where UInt<Ur, Br>: Sub<B1>,
+          U: Shr<Sub1<UInt<Ur, Br>>>
+{
+    type Output = Shright<U, Sub1<UInt<Ur, Br>>>;
+    fn shr(self, _: UInt<Ur, Br>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Multiply unsigned integers
+
+/// `UInt * B0 = UTerm`
+impl<U: Unsigned, B: Bit> Mul<B0> for UInt<U, B> {
+    type Output = UTerm;
+    fn mul(self, _: B0) -> Self::Output {
+        UTerm
+    }
+}
+
+/// `UTerm * B0 = UTerm`
+impl Mul<B0> for UTerm {
+    type Output = UTerm;
+    fn mul(self, _: B0) -> Self::Output {
+        UTerm
+    }
+}
+
+/// `UTerm * B1 = UTerm`
+impl Mul<B1> for UTerm {
+    type Output = UTerm;
+    fn mul(self, _: B1) -> Self::Output {
+        UTerm
+    }
+}
+
+/// `UInt * B1 = UInt`
+impl<U: Unsigned, B: Bit> Mul<B1> for UInt<U, B> {
+    type Output = UInt<U, B>;
+    fn mul(self, _: B1) -> Self::Output {
+        UInt::new()
+    }
+}
+
+/// `UInt<U, B> * UTerm = UTerm`
+impl<U: Unsigned, B: Bit> Mul<UTerm> for UInt<U, B> {
+    type Output = UTerm;
+    fn mul(self, _: UTerm) -> Self::Output {
+        UTerm
+    }
+}
+
+/// `UTerm * U = UTerm`
+impl<U: Unsigned> Mul<U> for UTerm {
+    type Output = UTerm;
+    fn mul(self, _: U) -> Self::Output {
+        UTerm
+    }
+}
+
+/// `UInt<Ul, B0> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0>`
+impl<Ul: Unsigned, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B0>
+    where Ul: Mul<UInt<Ur, B>>
+{
+    type Output = UInt<Prod<Ul, UInt<Ur, B>>, B0>;
+    fn mul(self, _: UInt<Ur, B>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+/// `UInt<Ul, B1> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0> + UInt<Ur, B>`
+impl<Ul: Unsigned, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B1>
+    where Ul: Mul<UInt<Ur, B>>,
+          UInt<Prod<Ul, UInt<Ur, B>>, B0>: Add<UInt<Ur, B>>
+{
+    type Output = Sum<UInt<Prod<Ul, UInt<Ur, B>>, B0>, UInt<Ur, B>>;
+    fn mul(self, _: UInt<Ur, B>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// Compare unsigned integers
+
+/// Zero == Zero
+impl Cmp<UTerm> for UTerm {
+    type Output = Equal;
+}
+
+/// Nonzero > Zero
+impl<U: Unsigned, B: Bit> Cmp<UTerm> for UInt<U, B> {
+    type Output = Greater;
+}
+
+/// Zero < Nonzero
+impl<U: Unsigned, B: Bit> Cmp<UInt<U, B>> for UTerm {
+    type Output = Less;
+}
+
+/// `UInt<Ul, B0>` cmp with `UInt<Ur, B0>`: `SoFar` is `Equal`
+impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B0>
+    where Ul: PrivateCmp<Ur, Equal>
+{
+    type Output = PrivateCmpOut<Ul, Ur, Equal>;
+}
+
+/// `UInt<Ul, B1>` cmp with `UInt<Ur, B1>`: `SoFar` is `Equal`
+impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B1>
+    where Ul: PrivateCmp<Ur, Equal>
+{
+    type Output = PrivateCmpOut<Ul, Ur, Equal>;
+}
+
+/// `UInt<Ul, B0>` cmp with `UInt<Ur, B1>`: `SoFar` is `Less`
+impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B0>
+    where Ul: PrivateCmp<Ur, Less>
+{
+    type Output = PrivateCmpOut<Ul, Ur, Less>;
+}
+
+/// `UInt<Ul, B1>` cmp with `UInt<Ur, B0>`: `SoFar` is `Greater`
+impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B1>
+    where Ul: PrivateCmp<Ur, Greater>
+{
+    type Output = PrivateCmpOut<Ul, Ur, Greater>;
+}
+
+/// Comparing non-terimal bits, with both having bit `B0`.
+/// These are `Equal`, so we propogate `SoFar`.
+impl<Ul, Ur, SoFar> PrivateCmp<UInt<Ur, B0>, SoFar> for UInt<Ul, B0>
+    where Ul: Unsigned,
+          Ur: Unsigned,
+          SoFar: Ord,
+          Ul: PrivateCmp<Ur, SoFar>
+{
+    type Output = PrivateCmpOut<Ul, Ur, SoFar>;
+}
+
+/// Comparing non-terimal bits, with both having bit `B1`.
+/// These are `Equal`, so we propogate `SoFar`.
+impl<Ul, Ur, SoFar> PrivateCmp<UInt<Ur, B1>, SoFar> for UInt<Ul, B1>
+    where Ul: Unsigned,
+          Ur: Unsigned,
+          SoFar: Ord,
+          Ul: PrivateCmp<Ur, SoFar>
+{
+    type Output = PrivateCmpOut<Ul, Ur, SoFar>;
+}
+
+/// Comparing non-terimal bits, with `Lhs` having bit `B0` and `Rhs` having bit `B1`.
+/// `SoFar`, Lhs is `Less`.
+impl<Ul, Ur, SoFar> PrivateCmp<UInt<Ur, B1>, SoFar> for UInt<Ul, B0>
+    where Ul: Unsigned,
+          Ur: Unsigned,
+          SoFar: Ord,
+          Ul: PrivateCmp<Ur, Less>
+{
+    type Output = PrivateCmpOut<Ul, Ur, Less>;
+}
+
+/// Comparing non-terimal bits, with `Lhs` having bit `B1` and `Rhs` having bit `B0`.
+/// `SoFar`, Lhs is `Greater`.
+impl<Ul, Ur, SoFar> PrivateCmp<UInt<Ur, B0>, SoFar> for UInt<Ul, B1>
+    where Ul: Unsigned,
+          Ur: Unsigned,
+          SoFar: Ord,
+          Ul: PrivateCmp<Ur, Greater>
+{
+    type Output = PrivateCmpOut<Ul, Ur, Greater>;
+}
+
+/// Got to the end of just the `Lhs`. It's `Less`.
+impl<U: Unsigned, B: Bit, SoFar: Ord> PrivateCmp<UInt<U, B>, SoFar> for UTerm {
+    type Output = Less;
+}
+
+/// Got to the end of just the `Rhs`. `Lhs` is `Greater`.
+impl<U: Unsigned, B: Bit, SoFar: Ord> PrivateCmp<UTerm, SoFar> for UInt<U, B> {
+    type Output = Greater;
+}
+
+/// Got to the end of both! Return `SoFar`
+impl<SoFar: Ord> PrivateCmp<UTerm, SoFar> for UTerm {
+    type Output = SoFar;
+}
+
+macro_rules! test_ord {
+    ($Lhs:ident > $Rhs:ident) => (
+        {
+            type Test = <$Lhs as Cmp<$Rhs>>::Output;
+            assert_eq!(::core::cmp::Ordering::Greater, <Test as Ord>::to_ordering());
+        }
+        );
+    ($Lhs:ident == $Rhs:ident) => (
+        {
+            type Test = <$Lhs as Cmp<$Rhs>>::Output;
+            assert_eq!(::core::cmp::Ordering::Equal, <Test as Ord>::to_ordering());
+        }
+        );
+    ($Lhs:ident < $Rhs:ident) => (
+        {
+            type Test = <$Lhs as Cmp<$Rhs>>::Output;
+            assert_eq!(::core::cmp::Ordering::Less, <Test as Ord>::to_ordering());
+        }
+    );
+}
+
+// ---------------------------------------------------------------------------------------
+// Getting difference in number of bits
+
+impl<Ul, Bl, Ur, Br> BitDiff<UInt<Ur, Br>> for UInt<Ul, Bl>
+    where Ul: Unsigned,
+          Bl: Bit,
+          Ur: Unsigned,
+          Br: Bit,
+          Ul: BitDiff<Ur>
+{
+    type Output = BitDiffOut<Ul, Ur>;
+}
+
+impl<Ul> BitDiff<UTerm> for Ul
+    where Ul: Unsigned + Len
+{
+    type Output = Length<Ul>;
+}
+
+// ---------------------------------------------------------------------------------------
+// Shifting one number until it's the size of another
+use private::ShiftDiff;
+impl<Ul: Unsigned, Ur: Unsigned> ShiftDiff<Ur> for Ul
+    where Ur: BitDiff<Ul>,
+          Ul: Shl<BitDiffOut<Ur, Ul>>
+{
+    type Output = Shleft<Ul, BitDiffOut<Ur, Ul>>;
+}
+
+// ---------------------------------------------------------------------------------------
+// Powers of unsigned integers
+
+/// X^N
+impl<X: Unsigned, N: Unsigned> Pow<N> for X
+    where X: PrivatePow<U1, N>
+{
+    type Output = PrivatePowOut<X, U1, N>;
+    fn powi(self, _: N) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+impl<Y: Unsigned, X: Unsigned> PrivatePow<Y, U0> for X {
+    type Output = Y;
+}
+
+impl<Y: Unsigned, X: Unsigned> PrivatePow<Y, U1> for X
+    where X: Mul<Y>
+{
+    type Output = Prod<X, Y>;
+}
+
+/// N is even
+impl<Y: Unsigned, U: Unsigned, B: Bit, X: Unsigned> PrivatePow<Y, UInt<UInt<U, B>, B0>> for X
+    where X: Mul,
+          Square<X>: PrivatePow<Y, UInt<U, B>>
+{
+    type Output = PrivatePowOut<Square<X>, Y, UInt<U, B>>;
+}
+
+/// N is odd
+impl<Y: Unsigned, U: Unsigned, B: Bit, X: Unsigned> PrivatePow<Y, UInt<UInt<U, B>, B1>> for X
+    where X: Mul + Mul<Y>,
+          Square<X>: PrivatePow<Prod<X, Y>, UInt<U, B>>
+{
+    type Output = PrivatePowOut<Square<X>, Prod<X, Y>, UInt<U, B>>;
+}
+
+// -----------------------------------------
+// GetBit
+
+#[allow(missing_docs)]
+pub trait GetBit<I> {
+    #[allow(missing_docs)]
+    type Output;
+}
+
+#[allow(missing_docs)]
+pub type GetBitOut<N, I> = <N as GetBit<I>>::Output;
+
+// Base case
+impl<Un, Bn> GetBit<U0> for UInt<Un, Bn> {
+    type Output = Bn;
+}
+
+// Recursion case
+impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn>
+    where UInt<Ui, Bi>: Sub<B1>,
+          Un: GetBit<Sub1<UInt<Ui, Bi>>>
+{
+    type Output = GetBitOut<Un, Sub1<UInt<Ui, Bi>>>;
+}
+
+// Ran out of bits
+impl<I> GetBit<I> for UTerm {
+    type Output = B0;
+}
+
+#[test]
+fn test_get_bit() {
+    use consts::*;
+    use Same;
+    type T1 = <GetBitOut<U2, U0> as Same<B0>>::Output;
+    type T2 = <GetBitOut<U2, U1> as Same<B1>>::Output;
+    type T3 = <GetBitOut<U2, U2> as Same<B0>>::Output;
+
+    <T1 as Bit>::to_bool();
+    <T2 as Bit>::to_bool();
+    <T3 as Bit>::to_bool();
+}
+
+
+// -----------------------------------------
+// SetBit
+
+/// A **type operator** that, when implemented for unsigned integer `N`, sets the bit at position
+/// `I` to `B`.
+pub trait SetBit<I, B> {
+    #[allow(missing_docs)]
+    type Output;
+}
+/// Alias for the result of calling `SetBit`: `SetBitOut<N, I, B> = <N as SetBit<I, B>>::Output`.
+pub type SetBitOut<N, I, B> = <N as SetBit<I, B>>::Output;
+
+use private::{PrivateSetBit, PrivateSetBitOut};
+
+// Call private one then trim it
+impl<N, I, B> SetBit<I, B> for N
+    where N: PrivateSetBit<I, B>,
+          PrivateSetBitOut<N, I, B>: Trim
+{
+    type Output = TrimOut<PrivateSetBitOut<N, I, B>>;
+}
+
+// Base case
+impl<Un, Bn, B> PrivateSetBit<U0, B> for UInt<Un, Bn> {
+    type Output = UInt<Un, B>;
+}
+
+// Recursion case
+impl<Un, Bn, Ui, Bi, B> PrivateSetBit<UInt<Ui, Bi>, B> for UInt<Un, Bn>
+    where UInt<Ui, Bi>: Sub<B1>,
+          Un: PrivateSetBit<Sub1<UInt<Ui, Bi>>, B>
+{
+    type Output = UInt<PrivateSetBitOut<Un, Sub1<UInt<Ui, Bi>>, B>, Bn>;
+}
+
+// Ran out of bits, setting B0
+impl<I> PrivateSetBit<I, B0> for UTerm {
+    type Output = UTerm;
+}
+
+// Ran out of bits, setting B1
+impl<I> PrivateSetBit<I, B1> for UTerm
+    where U1: Shl<I>
+{
+    type Output = Shleft<U1, I>;
+}
+
+#[test]
+fn test_set_bit() {
+    use consts::*;
+    use Same;
+    type T1 = <SetBitOut<U2, U0, B0> as Same<U2>>::Output;
+    type T2 = <SetBitOut<U2, U0, B1> as Same<U3>>::Output;
+    type T3 = <SetBitOut<U2, U1, B0> as Same<U0>>::Output;
+    type T4 = <SetBitOut<U2, U1, B1> as Same<U2>>::Output;
+    type T5 = <SetBitOut<U2, U2, B0> as Same<U2>>::Output;
+    type T6 = <SetBitOut<U2, U2, B1> as Same<U6>>::Output;
+    type T7 = <SetBitOut<U2, U3, B0> as Same<U2>>::Output;
+    type T8 = <SetBitOut<U2, U3, B1> as Same<U10>>::Output;
+    type T9 = <SetBitOut<U2, U4, B0> as Same<U2>>::Output;
+    type T10 = <SetBitOut<U2, U4, B1> as Same<U18>>::Output;
+
+    type T11 = <SetBitOut<U3, U0, B0> as Same<U2>>::Output;
+
+    <T1 as Unsigned>::to_u32();
+    <T2 as Unsigned>::to_u32();
+    <T3 as Unsigned>::to_u32();
+    <T4 as Unsigned>::to_u32();
+    <T5 as Unsigned>::to_u32();
+    <T6 as Unsigned>::to_u32();
+    <T7 as Unsigned>::to_u32();
+    <T8 as Unsigned>::to_u32();
+    <T9 as Unsigned>::to_u32();
+    <T10 as Unsigned>::to_u32();
+    <T11 as Unsigned>::to_u32();
+}
+
+// -----------------------------------------
+
+// Division algorithm:
+// We have N / D:
+// let Q = 0, R = 0
+// NBits = len(N)
+// for I in NBits-1..0:
+//   R <<=1
+//   R[0] = N[i]
+//   let C = R.cmp(D)
+//   if C == Equal or Greater:
+//     R -= D
+//     Q[i] = 1
+
+macro_rules! test_div {
+    ($a:ident / $b:ident = $c:ident) => (
+        {
+            type R = Quot<$a, $b>;
+            assert_eq!(<R as Unsigned>::to_usize(), $c::to_usize());
+        }
+    );
+}
+#[test]
+fn test_div() {
+    use consts::*;
+    use {Quot, Same};
+
+    test_div!(U0 / U1 = U0);
+    test_div!(U1 / U1 = U1);
+    test_div!(U2 / U1 = U2);
+    test_div!(U3 / U1 = U3);
+    test_div!(U4 / U1 = U4);
+
+    test_div!(U0 / U2 = U0);
+    test_div!(U1 / U2 = U0);
+    test_div!(U2 / U2 = U1);
+    test_div!(U3 / U2 = U1);
+    test_div!(U4 / U2 = U2);
+    test_div!(U6 / U2 = U3);
+    test_div!(U7 / U2 = U3);
+
+    type T = <SetBitOut<U0, U1, B1> as Same<U2>>::Output;
+    <T as Unsigned>::to_u32();
+}
+
+// -----------------------------------------
+// Div
+use core::ops::Div;
+
+// 0 // N
+impl<Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UTerm {
+    type Output = UTerm;
+    fn div(self, _: UInt<Ur, Br>) -> Self::Output {
+        UTerm
+    }
+}
+
+// M // N
+impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UInt<Ul, Bl>
+    where UInt<Ul, Bl>: Len,
+          Length<UInt<Ul, Bl>>: Sub<B1>,
+          (): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>
+{
+    type Output = PrivateDivQuot<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>;
+    fn div(self, _: UInt<Ur, Br>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// -----------------------------------------
+// Rem
+use core::ops::Rem;
+
+// 0 % N
+impl<Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UTerm {
+    type Output = UTerm;
+    fn rem(self, _: UInt<Ur, Br>) -> Self::Output {
+        UTerm
+    }
+}
+
+// M % N
+impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UInt<Ul, Bl>
+    where UInt<Ul, Bl>: Len,
+          Length<UInt<Ul, Bl>>: Sub<B1>,
+          (): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>
+{
+    type Output = PrivateDivRem<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>;
+    fn rem(self, _: UInt<Ur, Br>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+
+// -----------------------------------------
+// PrivateDiv
+use private::{PrivateDiv, PrivateDivQuot, PrivateDivRem};
+
+use Compare;
+// R == 0: We set R = UInt<UTerm, N[i]>, then call out to PrivateDivIf for the if statement
+impl<N, D, Q, I> PrivateDiv<N, D, Q, U0, I> for ()
+    where N: GetBit<I>,
+          UInt<UTerm, GetBitOut<N, I>>: Trim,
+          TrimOut<UInt<UTerm, GetBitOut<N, I>>>: Cmp<D>,
+          (): PrivateDivIf<N,
+                           D,
+                           Q,
+                           TrimOut<UInt<UTerm, GetBitOut<N, I>>>,
+                           I,
+                           Compare<TrimOut<UInt<UTerm, GetBitOut<N, I>>>, D>>
+{
+    type Quotient = PrivateDivIfQuot<N,
+                     D,
+                     Q,
+                     TrimOut<UInt<UTerm, GetBitOut<N, I>>>,
+                     I,
+                     Compare<TrimOut<UInt<UTerm, GetBitOut<N, I>>>, D>>;
+    type Remainder = PrivateDivIfRem<N,
+                    D,
+                    Q,
+                    TrimOut<UInt<UTerm, GetBitOut<N, I>>>,
+                    I,
+                    Compare<TrimOut<UInt<UTerm, GetBitOut<N, I>>>, D>>;
+}
+
+// R > 0: We perform R <<= 1 and R[0] = N[i], then call out to PrivateDivIf for the if statement
+impl<N, D, Q, Ur, Br, I> PrivateDiv<N, D, Q, UInt<Ur, Br>, I> for ()
+    where N: GetBit<I>,
+          UInt<UInt<Ur, Br>, GetBitOut<N, I>>: Cmp<D>,
+          (): PrivateDivIf<N,
+                           D,
+                           Q,
+                           UInt<UInt<Ur, Br>, GetBitOut<N, I>>,
+                           I,
+                           Compare<UInt<UInt<Ur, Br>, GetBitOut<N, I>>, D>>
+{
+    type Quotient = PrivateDivIfQuot<N,
+                     D,
+                     Q,
+                     UInt<UInt<Ur, Br>, GetBitOut<N, I>>,
+                     I,
+                     Compare<UInt<UInt<Ur, Br>, GetBitOut<N, I>>, D>>;
+    type Remainder = PrivateDivIfRem<N,
+                    D,
+                    Q,
+                    UInt<UInt<Ur, Br>, GetBitOut<N, I>>,
+                    I,
+                    Compare<UInt<UInt<Ur, Br>, GetBitOut<N, I>>, D>>;
+}
+
+// -----------------------------------------
+// PrivateDivIf
+
+use private::{PrivateDivIf, PrivateDivIfQuot, PrivateDivIfRem};
+
+// R < D, I > 0, we do nothing and recurse
+impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Less> for ()
+    where UInt<Ui, Bi>: Sub<B1>,
+          (): PrivateDiv<N, D, Q, R, Sub1<UInt<Ui, Bi>>>
+{
+    type Quotient = PrivateDivQuot<N, D, Q, R, Sub1<UInt<Ui, Bi>>>;
+    type Remainder = PrivateDivRem<N, D, Q, R, Sub1<UInt<Ui, Bi>>>;
+}
+
+// R == D, I > 0, we set R = 0, Q[I] = 1 and recurse
+impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Equal> for ()
+    where UInt<Ui, Bi>: Sub<B1>,
+          Q: SetBit<UInt<Ui, Bi>, B1>,
+          (): PrivateDiv<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, U0, Sub1<UInt<Ui, Bi>>>
+{
+    type Quotient = PrivateDivQuot<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, U0, Sub1<UInt<Ui, Bi>>>;
+    type Remainder = PrivateDivRem<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, U0, Sub1<UInt<Ui, Bi>>>;
+}
+
+use Diff;
+// R > D, I > 0, we set R -= D, Q[I] = 1 and recurse
+impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Greater> for ()
+    where UInt<Ui, Bi>: Sub<B1>,
+          R: Sub<D>,
+          Q: SetBit<UInt<Ui, Bi>, B1>,
+          (): PrivateDiv<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, Diff<R, D>, Sub1<UInt<Ui, Bi>>>
+{
+    type Quotient = PrivateDivQuot<N,
+                   D,
+                   SetBitOut<Q, UInt<Ui, Bi>, B1>,
+                   Diff<R, D>,
+                   Sub1<UInt<Ui, Bi>>>;
+    type Remainder = PrivateDivRem<N,
+                  D,
+                  SetBitOut<Q, UInt<Ui, Bi>, B1>,
+                  Diff<R, D>,
+                  Sub1<UInt<Ui, Bi>>>;
+}
+
+// R < D, I == 0: we do nothing, and return
+impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, U0, Less> for () {
+    type Quotient = Q;
+    type Remainder = R;
+}
+
+// R == D, I == 0: we set R = 0, Q[I] = 1, and return
+impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, U0, Equal> for ()
+    where Q: SetBit<U0, B1>
+{
+    type Quotient = SetBitOut<Q, U0, B1>;
+    type Remainder = U0;
+}
+
+// R > D, I == 0: We set R -= D, Q[I] = 1, and return
+impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, U0, Greater> for ()
+    where R: Sub<D>,
+          Q: SetBit<U0, B1>
+{
+    type Quotient = SetBitOut<Q, U0, B1>;
+    type Remainder = Diff<R, D>;
+}
+
+// -----------------------------------------
+// PartialDiv
+use {PartialDiv, Quot};
+impl<Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UTerm {
+    type Output = UTerm;
+    fn partial_div(self, _: UInt<Ur, Br>) -> Self::Output {
+        UTerm
+    }
+}
+
+// M / N
+impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UInt<Ul, Bl>
+    where UInt<Ul, Bl>: Div<UInt<Ur, Br>> + Rem<UInt<Ur, Br>, Output = U0>
+{
+    type Output = Quot<UInt<Ul, Bl>, UInt<Ur, Br>>;
+    fn partial_div(self, _: UInt<Ur, Br>) -> Self::Output {
+        unsafe { ::core::mem::uninitialized() }
+    }
+}
+
+// -----------------------------------------
+// PrivateMin
+use private::{PrivateMin, PrivateMinOut};
+
+impl<U, B, Ur> PrivateMin<Ur, Equal> for UInt<U, B>
+    where Ur: Unsigned,
+          U: Unsigned,
+          B: Bit
+{
+    type Output = UInt<U, B>;
+    fn private_min(self, _: Ur) -> Self::Output {
+        self
+    }
+}
+
+impl<U, B, Ur> PrivateMin<Ur, Less> for UInt<U, B>
+    where Ur: Unsigned,
+          U: Unsigned,
+          B: Bit
+{
+    type Output = UInt<U, B>;
+    fn private_min(self, _: Ur) -> Self::Output {
+        self
+    }
+}
+
+impl<U, B, Ur> PrivateMin<Ur, Greater> for UInt<U, B>
+    where Ur: Unsigned,
+          U: Unsigned,
+          B: Bit
+{
+    type Output = Ur;
+    fn private_min(self, rhs: Ur) -> Self::Output {
+        rhs
+    }
+}
+
+// -----------------------------------------
+// Min
+use Min;
+
+impl<U> Min<U> for UTerm
+    where U: Unsigned
+{
+    type Output = UTerm;
+    fn min(self, _: U) -> Self::Output {
+        self
+    }
+}
+
+impl<U, B, Ur> Min<Ur> for UInt<U, B>
+    where U: Unsigned,
+          B: Bit,
+          Ur: Unsigned,
+          UInt<U, B>: Cmp<Ur> + PrivateMin<Ur, Compare<UInt<U, B>, Ur>>
+{
+    type Output = PrivateMinOut<UInt<U, B>, Ur, Compare<UInt<U, B>, Ur>>;
+    fn min(self, rhs: Ur) -> Self::Output {
+        self.private_min(rhs)
+    }
+}
+
+// -----------------------------------------
+// PrivateMax
+use private::{PrivateMax, PrivateMaxOut};
+
+impl<U, B, Ur> PrivateMax<Ur, Equal> for UInt<U, B>
+    where Ur: Unsigned,
+          U: Unsigned,
+          B: Bit
+{
+    type Output = UInt<U, B>;
+    fn private_max(self, _: Ur) -> Self::Output {
+        self
+    }
+}
+
+impl<U, B, Ur> PrivateMax<Ur, Less> for UInt<U, B>
+    where Ur: Unsigned,
+          U: Unsigned,
+          B: Bit
+{
+    type Output = Ur;
+    fn private_max(self, rhs: Ur) -> Self::Output {
+        rhs
+    }
+}
+
+impl<U, B, Ur> PrivateMax<Ur, Greater> for UInt<U, B>
+    where Ur: Unsigned,
+          U: Unsigned,
+          B: Bit
+{
+    type Output = UInt<U, B>;
+    fn private_max(self, _: Ur) -> Self::Output {
+        self
+    }
+}
+
+// -----------------------------------------
+// Max
+use Max;
+
+impl<U> Max<U> for UTerm
+    where U: Unsigned
+{
+    type Output = U;
+    fn max(self, rhs: U) -> Self::Output {
+        rhs
+    }
+}
+
+impl<U, B, Ur> Max<Ur> for UInt<U, B>
+    where U: Unsigned,
+          B: Bit,
+          Ur: Unsigned,
+          UInt<U, B>: Cmp<Ur> + PrivateMax<Ur, Compare<UInt<U, B>, Ur>>
+{
+    type Output = PrivateMaxOut<UInt<U, B>, Ur, Compare<UInt<U, B>, Ur>>;
+    fn max(self, rhs: Ur) -> Self::Output {
+        self.private_max(rhs)
+    }
+}
diff --git a/crates/typenum-1.9.0/tests/test.rs b/crates/typenum-1.9.0/tests/test.rs
new file mode 100644
index 0000000..0471b27
--- /dev/null
+++ b/crates/typenum-1.9.0/tests/test.rs
@@ -0,0 +1 @@
+include!(concat!(env!("OUT_DIR"), "/tests.rs"));

_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits