[rust-crypto] Delete rust-crypto crate

rust-crypto is available in third_party/rust-mirrors/rust-crypto
We shouldn't keepe two instances of the same crate around.

Change-Id: I83bc391d7a06f695e6b876fec0b42ee272df998b
diff --git a/rustc_deps/Cargo.lock b/rustc_deps/Cargo.lock
index e39adc4..a9fc7d9 100644
--- a/rustc_deps/Cargo.lock
+++ b/rustc_deps/Cargo.lock
@@ -403,7 +403,7 @@
  "parking_lot 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "rouille 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rust-crypto 0.2.36",
  "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.43 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.43 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -989,7 +989,6 @@
 [[package]]
 name = "rust-crypto"
 version = "0.2.36"
-source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "gcc 0.3.54 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.40 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1571,7 +1570,6 @@
 "checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
 "checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
 "checksum rouille 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "cc1f8407af80b0630983b2c1f1860dda1960fdec8d3ee75ba8db14937756d3a0"
-"checksum rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)" = "f76d05d3993fd5f4af9434e8e436db163a12a9d40e1a58a726f27a01dfd12a2a"
 "checksum rustc-demangle 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11fb43a206a04116ffd7cfcf9bcb941f8eb6cc7ff667272246b0a1c74259a3cb"
 "checksum rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)" = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
 "checksum safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e27a8b19b835f7aea908818e871f5cc3a5a186550c30773be987e155e8163d8f"
diff --git a/rustc_deps/Cargo.toml b/rustc_deps/Cargo.toml
index 6392c57..dac3050 100644
--- a/rustc_deps/Cargo.toml
+++ b/rustc_deps/Cargo.toml
@@ -55,6 +55,7 @@
 backtrace-sys = { path = "tiny_mirrors/backtrace-sys" }
 fuchsia-zircon = { path = "../../../garnet/public/rust/crates/fuchsia-zircon" }
 fuchsia-zircon-sys = { path = "../../../garnet/public/rust/crates/fuchsia-zircon/fuchsia-zircon-sys" }
+rust-crypto = { path = "../../rust-mirrors/rust-crypto" }
 xi-core-lib = { path = "../../rust-mirrors/xi-editor/rust/core-lib" }
 xi-rope = { path = "../../rust-mirrors/xi-editor/rust/rope" }
 xi-rpc = { path = "../../rust-mirrors/xi-editor/rust/rpc" }
diff --git a/rustc_deps/vendor/rust-crypto/.cargo-checksum.json b/rustc_deps/vendor/rust-crypto/.cargo-checksum.json
deleted file mode 100644
index e43758e..0000000
--- a/rustc_deps/vendor/rust-crypto/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{".travis.yml":"5a9751380b0c3a7b895911bcaed279e169f8a3f485b23cf97a705d22dd9ff638","CHANGELOG.md":"64162af28314f332666a8302457a335a41b2b707c471d37443651ca96953ac04","Cargo.toml":"474b2fab942681ce20f4e861250fc103c6b485780e3f259d94777cf6dea6a55c","LICENSE-APACHE":"a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5","LICENSE-MIT":"52232c2cee3bb7d8cabe47ef367f1bf8bb607c22bdfca0219d6156cb7f446e9d","README.md":"2927163a1880c4ae49f34be0cb081d5cfab64424a08b35be67dced678067bc84","appveyor.yml":"168c328a68f50b4810207382ebe230f24ddbe646e807ba67edbe4ed49fc23a3e","build.rs":"cf493704500e75b1d086c06ba7eb4f7c194f48017fa07c47cb45b1b690998017","examples/symmetriccipher.rs":"7ecb181c9b485f68e88b01563888165f887349f010d0c359ff028ad93b2507b3","src/aead.rs":"1d3fee7f7a7b48bb902e1a7a45ce4d51072043e61bad36b06124b4c4b29e303d","src/aes.rs":"4a0dbb9fe774bc4c3237fc2a5a93baeaa0d75a715fd2c1a3e8ecd97f4ebab86f","src/aes_gcm.rs":"1fe2e5556df8d298a718e414536c3967f536521760e34ac12b2f9e0be8154317","src/aesni.rs":"115fa993e6aad86dd1fa261f1e3b52b73b03c0416b1e42ccbc4a23da80185056","src/aesni_helpers.asm":"fe504da11ab15120a8471e201970bc14584194e72a13b620b232890a2760e4c4","src/aesni_helpers.c":"a4e0d42c82196953c085052261d7c68afca1c8ef73c288643ae4741fbdcf335a","src/aessafe.rs":"450a0e541e911f89fde9b04a1babb66374916095db245850b9549fb194230d8c","src/api.rs":"1b24c3f919b9206ada38138bc9b601bd7767a3dfb46b00306359929b66744420","src/bcrypt.rs":"f82d063382a12eaf6a1ca39ca7be05625b0fba5abddf6c8ecc8f367764938226","src/bcrypt_pbkdf.rs":"392377c7fbf5d3cbc7c86b31c944cd4e179cbf5111b4f0780c257da4d5b4500d","src/blake2b.rs":"f9b31732e7d81591d4d3405a4be402fbf81048b44c4fbaecd9a4d417f09bf674","src/blake2s.rs":"7dd55a87e65fc4ff2471780c6ae7a9bd96c64e1b2653cbd5a70afe8bbfe001e0","src/blockmodes.rs":"ea71c1403727a3e40ae49b0253880333aa7356289e7a6087f1b4b6b990999bd3","src/blowfish.rs":"c054ce4272c2a02d23273ccc3067922089fd25cc4f3fabe3ac89bf1203020ada","src/buffer.rs":"fa1e6150e64697ed13bb7014f044804c4e114dccd7d41065de374ca14e37a8cf","src/chacha20.rs":"45918e41c2295186e0ce4fb674d28dc502aca36617e449b7991e1f44278e70bc","src/chacha20poly1305.rs":"2eaceb2b45f662f0f35f5649c7158503b57bdd7332c5eba558a59c0618a11ec0","src/cryptoutil.rs":"6788624b759ea17b39afa49921700e2868ea8f0dce33846904f056f0d4a573a5","src/curve25519.rs":"b231bd65eb28f9e8ef27710fc408a0f83d38ea2b385480da94f0436c8344576a","src/digest.rs":"c3a51d7d4daad5027a137d6e13ea7ccf9c27932db44c2db1736e3d6f5591947e","src/ed25519.rs":"83b8a821d1844ae25dbef88aeb3c462d8f060bd8811b75a5e13318bae4453cec","src/fortuna.rs":"3700f022d41360390c365482ecc618bf039f214846ccc5b36348557314c40f8e","src/ghash.rs":"6c3350781ed4263af4c2f46afb793b8b38af77644f668a238ec512608ffe692d","src/hc128.rs":"286cdf555920b2aa8498f3ec95f2eb2e9c56c291c0fd0f75666ec5de0a1a61ff","src/hkdf.rs":"9f4a7eb425c928f3dd9cf5ce0a9da19acee8cb5fcbe050aad6f4272935782af1","src/hmac.rs":"80875db532cee6d4c963d161f081612f4afed6d90103437219ceddccb74f82fc","src/lib.rs":"3e543793b71e4a0cd9f43c8508d84c9d77628c5991fa1cfa684ba90792edb105","src/mac.rs":"900acf3016e407a9d5e495a97618848bc10f1e3ad2dd300b7e2666337f996efd","src/md5.rs":"bcb9aa7c29b820001cee976e4abeea9ac0cfea20246905b21ea064b970057bb6","src/pbkdf2.rs":"e2ee493cdea76615d0dd52365da81e9dc1d74eefc447646c5bfc4875a5321be6","src/poly1305.rs":"753c150f80b60ea5596e38a6d7ca749255666fad66e545cf3496768436ee4038","src/rc4.rs":"ba34c235dad5964672a156cf232d2256dd232c8dcf9c7d4736be8fe37df503db","src/ripemd160.rs":"1a8010d70c1f61b8b484770a514ac82277319a5c8fa7838534bfce8e814a9dca","src/salsa20.rs":"287c1995b649f387b3d4fc5fbb6903da429a4f8037ee82ca85112013e09267a8","src/scrypt.rs":"c340e554b2d24fece4c186aa101eab4b5e09bb9830ba5a75712326183ea08f26","src/sha1.rs":"1d1c5dc17ccb42d6e1773c97383f0c7b2034abb3a711319cde952fdb748533ee","src/sha2.rs":"b0489c0204141271da7d361d747f305cb90f75448a546a02d739b1db192f5f51","src/sha3.rs":"fe8a988f4c248063210b48b5db205746ddbed9247a1e17d80bd480987c9ffe11","src/simd.rs":"6eb2cc90de248fc52a305e8b489d8b561760470aefbf1efce28719a9209df437","src/sosemanuk.rs":"55e8ccd3adb466a7ce81fa2f9cbe4786b3405857d87cd0890bf460fef6cfb350","src/step_by.rs":"80cfedeb69475ad69112a1674aef135be533661f63b17c9229e2ffefbfe2ddd3","src/symmetriccipher.rs":"0b937f809e973b840fec0070a4952c762889cfb596bf44dfbe2d3e19181bd379","src/util.rs":"7ba48fd8d714f3639014ec279f7a1470cf05162d0de542371b2f595c7fdea893","src/util_helpers.asm":"a42d35e4ec952c67258c01872c21d7b0f2f38fe2b21d38e74dd34f6c1f9c39c5","src/util_helpers.c":"f64aad37734d073f6c90626720f7a37da2130480216aa1b2b23f30a4a52bbbf2","src/whirlpool.rs":"d07ee7ba0acd5275aca4541bf16c5aa48dad072435e27d2691c07309cdb7758b"},"package":"f76d05d3993fd5f4af9434e8e436db163a12a9d40e1a58a726f27a01dfd12a2a"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/rust-crypto/.travis.yml b/rustc_deps/vendor/rust-crypto/.travis.yml
deleted file mode 100644
index 7e2ee06..0000000
--- a/rustc_deps/vendor/rust-crypto/.travis.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-language: rust
-rust:
-    - nightly
-    - stable
-sudo: false
diff --git a/rustc_deps/vendor/rust-crypto/CHANGELOG.md b/rustc_deps/vendor/rust-crypto/CHANGELOG.md
deleted file mode 100644
index 37cb8d5..0000000
--- a/rustc_deps/vendor/rust-crypto/CHANGELOG.md
+++ /dev/null
@@ -1,10 +0,0 @@
-Version v0.2.35 (4/4/2016)
-==========================
-
-* Improve cross compiling from GCC to msvc.
-* Fix BCrypt algorithm when using a cost of 31.
-* Improve building on OpenBSD.
-* Add implementation of SHA3 digest function.
-* Fix errors in Blake2b that could lead to incorrect output. The Blake2b
-  initialization functions are modified to take parameters by value instead of
-  by reference, which may break users of the interfaces.
diff --git a/rustc_deps/vendor/rust-crypto/Cargo.toml b/rustc_deps/vendor/rust-crypto/Cargo.toml
deleted file mode 100644
index 8ea941a..0000000
--- a/rustc_deps/vendor/rust-crypto/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "rust-crypto"
-version = "0.2.36"
-authors = ["The Rust-Crypto Project Developers"]
-license = "MIT/Apache-2.0"
-homepage = "https://github.com/DaGenix/rust-crypto/"
-repository = "https://github.com/DaGenix/rust-crypto/"
-description = "A (mostly) pure-Rust implementation of various common cryptographic algorithms."
-keywords = [ "Crypto", "MD5", "Sha1", "Sha2", "AES" ]
-readme = "README.md"
-build = "build.rs"
-
-[lib]
-name = "crypto"
-
-[features]
-with-bench = []
-
-[build-dependencies]
-gcc = "^0.3"
-
-[dependencies]
-libc = "^0.2"
-time = "^0.1"
-rand = "^0.3"
-rustc-serialize = "^0.3"
diff --git a/rustc_deps/vendor/rust-crypto/LICENSE-APACHE b/rustc_deps/vendor/rust-crypto/LICENSE-APACHE
deleted file mode 100644
index 78173fa..0000000
--- a/rustc_deps/vendor/rust-crypto/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              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/rustc_deps/vendor/rust-crypto/LICENSE-MIT b/rustc_deps/vendor/rust-crypto/LICENSE-MIT
deleted file mode 100644
index 1da3a5f..0000000
--- a/rustc_deps/vendor/rust-crypto/LICENSE-MIT
+++ /dev/null
@@ -1,26 +0,0 @@
-Copyright (c) 2006-2009 Graydon Hoare
-Copyright (c) 2009-2013 Mozilla Foundation
-
-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/rustc_deps/vendor/rust-crypto/README.md b/rustc_deps/vendor/rust-crypto/README.md
deleted file mode 100644
index 3e5c694..0000000
--- a/rustc_deps/vendor/rust-crypto/README.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# Rust-Crypto
-
-[![Build Status](https://travis-ci.org/DaGenix/rust-crypto.png?branch=master)](https://travis-ci.org/DaGenix/rust-crypto)
-
-A (mostly) pure-Rust implementation of various common cryptographic algorithms.
-
-Rust-Crypto seeks to create practical, auditable, pure-Rust implementations of common cryptographic
-algorithms with a minimum amount of assembly code where appropriate. The x86-64, x86, and
-ARM architectures are supported, although the x86-64 architecture receives the most testing.
-
-Rust-Crypto targets the current, stable build of Rust.
-If you are having issues while using an older version, please try upgrading to the latest stable.
-
-Rust-Crypto has not been thoroughly
-audited for correctness, so any use where security is important is not recommended at this time.
-
-## Usage
-
-To use Rust-Crypto, add the following to your Cargo.toml:
-
-```toml
-[dependencies]
-rust-crypto = "^0.2"
-```
-
-and the following to your crate root:
-
-```rust
-extern crate crypto;
-```
-
-## Contributions
-
-Contributions are extremely welcome. The most significant needs are help
-adding documentation, implementing new algorithms,
-and general cleanup and improvement of the code. By submitting a pull request you are agreeing to
-make you work available under the license
-terms of the Rust-Crypto project.
-
-## License
-
-Rust-Crypto is dual licensed under the MIT and Apache 2.0 licenses, the same licenses
-as the Rust compiler.
-
-## Algorithms
-
-Rust-Crypto already supports a significant number of algorithms and with your help
-it will support even more in the future. Currently supported algorithms include:
-
-* AES
-* Bcrypt
-* Blake2B
-* Blowfish
-* ChaCha20
-* Curve25519
-* ECB, CBC, and CTR block cipher modes
-* Ed25519
-* Fortuna
-* Ghash
-* HC128
-* HMAC
-* MD5
-* PBKDF2
-* PKCS padding for CBC block cipher mode
-* Poly1305
-* RC4
-* RIPEMD-160
-* Salsa20 and XSalsa20
-* Scrypt
-* Sha1
-* Sha2 (All fixed output size variants)
-* Sosemanuk
-* Whirlpool
diff --git a/rustc_deps/vendor/rust-crypto/appveyor.yml b/rustc_deps/vendor/rust-crypto/appveyor.yml
deleted file mode 100644
index 1184d4c..0000000
--- a/rustc_deps/vendor/rust-crypto/appveyor.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-clone_depth: 50
-environment:
-  matrix:
-  - TARGET: nightly-x86_64-pc-windows-msvc
-  - TARGET: nightly-i686-pc-windows-msvc
-  - TARGET: nightly-x86_64-pc-windows-gnu
-    MSYS_BITS: 64
-  - TARGET: nightly-i686-pc-windows-gnu
-    MSYS_BITS: 32
-  - TARGET: beta-x86_64-pc-windows-msvc
-  - TARGET: beta-i686-pc-windows-msvc
-  - TARGET: beta-x86_64-pc-windows-gnu
-    MSYS_BITS: 64
-  - TARGET: beta-i686-pc-windows-gnu
-    MSYS_BITS: 32
-  - TARGET: 1.8.0-x86_64-pc-windows-msvc
-  - TARGET: 1.8.0-i686-pc-windows-msvc
-  - TARGET: 1.8.0-x86_64-pc-windows-gnu
-    MSYS_BITS: 64
-  - TARGET: 1.8.0-i686-pc-windows-gnu
-    MSYS_BITS: 32
-  - TARGET: 1.7.0-x86_64-pc-windows-msvc
-  - TARGET: 1.7.0-x86_64-pc-windows-gnu
-    MSYS_BITS: 64
-  - TARGET: 1.7.0-i686-pc-windows-gnu
-    MSYS_BITS: 32
-  - TARGET: 1.6.0-x86_64-pc-windows-msvc
-  - TARGET: 1.6.0-x86_64-pc-windows-gnu
-    MSYS_BITS: 64
-  - TARGET: 1.6.0-i686-pc-windows-gnu
-    MSYS_BITS: 32
-  - TARGET: 1.5.0-x86_64-pc-windows-gnu
-    MSYS_BITS: 64
-  - TARGET: 1.5.0-i686-pc-windows-gnu
-    MSYS_BITS: 32
-  - TARGET: 1.4.0-x86_64-pc-windows-gnu
-    MSYS_BITS: 64
-  - TARGET: 1.4.0-i686-pc-windows-gnu
-    MSYS_BITS: 32
-install:
-  - git submodule update --init --recursive
-  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-${env:TARGET}.exe" -FileName "rust-install.exe"
-  - ps: .\rust-install.exe /VERYSILENT /NORESTART /DIR="C:\rust" | Out-Null
-  - ps: $env:PATH="$env:PATH;C:\rust\bin"
-  - if defined MSYS_BITS set PATH=C:\msys64\mingw%MSYS_BITS%\bin;C:\msys64\usr\bin;%PATH%
-  - rustc -vV
-  - cargo -vV
-build_script:
-  - cargo build
-  - cargo package
-test_script:
-  - cargo test
diff --git a/rustc_deps/vendor/rust-crypto/build.rs b/rustc_deps/vendor/rust-crypto/build.rs
deleted file mode 100644
index 92dd2b6..0000000
--- a/rustc_deps/vendor/rust-crypto/build.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-extern crate gcc;
-
-use std::env;
-use std::path::Path;
-
-fn main() {
-    let target = env::var("TARGET").unwrap();
-    let host = env::var("HOST").unwrap();
-    if target.contains("msvc") && host.contains("windows") {
-        let mut config = gcc::Config::new();
-        config.file("src/util_helpers.asm");
-        config.file("src/aesni_helpers.asm");
-        if target.contains("x86_64") {
-            config.define("X64", None);
-        }
-        config.compile("lib_rust_crypto_helpers.a");
-    }
-    else {
-        let mut cfg = gcc::Config::new();
-        cfg.file("src/util_helpers.c");
-        cfg.file("src/aesni_helpers.c");
-        if env::var_os("CC").is_none() {
-            if host.contains("openbsd") {
-                // Use clang on openbsd since there have been reports that
-                // GCC doesn't like some of the assembly that we use on that
-                // platform.
-                cfg.compiler(Path::new("clang"));
-            } else if target == host {
-                cfg.compiler(Path::new("cc"));
-            }
-        }
-        cfg.compile("lib_rust_crypto_helpers.a");
-    }
-}
-
diff --git a/rustc_deps/vendor/rust-crypto/examples/symmetriccipher.rs b/rustc_deps/vendor/rust-crypto/examples/symmetriccipher.rs
deleted file mode 100644
index 8f559f5..0000000
--- a/rustc_deps/vendor/rust-crypto/examples/symmetriccipher.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-extern crate crypto;
-extern crate rand;
-
-use crypto::{ symmetriccipher, buffer, aes, blockmodes };
-use crypto::buffer::{ ReadBuffer, WriteBuffer, BufferResult };
-
-use rand::{ Rng, OsRng };
-
-// Encrypt a buffer with the given key and iv using
-// AES-256/CBC/Pkcs encryption.
-fn encrypt(data: &[u8], key: &[u8], iv: &[u8]) -> Result<Vec<u8>, symmetriccipher::SymmetricCipherError> {
-
-    // Create an encryptor instance of the best performing
-    // type available for the platform.
-    let mut encryptor = aes::cbc_encryptor(
-            aes::KeySize::KeySize256,
-            key,
-            iv,
-            blockmodes::PkcsPadding);
-
-    // Each encryption operation encrypts some data from
-    // an input buffer into an output buffer. Those buffers
-    // must be instances of RefReaderBuffer and RefWriteBuffer
-    // (respectively) which keep track of how much data has been
-    // read from or written to them.
-    let mut final_result = Vec::<u8>::new();
-    let mut read_buffer = buffer::RefReadBuffer::new(data);
-    let mut buffer = [0; 4096];
-    let mut write_buffer = buffer::RefWriteBuffer::new(&mut buffer);
-
-    // Each encryption operation will "make progress". "Making progress"
-    // is a bit loosely defined, but basically, at the end of each operation
-    // either BufferUnderflow or BufferOverflow will be returned (unless
-    // there was an error). If the return value is BufferUnderflow, it means
-    // that the operation ended while wanting more input data. If the return
-    // value is BufferOverflow, it means that the operation ended because it
-    // needed more space to output data. As long as the next call to the encryption
-    // operation provides the space that was requested (either more input data
-    // or more output space), the operation is guaranteed to get closer to
-    // completing the full operation - ie: "make progress".
-    //
-    // Here, we pass the data to encrypt to the enryptor along with a fixed-size
-    // output buffer. The 'true' flag indicates that the end of the data that
-    // is to be encrypted is included in the input buffer (which is true, since
-    // the input data includes all the data to encrypt). After each call, we copy
-    // any output data to our result Vec. If we get a BufferOverflow, we keep
-    // going in the loop since it means that there is more work to do. We can
-    // complete as soon as we get a BufferUnderflow since the encryptor is telling
-    // us that it stopped processing data due to not having any more data in the
-    // input buffer.
-    loop {
-        let result = try!(encryptor.encrypt(&mut read_buffer, &mut write_buffer, true));
-
-        // "write_buffer.take_read_buffer().take_remaining()" means:
-        // from the writable buffer, create a new readable buffer which
-        // contains all data that has been written, and then access all
-        // of that data as a slice.
-        final_result.extend(write_buffer.take_read_buffer().take_remaining().iter().map(|&i| i));
-
-        match result {
-            BufferResult::BufferUnderflow => break,
-            BufferResult::BufferOverflow => { }
-        }
-    }
-
-    Ok(final_result)
-}
-
-// Decrypts a buffer with the given key and iv using
-// AES-256/CBC/Pkcs encryption.
-//
-// This function is very similar to encrypt(), so, please reference
-// comments in that function. In non-example code, if desired, it is possible to
-// share much of the implementation using closures to hide the operation
-// being performed. However, such code would make this example less clear.
-fn decrypt(encrypted_data: &[u8], key: &[u8], iv: &[u8]) -> Result<Vec<u8>, symmetriccipher::SymmetricCipherError> {
-    let mut decryptor = aes::cbc_decryptor(
-            aes::KeySize::KeySize256,
-            key,
-            iv,
-            blockmodes::PkcsPadding);
-
-    let mut final_result = Vec::<u8>::new();
-    let mut read_buffer = buffer::RefReadBuffer::new(encrypted_data);
-    let mut buffer = [0; 4096];
-    let mut write_buffer = buffer::RefWriteBuffer::new(&mut buffer);
-
-    loop {
-        let result = try!(decryptor.decrypt(&mut read_buffer, &mut write_buffer, true));
-        final_result.extend(write_buffer.take_read_buffer().take_remaining().iter().map(|&i| i));
-        match result {
-            BufferResult::BufferUnderflow => break,
-            BufferResult::BufferOverflow => { }
-        }
-    }
-
-    Ok(final_result)
-}
-
-fn main() {
-    let message = "Hello World!";
-
-    let mut key: [u8; 32] = [0; 32];
-    let mut iv: [u8; 16] = [0; 16];
-
-    // In a real program, the key and iv may be determined
-    // using some other mechanism. If a password is to be used
-    // as a key, an algorithm like PBKDF2, Bcrypt, or Scrypt (all
-    // supported by Rust-Crypto!) would be a good choice to derive
-    // a password. For the purposes of this example, the key and
-    // iv are just random values.
-    let mut rng = OsRng::new().ok().unwrap();
-    rng.fill_bytes(&mut key);
-    rng.fill_bytes(&mut iv);
-
-    let encrypted_data = encrypt(message.as_bytes(), &key, &iv).ok().unwrap();
-    let decrypted_data = decrypt(&encrypted_data[..], &key, &iv).ok().unwrap();
-
-    assert!(message.as_bytes() == &decrypted_data[..]);
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/aead.rs b/rustc_deps/vendor/rust-crypto/src/aead.rs
deleted file mode 100644
index 4f4f3b7..0000000
--- a/rustc_deps/vendor/rust-crypto/src/aead.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-pub trait AeadEncryptor {
-
-	fn encrypt(&mut self, input: &[u8], output: &mut [u8], tag: &mut [u8]);
-}
-
-pub trait AeadDecryptor {
-
-	fn decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8]) -> bool;
-}
\ No newline at end of file
diff --git a/rustc_deps/vendor/rust-crypto/src/aes.rs b/rustc_deps/vendor/rust-crypto/src/aes.rs
deleted file mode 100644
index 1de8c56..0000000
--- a/rustc_deps/vendor/rust-crypto/src/aes.rs
+++ /dev/null
@@ -1,787 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-use aesni;
-
-use aessafe;
-use blockmodes::{PaddingProcessor, EcbEncryptor, EcbDecryptor, CbcEncryptor, CbcDecryptor, CtrMode,
-    CtrModeX8};
-use symmetriccipher::{Encryptor, Decryptor, SynchronousStreamCipher};
-use util;
-
-/// AES key size
-#[derive(Clone, Copy)]
-pub enum KeySize {
-    KeySize128,
-    KeySize192,
-    KeySize256
-}
-
-/// Get the best implementation of an EcbEncryptor
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn ecb_encryptor<X: PaddingProcessor + Send + 'static>(
-        key_size: KeySize,
-        key: &[u8],
-        padding: X) -> Box<Encryptor> {
-    if util::supports_aesni() {
-        let aes_enc = aesni::AesNiEncryptor::new(key_size, key);
-        let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-        enc
-    } else {
-        match key_size {
-            KeySize::KeySize128 => {
-                let aes_enc = aessafe::AesSafe128Encryptor::new(key);
-                let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-                enc
-            }
-            KeySize::KeySize192 => {
-                let aes_enc = aessafe::AesSafe192Encryptor::new(key);
-                let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-                enc
-            }
-            KeySize::KeySize256 => {
-                let aes_enc = aessafe::AesSafe256Encryptor::new(key);
-                let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-                enc
-            }
-        }
-    }
-}
-
-/// Get the best implementation of an EcbEncryptor
-#[cfg(all(not(target_arch = "x86"), not(target_arch = "x86_64")))]
-pub fn ecb_encryptor<X: PaddingProcessor + Send + 'static>(
-        key_size: KeySize,
-        key: &[u8],
-        padding: X) -> Box<Encryptor> {
-    match key_size {
-        KeySize::KeySize128 => {
-            let aes_enc = aessafe::AesSafe128Encryptor::new(key);
-            let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-            enc
-        }
-        KeySize::KeySize192 => {
-            let aes_enc = aessafe::AesSafe192Encryptor::new(key);
-            let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-            enc
-        }
-        KeySize::KeySize256 => {
-            let aes_enc = aessafe::AesSafe256Encryptor::new(key);
-            let enc = Box::new(EcbEncryptor::new(aes_enc, padding));
-            enc
-        }
-    }
-}
-
-/// Get the best implementation of an EcbDecryptor
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn ecb_decryptor<X: PaddingProcessor + Send + 'static>(
-        key_size: KeySize,
-        key: &[u8],
-        padding: X) -> Box<Decryptor> {
-    if util::supports_aesni() {
-        let aes_dec = aesni::AesNiDecryptor::new(key_size, key);
-        let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-        dec
-    } else {
-        match key_size {
-            KeySize::KeySize128 => {
-                let aes_dec = aessafe::AesSafe128Decryptor::new(key);
-                let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-                dec
-            }
-            KeySize::KeySize192 => {
-                let aes_dec = aessafe::AesSafe192Decryptor::new(key);
-                let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-                dec
-            }
-            KeySize::KeySize256 => {
-                let aes_dec = aessafe::AesSafe256Decryptor::new(key);
-                let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-                dec
-            }
-        }
-    }
-}
-
-/// Get the best implementation of an EcbDecryptor
-#[cfg(all(not(target_arch = "x86"), not(target_arch = "x86_64")))]
-pub fn ecb_decryptor<X: PaddingProcessor + Send + 'static>(
-        key_size: KeySize,
-        key: &[u8],
-        padding: X) -> Box<Decryptor> {
-    match key_size {
-        KeySize::KeySize128 => {
-            let aes_dec = aessafe::AesSafe128Decryptor::new(key);
-            let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-            dec
-        }
-        KeySize::KeySize192 => {
-            let aes_dec = aessafe::AesSafe192Decryptor::new(key);
-            let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-            dec
-        }
-        KeySize::KeySize256 => {
-            let aes_dec = aessafe::AesSafe256Decryptor::new(key);
-            let dec = Box::new(EcbDecryptor::new(aes_dec, padding));
-            dec
-        }
-    }
-}
-
-/// Get the best implementation of a CbcEncryptor
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn cbc_encryptor<X: PaddingProcessor + Send + 'static>(
-        key_size: KeySize,
-        key: &[u8],
-        iv: &[u8],
-        padding: X) -> Box<Encryptor + 'static> {
-    if util::supports_aesni() {
-        let aes_enc = aesni::AesNiEncryptor::new(key_size, key);
-        let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-        enc
-    } else {
-        match key_size {
-            KeySize::KeySize128 => {
-                let aes_enc = aessafe::AesSafe128Encryptor::new(key);
-                let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-                enc
-            }
-            KeySize::KeySize192 => {
-                let aes_enc = aessafe::AesSafe192Encryptor::new(key);
-                let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-                enc
-            }
-            KeySize::KeySize256 => {
-                let aes_enc = aessafe::AesSafe256Encryptor::new(key);
-                let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-                enc
-            }
-        }
-    }
-}
-
-/// Get the best implementation of a CbcEncryptor
-#[cfg(all(not(target_arch = "x86"), not(target_arch = "x86_64")))]
-pub fn cbc_encryptor<X: PaddingProcessor + Send + 'static>(
-        key_size: KeySize,
-        key: &[u8],
-        iv: &[u8],
-        padding: X) -> Box<Encryptor + 'static> {
-    match key_size {
-        KeySize::KeySize128 => {
-            let aes_enc = aessafe::AesSafe128Encryptor::new(key);
-            let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-            enc
-        }
-        KeySize::KeySize192 => {
-            let aes_enc = aessafe::AesSafe192Encryptor::new(key);
-            let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-            enc
-        }
-        KeySize::KeySize256 => {
-            let aes_enc = aessafe::AesSafe256Encryptor::new(key);
-            let enc = Box::new(CbcEncryptor::new(aes_enc, padding, iv.to_vec()));
-            enc
-        }
-    }
-}
-
-/// Get the best implementation of a CbcDecryptor
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn cbc_decryptor<X: PaddingProcessor + Send + 'static>(
-        key_size: KeySize,
-        key: &[u8],
-        iv: &[u8],
-        padding: X) -> Box<Decryptor + 'static> {
-    if util::supports_aesni() {
-        let aes_dec = aesni::AesNiDecryptor::new(key_size, key);
-        let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-        dec
-    } else {
-        match key_size {
-            KeySize::KeySize128 => {
-                let aes_dec = aessafe::AesSafe128Decryptor::new(key);
-                let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-                dec
-            }
-            KeySize::KeySize192 => {
-                let aes_dec = aessafe::AesSafe192Decryptor::new(key);
-                let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-                dec
-            }
-            KeySize::KeySize256 => {
-                let aes_dec = aessafe::AesSafe256Decryptor::new(key);
-                let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-                dec
-            }
-        }
-    }
-}
-
-/// Get the best implementation of a CbcDecryptor
-#[cfg(all(not(target_arch = "x86"), not(target_arch = "x86_64")))]
-pub fn cbc_decryptor<X: PaddingProcessor + Send + 'static>(
-        key_size: KeySize,
-        key: &[u8],
-        iv: &[u8],
-        padding: X) -> Box<Decryptor + 'static> {
-    match key_size {
-        KeySize::KeySize128 => {
-            let aes_dec = aessafe::AesSafe128Decryptor::new(key);
-            let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-            dec as Box<Decryptor + 'static>
-        }
-        KeySize::KeySize192 => {
-            let aes_dec = aessafe::AesSafe192Decryptor::new(key);
-            let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-            dec as Box<Decryptor + 'static>
-        }
-        KeySize::KeySize256 => {
-            let aes_dec = aessafe::AesSafe256Decryptor::new(key);
-            let dec = Box::new(CbcDecryptor::new(aes_dec, padding, iv.to_vec()));
-            dec as Box<Decryptor + 'static>
-        }
-    }
-}
-
-/// Get the best implementation of a Ctr
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-pub fn ctr(
-        key_size: KeySize,
-        key: &[u8],
-        iv: &[u8]) -> Box<SynchronousStreamCipher + 'static> {
-    if util::supports_aesni() {
-        let aes_dec = aesni::AesNiEncryptor::new(key_size, key);
-        let dec = Box::new(CtrMode::new(aes_dec, iv.to_vec()));
-        dec
-    } else {
-        match key_size {
-            KeySize::KeySize128 => {
-                let aes_dec = aessafe::AesSafe128EncryptorX8::new(key);
-                let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-                dec
-            }
-            KeySize::KeySize192 => {
-                let aes_dec = aessafe::AesSafe192EncryptorX8::new(key);
-                let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-                dec
-            }
-            KeySize::KeySize256 => {
-                let aes_dec = aessafe::AesSafe256EncryptorX8::new(key);
-                let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-                dec
-            }
-        }
-    }
-}
-
-/// Get the best implementation of a Ctr
-#[cfg(all(not(target_arch = "x86"), not(target_arch = "x86_64")))]
-pub fn ctr(
-        key_size: KeySize,
-        key: &[u8],
-        iv: &[u8]) -> Box<SynchronousStreamCipher + 'static> {
-    match key_size {
-        KeySize::KeySize128 => {
-            let aes_dec = aessafe::AesSafe128EncryptorX8::new(key);
-            let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-            dec as Box<SynchronousStreamCipher>
-        }
-        KeySize::KeySize192 => {
-            let aes_dec = aessafe::AesSafe192EncryptorX8::new(key);
-            let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-            dec as Box<SynchronousStreamCipher>
-        }
-        KeySize::KeySize256 => {
-            let aes_dec = aessafe::AesSafe256EncryptorX8::new(key);
-            let dec = Box::new(CtrModeX8::new(aes_dec, iv));
-            dec as Box<SynchronousStreamCipher>
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::iter::repeat;
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    use aesni;
-
-    use aessafe;
-    use symmetriccipher::{BlockEncryptor, BlockDecryptor, BlockEncryptorX8, BlockDecryptorX8,
-            SynchronousStreamCipher};
-    use util;
-    use aes;
-    use aes::KeySize::{KeySize128, KeySize192, KeySize256};
-
-    // Test vectors from:
-    // http://www.inconteam.com/software-development/41-encryption/55-aes-test-vectors
-
-    struct Test {
-        key: Vec<u8>,
-        data: Vec<TestData>
-    }
-
-    struct TestData {
-        plain: Vec<u8>,
-        cipher: Vec<u8>
-    }
-
-    fn tests128() -> Vec<Test> {
-        vec![
-            Test {
-                key: vec![0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
-                       0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c],
-                data: vec![
-                    TestData {
-                        plain:  vec![0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-                                 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a],
-                        cipher: vec![0x3a, 0xd7, 0x7b, 0xb4, 0x0d, 0x7a, 0x36, 0x60,
-                                 0xa8, 0x9e, 0xca, 0xf3, 0x24, 0x66, 0xef, 0x97]
-                    },
-                    TestData {
-                        plain:  vec![0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-                                 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51],
-                        cipher: vec![0xf5, 0xd3, 0xd5, 0x85, 0x03, 0xb9, 0x69, 0x9d,
-                                 0xe7, 0x85, 0x89, 0x5a, 0x96, 0xfd, 0xba, 0xaf]
-                    },
-                    TestData {
-                        plain:  vec![0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-                                 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef],
-                        cipher: vec![0x43, 0xb1, 0xcd, 0x7f, 0x59, 0x8e, 0xce, 0x23,
-                                 0x88, 0x1b, 0x00, 0xe3, 0xed, 0x03, 0x06, 0x88]
-                    },
-                    TestData {
-                        plain:  vec![0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-                                 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10],
-                        cipher: vec![0x7b, 0x0c, 0x78, 0x5e, 0x27, 0xe8, 0xad, 0x3f,
-                                 0x82, 0x23, 0x20, 0x71, 0x04, 0x72, 0x5d, 0xd4]
-                    }
-                ]
-            }
-        ]
-    }
-
-    fn tests192() -> Vec<Test> {
-        vec![
-            Test {
-                key: vec![0x8e, 0x73, 0xb0, 0xf7, 0xda, 0x0e, 0x64, 0x52, 0xc8, 0x10, 0xf3, 0x2b,
-                       0x80, 0x90, 0x79, 0xe5, 0x62, 0xf8, 0xea, 0xd2, 0x52, 0x2c, 0x6b, 0x7b],
-                data: vec![
-                    TestData {
-                        plain:  vec![0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-                                  0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a],
-                        cipher: vec![0xbd, 0x33, 0x4f, 0x1d, 0x6e, 0x45, 0xf2, 0x5f,
-                                  0xf7, 0x12, 0xa2, 0x14, 0x57, 0x1f, 0xa5, 0xcc]
-                    },
-                    TestData {
-                        plain:  vec![0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-                                  0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51],
-                        cipher: vec![0x97, 0x41, 0x04, 0x84, 0x6d, 0x0a, 0xd3, 0xad,
-                                  0x77, 0x34, 0xec, 0xb3, 0xec, 0xee, 0x4e, 0xef]
-                    },
-                    TestData {
-                        plain:  vec![0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-                                  0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef],
-                        cipher: vec![0xef, 0x7a, 0xfd, 0x22, 0x70, 0xe2, 0xe6, 0x0a,
-                                  0xdc, 0xe0, 0xba, 0x2f, 0xac, 0xe6, 0x44, 0x4e]
-                    },
-                    TestData {
-                        plain:  vec![0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-                                  0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10],
-                        cipher: vec![0x9a, 0x4b, 0x41, 0xba, 0x73, 0x8d, 0x6c, 0x72,
-                                  0xfb, 0x16, 0x69, 0x16, 0x03, 0xc1, 0x8e, 0x0e]
-                    }
-                ]
-            }
-        ]
-    }
-
-    fn tests256() -> Vec<Test> {
-        vec![
-            Test {
-                key: vec![0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
-                       0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
-                       0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
-                       0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4],
-                data: vec![
-                    TestData {
-                        plain:  vec![0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-                                  0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a],
-                        cipher: vec![0xf3, 0xee, 0xd1, 0xbd, 0xb5, 0xd2, 0xa0, 0x3c,
-                                  0x06, 0x4b, 0x5a, 0x7e, 0x3d, 0xb1, 0x81, 0xf8]
-                    },
-                    TestData {
-                        plain:  vec![0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-                                  0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51],
-                        cipher: vec![0x59, 0x1c, 0xcb, 0x10, 0xd4, 0x10, 0xed, 0x26,
-                                  0xdc, 0x5b, 0xa7, 0x4a, 0x31, 0x36, 0x28, 0x70]
-                    },
-                    TestData {
-                        plain:  vec![0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-                                  0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef],
-                        cipher: vec![0xb6, 0xed, 0x21, 0xb9, 0x9c, 0xa6, 0xf4, 0xf9,
-                                  0xf1, 0x53, 0xe7, 0xb1, 0xbe, 0xaf, 0xed, 0x1d]
-                    },
-                    TestData {
-                        plain:  vec![0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-                                  0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10],
-                        cipher: vec![0x23, 0x30, 0x4b, 0x7a, 0x39, 0xf9, 0xf3, 0xff,
-                                  0x06, 0x7d, 0x8d, 0x8f, 0x9e, 0x24, 0xec, 0xc7]
-                    }
-                ]
-            }
-        ]
-    }
-
-    struct CtrTest {
-        key: Vec<u8>,
-        ctr: Vec<u8>,
-        plain: Vec<u8>,
-        cipher: Vec<u8>
-    }
-
-    fn aes_ctr_tests() -> Vec<CtrTest> {
-        vec![
-            CtrTest {
-                key: repeat(1).take(16).collect(),
-                ctr: repeat(3).take(16).collect(),
-                plain: repeat(2).take(33).collect(),
-                cipher: vec![
-                    0x64, 0x3e, 0x05, 0x19, 0x79, 0x78, 0xd7, 0x45,
-                    0xa9, 0x10, 0x5f, 0xd8, 0x4c, 0xd7, 0xe6, 0xb1,
-                    0x5f, 0x66, 0xc6, 0x17, 0x4b, 0x25, 0xea, 0x24,
-                    0xe6, 0xf9, 0x19, 0x09, 0xb7, 0xdd, 0x84, 0xfb,
-                    0x86 ]
-            }
-        ]
-    }
-
-    fn run_test<E: BlockEncryptor, D: BlockDecryptor>(enc: &mut E, dec: &mut D, test: &Test) {
-        let mut tmp = [0u8; 16];
-        for data in test.data.iter() {
-            enc.encrypt_block(&data.plain[..], &mut tmp);
-            assert!(tmp[..] == data.cipher[..]);
-            dec.decrypt_block(&data.cipher[..], &mut tmp);
-            assert!(tmp[..] == data.plain[..]);
-        }
-    }
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    #[test]
-    fn test_aesni_128() {
-        if util::supports_aesni() {
-            let tests = tests128();
-            for t in tests.iter() {
-                let mut enc = aesni::AesNiEncryptor::new(KeySize128, &t.key[..]);
-                let mut dec = aesni::AesNiDecryptor::new(KeySize128, &t.key[..]);
-                run_test(&mut enc, &mut dec, t);
-            }
-        }
-    }
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    #[test]
-    fn test_aesni_192() {
-        if util::supports_aesni() {
-            let tests = tests192();
-            for t in tests.iter() {
-                let mut enc = aesni::AesNiEncryptor::new(KeySize192, &t.key[..]);
-                let mut dec = aesni::AesNiDecryptor::new(KeySize192, &t.key[..]);
-                run_test(&mut enc, &mut dec, t);
-            }
-        }
-    }
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    #[test]
-    fn test_aesni_256() {
-        if util::supports_aesni() {
-            let tests = tests256();
-            for t in tests.iter() {
-                let mut enc = aesni::AesNiEncryptor::new(KeySize256, &t.key[..]);
-                let mut dec = aesni::AesNiDecryptor::new(KeySize256, &t.key[..]);
-                run_test(&mut enc, &mut dec, t);
-            }
-        }
-    }
-
-    #[test]
-    fn test_aessafe_128() {
-        let tests = tests128();
-        for t in tests.iter() {
-            let mut enc = aessafe::AesSafe128Encryptor::new(&t.key[..]);
-            let mut dec = aessafe::AesSafe128Decryptor::new(&t.key[..]);
-            run_test(&mut enc, &mut dec, t);
-        }
-    }
-
-    #[test]
-    fn test_aessafe_192() {
-        let tests = tests192();
-        for t in tests.iter() {
-            let mut enc = aessafe::AesSafe192Encryptor::new(&t.key[..]);
-            let mut dec = aessafe::AesSafe192Decryptor::new(&t.key[..]);
-            run_test(&mut enc, &mut dec, t);
-        }
-    }
-
-    #[test]
-    fn test_aessafe_256() {
-        let tests = tests256();
-        for t in tests.iter() {
-            let mut enc = aessafe::AesSafe256Encryptor::new(&t.key[..]);
-            let mut dec = aessafe::AesSafe256Decryptor::new(&t.key[..]);
-            run_test(&mut enc, &mut dec, t);
-        }
-    }
-
-    // The following test vectors are all from NIST SP 800-38A
-
-    #[test]
-    fn test_aessafe_128_x8() {
-        let key: [u8; 16] = [
-            0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
-            0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c ];
-        let plain: [u8; 128] = [
-            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
-            0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-            0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
-            0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-            0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
-            0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-            0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10,
-            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
-            0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-            0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
-            0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-            0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
-            0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-            0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 ];
-        let cipher: [u8; 128] = [
-            0x3a, 0xd7, 0x7b, 0xb4, 0x0d, 0x7a, 0x36, 0x60,
-            0xa8, 0x9e, 0xca, 0xf3, 0x24, 0x66, 0xef, 0x97,
-            0xf5, 0xd3, 0xd5, 0x85, 0x03, 0xb9, 0x69, 0x9d,
-            0xe7, 0x85, 0x89, 0x5a, 0x96, 0xfd, 0xba, 0xaf,
-            0x43, 0xb1, 0xcd, 0x7f, 0x59, 0x8e, 0xce, 0x23,
-            0x88, 0x1b, 0x00, 0xe3, 0xed, 0x03, 0x06, 0x88,
-            0x7b, 0x0c, 0x78, 0x5e, 0x27, 0xe8, 0xad, 0x3f,
-            0x82, 0x23, 0x20, 0x71, 0x04, 0x72, 0x5d, 0xd4,
-            0x3a, 0xd7, 0x7b, 0xb4, 0x0d, 0x7a, 0x36, 0x60,
-            0xa8, 0x9e, 0xca, 0xf3, 0x24, 0x66, 0xef, 0x97,
-            0xf5, 0xd3, 0xd5, 0x85, 0x03, 0xb9, 0x69, 0x9d,
-            0xe7, 0x85, 0x89, 0x5a, 0x96, 0xfd, 0xba, 0xaf,
-            0x43, 0xb1, 0xcd, 0x7f, 0x59, 0x8e, 0xce, 0x23,
-            0x88, 0x1b, 0x00, 0xe3, 0xed, 0x03, 0x06, 0x88,
-            0x7b, 0x0c, 0x78, 0x5e, 0x27, 0xe8, 0xad, 0x3f,
-            0x82, 0x23, 0x20, 0x71, 0x04, 0x72, 0x5d, 0xd4 ];
-
-        let enc = aessafe::AesSafe128EncryptorX8::new(&key);
-        let dec = aessafe::AesSafe128DecryptorX8::new(&key);
-        let mut tmp = [0u8; 128];
-        enc.encrypt_block_x8(&plain, &mut tmp);
-        assert!(tmp[..] == cipher[..]);
-        dec.decrypt_block_x8(&cipher, &mut tmp);
-        assert!(tmp[..] == plain[..]);
-    }
-
-    #[test]
-    fn test_aessafe_192_x8() {
-        let key: [u8; 24] = [
-            0x8e, 0x73, 0xb0, 0xf7, 0xda, 0x0e, 0x64, 0x52, 0xc8, 0x10, 0xf3, 0x2b,
-            0x80, 0x90, 0x79, 0xe5, 0x62, 0xf8, 0xea, 0xd2, 0x52, 0x2c, 0x6b, 0x7b ];
-        let plain: [u8; 128] = [
-            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
-            0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-            0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
-            0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-            0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
-            0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-            0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10,
-            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
-            0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-            0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
-            0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-            0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
-            0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-            0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 ];
-        let cipher: [u8; 128] = [
-            0xbd, 0x33, 0x4f, 0x1d, 0x6e, 0x45, 0xf2, 0x5f,
-            0xf7, 0x12, 0xa2, 0x14, 0x57, 0x1f, 0xa5, 0xcc,
-            0x97, 0x41, 0x04, 0x84, 0x6d, 0x0a, 0xd3, 0xad,
-            0x77, 0x34, 0xec, 0xb3, 0xec, 0xee, 0x4e, 0xef,
-            0xef, 0x7a, 0xfd, 0x22, 0x70, 0xe2, 0xe6, 0x0a,
-            0xdc, 0xe0, 0xba, 0x2f, 0xac, 0xe6, 0x44, 0x4e,
-            0x9a, 0x4b, 0x41, 0xba, 0x73, 0x8d, 0x6c, 0x72,
-            0xfb, 0x16, 0x69, 0x16, 0x03, 0xc1, 0x8e, 0x0e,
-            0xbd, 0x33, 0x4f, 0x1d, 0x6e, 0x45, 0xf2, 0x5f,
-            0xf7, 0x12, 0xa2, 0x14, 0x57, 0x1f, 0xa5, 0xcc,
-            0x97, 0x41, 0x04, 0x84, 0x6d, 0x0a, 0xd3, 0xad,
-            0x77, 0x34, 0xec, 0xb3, 0xec, 0xee, 0x4e, 0xef,
-            0xef, 0x7a, 0xfd, 0x22, 0x70, 0xe2, 0xe6, 0x0a,
-            0xdc, 0xe0, 0xba, 0x2f, 0xac, 0xe6, 0x44, 0x4e,
-            0x9a, 0x4b, 0x41, 0xba, 0x73, 0x8d, 0x6c, 0x72,
-            0xfb, 0x16, 0x69, 0x16, 0x03, 0xc1, 0x8e, 0x0e ];
-
-        let enc = aessafe::AesSafe192EncryptorX8::new(&key);
-        let dec = aessafe::AesSafe192DecryptorX8::new(&key);
-        let mut tmp = [0u8; 128];
-        enc.encrypt_block_x8(&plain, &mut tmp);
-        assert!(tmp[..] == cipher[..]);
-        dec.decrypt_block_x8(&cipher, &mut tmp);
-        assert!(tmp[..] == plain[..]);
-    }
-
-    #[test]
-    fn test_aessafe_256_x8() {
-        let key: [u8; 32] = [
-            0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
-            0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
-            0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
-            0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4 ];
-        let plain: [u8; 128] = [
-            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
-            0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-            0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
-            0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-            0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
-            0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-            0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10,
-            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
-            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
-            0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
-            0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
-            0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11,
-            0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
-            0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17,
-            0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 ];
-        let cipher: [u8; 128] = [
-            0xf3, 0xee, 0xd1, 0xbd, 0xb5, 0xd2, 0xa0, 0x3c,
-            0x06, 0x4b, 0x5a, 0x7e, 0x3d, 0xb1, 0x81, 0xf8,
-            0x59, 0x1c, 0xcb, 0x10, 0xd4, 0x10, 0xed, 0x26,
-            0xdc, 0x5b, 0xa7, 0x4a, 0x31, 0x36, 0x28, 0x70,
-            0xb6, 0xed, 0x21, 0xb9, 0x9c, 0xa6, 0xf4, 0xf9,
-            0xf1, 0x53, 0xe7, 0xb1, 0xbe, 0xaf, 0xed, 0x1d,
-            0x23, 0x30, 0x4b, 0x7a, 0x39, 0xf9, 0xf3, 0xff,
-            0x06, 0x7d, 0x8d, 0x8f, 0x9e, 0x24, 0xec, 0xc7,
-            0xf3, 0xee, 0xd1, 0xbd, 0xb5, 0xd2, 0xa0, 0x3c,
-            0x06, 0x4b, 0x5a, 0x7e, 0x3d, 0xb1, 0x81, 0xf8,
-            0x59, 0x1c, 0xcb, 0x10, 0xd4, 0x10, 0xed, 0x26,
-            0xdc, 0x5b, 0xa7, 0x4a, 0x31, 0x36, 0x28, 0x70,
-            0xb6, 0xed, 0x21, 0xb9, 0x9c, 0xa6, 0xf4, 0xf9,
-            0xf1, 0x53, 0xe7, 0xb1, 0xbe, 0xaf, 0xed, 0x1d,
-            0x23, 0x30, 0x4b, 0x7a, 0x39, 0xf9, 0xf3, 0xff,
-            0x06, 0x7d, 0x8d, 0x8f, 0x9e, 0x24, 0xec, 0xc7 ];
-
-        let enc = aessafe::AesSafe256EncryptorX8::new(&key);
-        let dec = aessafe::AesSafe256DecryptorX8::new(&key);
-        let mut tmp = [0u8; 128];
-        enc.encrypt_block_x8(&plain, &mut tmp);
-        assert!(tmp[..] == cipher[..]);
-        dec.decrypt_block_x8(&cipher, &mut tmp);
-        assert!(tmp[..] == plain[..]);
-    }
-
-    #[test]
-    fn aes_ctr_box() {
-        let tests = aes_ctr_tests();
-        for test in tests.iter() {
-            let mut aes_enc = aes::ctr(aes::KeySize::KeySize128, &test.key[..], &test.ctr[..]);
-            let mut result: Vec<u8> = repeat(0).take(test.plain.len()).collect();
-            aes_enc.process(&test.plain[..], &mut result[..]);
-            let res: &[u8] = result.as_ref();
-            assert!(res == &test.cipher[..]);
-        }
-    }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use test::Bencher;
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    use aesni;
-
-    use aessafe;
-    use symmetriccipher::{BlockEncryptor, BlockEncryptorX8};
-    use util;
-    use aes::KeySize::{self, KeySize128, KeySize192, KeySize256};
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    #[bench]
-    pub fn aesni_128_bench(bh: &mut Bencher) {
-        aesni_bench(bh, KeySize128);
-    }
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    #[bench]
-    pub fn aesni_192_bench(bh: &mut Bencher) {
-        aesni_bench(bh, KeySize192);
-    }
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    #[bench]
-    pub fn aesni_256_bench(bh: &mut Bencher) {
-        aesni_bench(bh, KeySize256);
-    }
-
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    fn aesni_bench(bh: &mut Bencher, key_size: KeySize) {
-        if util::supports_aesni() {
-            let key: [u8; 16] = [1u8; 16];
-            let plain: [u8; 16] = [2u8; 16];
-
-            let a = aesni::AesNiEncryptor::new(key_size, &key);
-
-            let mut tmp = [0u8; 16];
-
-            bh.iter( || {
-                a.encrypt_block(&plain, &mut tmp);
-            });
-
-            bh.bytes = (plain.len()) as u64;
-        }
-    }
-
-    #[bench]
-    pub fn aes_safe_bench(bh: &mut Bencher) {
-        let key: [u8; 16] = [1u8; 16];
-        let plain: [u8; 16] = [2u8; 16];
-
-        let a = aessafe::AesSafe128Encryptor::new(&key);
-
-        let mut tmp = [0u8; 16];
-
-        bh.iter( || {
-            a.encrypt_block(&plain, &mut tmp);
-        });
-
-        bh.bytes = (plain.len()) as u64;
-    }
-
-    #[bench]
-    pub fn aes_safe_x8_bench(bh: &mut Bencher) {
-        let key: [u8; 16] = [1u8; 16];
-        let plain: [u8; 128] = [2u8; 128];
-
-        let a = aessafe::AesSafe128EncryptorX8::new(&key);
-
-        let mut tmp = [0u8; 128];
-
-        bh.iter( || {
-            a.encrypt_block_x8(&plain, &mut tmp);
-        });
-
-        bh.bytes = (plain.len()) as u64;
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/aes_gcm.rs b/rustc_deps/vendor/rust-crypto/src/aes_gcm.rs
deleted file mode 100644
index e560b2d..0000000
--- a/rustc_deps/vendor/rust-crypto/src/aes_gcm.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use aes::{ctr, KeySize};
-use aead::{AeadEncryptor,AeadDecryptor};
-use cryptoutil::copy_memory;
-use symmetriccipher::SynchronousStreamCipher;
-use ghash::{Ghash};
-use util::fixed_time_eq;
-
-pub struct AesGcm<'a> {
-    cipher: Box<SynchronousStreamCipher + 'a>,
-    mac: Ghash,
-    finished: bool,
-    end_tag: [u8; 16]
-}
-
-impl<'a> AesGcm<'a> {
-    pub fn new (key_size: KeySize, key: &[u8], nonce: &[u8], aad: &[u8]) -> AesGcm<'a> {
-        assert!(key.len() == 16 || key.len() == 24 || key.len() == 32);
-        assert!(nonce.len() == 12);
-
-        // GCM technically differs from CTR mode in how role overs are handled
-        // GCM only touches the right most 4 bytes while CTR roles all 16 over
-        // when the iv is only 96 bits (12 bytes) then 4 bytes of zeros are
-        // appended to it meaning you have to encrypt 2^37 bytes (256 gigabytes)
-        // of data before a difference crops up.
-        // The GCM handles nonces of other lengths by hashing them once with ghash
-        // this would cause the roleover behavior to potentially be triggered much
-        // earlier preventing the use of generic CTR mode.
-
-        let mut iv = [0u8; 16];
-        copy_memory(nonce, &mut iv);
-        iv[15] = 1u8;
-        let mut cipher = ctr(key_size,key,&iv);
-        let temp_block = [0u8; 16];
-        let mut final_block = [0u8; 16];
-        cipher.process(&temp_block, &mut final_block);
-        let mut hash_key =  [0u8; 16];
-        let mut encryptor = ctr(key_size,key,&temp_block);
-        encryptor.process(&temp_block, &mut hash_key);
-        AesGcm {
-            cipher: cipher,
-            mac:  Ghash::new(&hash_key).input_a(aad),
-            finished: false,
-            end_tag: final_block
-        }
-    }
-    
-}
-
-impl<'a> AeadEncryptor for AesGcm<'static> {
-    fn encrypt(&mut self, input: &[u8], output: &mut [u8], tag: &mut [u8]) {
-        assert!(input.len() == output.len());
-        assert!(!self.finished);
-        self.cipher.process(input, output);
-        let result = self.mac.input_c(output).result();
-        self.finished = true;
-        for i in 0..16 {
-            tag[i] = result[i] ^ self.end_tag[i];
-        }
-    }
-}
-
-impl<'a> AeadDecryptor for AesGcm<'static> {
-    fn decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8])  -> bool {
-        assert!(input.len() == output.len());
-        assert!(!self.finished);
-        self.finished = true;
-        let mut calc_tag = self.mac.input_c(input).result();
-        for i in 0..16 {
-            calc_tag[i] ^= self.end_tag[i];
-        }
-        if fixed_time_eq(&calc_tag, tag) {
-            self.cipher.process(input, output);
-            true
-        } else {
-            false
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use aes::KeySize;
-    use aes_gcm::AesGcm;
-    use aead::{AeadEncryptor, AeadDecryptor};
-    use serialize::hex::FromHex;
-    use std::iter::repeat;
-    fn hex_to_bytes(raw_hex: &str) -> Vec<u8> {
-        raw_hex.from_hex().ok().unwrap()
-    }
-    struct TestVector {
-                key:  Vec<u8>,
-                iv:  Vec<u8>,
-                plain_text: Vec<u8>,
-                cipher_text:  Vec<u8>,
-                aad: Vec<u8>,
-                tag:  Vec<u8>,
-            }
-
-    fn get_test_vectors()-> [TestVector; 5]{
-      [
-        TestVector {
-                key: hex_to_bytes("00000000000000000000000000000000"),
-                iv: hex_to_bytes("000000000000000000000000"),
-                plain_text: hex_to_bytes(""),
-                cipher_text: hex_to_bytes(""),
-                aad: hex_to_bytes(""),
-                tag: hex_to_bytes("58e2fccefa7e3061367f1d57a4e7455a")
-            },
-            TestVector {
-                key: hex_to_bytes("00000000000000000000000000000000"),
-                iv: hex_to_bytes("000000000000000000000000"),
-                plain_text: hex_to_bytes("00000000000000000000000000000000"),
-                cipher_text: hex_to_bytes("0388dace60b6a392f328c2b971b2fe78"),
-                aad: hex_to_bytes(""),
-                tag: hex_to_bytes("ab6e47d42cec13bdf53a67b21257bddf")
-            },
-            TestVector {
-                key: hex_to_bytes("feffe9928665731c6d6a8f9467308308"),
-                iv: hex_to_bytes("cafebabefacedbaddecaf888"),
-                plain_text: hex_to_bytes("d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39"),
-                cipher_text: hex_to_bytes("42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091"),
-                aad: hex_to_bytes("feedfacedeadbeeffeedfacedeadbeefabaddad2"),
-                tag: hex_to_bytes("5bc94fbc3221a5db94fae95ae7121a47")
-            },
-            TestVector {
-                key: hex_to_bytes("feffe9928665731c6d6a8f9467308308feffe9928665731c"),
-                iv: hex_to_bytes("cafebabefacedbaddecaf888"),
-                plain_text: hex_to_bytes("d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39"),
-                cipher_text: hex_to_bytes("3980ca0b3c00e841eb06fac4872a2757859e1ceaa6efd984628593b40ca1e19c7d773d00c144c525ac619d18c84a3f4718e2448b2fe324d9ccda2710"),
-                aad: hex_to_bytes("feedfacedeadbeeffeedfacedeadbeefabaddad2"),
-                tag: hex_to_bytes("2519498e80f1478f37ba55bd6d27618c")
-            },
-            TestVector {
-                key: hex_to_bytes("feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308"),
-                iv: hex_to_bytes("cafebabefacedbaddecaf888"),
-                plain_text: hex_to_bytes("d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39"),
-                cipher_text: hex_to_bytes("522dc1f099567d07f47f37a32a84427d643a8cdcbfe5c0c97598a2bd2555d1aa8cb08e48590dbb3da7b08b1056828838c5f61e6393ba7a0abcc9f662"),
-                aad: hex_to_bytes("feedfacedeadbeeffeedfacedeadbeefabaddad2"),
-                tag: hex_to_bytes("76fc6ece0f4e1768cddf8853bb2d551b")
-            },
-    ]
-}
-    #[test]
-    fn aes_gcm_test() {
-            
-        for item in get_test_vectors().iter() {
-            let key_size = match item.key.len() {
-                16 => KeySize::KeySize128,
-                24 => KeySize::KeySize192,
-                32 => KeySize::KeySize256,
-                _ => unreachable!()
-            };
-            let mut cipher = AesGcm::new(key_size, &item.key[..], &item.iv[..], &item.aad[..]);
-            let mut out: Vec<u8> = repeat(0).take(item.plain_text.len()).collect();
-            
-            let mut out_tag: Vec<u8> = repeat(0).take(16).collect();
-            
-            cipher.encrypt(&item.plain_text[..], &mut out[..],&mut out_tag[..]);
-            assert_eq!(out, item.cipher_text);
-            assert_eq!(out_tag, item.tag);
-        }
-    }
-
-    #[test]
-    fn aes_gcm_decrypt_test() {
-            
-        for item in get_test_vectors().iter() {
-            let key_size = match item.key.len() {
-                16 => KeySize::KeySize128,
-                24 => KeySize::KeySize192,
-                32 => KeySize::KeySize256,
-                _ => unreachable!()
-            };
-            let mut decipher = AesGcm::new(key_size, &item.key[..], &item.iv[..], &item.aad[..]);
-            let mut out: Vec<u8> = repeat(0).take(item.plain_text.len()).collect();
-                        
-            let result = decipher.decrypt(&item.cipher_text[..], &mut out[..], &item.tag[..]);
-            assert_eq!(out, item.plain_text);
-            assert!(result);
-        }
-    }
-    #[test]
-    fn aes_gcm_decrypt_fail_test() {
-            
-        for item in get_test_vectors().iter() {
-            let key_size = match item.key.len() {
-                16 => KeySize::KeySize128,
-                24 => KeySize::KeySize192,
-                32 => KeySize::KeySize256,
-                _ => unreachable!()
-            };
-            let mut decipher = AesGcm::new(key_size, &item.key[..], &item.iv[..], &item.aad[..]);
-            let tag: Vec<u8> = repeat(0).take(16).collect();
-            let mut out1: Vec<u8> = repeat(0).take(item.plain_text.len()).collect();
-            let out2: Vec<u8> = repeat(0).take(item.plain_text.len()).collect();
-            let result = decipher.decrypt(&item.cipher_text[..], &mut out1[..], &tag[..]);
-            assert_eq!(out1, out2);
-            assert!(!result);
-        }
-    }
-
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use test::Bencher;
-    use aes::KeySize;
-    use aes_gcm::AesGcm;
-    use aead::{AeadEncryptor, AeadDecryptor};
-
-    #[bench]
-    pub fn gsm_10(bh: & mut Bencher) {
-    	let input = [1u8; 10];
-    	let aad = [3u8; 10];
-    	bh.iter( || {
-	        let mut cipher = AesGcm::new(KeySize::KeySize256, &[0; 32], &[0; 12], &aad);
-	        let mut decipher = AesGcm::new(KeySize::KeySize256, &[0; 32], &[0; 12], &aad);
-	        
-	        let mut output = [0u8; 10];
-	        let mut tag = [0u8; 16];
-	        let mut output2 = [0u8; 10];
-            cipher.encrypt(&input, &mut output, &mut tag);
-            decipher.decrypt(&output, &mut output2, &tag);
-            
-        });
-        bh.bytes = 10u64;
-    }
-        
-
-    #[bench]
-    pub fn gsm_1k(bh: & mut Bencher) {
-    	let input = [1u8; 1024];
-    	let aad = [3u8; 1024];
-    	bh.iter( || {
-        let mut cipher = AesGcm::new(KeySize::KeySize256, &[0; 32], &[0; 12], &aad);
-        let mut decipher = AesGcm::new(KeySize::KeySize256, &[0; 32], &[0; 12], &aad);
-        
-        let mut output = [0u8; 1024];
-        let mut tag = [0u8; 16];
-        let mut output2 = [0u8; 1024];
-        
-            cipher.encrypt(&input, &mut output, &mut tag);
-            decipher.decrypt(&output, &mut output2, &tag);
-        });
-    	bh.bytes = 1024u64;
-        
-    }
-
-    #[bench]
-    pub fn gsm_64k(bh: & mut Bencher) {
-    	let input = [1u8; 65536];
-    	let aad = [3u8; 65536];
-    	  bh.iter( || {
-        let mut cipher = AesGcm::new(KeySize::KeySize256, &[0; 32], &[0; 12], &aad);
-        let mut decipher = AesGcm::new(KeySize::KeySize256, &[0; 32], &[0; 12], &aad);
-        
-        let mut output = [0u8; 65536];
-        let mut tag = [0u8; 16];
-        let mut output2 = [0u8; 65536];
-      
-            cipher.encrypt(&input, &mut output, &mut tag);
-            decipher.decrypt(&output, &mut output2, &tag);
-
-        });
-    	   bh.bytes = 65536u64;
-        
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/aesni.rs b/rustc_deps/vendor/rust-crypto/src/aesni.rs
deleted file mode 100644
index e5d3857..0000000
--- a/rustc_deps/vendor/rust-crypto/src/aesni.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use aes::KeySize;
-use aes::KeySize::{KeySize128, KeySize192, KeySize256};
-use symmetriccipher::{BlockEncryptor, BlockDecryptor};
-use util::supports_aesni;
-
-#[derive(Copy)]
-pub struct AesNiEncryptor {
-    rounds: u8,
-    round_keys: [u8; 240]
-}
-
-impl Clone for AesNiEncryptor { fn clone(&self) -> AesNiEncryptor { *self } }
-
-#[derive(Copy)]
-pub struct AesNiDecryptor {
-    rounds: u8,
-    round_keys: [u8; 240]
-}
-
-impl Clone for AesNiDecryptor { fn clone(&self) -> AesNiDecryptor { *self } }
-
-/// The number of rounds as well as a function to setup an appropriately sized key.
-type RoundSetupInfo = (u8, fn(&[u8], KeyType, &mut [u8]));
-
-impl AesNiEncryptor {
-    pub fn new(key_size: KeySize, key: &[u8]) -> AesNiEncryptor {
-        if !supports_aesni() {
-            panic!("AES-NI not supported on this architecture. If you are \
-                using the MSVC toolchain, this is because the AES-NI method's \
-                have not been ported, yet");
-        }
-        let (rounds, setup_function): RoundSetupInfo = match key_size {
-            KeySize128 => (10, setup_working_key_aesni_128),
-            KeySize192 => (12, setup_working_key_aesni_192),
-            KeySize256 => (14, setup_working_key_aesni_256)
-        };
-        let mut e = AesNiEncryptor {
-            rounds: rounds,
-            round_keys: [0u8; 240]
-        };
-        setup_function(key, KeyType::Encryption, &mut e.round_keys[0..size(e.rounds)]);
-        e
-    }
-}
-
-impl AesNiDecryptor {
-    pub fn new(key_size: KeySize, key: &[u8]) -> AesNiDecryptor {
-        if !supports_aesni() {
-            panic!("AES-NI not supported on this architecture. If you are \
-                using the MSVC toolchain, this is because the AES-NI method's \
-                have not been ported, yet");
-        }
-        let (rounds, setup_function): RoundSetupInfo = match key_size {
-            KeySize128 => (10, setup_working_key_aesni_128),
-            KeySize192 => (12, setup_working_key_aesni_192),
-            KeySize256 => (14, setup_working_key_aesni_256)
-        };
-        let mut d = AesNiDecryptor {
-            rounds: rounds,
-            round_keys: [0u8; 240]
-        };
-        setup_function(key, KeyType::Decryption, &mut d.round_keys[0..size(d.rounds)]);
-        d
-    }
-
-}
-
-impl BlockEncryptor for AesNiEncryptor {
-    fn block_size(&self) -> usize { 16 }
-    fn encrypt_block(&self, input: &[u8], output: &mut [u8]) {
-        encrypt_block_aesni(self.rounds, input, &self.round_keys[0..size(self.rounds)], output);
-    }
-}
-
-impl BlockDecryptor for AesNiDecryptor {
-    fn block_size(&self) -> usize { 16 }
-    fn decrypt_block(&self, input: &[u8], output: &mut [u8]) {
-        decrypt_block_aesni(self.rounds, input, &self.round_keys[0..size(self.rounds)], output);
-    }
-}
-
-enum KeyType {
-    Encryption,
-    Decryption
-}
-
-#[inline(always)]
-fn size(rounds: u8) -> usize { 16 * ((rounds as usize) + 1) }
-
-extern {
-    fn rust_crypto_aesni_aesimc(round_keys: *mut u8);
-    fn rust_crypto_aesni_setup_working_key_128(key: *const u8, round_key: *mut u8);
-    fn rust_crypto_aesni_setup_working_key_192(key: *const u8, round_key: *mut u8);
-    fn rust_crypto_aesni_setup_working_key_256(key: *const u8, round_key: *mut u8);
-    fn rust_crypto_aesni_encrypt_block(
-            rounds: u8,
-            input: *const u8,
-            round_keys: *const u8,
-            output: *mut u8);
-    fn rust_crypto_aesni_decrypt_block(
-            rounds: u8,
-            input: *const u8,
-            round_keys: *const u8,
-            output: *mut u8);
-}
-
-fn setup_working_key_aesni_128(key: &[u8], key_type: KeyType, round_key: &mut [u8]) {
-    unsafe {
-        rust_crypto_aesni_setup_working_key_128(key.as_ptr(), round_key.as_mut_ptr());
-
-        match key_type {
-            KeyType::Decryption => {
-                // range of rounds keys from #1 to #9; skip the first and last key
-                for i in 1..10 {
-                    rust_crypto_aesni_aesimc(round_key.get_unchecked_mut(16 * i));
-                }
-            }
-            KeyType::Encryption => { /* nothing more to do */ }
-        }
-    }
-}
-
-fn setup_working_key_aesni_192(key: &[u8], key_type: KeyType, round_key: &mut [u8]) {
-    unsafe {
-        rust_crypto_aesni_setup_working_key_192(key.as_ptr(), round_key.as_mut_ptr());
-
-        match key_type {
-            KeyType::Decryption => {
-                // range of rounds keys from #1 to #11; skip the first and last key
-                for i in 1..12 {
-                    rust_crypto_aesni_aesimc(round_key.get_unchecked_mut(16 * i));
-                }
-            }
-            KeyType::Encryption => { /* nothing more to do */ }
-        }
-    }
-}
-
-fn setup_working_key_aesni_256(key: &[u8], key_type: KeyType, round_key: &mut [u8]) {
-    unsafe {
-        rust_crypto_aesni_setup_working_key_256(key.as_ptr(), round_key.as_mut_ptr());
-
-        match key_type {
-            KeyType::Decryption => {
-                // range of rounds keys from #1 to #13; skip the first and last key
-                for i in 1..14 {
-                    rust_crypto_aesni_aesimc(round_key.get_unchecked_mut(16 * i));
-                }
-            }
-            KeyType::Encryption => { /* nothing more to do */ }
-        }
-    }
-}
-
-fn encrypt_block_aesni(rounds: u8, input: &[u8], round_keys: &[u8], output: &mut [u8]) {
-    unsafe {
-        rust_crypto_aesni_encrypt_block(
-                rounds,
-                input.as_ptr(),
-                round_keys.as_ptr(),
-                output.as_mut_ptr());
-    }
-}
-
-fn decrypt_block_aesni(rounds: u8, input: &[u8], round_keys: &[u8], output: &mut [u8]) {
-    unsafe {
-        rust_crypto_aesni_decrypt_block(
-                rounds as u8,
-                input.as_ptr(),
-                round_keys.get_unchecked(round_keys.len() - 16),
-                output.as_mut_ptr());
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/aesni_helpers.asm b/rustc_deps/vendor/rust-crypto/src/aesni_helpers.asm
deleted file mode 100755
index ce5fa0e..0000000
--- a/rustc_deps/vendor/rust-crypto/src/aesni_helpers.asm
+++ /dev/null
@@ -1,34 +0,0 @@
-ifndef X64
-.686p
-.XMM
-.model flat, C
-endif
-
-.code
-
-rust_crypto_aesni_aesimc PROC public
-  ret
-rust_crypto_aesni_aesimc ENDP
-
-rust_crypto_aesni_setup_working_key_128 PROC public
-  ret
-rust_crypto_aesni_setup_working_key_128 ENDP
-
-rust_crypto_aesni_setup_working_key_192 PROC public
-  ret
-rust_crypto_aesni_setup_working_key_192 ENDP
-
-rust_crypto_aesni_setup_working_key_256 PROC public
-  ret
-rust_crypto_aesni_setup_working_key_256 ENDP
-
-rust_crypto_aesni_encrypt_block PROC public
-  ret
-rust_crypto_aesni_encrypt_block ENDP
-
-rust_crypto_aesni_decrypt_block PROC public
-  ret
-rust_crypto_aesni_decrypt_block ENDP
-
-end
-
diff --git a/rustc_deps/vendor/rust-crypto/src/aesni_helpers.c b/rustc_deps/vendor/rust-crypto/src/aesni_helpers.c
deleted file mode 100644
index fa49290..0000000
--- a/rustc_deps/vendor/rust-crypto/src/aesni_helpers.c
+++ /dev/null
@@ -1,360 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#include <stdint.h>
-#include <stdlib.h>
-
-#if defined(__i386__) || defined(__x86_64__)
-
-void rust_crypto_aesni_aesimc(uint8_t* round_keys) {
-    #ifdef __SSE__
-    asm volatile(
-        " \
-            movdqu (%0), %%xmm1; \
-            aesimc %%xmm1, %%xmm1; \
-            movdqu %%xmm1, (%0); \
-        "
-    : // outputs
-    : "r" (round_keys) // inputs
-    : "xmm1", "memory" // clobbers
-    );
-    #else
-    exit(1);
-    #endif
-}
-
-void rust_crypto_aesni_setup_working_key_128(
-        uint8_t* key,
-        uint8_t* round_key) {
-    #ifdef __SSE__
-    asm volatile(
-        " \
-            movdqu (%1), %%xmm1; \
-            movdqu %%xmm1, (%0); \
-            add $0x10, %0; \
-            \
-            aeskeygenassist $0x01, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x02, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x04, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x08, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x10, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x20, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x40, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x80, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x1b, %%xmm1, %%xmm2; \
-            call 1f; \
-            aeskeygenassist $0x36, %%xmm1, %%xmm2; \
-            call 1f; \
-            \
-            jmp 2f; \
-            \
-            1: \
-            pshufd $0xff, %%xmm2, %%xmm2; \
-            vpslldq $0x04, %%xmm1, %%xmm3; \
-            pxor %%xmm3, %%xmm1; \
-            vpslldq $0x4, %%xmm1, %%xmm3; \
-            pxor %%xmm3, %%xmm1; \
-            vpslldq $0x04, %%xmm1, %%xmm3; \
-            pxor %%xmm3, %%xmm1; \
-            pxor %%xmm2, %%xmm1; \
-            movdqu %%xmm1, (%0); \
-            add $0x10, %0; \
-            ret; \
-            \
-            2: \
-        "
-    : "+r" (round_key)
-    : "r" (key)
-    : "xmm1", "xmm2", "xmm3", "memory"
-    );
-    #else
-    exit(1);
-    #endif
-}
-
-void rust_crypto_aesni_setup_working_key_192(
-        uint8_t* key,
-        uint8_t* round_key) {
-    #ifdef __SSE__
-    asm volatile(
-        " \
-            movdqu (%1), %%xmm1; \
-            movdqu 16(%1), %%xmm3; \
-            movdqu %%xmm1, (%0); \
-            movdqa %%xmm3, %%xmm5; \
-            \
-            aeskeygenassist $0x1, %%xmm3, %%xmm2; \
-            call 1f; \
-            shufpd $0, %%xmm1, %%xmm5; \
-            movdqu %%xmm5, 16(%0); \
-            movdqa %%xmm1, %%xmm6; \
-            shufpd $1, %%xmm3, %%xmm6; \
-            movdqu %%xmm6, 32(%0); \
-            \
-            aeskeygenassist $0x2, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 48(%0); \
-            movdqa %%xmm3, %%xmm5; \
-            \
-            aeskeygenassist $0x4, %%xmm3, %%xmm2; \
-            call 1f; \
-            shufpd $0, %%xmm1, %%xmm5; \
-            movdqu %%xmm5, 64(%0); \
-            movdqa %%xmm1, %%xmm6; \
-            shufpd $1, %%xmm3, %%xmm6; \
-            movdqu %%xmm6, 80(%0); \
-            \
-            aeskeygenassist $0x8, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 96(%0); \
-            movdqa %%xmm3, %%xmm5; \
-            \
-            aeskeygenassist $0x10, %%xmm3, %%xmm2; \
-            call 1f; \
-            shufpd $0, %%xmm1, %%xmm5; \
-            movdqu %%xmm5, 112(%0); \
-            movdqa %%xmm1, %%xmm6; \
-            shufpd $1, %%xmm3, %%xmm6; \
-            movdqu %%xmm6, 128(%0); \
-            \
-            aeskeygenassist $0x20, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 144(%0); \
-            movdqa %%xmm3, %%xmm5; \
-            \
-            aeskeygenassist $0x40, %%xmm3, %%xmm2; \
-            call 1f; \
-            shufpd $0, %%xmm1, %%xmm5; \
-            movdqu %%xmm5, 160(%0); \
-            movdqa %%xmm1, %%xmm6; \
-            shufpd $1, %%xmm3, %%xmm6; \
-            movdqu %%xmm6, 176(%0); \
-            \
-            aeskeygenassist $0x80, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 192(%0); \
-            \
-            jmp 2f; \
-            \
-            1: \
-            pshufd $0x55, %%xmm2, %%xmm2; \
-            movdqu %%xmm1, %%xmm4; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm1; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm1; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm1; \
-            pxor %%xmm2, %%xmm1; \
-            pshufd $0xff, %%xmm1, %%xmm2; \
-            movdqu %%xmm3, %%xmm4; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm3; \
-            pxor %%xmm2, %%xmm3; \
-            ret; \
-            \
-            2: \
-        "
-    : "+r" (round_key)
-    : "r" (key)
-    : "xmm1", "xmm2", "xmm3", "memory"
-    );
-    #else
-    exit(1);
-    #endif
-}
-
-void rust_crypto_aesni_setup_working_key_256(
-        uint8_t* key,
-        uint8_t* round_key) {
-    #ifdef __SSE__
-    asm volatile(
-        " \
-            movdqu (%1), %%xmm1; \
-            movdqu 16(%1), %%xmm3; \
-            movdqu %%xmm1, (%0); \
-            movdqu %%xmm3, 16(%0); \
-            \
-            aeskeygenassist $0x1, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 32(%0); \
-            \
-            aeskeygenassist $0x0, %%xmm1, %%xmm2; \
-            call 2f; \
-            movdqu %%xmm3, 48(%0); \
-            \
-            aeskeygenassist $0x2, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 64(%0); \
-            \
-            aeskeygenassist $0x0, %%xmm1, %%xmm2; \
-            call 2f; \
-            movdqu %%xmm3, 80(%0); \
-            \
-            aeskeygenassist $0x4, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 96(%0); \
-            \
-            aeskeygenassist $0x0, %%xmm1, %%xmm2; \
-            call 2f; \
-            movdqu %%xmm3, 112(%0); \
-            \
-            aeskeygenassist $0x8, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 128(%0); \
-            \
-            aeskeygenassist $0x0, %%xmm1, %%xmm2; \
-            call 2f; \
-            movdqu %%xmm3, 144(%0); \
-            \
-            aeskeygenassist $0x10, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 160(%0); \
-            \
-            aeskeygenassist $0x0, %%xmm1, %%xmm2; \
-            call 2f; \
-            movdqu %%xmm3, 176(%0); \
-            \
-            aeskeygenassist $0x20, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 192(%0); \
-            \
-            aeskeygenassist $0x0, %%xmm1, %%xmm2; \
-            call 2f; \
-            movdqu %%xmm3, 208(%0); \
-            \
-            aeskeygenassist $0x40, %%xmm3, %%xmm2; \
-            call 1f; \
-            movdqu %%xmm1, 224(%0); \
-            \
-            jmp 3f; \
-            \
-            1: \
-            pshufd $0xff, %%xmm2, %%xmm2; \
-            movdqa %%xmm1, %%xmm4; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm1; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm1; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm1; \
-            pxor %%xmm2, %%xmm1; \
-            ret; \
-            \
-            2: \
-            pshufd $0xaa, %%xmm2, %%xmm2; \
-            movdqa %%xmm3, %%xmm4; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm3; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm3; \
-            pslldq $4, %%xmm4; \
-            pxor %%xmm4, %%xmm3; \
-            pxor %%xmm2, %%xmm3; \
-            ret; \
-            \
-            3: \
-        "
-    : "+r" (round_key)
-    : "r" (key)
-    : "xmm1", "xmm2", "xmm3", "memory"
-    );
-    #else
-    exit(1);
-    #endif
-}
-
-void rust_crypto_aesni_encrypt_block(
-            uint8_t rounds,
-            uint8_t* input,
-            uint8_t* round_keys,
-            uint8_t* output) {
-    #ifdef __SSE__
-    asm volatile(
-    " \
-        /* Copy the data to encrypt to xmm1 */ \
-        movdqu (%2), %%xmm1; \
-        \
-        /* Perform round 0 - the whitening step */ \
-        movdqu (%1), %%xmm0; \
-        add $0x10, %1; \
-        pxor %%xmm0, %%xmm1; \
-        \
-        /* Perform all remaining rounds (except the final one) */ \
-        1: \
-        movdqu (%1), %%xmm0; \
-        add $0x10, %1; \
-        aesenc %%xmm0, %%xmm1; \
-        sub $0x01, %0; \
-        cmp $0x01, %0; \
-        jne 1b; \
-        \
-        /* Perform the last round */ \
-        movdqu (%1), %%xmm0; \
-        aesenclast %%xmm0, %%xmm1; \
-        \
-        /* Finally, move the result from xmm1 to outp */ \
-        movdqu %%xmm1, (%3); \
-    "
-    : "+&r" (rounds), "+&r" (round_keys) // outputs
-    : "r" (input), "r" (output) // inputs
-    : "xmm0", "xmm1", "memory", "cc" // clobbers
-    );
-    #else
-    exit(1);
-    #endif
-}
-
-void rust_crypto_aesni_decrypt_block(
-            uint8_t rounds,
-            uint8_t* input,
-            uint8_t* round_keys,
-            uint8_t* output) {
-    #ifdef __SSE__
-    asm volatile(
-        " \
-            /* Copy the data to decrypt to xmm1 */ \
-            movdqu (%2), %%xmm1; \
-            \
-            /* Perform round 0 - the whitening step */ \
-            movdqu (%1), %%xmm0; \
-            sub $0x10, %1; \
-            pxor %%xmm0, %%xmm1; \
-            \
-            /* Perform all remaining rounds (except the final one) */ \
-            1: \
-            movdqu (%1), %%xmm0; \
-            sub $0x10, %1; \
-            aesdec %%xmm0, %%xmm1; \
-            sub $0x01, %0; \
-            cmp $0x01, %0; \
-            jne 1b; \
-            \
-            /* Perform the last round */ \
-            movdqu (%1), %%xmm0; \
-            aesdeclast %%xmm0, %%xmm1; \
-            \
-            /* Finally, move the result from xmm1 to outp */ \
-            movdqu %%xmm1, (%3); \
-        "
-    : "+&r" (rounds), "+&r" (round_keys) // outputs
-    : "r" (input), "r" (output) // inputs
-    : "xmm0", "xmm1", "memory", "cc" // clobbers
-    );
-    #else
-    exit(1);
-    #endif
-}
-
-#endif
diff --git a/rustc_deps/vendor/rust-crypto/src/aessafe.rs b/rustc_deps/vendor/rust-crypto/src/aessafe.rs
deleted file mode 100644
index 82fda89..0000000
--- a/rustc_deps/vendor/rust-crypto/src/aessafe.rs
+++ /dev/null
@@ -1,1231 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/*!
-
-The `aessafe` module implements the AES algorithm completely in software without using any table
-lookups or other timing dependant mechanisms. This module actually contains two seperate
-implementations - an implementation that works on a single block at a time and a second
-implementation that processes 8 blocks in parallel. Some block encryption modes really only work if
-you are processing a single blocks (CFB, OFB, and CBC encryption for example) while other modes
-are trivially parallelizable (CTR and CBC decryption). Processing more blocks at once allows for
-greater efficiency, especially when using wide registers, such as the XMM registers available in
-x86 processors.
-
-## AES Algorithm
-
-There are lots of places to go to on the internet for an involved description of how AES works. For
-the purposes of this description, it sufficies to say that AES is just a block cipher that takes
-a key of 16, 24, or 32 bytes and uses that to either encrypt or decrypt a block of 16 bytes. An
-encryption or decryption operation consists of a number of rounds which involve some combination of
-the following 4 basic operations:
-
-* ShiftRows
-* MixColumns
-* SubBytes
-* AddRoundKey
-
-## Timing problems
-
-Most software implementations of AES use a large set of lookup tables - generally at least the
-SubBytes step is implemented via lookup tables; faster implementations generally implement the
-MixColumns step this way as well. This is largely a design flaw in the AES implementation as it was
-not realized during the NIST standardization process that table lookups can lead to security
-problems [1]. The issue is that not all table lookups occur in constant time - an address that was
-recently used is looked up much faster than one that hasn't been used in a while. A careful
-adversary can measure the amount of time that each AES operation takes and use that information to
-help determine the secret key or plain text information. More specifically, its not table lookups
-that lead to these types of timing attacks - the issue is table lookups that use secret information
-as part of the address to lookup. A table lookup that is performed the exact same way every time
-regardless of the key or plaintext doesn't leak any information. This implementation uses no data
-dependant table lookups.
-
-## Bit Slicing
-
-Bit Slicing is a technique that is basically a software emulation of hardware implementation
-techniques. One of the earliest implementations of this technique was for a DES implementation [4].
-In hardware, table lookups do not present the same timing problems as they do in software, however
-they present other problems - namely that a 256 byte S-box table takes up a huge amount of space on
-a chip. Hardware implementations, thus, tend to avoid table lookups and instead calculate the
-contents of the S-Boxes as part of every operation. So, the key to an efficient Bit Sliced software
-implementation is to re-arrange all of the bits of data to process into a form that can easily be
-applied in much the same way that it would be in hardeware. It is fortunate, that AES was designed
-such that these types of hardware implementations could be very efficient - the contents of the
-S-boxes are defined by a mathematical formula.
-
-A hardware implementation works on single bits at a time. Unlike adding variables in software,
-however, that occur generally one at a time, hardware implementations are extremely parallel and
-operate on many, many bits at once. Bit Slicing emulates that by moving all "equivalent" bits into
-common registers and then operating on large groups of bits all at once. Calculating the S-box value
-for a single bit is extremely expensive, but its much cheaper when you can amortize that cost over
-128 bits (as in an XMM register). This implementation follows the same strategy as in [5] and that
-is an excellent source for more specific details. However, a short description follows.
-
-The input data is simply a collection of bytes. Each byte is comprised of 8 bits, a low order bit
-(bit 0) through a high order bit (bit 7). Bit slicing the input data simply takes all of the low
-order bits (bit 0) from the input data, and moves them into a single register (eg: XMM0). Next, all
-of them 2nd lowest bits are moved into their own register (eg: XMM1), and so on. After completion,
-we're left with 8 variables, each of which contains an equivalent set of bits. The exact order of
-those bits is irrevent for the implementation of the SubBytes step, however, it is very important
-for the MixColumns step. Again, see [5] for details. Due to the design of AES, its them possible to
-execute the entire AES operation using just bitwise exclusive ors and rotates once we have Bit
-Sliced the input data. After the completion of the AES operation, we then un-Bit Slice the data
-to give us our output. Clearly, the more bits that we can process at once, the faster this will go -
-thus, the version that processes 8 blocks at once is roughly 8 times faster than processing just a
-single block at a time.
-
-The ShiftRows step is fairly straight-forward to implement on the Bit Sliced state. The MixColumns
-and especially the SubBytes steps are more complicated. This implementation draws heavily on the
-formulas from [5], [6], and [7] to implement these steps.
-
-## Implementation
-
-Both implementations work basically the same way and share pretty much all of their code. The key
-is first processed to create all of the round keys where each round key is just a 16 byte chunk of
-data that is combined into the AES state by the AddRoundKey step as part of each encryption or
-decryption round. Processing the round key can be expensive, so this is done before encryption or
-decryption. Before encrypting or decrypting data, the data to be processed by be Bit Sliced into 8
-seperate variables where each variable holds equivalent bytes from the state. This Bit Sliced state
-is stored as a Bs8State<T>, where T is the type that stores each set of bits. The first
-implementation stores these bits in a u32 which permits up to 8 * 32 = 1024 bits of data to be
-processed at once. This implementation only processes a single block at a time, so, in reality, only
-512 bits are processed at once and the remaining 512 bits of the variables are unused. The 2nd
-implementation uses u32x4s - vectors of 4 u32s. Thus, we can process 8 * 128 = 4096 bits at once,
-which corresponds exactly to 8 blocks.
-
-The Bs8State struct implements the AesOps trait, which contains methods for each of the 4 main steps
-of the AES algorithm. The types, T, each implement the AesBitValueOps trait, which containts methods
-necessary for processing a collection or bit values and the AesOps trait relies heavily on this
-trait to perform its operations.
-
-The Bs4State and Bs2State struct implement operations of various subfields of the full GF(2^8)
-finite field which allows for efficient computation of the AES S-Boxes. See [7] for details.
-
-## References
-
-[1] - "Cache-Collision Timing Attacks Against AES". Joseph Bonneau and Ilya Mironov.
-      http://www.jbonneau.com/doc/BM06-CHES-aes_cache_timing.pdf
-[2] - "Software mitigations to hedge AES against cache-based software side channel vulnerabilities".
-      Ernie Brickell, et al. http://eprint.iacr.org/2006/052.pdf.
-[3] - "Cache Attacks and Countermeasures: the Case of AES (Extended Version)".
-      Dag Arne Osvik, et al. tau.ac.il/~tromer/papers/cache.pdf‎.
-[4] - "A Fast New DES Implementation in Software". Eli Biham.
-      http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.52.5429&rep=rep1&type=pdf.
-[5] - "Faster and Timing-Attack Resistant AES-GCM". Emilia K ╠łasper and Peter Schwabe.
-      http://www.chesworkshop.org/ches2009/presentations/01_Session_1/CHES2009_ekasper.pdf.
-[6] - "FAST AES DECRYPTION". Vinit Azad. http://webcache.googleusercontent.com/
-      search?q=cache:ld_f8pSgURcJ:csusdspace.calstate.edu/bitstream/handle/10211.9/1224/
-      Vinit_Azad_MS_Report.doc%3Fsequence%3D2+&cd=4&hl=en&ct=clnk&gl=us&client=ubuntu.
-[7] - "A Very Compact Rijndael S-box". D. Canright.
-      http://www.dtic.mil/cgi-bin/GetTRDoc?AD=ADA434781.
-*/
-
-use std::ops::{BitAnd, BitXor, Not};
-use std::default::Default;
-
-use cryptoutil::{read_u32v_le, write_u32_le};
-use simd::u32x4;
-use step_by::RangeExt;
-use symmetriccipher::{BlockEncryptor, BlockEncryptorX8, BlockDecryptor, BlockDecryptorX8};
-
-const U32X4_0: u32x4 = u32x4(0, 0, 0, 0);
-const U32X4_1: u32x4 = u32x4(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff);
-
-macro_rules! define_aes_struct(
-    (
-        $name:ident,
-        $rounds:expr
-    ) => (
-        #[derive(Clone, Copy)]
-        pub struct $name {
-            sk: [Bs8State<u16>; ($rounds + 1)]
-        }
-    )
-);
-
-macro_rules! define_aes_impl(
-    (
-        $name:ident,
-        $mode:ident,
-        $rounds:expr,
-        $key_size:expr
-    ) => (
-        impl $name {
-            pub fn new(key: &[u8]) -> $name {
-                let mut a =  $name {
-                    sk: [Bs8State(0, 0, 0, 0, 0, 0, 0, 0); ($rounds + 1)]
-                };
-                let mut tmp = [[0u32; 4]; ($rounds + 1)];
-                create_round_keys(key, KeyType::$mode, &mut tmp);
-                for i in 0..$rounds + 1 {
-                    a.sk[i] = bit_slice_4x4_with_u16(tmp[i][0], tmp[i][1], tmp[i][2], tmp[i][3]);
-                }
-                a
-            }
-        }
-    )
-);
-
-macro_rules! define_aes_enc(
-    (
-        $name:ident,
-        $rounds:expr
-    ) => (
-        impl BlockEncryptor for $name {
-            fn block_size(&self) -> usize { 16 }
-            fn encrypt_block(&self, input: &[u8], output: &mut [u8]) {
-                let mut bs = bit_slice_1x16_with_u16(input);
-                bs = encrypt_core(&bs, &self.sk);
-                un_bit_slice_1x16_with_u16(&bs, output);
-            }
-        }
-    )
-);
-
-macro_rules! define_aes_dec(
-    (
-        $name:ident,
-        $rounds:expr
-    ) => (
-        impl BlockDecryptor for $name {
-            fn block_size(&self) -> usize { 16 }
-            fn decrypt_block(&self, input: &[u8], output: &mut [u8]) {
-                let mut bs = bit_slice_1x16_with_u16(input);
-                bs = decrypt_core(&bs, &self.sk);
-                un_bit_slice_1x16_with_u16(&bs, output);
-            }
-        }
-    )
-);
-
-define_aes_struct!(AesSafe128Encryptor, 10);
-define_aes_struct!(AesSafe128Decryptor, 10);
-define_aes_impl!(AesSafe128Encryptor, Encryption, 10, 16);
-define_aes_impl!(AesSafe128Decryptor, Decryption, 10, 16);
-define_aes_enc!(AesSafe128Encryptor, 10);
-define_aes_dec!(AesSafe128Decryptor, 10);
-
-define_aes_struct!(AesSafe192Encryptor, 12);
-define_aes_struct!(AesSafe192Decryptor, 12);
-define_aes_impl!(AesSafe192Encryptor, Encryption, 12, 24);
-define_aes_impl!(AesSafe192Decryptor, Decryption, 12, 24);
-define_aes_enc!(AesSafe192Encryptor, 12);
-define_aes_dec!(AesSafe192Decryptor, 12);
-
-define_aes_struct!(AesSafe256Encryptor, 14);
-define_aes_struct!(AesSafe256Decryptor, 14);
-define_aes_impl!(AesSafe256Encryptor, Encryption, 14, 32);
-define_aes_impl!(AesSafe256Decryptor, Decryption, 14, 32);
-define_aes_enc!(AesSafe256Encryptor, 14);
-define_aes_dec!(AesSafe256Decryptor, 14);
-
-macro_rules! define_aes_struct_x8(
-    (
-        $name:ident,
-        $rounds:expr
-    ) => (
-        #[derive(Clone, Copy)]
-        pub struct $name {
-            sk: [Bs8State<u32x4>; ($rounds + 1)]
-        }
-    )
-);
-
-macro_rules! define_aes_impl_x8(
-    (
-        $name:ident,
-        $mode:ident,
-        $rounds:expr,
-        $key_size:expr
-    ) => (
-        impl $name {
-            pub fn new(key: &[u8]) -> $name {
-                let mut a =  $name {
-                    sk: [
-                        Bs8State(
-                            U32X4_0,
-                            U32X4_0,
-                            U32X4_0,
-                            U32X4_0,
-                            U32X4_0,
-                            U32X4_0,
-                            U32X4_0,
-                            U32X4_0);
-                        ($rounds + 1)]
-                };
-                let mut tmp = [[0u32; 4]; ($rounds + 1)];
-                create_round_keys(key, KeyType::$mode, &mut tmp);
-                for i in 0..$rounds + 1 {
-                    a.sk[i] = bit_slice_fill_4x4_with_u32x4(
-                        tmp[i][0],
-                        tmp[i][1],
-                        tmp[i][2],
-                        tmp[i][3]);
-                }
-                a
-            }
-        }
-    )
-);
-
-macro_rules! define_aes_enc_x8(
-    (
-        $name:ident,
-        $rounds:expr
-    ) => (
-        impl BlockEncryptorX8 for $name {
-            fn block_size(&self) -> usize { 16 }
-            fn encrypt_block_x8(&self, input: &[u8], output: &mut [u8]) {
-                let bs = bit_slice_1x128_with_u32x4(input);
-                let bs2 = encrypt_core(&bs, &self.sk);
-                un_bit_slice_1x128_with_u32x4(bs2, output);
-            }
-        }
-    )
-);
-
-macro_rules! define_aes_dec_x8(
-    (
-        $name:ident,
-        $rounds:expr
-    ) => (
-        impl BlockDecryptorX8 for $name {
-            fn block_size(&self) -> usize { 16 }
-            fn decrypt_block_x8(&self, input: &[u8], output: &mut [u8]) {
-                let bs = bit_slice_1x128_with_u32x4(input);
-                let bs2 = decrypt_core(&bs, &self.sk);
-                un_bit_slice_1x128_with_u32x4(bs2, output);
-            }
-        }
-    )
-);
-
-define_aes_struct_x8!(AesSafe128EncryptorX8, 10);
-define_aes_struct_x8!(AesSafe128DecryptorX8, 10);
-define_aes_impl_x8!(AesSafe128EncryptorX8, Encryption, 10, 16);
-define_aes_impl_x8!(AesSafe128DecryptorX8, Decryption, 10, 16);
-define_aes_enc_x8!(AesSafe128EncryptorX8, 10);
-define_aes_dec_x8!(AesSafe128DecryptorX8, 10);
-
-define_aes_struct_x8!(AesSafe192EncryptorX8, 12);
-define_aes_struct_x8!(AesSafe192DecryptorX8, 12);
-define_aes_impl_x8!(AesSafe192EncryptorX8, Encryption, 12, 24);
-define_aes_impl_x8!(AesSafe192DecryptorX8, Decryption, 12, 24);
-define_aes_enc_x8!(AesSafe192EncryptorX8, 12);
-define_aes_dec_x8!(AesSafe192DecryptorX8, 12);
-
-define_aes_struct_x8!(AesSafe256EncryptorX8, 14);
-define_aes_struct_x8!(AesSafe256DecryptorX8, 14);
-define_aes_impl_x8!(AesSafe256EncryptorX8, Encryption, 14, 32);
-define_aes_impl_x8!(AesSafe256DecryptorX8, Decryption, 14, 32);
-define_aes_enc_x8!(AesSafe256EncryptorX8, 14);
-define_aes_dec_x8!(AesSafe256DecryptorX8, 14);
-
-fn ffmulx(x: u32) -> u32 {
-    let m1: u32 = 0x80808080;
-    let m2: u32 = 0x7f7f7f7f;
-    let m3: u32 = 0x0000001b;
-    ((x & m2) << 1) ^ (((x & m1) >> 7) * m3)
-}
-
-fn inv_mcol(x: u32) -> u32 {
-    let f2 = ffmulx(x);
-    let f4 = ffmulx(f2);
-    let f8 = ffmulx(f4);
-    let f9 = x ^ f8;
-
-    f2 ^ f4 ^ f8 ^ (f2 ^ f9).rotate_right(8) ^ (f4 ^ f9).rotate_right(16) ^ f9.rotate_right(24)
-}
-
-fn sub_word(x: u32) -> u32 {
-    let bs = bit_slice_4x1_with_u16(x).sub_bytes();
-    un_bit_slice_4x1_with_u16(&bs)
-}
-
-enum KeyType {
-    Encryption,
-    Decryption
-}
-
-// This array is not accessed in any key-dependant way, so there are no timing problems inherent in
-// using it.
-static RCON: [u32; 10] = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
-
-// The round keys are created without bit-slicing the key data. The individual implementations bit
-// slice the round keys returned from this function. This function, and the few functions above, are
-// derived from the BouncyCastle AES implementation.
-fn create_round_keys(key: &[u8], key_type: KeyType, round_keys: &mut [[u32; 4]]) {
-    let (key_words, rounds) = match key.len() {
-        16 => (4, 10),
-        24 => (6, 12),
-        32 => (8, 14),
-        _ => panic!("Invalid AES key size.")
-    };
-
-    // The key is copied directly into the first few round keys
-    let mut j = 0;
-    for i in (0..key.len()).step_up(4) {
-        round_keys[j / 4][j % 4] =
-            (key[i] as u32) |
-            ((key[i+1] as u32) << 8) |
-            ((key[i+2] as u32) << 16) |
-            ((key[i+3] as u32) << 24);
-        j += 1;
-    };
-
-    // Calculate the rest of the round keys
-    for i in key_words..(rounds + 1) * 4 {
-        let mut tmp = round_keys[(i - 1) / 4][(i - 1) % 4];
-        if (i % key_words) == 0 {
-            tmp = sub_word(tmp.rotate_right(8)) ^ RCON[(i / key_words) - 1];
-        } else if (key_words == 8) && ((i % key_words) == 4) {
-            // This is only necessary for AES-256 keys
-            tmp = sub_word(tmp);
-        }
-        round_keys[i / 4][i % 4] = round_keys[(i - key_words) / 4][(i - key_words) % 4] ^ tmp;
-    }
-
-    // Decryption round keys require extra processing
-    match key_type {
-        KeyType::Decryption => {
-            for j in 1..rounds {
-                for i in 0..4 {
-                    round_keys[j][i] = inv_mcol(round_keys[j][i]);
-                }
-            }
-        },
-        KeyType::Encryption => { }
-    }
-}
-
-// This trait defines all of the operations needed for a type to be processed as part of an AES
-// encryption or decryption operation.
-trait AesOps {
-    fn sub_bytes(self) -> Self;
-    fn inv_sub_bytes(self) -> Self;
-    fn shift_rows(self) -> Self;
-    fn inv_shift_rows(self) -> Self;
-    fn mix_columns(self) -> Self;
-    fn inv_mix_columns(self) -> Self;
-    fn add_round_key(self, rk: &Self) -> Self;
-}
-
-fn encrypt_core<S: AesOps + Copy>(state: &S, sk: &[S]) -> S {
-    // Round 0 - add round key
-    let mut tmp = state.add_round_key(&sk[0]);
-
-    // Remaining rounds (except last round)
-    for i in 1..sk.len() - 1 {
-        tmp = tmp.sub_bytes();
-        tmp = tmp.shift_rows();
-        tmp = tmp.mix_columns();
-        tmp = tmp.add_round_key(&sk[i]);
-    }
-
-    // Last round
-    tmp = tmp.sub_bytes();
-    tmp = tmp.shift_rows();
-    tmp = tmp.add_round_key(&sk[sk.len() - 1]);
-
-    tmp
-}
-
-fn decrypt_core<S: AesOps + Copy>(state: &S, sk: &[S]) -> S {
-    // Round 0 - add round key
-    let mut tmp = state.add_round_key(&sk[sk.len() - 1]);
-
-    // Remaining rounds (except last round)
-    for i in 1..sk.len() - 1 {
-        tmp = tmp.inv_sub_bytes();
-        tmp = tmp.inv_shift_rows();
-        tmp = tmp.inv_mix_columns();
-        tmp = tmp.add_round_key(&sk[sk.len() - 1 - i]);
-    }
-
-    // Last round
-    tmp = tmp.inv_sub_bytes();
-    tmp = tmp.inv_shift_rows();
-    tmp = tmp.add_round_key(&sk[0]);
-
-    tmp
-}
-
-#[derive(Clone, Copy)]
-struct Bs8State<T>(T, T, T, T, T, T, T, T);
-
-impl <T: Copy> Bs8State<T> {
-    fn split(self) -> (Bs4State<T>, Bs4State<T>) {
-        let Bs8State(x0, x1, x2, x3, x4, x5, x6, x7) = self;
-        (Bs4State(x0, x1, x2, x3), Bs4State(x4, x5, x6, x7))
-    }
-}
-
-impl <T: BitXor<Output = T> + Copy> Bs8State<T> {
-    fn xor(self, rhs: Bs8State<T>) -> Bs8State<T> {
-        let Bs8State(a0, a1, a2, a3, a4, a5, a6, a7) = self;
-        let Bs8State(b0, b1, b2, b3, b4, b5, b6, b7) = rhs;
-        Bs8State(a0 ^ b0, a1 ^ b1, a2 ^ b2, a3 ^ b3, a4 ^ b4, a5 ^ b5, a6 ^ b6, a7 ^ b7)
-    }
-
-    // We need to be able to convert a Bs8State to and from a polynomial basis and a normal
-    // basis. That transformation could be done via pseudocode that roughly looks like the
-    // following:
-    //
-    // for x in 0..8 {
-    //     for y in 0..8 {
-    //         result.x ^= input.y & MATRIX[7 - y][x]
-    //     }
-    // }
-    //
-    // Where the MATRIX is one of the following depending on the conversion being done.
-    // (The affine transformation step is included in all of these matrices):
-    //
-    // A2X = [
-    //     [ 0,  0,  0, -1, -1,  0,  0, -1],
-    //     [-1, -1,  0,  0, -1, -1, -1, -1],
-    //     [ 0, -1,  0,  0, -1, -1, -1, -1],
-    //     [ 0,  0,  0, -1,  0,  0, -1,  0],
-    //     [-1,  0,  0, -1,  0,  0,  0,  0],
-    //     [-1,  0,  0,  0,  0,  0,  0, -1],
-    //     [-1,  0,  0, -1,  0, -1,  0, -1],
-    //     [-1, -1, -1, -1, -1, -1, -1, -1]
-    // ];
-    //
-    // X2A = [
-    //     [ 0,  0, -1,  0,  0, -1, -1,  0],
-    //     [ 0,  0,  0, -1, -1, -1, -1,  0],
-    //     [ 0, -1, -1, -1,  0, -1, -1,  0],
-    //     [ 0,  0, -1, -1,  0,  0,  0, -1],
-    //     [ 0,  0,  0, -1,  0, -1, -1,  0],
-    //     [-1,  0,  0, -1,  0, -1,  0,  0],
-    //     [ 0, -1, -1, -1, -1,  0, -1, -1],
-    //     [ 0,  0,  0,  0,  0, -1, -1,  0],
-    // ];
-    //
-    // X2S = [
-    //     [ 0,  0,  0, -1, -1,  0, -1,  0],
-    //     [-1,  0, -1, -1,  0, -1,  0,  0],
-    //     [ 0, -1, -1, -1, -1,  0,  0, -1],
-    //     [-1, -1,  0, -1,  0,  0,  0,  0],
-    //     [ 0,  0, -1, -1, -1,  0, -1, -1],
-    //     [ 0,  0, -1,  0,  0,  0,  0,  0],
-    //     [-1, -1,  0,  0,  0,  0,  0,  0],
-    //     [ 0,  0, -1,  0,  0, -1,  0,  0],
-    // ];
-    //
-    // S2X = [
-    //     [ 0,  0, -1, -1,  0,  0,  0, -1],
-    //     [-1,  0,  0, -1, -1, -1, -1,  0],
-    //     [-1,  0, -1,  0,  0,  0,  0,  0],
-    //     [-1, -1,  0, -1,  0, -1, -1, -1],
-    //     [ 0, -1,  0,  0, -1,  0,  0,  0],
-    //     [ 0,  0, -1,  0,  0,  0,  0,  0],
-    //     [-1,  0,  0,  0, -1,  0, -1,  0],
-    //     [-1, -1,  0,  0, -1,  0, -1,  0],
-    // ];
-    //
-    // Looking at the pseudocode implementation, we see that there is no point
-    // in processing any of the elements in those matrices that have zero values
-    // since a logical AND with 0 will produce 0 which will have no effect when it
-    // is XORed into the result.
-    //
-    // LLVM doesn't appear to be able to fully unroll the loops in the pseudocode
-    // above and to eliminate processing of the 0 elements. So, each transformation is
-    // implemented independently directly in fully unrolled form with the 0 elements
-    // removed.
-    //
-    // As an optimization, elements that are XORed together multiple times are
-    // XORed just once and then used multiple times. I wrote a simple program that
-    // greedily looked for terms to combine to create the implementations below.
-    // It is likely that this could be optimized more.
-
-    fn change_basis_a2x(&self) -> Bs8State<T> {
-        let t06 = self.6 ^ self.0;
-        let t056 = self.5 ^ t06;
-        let t0156 = t056 ^ self.1;
-        let t13 = self.1 ^ self.3;
-
-        let x0 = self.2 ^ t06 ^ t13;
-        let x1 = t056;
-        let x2 = self.0;
-        let x3 = self.0 ^ self.4 ^ self.7 ^ t13;
-        let x4 = self.7 ^ t056;
-        let x5 = t0156;
-        let x6 = self.4 ^ t056;
-        let x7 = self.2 ^ self.7 ^ t0156;
-
-        Bs8State(x0, x1, x2, x3, x4, x5, x6, x7)
-    }
-
-    fn change_basis_x2s(&self) -> Bs8State<T> {
-        let t46 = self.4 ^ self.6;
-        let t35 = self.3 ^ self.5;
-        let t06 = self.0 ^ self.6;
-        let t357 = t35 ^ self.7;
-
-        let x0 = self.1 ^ t46;
-        let x1 = self.1 ^ self.4 ^ self.5;
-        let x2 = self.2 ^ t35 ^ t06;
-        let x3 = t46 ^ t357;
-        let x4 = t357;
-        let x5 = t06;
-        let x6 = self.3 ^ self.7;
-        let x7 = t35;
-
-        Bs8State(x0, x1, x2, x3, x4, x5, x6, x7)
-    }
-
-    fn change_basis_x2a(&self) -> Bs8State<T> {
-        let t15 = self.1 ^ self.5;
-        let t36 = self.3 ^ self.6;
-        let t1356 = t15 ^ t36;
-        let t07 = self.0 ^ self.7;
-
-        let x0 = self.2;
-        let x1 = t15;
-        let x2 = self.4 ^ self.7 ^ t15;
-        let x3 = self.2 ^ self.4 ^ t1356;
-        let x4 = self.1 ^ self.6;
-        let x5 = self.2 ^ self.5 ^ t36 ^ t07;
-        let x6 = t1356 ^ t07;
-        let x7 = self.1 ^ self.4;
-
-        Bs8State(x0, x1, x2, x3, x4, x5, x6, x7)
-    }
-
-    fn change_basis_s2x(&self) -> Bs8State<T> {
-        let t46 = self.4 ^ self.6;
-        let t01 = self.0 ^ self.1;
-        let t0146 = t01 ^ t46;
-
-        let x0 = self.5 ^ t0146;
-        let x1 = self.0 ^ self.3 ^ self.4;
-        let x2 = self.2 ^ self.5 ^ self.7;
-        let x3 = self.7 ^ t46;
-        let x4 = self.3 ^ self.6 ^ t01;
-        let x5 = t46;
-        let x6 = t0146;
-        let x7 = self.4 ^ self.7;
-
-        Bs8State(x0, x1, x2, x3, x4, x5, x6, x7)
-    }
-}
-
-impl <T: Not<Output = T> + Copy> Bs8State<T> {
-    // The special value "x63" is used as part of the sub_bytes and inv_sub_bytes
-    // steps. It is conceptually a Bs8State value where the 0th, 1st, 5th, and 6th
-    // elements are all 1s and the other elements are all 0s. The only thing that
-    // we do with the "x63" value is to XOR a Bs8State with it. We optimize that XOR
-    // below into just inverting 4 of the elements and leaving the other 4 elements
-    // untouched.
-    fn xor_x63(self) -> Bs8State<T> {
-        Bs8State (
-            !self.0,
-            !self.1,
-            self.2,
-            self.3,
-            self.4,
-            !self.5,
-            !self.6,
-            self.7)
-    }
-}
-
-#[derive(Clone, Copy)]
-struct Bs4State<T>(T, T, T, T);
-
-impl <T: Copy> Bs4State<T> {
-    fn split(self) -> (Bs2State<T>, Bs2State<T>) {
-        let Bs4State(x0, x1, x2, x3) = self;
-        (Bs2State(x0, x1), Bs2State(x2, x3))
-    }
-
-    fn join(self, rhs: Bs4State<T>) -> Bs8State<T> {
-        let Bs4State(a0, a1, a2, a3) = self;
-        let Bs4State(b0, b1, b2, b3) = rhs;
-        Bs8State(a0, a1, a2, a3, b0, b1, b2, b3)
-    }
-}
-
-impl <T: BitXor<Output = T> + Copy> Bs4State<T> {
-    fn xor(self, rhs: Bs4State<T>) -> Bs4State<T> {
-        let Bs4State(a0, a1, a2, a3) = self;
-        let Bs4State(b0, b1, b2, b3) = rhs;
-        Bs4State(a0 ^ b0, a1 ^ b1, a2 ^ b2, a3 ^ b3)
-    }
-}
-
-#[derive(Clone, Copy)]
-struct Bs2State<T>(T, T);
-
-impl <T> Bs2State<T> {
-    fn split(self) -> (T, T) {
-        let Bs2State(x0, x1) = self;
-        (x0, x1)
-    }
-
-    fn join(self, rhs: Bs2State<T>) -> Bs4State<T> {
-        let Bs2State(a0, a1) = self;
-        let Bs2State(b0, b1) = rhs;
-        Bs4State(a0, a1, b0, b1)
-    }
-}
-
-impl <T: BitXor<Output = T> + Copy> Bs2State<T> {
-    fn xor(self, rhs: Bs2State<T>) -> Bs2State<T> {
-        let Bs2State(a0, a1) = self;
-        let Bs2State(b0, b1) = rhs;
-        Bs2State(a0 ^ b0, a1 ^ b1)
-    }
-}
-
-// Bit Slice data in the form of 4 u32s in column-major order
-fn bit_slice_4x4_with_u16(a: u32, b: u32, c: u32, d: u32) -> Bs8State<u16> {
-    fn pb(x: u32, bit: u32, shift: u32) -> u16 {
-        (((x >> bit) & 1) as u16) << shift
-    }
-
-    fn construct(a: u32, b: u32, c: u32, d: u32, bit: u32) -> u16 {
-        pb(a, bit, 0)       | pb(b, bit, 1)       | pb(c, bit, 2)       | pb(d, bit, 3)       |
-        pb(a, bit + 8, 4)   | pb(b, bit + 8, 5)   | pb(c, bit + 8, 6)   | pb(d, bit + 8, 7)   |
-        pb(a, bit + 16, 8)  | pb(b, bit + 16, 9)  | pb(c, bit + 16, 10) | pb(d, bit + 16, 11) |
-        pb(a, bit + 24, 12) | pb(b, bit + 24, 13) | pb(c, bit + 24, 14) | pb(d, bit + 24, 15)
-    }
-
-    let x0 = construct(a, b, c, d, 0);
-    let x1 = construct(a, b, c, d, 1);
-    let x2 = construct(a, b, c, d, 2);
-    let x3 = construct(a, b, c, d, 3);
-    let x4 = construct(a, b, c, d, 4);
-    let x5 = construct(a, b, c, d, 5);
-    let x6 = construct(a, b, c, d, 6);
-    let x7 = construct(a, b, c, d, 7);
-
-    Bs8State(x0, x1, x2, x3, x4, x5, x6, x7)
-}
-
-// Bit slice a single u32 value - this is used to calculate the SubBytes step when creating the
-// round keys.
-fn bit_slice_4x1_with_u16(a: u32) -> Bs8State<u16> {
-    bit_slice_4x4_with_u16(a, 0, 0, 0)
-}
-
-// Bit slice a 16 byte array in column major order
-fn bit_slice_1x16_with_u16(data: &[u8]) -> Bs8State<u16> {
-    let mut n = [0u32; 4];
-    read_u32v_le(&mut n, data);
-
-    let a = n[0];
-    let b = n[1];
-    let c = n[2];
-    let d = n[3];
-
-    bit_slice_4x4_with_u16(a, b, c, d)
-}
-
-// Un Bit Slice into a set of 4 u32s
-fn un_bit_slice_4x4_with_u16(bs: &Bs8State<u16>) -> (u32, u32, u32, u32) {
-    fn pb(x: u16, bit: u32, shift: u32) -> u32 {
-        (((x >> bit) & 1) as u32) << shift
-    }
-
-    fn deconstruct(bs: &Bs8State<u16>, bit: u32) -> u32 {
-        let Bs8State(x0, x1, x2, x3, x4, x5, x6, x7) = *bs;
-
-        pb(x0, bit, 0) | pb(x1, bit, 1) | pb(x2, bit, 2) | pb(x3, bit, 3) |
-        pb(x4, bit, 4) | pb(x5, bit, 5) | pb(x6, bit, 6) | pb(x7, bit, 7) |
-
-        pb(x0, bit + 4, 8)  | pb(x1, bit + 4, 9)  | pb(x2, bit + 4, 10) | pb(x3, bit + 4, 11) |
-        pb(x4, bit + 4, 12) | pb(x5, bit + 4, 13) | pb(x6, bit + 4, 14) | pb(x7, bit + 4, 15) |
-
-        pb(x0, bit + 8, 16) | pb(x1, bit + 8, 17) | pb(x2, bit + 8, 18) | pb(x3, bit + 8, 19) |
-        pb(x4, bit + 8, 20) | pb(x5, bit + 8, 21) | pb(x6, bit + 8, 22) | pb(x7, bit + 8, 23) |
-
-        pb(x0, bit + 12, 24) | pb(x1, bit + 12, 25) | pb(x2, bit + 12, 26) | pb(x3, bit + 12, 27) |
-        pb(x4, bit + 12, 28) | pb(x5, bit + 12, 29) | pb(x6, bit + 12, 30) | pb(x7, bit + 12, 31)
-    }
-
-    let a = deconstruct(bs, 0);
-    let b = deconstruct(bs, 1);
-    let c = deconstruct(bs, 2);
-    let d = deconstruct(bs, 3);
-
-    (a, b, c, d)
-}
-
-// Un Bit Slice into a single u32. This is used when creating the round keys.
-fn un_bit_slice_4x1_with_u16(bs: &Bs8State<u16>) -> u32 {
-    let (a, _, _, _) = un_bit_slice_4x4_with_u16(bs);
-    a
-}
-
-// Un Bit Slice into a 16 byte array
-fn un_bit_slice_1x16_with_u16(bs: &Bs8State<u16>, output: &mut [u8]) {
-    let (a, b, c, d) = un_bit_slice_4x4_with_u16(bs);
-
-    write_u32_le(&mut output[0..4], a);
-    write_u32_le(&mut output[4..8], b);
-    write_u32_le(&mut output[8..12], c);
-    write_u32_le(&mut output[12..16], d);
-}
-
-// Bit Slice a 128 byte array of eight 16 byte blocks. Each block is in column major order.
-fn bit_slice_1x128_with_u32x4(data: &[u8]) -> Bs8State<u32x4> {
-    let bit0 = u32x4(0x01010101, 0x01010101, 0x01010101, 0x01010101);
-    let bit1 = u32x4(0x02020202, 0x02020202, 0x02020202, 0x02020202);
-    let bit2 = u32x4(0x04040404, 0x04040404, 0x04040404, 0x04040404);
-    let bit3 = u32x4(0x08080808, 0x08080808, 0x08080808, 0x08080808);
-    let bit4 = u32x4(0x10101010, 0x10101010, 0x10101010, 0x10101010);
-    let bit5 = u32x4(0x20202020, 0x20202020, 0x20202020, 0x20202020);
-    let bit6 = u32x4(0x40404040, 0x40404040, 0x40404040, 0x40404040);
-    let bit7 = u32x4(0x80808080, 0x80808080, 0x80808080, 0x80808080);
-
-    fn read_row_major(data: &[u8]) -> u32x4 {
-        u32x4(
-            (data[0] as u32) |
-            ((data[4] as u32) << 8) |
-            ((data[8] as u32) << 16) |
-            ((data[12] as u32) << 24),
-            (data[1] as u32) |
-            ((data[5] as u32) << 8) |
-            ((data[9] as u32) << 16) |
-            ((data[13] as u32) << 24),
-            (data[2] as u32) |
-            ((data[6] as u32) << 8) |
-            ((data[10] as u32) << 16) |
-            ((data[14] as u32) << 24),
-            (data[3] as u32) |
-            ((data[7] as u32) << 8) |
-            ((data[11] as u32) << 16) |
-            ((data[15] as u32) << 24))
-    }
-
-    let t0 = read_row_major(&data[0..16]);
-    let t1 = read_row_major(&data[16..32]);
-    let t2 = read_row_major(&data[32..48]);
-    let t3 = read_row_major(&data[48..64]);
-    let t4 = read_row_major(&data[64..80]);
-    let t5 = read_row_major(&data[80..96]);
-    let t6 = read_row_major(&data[96..112]);
-    let t7 = read_row_major(&data[112..128]);
-
-    let x0 = (t0 & bit0) | (t1.lsh(1) & bit1) | (t2.lsh(2) & bit2) | (t3.lsh(3) & bit3) |
-        (t4.lsh(4) & bit4) | (t5.lsh(5) & bit5) | (t6.lsh(6) & bit6) | (t7.lsh(7) & bit7);
-    let x1 = (t0.rsh(1) & bit0) | (t1 & bit1) | (t2.lsh(1) & bit2) | (t3.lsh(2) & bit3) |
-        (t4.lsh(3) & bit4) | (t5.lsh(4) & bit5) | (t6.lsh(5) & bit6) | (t7.lsh(6) & bit7);
-    let x2 = (t0.rsh(2) & bit0) | (t1.rsh(1) & bit1) | (t2 & bit2) | (t3.lsh(1) & bit3) |
-        (t4.lsh(2) & bit4) | (t5.lsh(3) & bit5) | (t6.lsh(4) & bit6) | (t7.lsh(5) & bit7);
-    let x3 = (t0.rsh(3) & bit0) | (t1.rsh(2) & bit1) | (t2.rsh(1) & bit2) | (t3 & bit3) |
-        (t4.lsh(1) & bit4) | (t5.lsh(2) & bit5) | (t6.lsh(3) & bit6) | (t7.lsh(4) & bit7);
-    let x4 = (t0.rsh(4) & bit0) | (t1.rsh(3) & bit1) | (t2.rsh(2) & bit2) | (t3.rsh(1) & bit3) |
-        (t4 & bit4) | (t5.lsh(1) & bit5) | (t6.lsh(2) & bit6) | (t7.lsh(3) & bit7);
-    let x5 = (t0.rsh(5) & bit0) | (t1.rsh(4) & bit1) | (t2.rsh(3) & bit2) | (t3.rsh(2) & bit3) |
-        (t4.rsh(1) & bit4) | (t5 & bit5) | (t6.lsh(1) & bit6) | (t7.lsh(2) & bit7);
-    let x6 = (t0.rsh(6) & bit0) | (t1.rsh(5) & bit1) | (t2.rsh(4) & bit2) | (t3.rsh(3) & bit3) |
-        (t4.rsh(2) & bit4) | (t5.rsh(1) & bit5) | (t6 & bit6) | (t7.lsh(1) & bit7);
-    let x7 = (t0.rsh(7) & bit0) | (t1.rsh(6) & bit1) | (t2.rsh(5) & bit2) | (t3.rsh(4) & bit3) |
-        (t4.rsh(3) & bit4) | (t5.rsh(2) & bit5) | (t6.rsh(1) & bit6) | (t7 & bit7);
-
-    Bs8State(x0, x1, x2, x3, x4, x5, x6, x7)
-}
-
-// Bit slice a set of 4 u32s by filling a full 128 byte data block with those repeated values. This
-// is used as part of bit slicing the round keys.
-fn bit_slice_fill_4x4_with_u32x4(a: u32, b: u32, c: u32, d: u32) -> Bs8State<u32x4> {
-    let mut tmp = [0u8; 128];
-    for i in 0..8 {
-        write_u32_le(&mut tmp[i * 16..i * 16 + 4], a);
-        write_u32_le(&mut tmp[i * 16 + 4..i * 16 + 8], b);
-        write_u32_le(&mut tmp[i * 16 + 8..i * 16 + 12], c);
-        write_u32_le(&mut tmp[i * 16 + 12..i * 16 + 16], d);
-    }
-    bit_slice_1x128_with_u32x4(&tmp)
-}
-
-// Un bit slice into a 128 byte buffer.
-fn un_bit_slice_1x128_with_u32x4(bs: Bs8State<u32x4>, output: &mut [u8]) {
-    let Bs8State(t0, t1, t2, t3, t4, t5, t6, t7) = bs;
-
-    let bit0 = u32x4(0x01010101, 0x01010101, 0x01010101, 0x01010101);
-    let bit1 = u32x4(0x02020202, 0x02020202, 0x02020202, 0x02020202);
-    let bit2 = u32x4(0x04040404, 0x04040404, 0x04040404, 0x04040404);
-    let bit3 = u32x4(0x08080808, 0x08080808, 0x08080808, 0x08080808);
-    let bit4 = u32x4(0x10101010, 0x10101010, 0x10101010, 0x10101010);
-    let bit5 = u32x4(0x20202020, 0x20202020, 0x20202020, 0x20202020);
-    let bit6 = u32x4(0x40404040, 0x40404040, 0x40404040, 0x40404040);
-    let bit7 = u32x4(0x80808080, 0x80808080, 0x80808080, 0x80808080);
-
-    // decode the individual blocks, in row-major order
-    // TODO: this is identical to the same block in bit_slice_1x128_with_u32x4
-    let x0 = (t0 & bit0) | (t1.lsh(1) & bit1) | (t2.lsh(2) & bit2) | (t3.lsh(3) & bit3) |
-        (t4.lsh(4) & bit4) | (t5.lsh(5) & bit5) | (t6.lsh(6) & bit6) | (t7.lsh(7) & bit7);
-    let x1 = (t0.rsh(1) & bit0) | (t1 & bit1) | (t2.lsh(1) & bit2) | (t3.lsh(2) & bit3) |
-        (t4.lsh(3) & bit4) | (t5.lsh(4) & bit5) | (t6.lsh(5) & bit6) | (t7.lsh(6) & bit7);
-    let x2 = (t0.rsh(2) & bit0) | (t1.rsh(1) & bit1) | (t2 & bit2) | (t3.lsh(1) & bit3) |
-        (t4.lsh(2) & bit4) | (t5.lsh(3) & bit5) | (t6.lsh(4) & bit6) | (t7.lsh(5) & bit7);
-    let x3 = (t0.rsh(3) & bit0) | (t1.rsh(2) & bit1) | (t2.rsh(1) & bit2) | (t3 & bit3) |
-        (t4.lsh(1) & bit4) | (t5.lsh(2) & bit5) | (t6.lsh(3) & bit6) | (t7.lsh(4) & bit7);
-    let x4 = (t0.rsh(4) & bit0) | (t1.rsh(3) & bit1) | (t2.rsh(2) & bit2) | (t3.rsh(1) & bit3) |
-        (t4 & bit4) | (t5.lsh(1) & bit5) | (t6.lsh(2) & bit6) | (t7.lsh(3) & bit7);
-    let x5 = (t0.rsh(5) & bit0) | (t1.rsh(4) & bit1) | (t2.rsh(3) & bit2) | (t3.rsh(2) & bit3) |
-        (t4.rsh(1) & bit4) | (t5 & bit5) | (t6.lsh(1) & bit6) | (t7.lsh(2) & bit7);
-    let x6 = (t0.rsh(6) & bit0) | (t1.rsh(5) & bit1) | (t2.rsh(4) & bit2) | (t3.rsh(3) & bit3) |
-        (t4.rsh(2) & bit4) | (t5.rsh(1) & bit5) | (t6 & bit6) | (t7.lsh(1) & bit7);
-    let x7 = (t0.rsh(7) & bit0) | (t1.rsh(6) & bit1) | (t2.rsh(5) & bit2) | (t3.rsh(4) & bit3) |
-        (t4.rsh(3) & bit4) | (t5.rsh(2) & bit5) | (t6.rsh(1) & bit6) | (t7 & bit7);
-
-    fn write_row_major(block: u32x4, output: &mut [u8]) {
-        let u32x4(a0, a1, a2, a3) = block;
-        output[0] = a0 as u8;
-        output[1] = a1 as u8;
-        output[2] = a2 as u8;
-        output[3] = a3 as u8;
-        output[4] = (a0 >> 8) as u8;
-        output[5] = (a1 >> 8) as u8;
-        output[6] = (a2 >> 8) as u8;
-        output[7] = (a3 >> 8) as u8;
-        output[8] = (a0 >> 16) as u8;
-        output[9] = (a1 >> 16) as u8;
-        output[10] = (a2 >> 16) as u8;
-        output[11] = (a3 >> 16) as u8;
-        output[12] = (a0 >> 24) as u8;
-        output[13] = (a1 >> 24) as u8;
-        output[14] = (a2 >> 24) as u8;
-        output[15] = (a3 >> 24) as u8;
-    }
-
-    write_row_major(x0, &mut output[0..16]);
-    write_row_major(x1, &mut output[16..32]);
-    write_row_major(x2, &mut output[32..48]);
-    write_row_major(x3, &mut output[48..64]);
-    write_row_major(x4, &mut output[64..80]);
-    write_row_major(x5, &mut output[80..96]);
-    write_row_major(x6, &mut output[96..112]);
-    write_row_major(x7, &mut output[112..128])
-}
-
-// The Gf2Ops, Gf4Ops, and Gf8Ops traits specify the functions needed to calculate the AES S-Box
-// values. This particuar implementation of those S-Box values is taken from [7], so that is where
-// to look for details on how all that all works. This includes the transformations matrices defined
-// below for the change_basis operation on the u32 and u32x4 types.
-
-// Operations in GF(2^2) using normal basis (Omega^2,Omega)
-trait Gf2Ops {
-    // multiply
-    fn mul(self, y: Self) -> Self;
-
-    // scale by N = Omega^2
-    fn scl_n(self) -> Self;
-
-    // scale by N^2 = Omega
-    fn scl_n2(self) -> Self;
-
-    // square
-    fn sq(self) -> Self;
-
-    // Same as sqaure
-    fn inv(self) -> Self;
-}
-
-impl <T: BitXor<Output = T> + BitAnd<Output = T> + Copy> Gf2Ops for Bs2State<T> {
-    fn mul(self, y: Bs2State<T>) -> Bs2State<T> {
-        let (b, a) = self.split();
-        let (d, c) = y.split();
-        let e = (a ^ b) & (c ^ d);
-        let p = (a & c) ^ e;
-        let q = (b & d) ^ e;
-        Bs2State(q, p)
-    }
-
-    fn scl_n(self) -> Bs2State<T> {
-        let (b, a) = self.split();
-        let q = a ^ b;
-        Bs2State(q, b)
-    }
-
-    fn scl_n2(self) -> Bs2State<T> {
-        let (b, a) = self.split();
-        let p = a ^ b;
-        let q = a;
-        Bs2State(q, p)
-    }
-
-    fn sq(self) -> Bs2State<T> {
-        let (b, a) = self.split();
-        Bs2State(a, b)
-    }
-
-    fn inv(self) -> Bs2State<T> {
-        self.sq()
-    }
-}
-
-// Operations in GF(2^4) using normal basis (alpha^8,alpha^2)
-trait Gf4Ops {
-    // multiply
-    fn mul(self, y: Self) -> Self;
-
-    // square & scale by nu
-    // nu = beta^8 = N^2*alpha^2, N = w^2
-    fn sq_scl(self) -> Self;
-
-    // inverse
-    fn inv(self) -> Self;
-}
-
-impl <T: BitXor<Output = T> + BitAnd<Output = T> + Copy> Gf4Ops for Bs4State<T> {
-    fn mul(self, y: Bs4State<T>) -> Bs4State<T> {
-        let (b, a) = self.split();
-        let (d, c) = y.split();
-        let f = c.xor(d);
-        let e = a.xor(b).mul(f).scl_n();
-        let p = a.mul(c).xor(e);
-        let q = b.mul(d).xor(e);
-        q.join(p)
-    }
-
-    fn sq_scl(self) -> Bs4State<T> {
-        let (b, a) = self.split();
-        let p = a.xor(b).sq();
-        let q = b.sq().scl_n2();
-        q.join(p)
-    }
-
-    fn inv(self) -> Bs4State<T> {
-        let (b, a) = self.split();
-        let c = a.xor(b).sq().scl_n();
-        let d = a.mul(b);
-        let e = c.xor(d).inv();
-        let p = e.mul(b);
-        let q = e.mul(a);
-        q.join(p)
-    }
-}
-
-// Operations in GF(2^8) using normal basis (d^16,d)
-trait Gf8Ops {
-    // inverse
-    fn inv(&self) -> Self;
-}
-
-impl <T: BitXor<Output = T> + BitAnd<Output = T> + Copy + Default> Gf8Ops for Bs8State<T> {
-    fn inv(&self) -> Bs8State<T> {
-        let (b, a) = self.split();
-        let c = a.xor(b).sq_scl();
-        let d = a.mul(b);
-        let e = c.xor(d).inv();
-        let p = e.mul(b);
-        let q = e.mul(a);
-        q.join(p)
-    }
-}
-
-impl <T: AesBitValueOps + Copy + 'static> AesOps for Bs8State<T> {
-    fn sub_bytes(self) -> Bs8State<T> {
-        let nb: Bs8State<T> = self.change_basis_a2x();
-        let inv = nb.inv();
-        let nb2: Bs8State<T> = inv.change_basis_x2s();
-        nb2.xor_x63()
-    }
-
-    fn inv_sub_bytes(self) -> Bs8State<T> {
-        let t = self.xor_x63();
-        let nb: Bs8State<T> = t.change_basis_s2x();
-        let inv = nb.inv();
-        inv.change_basis_x2a()
-    }
-
-    fn shift_rows(self) -> Bs8State<T> {
-        let Bs8State(x0, x1, x2, x3, x4, x5, x6, x7) = self;
-        Bs8State(
-            x0.shift_row(),
-            x1.shift_row(),
-            x2.shift_row(),
-            x3.shift_row(),
-            x4.shift_row(),
-            x5.shift_row(),
-            x6.shift_row(),
-            x7.shift_row())
-    }
-
-    fn inv_shift_rows(self) -> Bs8State<T> {
-        let Bs8State(x0, x1, x2, x3, x4, x5, x6, x7) = self;
-        Bs8State(
-            x0.inv_shift_row(),
-            x1.inv_shift_row(),
-            x2.inv_shift_row(),
-            x3.inv_shift_row(),
-            x4.inv_shift_row(),
-            x5.inv_shift_row(),
-            x6.inv_shift_row(),
-            x7.inv_shift_row())
-    }
-
-    // Formula from [5]
-    fn mix_columns(self) -> Bs8State<T> {
-        let Bs8State(x0, x1, x2, x3, x4, x5, x6, x7) = self;
-
-        let x0out = x7 ^ x7.ror1() ^ x0.ror1() ^ (x0 ^ x0.ror1()).ror2();
-        let x1out = x0 ^ x0.ror1() ^ x7 ^ x7.ror1() ^ x1.ror1() ^ (x1 ^ x1.ror1()).ror2();
-        let x2out = x1 ^ x1.ror1() ^ x2.ror1() ^ (x2 ^ x2.ror1()).ror2();
-        let x3out = x2 ^ x2.ror1() ^ x7 ^ x7.ror1() ^ x3.ror1() ^ (x3 ^ x3.ror1()).ror2();
-        let x4out = x3 ^ x3.ror1() ^ x7 ^ x7.ror1() ^ x4.ror1() ^ (x4 ^ x4.ror1()).ror2();
-        let x5out = x4 ^ x4.ror1() ^ x5.ror1() ^ (x5 ^ x5.ror1()).ror2();
-        let x6out = x5 ^ x5.ror1() ^ x6.ror1() ^ (x6 ^ x6.ror1()).ror2();
-        let x7out = x6 ^ x6.ror1() ^ x7.ror1() ^ (x7 ^ x7.ror1()).ror2();
-
-        Bs8State(x0out, x1out, x2out, x3out, x4out, x5out, x6out, x7out)
-    }
-
-    // Formula from [6]
-    fn inv_mix_columns(self) -> Bs8State<T> {
-        let Bs8State(x0, x1, x2, x3, x4, x5, x6, x7) = self;
-
-        let x0out = x5 ^ x6 ^ x7 ^
-            (x5 ^ x7 ^ x0).ror1() ^
-            (x0 ^ x5 ^ x6).ror2() ^
-            (x5 ^ x0).ror3();
-        let x1out = x5 ^ x0 ^
-            (x6 ^ x5 ^ x0 ^ x7 ^ x1).ror1() ^
-            (x1 ^ x7 ^ x5).ror2() ^
-            (x6 ^ x5 ^ x1).ror3();
-        let x2out = x6 ^ x0 ^ x1 ^
-            (x7 ^ x6 ^ x1 ^ x2).ror1() ^
-            (x0 ^ x2 ^ x6).ror2() ^
-            (x7 ^ x6 ^ x2).ror3();
-        let x3out = x0 ^ x5 ^ x1 ^ x6 ^ x2 ^
-            (x0 ^ x5 ^ x2 ^ x3).ror1() ^
-            (x0 ^ x1 ^ x3 ^ x5 ^ x6 ^ x7).ror2() ^
-            (x0 ^ x5 ^ x7 ^ x3).ror3();
-        let x4out = x1 ^ x5 ^ x2 ^ x3 ^
-            (x1 ^ x6 ^ x5 ^ x3 ^ x7 ^ x4).ror1() ^
-            (x1 ^ x2 ^ x4 ^ x5 ^ x7).ror2() ^
-            (x1 ^ x5 ^ x6 ^ x4).ror3();
-        let x5out = x2 ^ x6 ^ x3 ^ x4 ^
-            (x2 ^ x7 ^ x6 ^ x4 ^ x5).ror1() ^
-            (x2 ^ x3 ^ x5 ^ x6).ror2() ^
-            (x2 ^ x6 ^ x7 ^ x5).ror3();
-        let x6out =  x3 ^ x7 ^ x4 ^ x5 ^
-            (x3 ^ x7 ^ x5 ^ x6).ror1() ^
-            (x3 ^ x4 ^ x6 ^ x7).ror2() ^
-            (x3 ^ x7 ^ x6).ror3();
-        let x7out = x4 ^ x5 ^ x6 ^
-            (x4 ^ x6 ^ x7).ror1() ^
-            (x4 ^ x5 ^ x7).ror2() ^
-            (x4 ^ x7).ror3();
-
-        Bs8State(x0out, x1out, x2out, x3out, x4out, x5out, x6out, x7out)
-    }
-
-    fn add_round_key(self, rk: &Bs8State<T>) -> Bs8State<T> {
-        self.xor(*rk)
-    }
-}
-
-trait AesBitValueOps: BitXor<Output = Self> + BitAnd<Output = Self> + Not<Output = Self> + Default + Sized {
-    fn shift_row(self) -> Self;
-    fn inv_shift_row(self) -> Self;
-    fn ror1(self) -> Self;
-    fn ror2(self) -> Self;
-    fn ror3(self) -> Self;
-}
-
-impl AesBitValueOps for u16 {
-    fn shift_row(self) -> u16 {
-        // first 4 bits represent first row - don't shift
-        (self & 0x000f) |
-        // next 4 bits represent 2nd row - left rotate 1 bit
-        ((self & 0x00e0) >> 1) | ((self & 0x0010) << 3) |
-        // next 4 bits represent 3rd row - left rotate 2 bits
-        ((self & 0x0c00) >> 2) | ((self & 0x0300) << 2) |
-        // next 4 bits represent 4th row - left rotate 3 bits
-        ((self & 0x8000) >> 3) | ((self & 0x7000) << 1)
-    }
-
-    fn inv_shift_row(self) -> u16 {
-        // first 4 bits represent first row - don't shift
-        (self & 0x000f) |
-        // next 4 bits represent 2nd row - right rotate 1 bit
-        ((self & 0x0080) >> 3) | ((self & 0x0070) << 1) |
-        // next 4 bits represent 3rd row - right rotate 2 bits
-        ((self & 0x0c00) >> 2) | ((self & 0x0300) << 2) |
-        // next 4 bits represent 4th row - right rotate 3 bits
-        ((self & 0xe000) >> 1) | ((self & 0x1000) << 3)
-    }
-
-    fn ror1(self) -> u16 {
-        self >> 4 | self << 12
-    }
-
-    fn ror2(self) -> u16 {
-        self >> 8 | self << 8
-    }
-
-    fn ror3(self) -> u16 {
-        self >> 12 | self << 4
-    }
-}
-
-impl u32x4 {
-    fn lsh(self, s: u32) -> u32x4 {
-        let u32x4(a0, a1, a2, a3) = self;
-        u32x4(
-            a0 << s,
-            (a1 << s) | (a0 >> (32 - s)),
-            (a2 << s) | (a1 >> (32 - s)),
-            (a3 << s) | (a2 >> (32 - s)))
-    }
-
-    fn rsh(self, s: u32) -> u32x4 {
-        let u32x4(a0, a1, a2, a3) = self;
-        u32x4(
-            (a0 >> s) | (a1 << (32 - s)),
-            (a1 >> s) | (a2 << (32 - s)),
-            (a2 >> s) | (a3 << (32 - s)),
-            a3 >> s)
-    }
-}
-
-impl Not for u32x4 {
-    type Output = u32x4;
-
-    fn not(self) -> u32x4 {
-        self ^ U32X4_1
-    }
-}
-
-impl Default for u32x4 {
-    fn default() -> u32x4 {
-        u32x4(0, 0, 0, 0)
-    }
-}
-
-impl AesBitValueOps for u32x4 {
-    fn shift_row(self) -> u32x4 {
-        let u32x4(a0, a1, a2, a3) = self;
-        u32x4(a0, a1 >> 8 | a1 << 24, a2 >> 16 | a2 << 16, a3 >> 24 | a3 << 8)
-    }
-
-    fn inv_shift_row(self) -> u32x4 {
-        let u32x4(a0, a1, a2, a3) = self;
-        u32x4(a0, a1 >> 24 | a1 << 8, a2 >> 16 | a2 << 16, a3 >> 8 | a3 << 24)
-    }
-
-    fn ror1(self) -> u32x4 {
-        let u32x4(a0, a1, a2, a3) = self;
-        u32x4(a1, a2, a3, a0)
-    }
-
-    fn ror2(self) -> u32x4 {
-        let u32x4(a0, a1, a2, a3) = self;
-        u32x4(a2, a3, a0, a1)
-    }
-
-    fn ror3(self) -> u32x4 {
-        let u32x4(a0, a1, a2, a3) = self;
-        u32x4(a3, a0, a1, a2)
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/api.rs b/rustc_deps/vendor/rust-crypto/src/api.rs
deleted file mode 100644
index ab3ac75..0000000
--- a/rustc_deps/vendor/rust-crypto/src/api.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-enum DigestSpec {
-    Md5,
-    Sha1,
-    Sha224,
-    Sha256,
-    Sha384,
-    Sha512,
-    Blake2b,
-    Ripemd160,
-    Whirlpool,
-}
-
-enum MacSpec {
-    Hmac,
-}
-
-enum BlockModeSpec {
-    Ebc,
-    Cbc,
-    Ctr,
-}
-
-enum BlodeModePaddingSpec {
-    NoPadding,
-    Pkcs,
-}
-
-enum SymmetricCipherSpec {
-    Aes,
-    Des,
-    Rc4,
-    Blowfish,
-    ChaCha20,
-    Hc128,
-    Salsa20,
-    XSalsa20,
-    Sosemanuk,
-}
-
-enum KdfSpec {
-    Pbkdf2,
-    Bcrypt,
-    Scrypt,
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/bcrypt.rs b/rustc_deps/vendor/rust-crypto/src/bcrypt.rs
deleted file mode 100644
index 55b5767..0000000
--- a/rustc_deps/vendor/rust-crypto/src/bcrypt.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use blowfish::Blowfish;
-use cryptoutil::{write_u32_be};
-use step_by::RangeExt;
-
-fn setup(cost: u32, salt: &[u8], key: &[u8]) -> Blowfish {
-    assert!(cost < 32);
-    let mut state = Blowfish::init_state();
-    
-    state.salted_expand_key(salt, key);
-    for _ in 0..1u32 << cost {
-        state.expand_key(key);
-        state.expand_key(salt);
-    }
-
-    state
-}
-
-pub fn bcrypt(cost: u32, salt: &[u8], password: &[u8], output: &mut [u8]) {
-    assert!(salt.len() == 16);
-    assert!(0 < password.len() && password.len() <= 72);
-    assert!(output.len() == 24);
-
-    let state = setup(cost, salt, password);
-    // OrpheanBeholderScryDoubt
-    let mut ctext = [0x4f727068, 0x65616e42, 0x65686f6c, 0x64657253, 0x63727944, 0x6f756274];
-    for i in (0..6).step_up(2) {
-        for _ in 0..64 {
-            let (l, r) = state.encrypt(ctext[i], ctext[i+1]);
-            ctext[i] = l;
-            ctext[i+1] = r;
-        }
-        write_u32_be(&mut output[i*4..(i+1)*4], ctext[i]);
-        write_u32_be(&mut output[(i+1)*4..(i+2)*4], ctext[i+1]);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use bcrypt::bcrypt;
-
-    struct Test {
-        cost: u32,
-        salt: Vec<u8>,
-        input: Vec<u8>,
-        output: Vec<u8>
-    }
-
-    // These are $2y$ versions of the test vectors. $2x$ is broken and $2a$ does weird bit-twiddling
-    // when it encounters a 0xFF byte.
-    fn openwall_test_vectors() -> Vec<Test> {
-        vec![
-            Test {
-                input: vec![0x55u8, 0x2Au8, 0x55u8, 0x00u8],
-                cost: 5,
-                salt: vec![0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8],
-                output: vec![0x1Bu8, 0xB6u8, 0x91u8, 0x43u8, 0xF9u8, 0xA8u8, 0xD3u8, 0x04u8, 0xC8u8, 0xD2u8, 0x3Du8, 0x99u8, 0xABu8, 0x04u8, 0x9Au8, 0x77u8, 0xA6u8, 0x8Eu8, 0x2Cu8, 0xCCu8, 0x74u8, 0x42u8, 0x06u8]
-            },
-            Test {
-                input: vec![0x55u8, 0x2Au8, 0x55u8, 0x2Au8, 0x00u8],
-                cost: 5,
-                salt: vec![0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8],
-                output: vec![0x5Cu8, 0x84u8, 0x35u8, 0x0Bu8, 0xDFu8, 0xBAu8, 0xA9u8, 0x6Au8, 0xC1u8, 0x6Fu8, 0x61u8, 0x5Au8, 0xE7u8, 0x9Fu8, 0x35u8, 0xCFu8, 0xDAu8, 0xCDu8, 0x68u8, 0x2Du8, 0x36u8, 0x9Fu8, 0x23u8]
-            },
-            Test {
-                input: vec![0x55u8, 0x2Au8, 0x55u8, 0x2Au8, 0x55u8, 0x00u8],
-                cost: 5,
-                salt: vec![0x65u8, 0x96u8, 0x59u8, 0x65u8, 0x96u8, 0x59u8, 0x65u8, 0x96u8, 0x59u8, 0x65u8, 0x96u8, 0x59u8, 0x65u8, 0x96u8, 0x59u8, 0x65u8],
-                output: vec![0x09u8, 0xE6u8, 0x73u8, 0xA3u8, 0xF9u8, 0xA5u8, 0x44u8, 0x81u8, 0x8Eu8, 0xB8u8, 0xDDu8, 0x69u8, 0xA8u8, 0xCBu8, 0x28u8, 0xB3u8, 0x2Fu8, 0x6Fu8, 0x7Bu8, 0xE6u8, 0x04u8, 0xCFu8, 0xA7u8]
-            },
-            Test {
-                input: vec![0x30u8, 0x31u8, 0x32u8, 0x33u8, 0x34u8, 0x35u8, 0x36u8, 0x37u8, 0x38u8, 0x39u8, 0x61u8, 0x62u8, 0x63u8, 0x64u8, 0x65u8, 0x66u8, 0x67u8, 0x68u8, 0x69u8, 0x6Au8, 0x6Bu8, 0x6Cu8, 0x6Du8, 0x6Eu8, 0x6Fu8, 0x70u8, 0x71u8, 0x72u8, 0x73u8, 0x74u8, 0x75u8, 0x76u8, 0x77u8, 0x78u8, 0x79u8, 0x7Au8, 0x41u8, 0x42u8, 0x43u8, 0x44u8, 0x45u8, 0x46u8, 0x47u8, 0x48u8, 0x49u8, 0x4Au8, 0x4Bu8, 0x4Cu8, 0x4Du8, 0x4Eu8, 0x4Fu8, 0x50u8, 0x51u8, 0x52u8, 0x53u8, 0x54u8, 0x55u8, 0x56u8, 0x57u8, 0x58u8, 0x59u8, 0x5Au8, 0x30u8, 0x31u8, 0x32u8, 0x33u8, 0x34u8, 0x35u8, 0x36u8, 0x37u8, 0x38u8, 0x39u8],
-                cost: 5,
-                salt: vec![0x71u8, 0xD7u8, 0x9Fu8, 0x82u8, 0x18u8, 0xA3u8, 0x92u8, 0x59u8, 0xA7u8, 0xA2u8, 0x9Au8, 0xABu8, 0xB2u8, 0xDBu8, 0xAFu8, 0xC3u8],
-                output: vec![0xEEu8, 0xEEu8, 0x31u8, 0xF8u8, 0x09u8, 0x19u8, 0x92u8, 0x04u8, 0x25u8, 0x88u8, 0x10u8, 0x02u8, 0xD1u8, 0x40u8, 0xD5u8, 0x55u8, 0xB2u8, 0x8Au8, 0x5Cu8, 0x72u8, 0xE0u8, 0x0Fu8, 0x09u8]
-            },
-            Test {
-                input: vec![0xFFu8, 0xFFu8, 0xA3u8, 0x00u8],
-                cost: 5,
-                salt: vec![0x05u8, 0x03u8, 0x00u8, 0x85u8, 0xD5u8, 0xEDu8, 0x4Cu8, 0x17u8, 0x6Bu8, 0x2Au8, 0xC3u8, 0xCBu8, 0xEEu8, 0x47u8, 0x29u8, 0x1Cu8],
-                output: vec![0x10u8, 0x6Eu8, 0xE0u8, 0x9Cu8, 0x97u8, 0x1Cu8, 0x43u8, 0xA1u8, 0x9Du8, 0x8Au8, 0x25u8, 0xC5u8, 0x95u8, 0xDFu8, 0x91u8, 0xDFu8, 0xF4u8, 0xF0u8, 0x9Bu8, 0x56u8, 0x54u8, 0x3Bu8, 0x98u8]
-            },
-            Test {
-                input: vec![0xA3u8, 0x00u8],
-                cost: 5,
-                salt: vec![0x05u8, 0x03u8, 0x00u8, 0x85u8, 0xD5u8, 0xEDu8, 0x4Cu8, 0x17u8, 0x6Bu8, 0x2Au8, 0xC3u8, 0xCBu8, 0xEEu8, 0x47u8, 0x29u8, 0x1Cu8],
-                output: vec![0x51u8, 0xCFu8, 0x6Eu8, 0x8Du8, 0xDAu8, 0x3Au8, 0x01u8, 0x0Du8, 0x4Cu8, 0xAFu8, 0x11u8, 0xE9u8, 0x67u8, 0x7Au8, 0xD2u8, 0x36u8, 0x84u8, 0x98u8, 0xFFu8, 0xCAu8, 0x96u8, 0x9Cu8, 0x4Bu8]
-            },
-            Test {
-                input: vec![0xFFu8, 0xA3u8, 0x33u8, 0x34u8, 0xFFu8, 0xFFu8, 0xFFu8, 0xA3u8, 0x33u8, 0x34u8, 0x35u8, 0x00u8],
-                cost: 5,
-                salt: vec![0x05u8, 0x03u8, 0x00u8, 0x85u8, 0xD5u8, 0xEDu8, 0x4Cu8, 0x17u8, 0x6Bu8, 0x2Au8, 0xC3u8, 0xCBu8, 0xEEu8, 0x47u8, 0x29u8, 0x1Cu8],
-                output: vec![0xA8u8, 0x00u8, 0x69u8, 0xE3u8, 0xB6u8, 0x57u8, 0x86u8, 0x9Fu8, 0x2Au8, 0x09u8, 0x17u8, 0x16u8, 0xC4u8, 0x98u8, 0x00u8, 0x12u8, 0xE9u8, 0xBAu8, 0xD5u8, 0x38u8, 0x6Eu8, 0x69u8, 0x19u8]
-            },
-            Test {
-                input: vec![0xFFu8, 0xA3u8, 0x33u8, 0x34u8, 0x35u8, 0x00u8],
-                cost: 5,
-                salt: vec![0x05u8, 0x03u8, 0x00u8, 0x85u8, 0xD5u8, 0xEDu8, 0x4Cu8, 0x17u8, 0x6Bu8, 0x2Au8, 0xC3u8, 0xCBu8, 0xEEu8, 0x47u8, 0x29u8, 0x1Cu8],
-                output: vec![0xA5u8, 0x38u8, 0xEFu8, 0xE2u8, 0x70u8, 0x49u8, 0x4Eu8, 0x3Bu8, 0x7Cu8, 0xD6u8, 0x81u8, 0x2Bu8, 0xFFu8, 0x16u8, 0x96u8, 0xC7u8, 0x1Bu8, 0xACu8, 0xD2u8, 0x98u8, 0x67u8, 0x87u8, 0xF8u8]
-            },
-            Test {
-                input: vec![0xA3u8, 0x61u8, 0x62u8, 0x00u8],
-                cost: 5,
-                salt: vec![0x05u8, 0x03u8, 0x00u8, 0x85u8, 0xD5u8, 0xEDu8, 0x4Cu8, 0x17u8, 0x6Bu8, 0x2Au8, 0xC3u8, 0xCBu8, 0xEEu8, 0x47u8, 0x29u8, 0x1Cu8],
-                output: vec![0xF0u8, 0xA8u8, 0x67u8, 0x4Au8, 0x62u8, 0xF4u8, 0xBEu8, 0xA4u8, 0xD7u8, 0x7Bu8, 0x7Du8, 0x30u8, 0x70u8, 0xFBu8, 0xC9u8, 0x86u8, 0x4Cu8, 0x2Cu8, 0x00u8, 0x74u8, 0xE7u8, 0x50u8, 0xA5u8]
-            },
-            Test {
-                input: vec![0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8, 0xAAu8],
-                cost: 5,
-                salt: vec![0x05u8, 0x03u8, 0x00u8, 0x85u8, 0xD5u8, 0xEDu8, 0x4Cu8, 0x17u8, 0x6Bu8, 0x2Au8, 0xC3u8, 0xCBu8, 0xEEu8, 0x47u8, 0x29u8, 0x1Cu8],
-                output: vec![0xBBu8, 0x24u8, 0x90u8, 0x2Bu8, 0x59u8, 0x50u8, 0x90u8, 0xBFu8, 0xC8u8, 0x24u8, 0x64u8, 0x70u8, 0x8Cu8, 0x69u8, 0xB1u8, 0xB2u8, 0xD5u8, 0xB4u8, 0xC5u8, 0x88u8, 0xC6u8, 0x3Bu8, 0x3Fu8]
-            },
-            Test {
-                input: vec![0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8, 0xAAu8, 0x55u8],
-                cost: 5,
-                salt: vec![0x05u8, 0x03u8, 0x00u8, 0x85u8, 0xD5u8, 0xEDu8, 0x4Cu8, 0x17u8, 0x6Bu8, 0x2Au8, 0xC3u8, 0xCBu8, 0xEEu8, 0x47u8, 0x29u8, 0x1Cu8],
-                output: vec![0x4Fu8, 0xFCu8, 0xEDu8, 0x16u8, 0x59u8, 0x34u8, 0x7Bu8, 0x33u8, 0x9Du8, 0x48u8, 0x6Eu8, 0x1Du8, 0xACu8, 0x0Cu8, 0x62u8, 0xB2u8, 0x76u8, 0xABu8, 0x63u8, 0xBCu8, 0xB3u8, 0xE3u8, 0x4Du8]
-            },
-            Test {
-                input: vec![0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8, 0x55u8, 0xAAu8, 0xFFu8],
-                cost: 5,
-                salt: vec![0x05u8, 0x03u8, 0x00u8, 0x85u8, 0xD5u8, 0xEDu8, 0x4Cu8, 0x17u8, 0x6Bu8, 0x2Au8, 0xC3u8, 0xCBu8, 0xEEu8, 0x47u8, 0x29u8, 0x1Cu8],
-                output: vec![0xFEu8, 0xF4u8, 0x9Bu8, 0xD5u8, 0xE2u8, 0xE1u8, 0xA3u8, 0x9Cu8, 0x25u8, 0xE0u8, 0xFCu8, 0x4Bu8, 0x06u8, 0x9Eu8, 0xF3u8, 0x9Au8, 0x3Au8, 0xECu8, 0x36u8, 0xD3u8, 0xABu8, 0x60u8, 0x48u8]
-            },
-            Test {
-                input: vec![0x00u8],
-                cost: 5,
-                salt: vec![0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8, 0x41u8, 0x04u8, 0x10u8],
-                output: vec![0xF7u8, 0x02u8, 0x36u8, 0x5Cu8, 0x4Du8, 0x4Au8, 0xE1u8, 0xD5u8, 0x3Du8, 0x97u8, 0xCDu8, 0x28u8, 0xB0u8, 0xB9u8, 0x3Fu8, 0x11u8, 0xF7u8, 0x9Fu8, 0xCEu8, 0x44u8, 0xD5u8, 0x60u8, 0xFDu8]
-            }
-        ]
-    }
-
-    #[test]
-    fn test_openwall_test_vectors() {
-        let tests = openwall_test_vectors();
-        let mut output = [0u8; 24];
-        for test in tests.iter() {
-            bcrypt(test.cost, &test.salt[..], &test.input[..], &mut output[..]);
-            assert!(output[0..23] == test.output[..]);
-        }
-    }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use test::Bencher;
-    use bcrypt::bcrypt;
-
-    #[bench]
-    pub fn bcrypt_16_5(bh: & mut Bencher) {
-        let pass = [0u8; 16];
-        let salt = [0u8; 16];
-        let mut out  = [0u8; 24];
-        bh.iter( || {
-            bcrypt(5, &salt, &pass, &mut out);
-        });
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/bcrypt_pbkdf.rs b/rustc_deps/vendor/rust-crypto/src/bcrypt_pbkdf.rs
deleted file mode 100644
index afaeb3b..0000000
--- a/rustc_deps/vendor/rust-crypto/src/bcrypt_pbkdf.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use blowfish::Blowfish;
-use cryptoutil::{read_u32v_be, write_u32_be, write_u32_le};
-use sha2::Sha512;
-use digest::Digest;
-use step_by::RangeExt;
-
-fn bcrypt_hash(hpass: &[u8], hsalt: &[u8], output: &mut [u8; 32]) {
-    let mut bf = Blowfish::init_state();
-    bf.salted_expand_key(hsalt, hpass);
-
-    for _ in 0..64 {
-        bf.expand_key(hsalt);
-        bf.expand_key(hpass);
-    }
-
-    let mut buf = [0u32; 8];
-    read_u32v_be(&mut buf, b"OxychromaticBlowfishSwatDynamite");
-
-    for i in (0..8).step_up(2) {
-        for _ in 0..64 {
-            let (l, r) = bf.encrypt(buf[i], buf[i+1]);
-            buf[i] = l;
-            buf[i+1] = r;
-        }
-    }
-
-    for i in 0..8 {
-        write_u32_le(&mut output[i*4..(i+1)*4], buf[i]);
-    }
-}
-
-pub fn bcrypt_pbkdf(password: &[u8], salt: &[u8], rounds: u32, output: &mut [u8]) {
-    let mut hpass = [0u8; 64];
-
-    assert!(password.len() > 0);
-    assert!(salt.len() > 0);
-    assert!(rounds > 0);
-    assert!(output.len() > 0);
-    assert!(output.len() <= 1024);
-
-    let nblocks = (output.len() + 31) / 32;
-
-    let mut h = Sha512::new();
-    h.input(password);
-    h.result(&mut hpass);
-
-    for block in 1..(nblocks+1) {
-        let mut count = [0u8; 4];
-        let mut hsalt = [0u8; 64];
-        let mut out   = [0u8; 32];
-        write_u32_be(&mut count, block as u32);
-
-        h.reset();
-        h.input(salt);
-        h.input(&count);
-        h.result(&mut hsalt);
-
-        bcrypt_hash(&hpass, &hsalt, &mut out);
-        let mut tmp = out;
-
-        for _ in 1..rounds {
-            h.reset();
-            h.input(&tmp);
-            h.result(&mut hsalt);
-
-            bcrypt_hash(&hpass, &hsalt, &mut tmp);
-            for i in 0..out.len() {
-                out[i] ^= tmp[i];
-            }
-
-            for i in 0..out.len() {
-                let idx = i * nblocks + (block-1);
-                if idx < output.len() {
-                    output[idx] = out[i];
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::iter::repeat;
-
-    use bcrypt_pbkdf::{bcrypt_pbkdf, bcrypt_hash};
-
-    #[test]
-    fn test_bcrypt_hash() {
-        struct Test {
-            hpass: [u8; 64],
-            hsalt: [u8; 64],
-            out:   [u8; 32],
-        }
-
-        let tests = vec!(
-            Test{
-                hpass: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                hsalt: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                out: [
-                    0x46, 0x02, 0x86, 0xe9, 0x72, 0xfa, 0x83, 0x3f, 0x8b, 0x12, 0x83, 0xad, 0x8f, 0xa9, 0x19, 0xfa,
-                    0x29, 0xbd, 0xe2, 0x0e, 0x23, 0x32, 0x9e, 0x77, 0x4d, 0x84, 0x22, 0xba, 0xc0, 0xa7, 0x92, 0x6c, ],
-            }, Test{
-                hpass: [
-                    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-                    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-                    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-                    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f ],
-                hsalt: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                out: [
-                    0xb0, 0xb2, 0x29, 0xdb, 0xc6, 0xba, 0xde, 0xf0, 0xe1, 0xda, 0x25, 0x27, 0x47, 0x4a, 0x8b, 0x28,
-                    0x88, 0x8f, 0x8b, 0x06, 0x14, 0x76, 0xfe, 0x80, 0xc3, 0x22, 0x56, 0xe1, 0x14, 0x2d, 0xd0, 0x0d ],
-            }, Test{
-                hpass: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                hsalt: [
-                    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-                    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-                    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-                    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f ],
-                out: [
-                    0xb6, 0x2b, 0x4e, 0x36, 0x7d, 0x31, 0x57, 0xf5, 0xc3, 0x1e, 0x4d, 0x2c, 0xba, 0xfb, 0x29, 0x31,
-                    0x49, 0x4d, 0x9d, 0x3b, 0xdd, 0x17, 0x1d, 0x55, 0xcf, 0x79, 0x9f, 0xa4, 0x41, 0x60, 0x42, 0xe2 ],
-            }, Test{
-                hpass: [
-                    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-                    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-                    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-                    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f ],
-                hsalt: [
-                    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-                    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-                    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-                    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f ],
-                out: [
-                    0xc6, 0xa9, 0x5f, 0xe6, 0x41, 0x31, 0x15, 0xfb, 0x57, 0xe9, 0x9f, 0x75, 0x74, 0x98, 0xe8, 0x5d,
-                    0xa3, 0xc6, 0xe1, 0xdf, 0x0c, 0x3c, 0x93, 0xaa, 0x97, 0x5c, 0x54, 0x8a, 0x34, 0x43, 0x26, 0xf8 ],
-            },
-        );
-
-        for t in tests.iter() {
-            let mut out = [0u8; 32];
-            bcrypt_hash(&t.hpass, &t.hsalt, &mut out);
-            assert!(out == t.out);
-        }
-    }
-
-    #[test]
-    fn test_openbsd_vectors() {
-        struct Test{
-            password: Vec<u8>,
-            salt: Vec<u8>,
-            rounds: u32,
-            out: Vec<u8>,
-        }
-
-        let tests = vec!(
-            Test{
-                password: b"password".to_vec(),
-                salt: b"salt".to_vec(),
-                rounds: 4,
-                out: vec![
-                    0x5b, 0xbf, 0x0c, 0xc2, 0x93, 0x58, 0x7f, 0x1c, 0x36, 0x35, 0x55, 0x5c, 0x27, 0x79, 0x65, 0x98,
-                    0xd4, 0x7e, 0x57, 0x90, 0x71, 0xbf, 0x42, 0x7e, 0x9d, 0x8f, 0xbe, 0x84, 0x2a, 0xba, 0x34, 0xd9],
-            }, Test{
-                password: b"password".to_vec(),
-                salt: vec![0],
-                rounds: 4,
-                out: vec![0xc1, 0x2b, 0x56, 0x62, 0x35, 0xee, 0xe0, 0x4c, 0x21, 0x25, 0x98, 0x97, 0x0a, 0x57, 0x9a, 0x67],
-            }, Test{
-                password: vec![0],
-                salt: b"salt".to_vec(),
-                rounds: 4,
-                out: vec![0x60, 0x51, 0xbe, 0x18, 0xc2, 0xf4, 0xf8, 0x2c, 0xbf, 0x0e, 0xfe, 0xe5, 0x47, 0x1b, 0x4b, 0xb9],
-            }, Test{
-                password: b"password\x00".to_vec(),
-                salt: b"salt\x00".to_vec(),
-                rounds: 4,
-                out: vec![
-                    0x74, 0x10, 0xe4, 0x4c, 0xf4, 0xfa, 0x07, 0xbf, 0xaa, 0xc8, 0xa9, 0x28, 0xb1, 0x72, 0x7f, 0xac,
-                    0x00, 0x13, 0x75, 0xe7, 0xbf, 0x73, 0x84, 0x37, 0x0f, 0x48, 0xef, 0xd1, 0x21, 0x74, 0x30, 0x50],
-            }, Test{
-                password: b"pass\x00wor".to_vec(),
-                salt: b"sa\x00l".to_vec(),
-                rounds: 4,
-                out: vec![0xc2, 0xbf, 0xfd, 0x9d, 0xb3, 0x8f, 0x65, 0x69, 0xef, 0xef, 0x43, 0x72, 0xf4, 0xde, 0x83, 0xc0],
-            }, Test{
-                password: b"pass\x00word".to_vec(),
-                salt: b"sa\x00lt".to_vec(),
-                rounds: 4,
-                out: vec![0x4b, 0xa4, 0xac, 0x39, 0x25, 0xc0, 0xe8, 0xd7, 0xf0, 0xcd, 0xb6, 0xbb, 0x16, 0x84, 0xa5, 0x6f],
-            }, Test{
-                password: b"password".to_vec(),
-                salt: b"salt".to_vec(),
-                rounds: 8,
-                out: vec![
-                    0xe1, 0x36, 0x7e, 0xc5, 0x15, 0x1a, 0x33, 0xfa, 0xac, 0x4c, 0xc1, 0xc1, 0x44, 0xcd, 0x23, 0xfa,
-                    0x15, 0xd5, 0x54, 0x84, 0x93, 0xec, 0xc9, 0x9b, 0x9b, 0x5d, 0x9c, 0x0d, 0x3b, 0x27, 0xbe, 0xc7,
-                    0x62, 0x27, 0xea, 0x66, 0x08, 0x8b, 0x84, 0x9b, 0x20, 0xab, 0x7a, 0xa4, 0x78, 0x01, 0x02, 0x46,
-                    0xe7, 0x4b, 0xba, 0x51, 0x72, 0x3f, 0xef, 0xa9, 0xf9, 0x47, 0x4d, 0x65, 0x08, 0x84, 0x5e, 0x8d],
-            }, Test{
-                password: b"password".to_vec(),
-                salt: b"salt".to_vec(),
-                rounds: 42,
-                out: vec![0x83, 0x3c, 0xf0, 0xdc, 0xf5, 0x6d, 0xb6, 0x56, 0x08, 0xe8, 0xf0, 0xdc, 0x0c, 0xe8, 0x82, 0xbd],
-            }, Test{
-                password: b"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.".to_vec(),
-                salt: b"salis\x00".to_vec(),
-                rounds: 8,
-                out: vec![0x10, 0x97, 0x8b, 0x07, 0x25, 0x3d, 0xf5, 0x7f, 0x71, 0xa1, 0x62, 0xeb, 0x0e, 0x8a, 0xd3, 0x0a],
-            }, Test{
-                password: vec![0x0d, 0xb3, 0xac, 0x94, 0xb3, 0xee, 0x53, 0x28, 0x4f, 0x4a, 0x22, 0x89, 0x3b, 0x3c, 0x24, 0xae],
-                salt: vec![0x3a, 0x62, 0xf0, 0xf0, 0xdb, 0xce, 0xf8, 0x23, 0xcf, 0xcc, 0x85, 0x48, 0x56, 0xea, 0x10, 0x28],
-                rounds: 8,
-                out: vec![0x20, 0x44, 0x38, 0x17, 0x5e, 0xee, 0x7c, 0xe1, 0x36, 0xc9, 0x1b, 0x49, 0xa6, 0x79, 0x23, 0xff],
-            }, Test{
-                password: vec![0x0d, 0xb3, 0xac, 0x94, 0xb3, 0xee, 0x53, 0x28, 0x4f, 0x4a, 0x22, 0x89, 0x3b, 0x3c, 0x24, 0xae],
-                salt: vec![0x3a, 0x62, 0xf0, 0xf0, 0xdb, 0xce, 0xf8, 0x23, 0xcf, 0xcc, 0x85, 0x48, 0x56, 0xea, 0x10, 0x28],
-                rounds: 8,
-                out: vec![
-                    0x20, 0x54, 0xb9, 0xff, 0xf3, 0x4e, 0x37, 0x21, 0x44, 0x03, 0x34, 0x74, 0x68, 0x28, 0xe9, 0xed,
-                    0x38, 0xde, 0x4b, 0x72, 0xe0, 0xa6, 0x9a, 0xdc, 0x17, 0x0a, 0x13, 0xb5, 0xe8, 0xd6, 0x46, 0x38,
-                    0x5e, 0xa4, 0x03, 0x4a, 0xe6, 0xd2, 0x66, 0x00, 0xee, 0x23, 0x32, 0xc5, 0xed, 0x40, 0xad, 0x55,
-                    0x7c, 0x86, 0xe3, 0x40, 0x3f, 0xbb, 0x30, 0xe4, 0xe1, 0xdc, 0x1a, 0xe0, 0x6b, 0x99, 0xa0, 0x71,
-                    0x36, 0x8f, 0x51, 0x8d, 0x2c, 0x42, 0x66, 0x51, 0xc9, 0xe7, 0xe4, 0x37, 0xfd, 0x6c, 0x91, 0x5b,
-                    0x1b, 0xbf, 0xc3, 0xa4, 0xce, 0xa7, 0x14, 0x91, 0x49, 0x0e, 0xa7, 0xaf, 0xb7, 0xdd, 0x02, 0x90,
-                    0xa6, 0x78, 0xa4, 0xf4, 0x41, 0x12, 0x8d, 0xb1, 0x79, 0x2e, 0xab, 0x27, 0x76, 0xb2, 0x1e, 0xb4,
-                    0x23, 0x8e, 0x07, 0x15, 0xad, 0xd4, 0x12, 0x7d, 0xff, 0x44, 0xe4, 0xb3, 0xe4, 0xcc, 0x4c, 0x4f,
-                    0x99, 0x70, 0x08, 0x3f, 0x3f, 0x74, 0xbd, 0x69, 0x88, 0x73, 0xfd, 0xf6, 0x48, 0x84, 0x4f, 0x75,
-                    0xc9, 0xbf, 0x7f, 0x9e, 0x0c, 0x4d, 0x9e, 0x5d, 0x89, 0xa7, 0x78, 0x39, 0x97, 0x49, 0x29, 0x66,
-                    0x61, 0x67, 0x07, 0x61, 0x1c, 0xb9, 0x01, 0xde, 0x31, 0xa1, 0x97, 0x26, 0xb6, 0xe0, 0x8c, 0x3a,
-                    0x80, 0x01, 0x66, 0x1f, 0x2d, 0x5c, 0x9d, 0xcc, 0x33, 0xb4, 0xaa, 0x07, 0x2f, 0x90, 0xdd, 0x0b,
-                    0x3f, 0x54, 0x8d, 0x5e, 0xeb, 0xa4, 0x21, 0x13, 0x97, 0xe2, 0xfb, 0x06, 0x2e, 0x52, 0x6e, 0x1d,
-                    0x68, 0xf4, 0x6a, 0x4c, 0xe2, 0x56, 0x18, 0x5b, 0x4b, 0xad, 0xc2, 0x68, 0x5f, 0xbe, 0x78, 0xe1,
-                    0xc7, 0x65, 0x7b, 0x59, 0xf8, 0x3a, 0xb9, 0xab, 0x80, 0xcf, 0x93, 0x18, 0xd6, 0xad, 0xd1, 0xf5,
-                    0x93, 0x3f, 0x12, 0xd6, 0xf3, 0x61, 0x82, 0xc8, 0xe8, 0x11, 0x5f, 0x68, 0x03, 0x0a, 0x12, 0x44],
-            },
-        );
-
-        for t in tests.iter() {
-            let mut out: Vec<u8> = repeat(0).take(t.out.len()).collect();
-            bcrypt_pbkdf(&t.password[..], &t.salt[..], t.rounds, &mut out[..]);
-            assert_eq!(out, t.out);
-        }
-    }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use test::Bencher;
-    use bcrypt_pbkdf::bcrypt_pbkdf;
-
-    #[bench]
-    fn bench_bcrypt_pbkdf_5_32(b: &mut Bencher) {
-        let pass = [0u8; 16];
-        let salt = [0u8; 16];
-        let mut out  = [0u8; 32];
-
-        b.iter(|| {
-            bcrypt_pbkdf(&pass, &salt, 5, &mut out);
-        });
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/blake2b.rs b/rustc_deps/vendor/rust-crypto/src/blake2b.rs
deleted file mode 100644
index eb946cc..0000000
--- a/rustc_deps/vendor/rust-crypto/src/blake2b.rs
+++ /dev/null
@@ -1,562 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::iter::repeat;
-use cryptoutil::{copy_memory, read_u64v_le, write_u64v_le};
-use digest::Digest;
-use mac::{Mac, MacResult};
-use util::secure_memset;
-
-static IV : [u64; 8] = [
-  0x6a09e667f3bcc908, 0xbb67ae8584caa73b,
-  0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
-  0x510e527fade682d1, 0x9b05688c2b3e6c1f,
-  0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,
-];
-
-static SIGMA : [[usize; 16]; 12] = [
-  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 ],
-  [ 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 ],
-  [ 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4 ],
-  [  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8 ],
-  [  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13 ],
-  [  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 ],
-  [ 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11 ],
-  [ 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10 ],
-  [  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5 ],
-  [ 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 ],
-  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 ],
-  [ 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 ],
-];
-
-const BLAKE2B_BLOCKBYTES : usize = 128;
-const BLAKE2B_OUTBYTES : usize = 64;
-const BLAKE2B_KEYBYTES : usize = 64;
-const BLAKE2B_SALTBYTES : usize = 16;
-const BLAKE2B_PERSONALBYTES : usize = 16;
-
-#[derive(Copy)]
-pub struct Blake2b {
-    h: [u64; 8],
-    t: [u64; 2],
-    f: [u64; 2],
-    buf: [u8; 2*BLAKE2B_BLOCKBYTES],
-    buflen: usize,
-    key: [u8; BLAKE2B_KEYBYTES],
-    key_length: u8,
-    last_node: u8,
-    digest_length: u8,
-    computed: bool, // whether the final digest has been computed
-    param: Blake2bParam
-}
-
-impl Clone for Blake2b { fn clone(&self) -> Blake2b { *self } }
-
-#[derive(Copy, Clone)]
-struct Blake2bParam {
-    digest_length: u8,
-    key_length: u8,
-    fanout: u8,
-    depth: u8,
-    leaf_length: u32,
-    node_offset: u64,
-    node_depth: u8,
-    inner_length: u8,
-    reserved: [u8; 14],
-    salt: [u8; BLAKE2B_SALTBYTES],
-    personal: [u8; BLAKE2B_PERSONALBYTES],
-}
-
-macro_rules! G( ($r:expr, $i:expr, $a:expr, $b:expr, $c:expr, $d:expr, $m:expr) => ({
-    $a = $a.wrapping_add($b).wrapping_add($m[SIGMA[$r][2*$i+0]]);
-    $d = ($d ^ $a).rotate_right(32);
-    $c = $c.wrapping_add($d);
-    $b = ($b ^ $c).rotate_right(24);
-    $a = $a.wrapping_add($b).wrapping_add($m[SIGMA[$r][2*$i+1]]);
-    $d = ($d ^ $a).rotate_right(16);
-    $c = $c .wrapping_add($d);
-    $b = ($b ^ $c).rotate_right(63);
-}));
-
-macro_rules! round( ($r:expr, $v:expr, $m:expr) => ( {
-    G!($r,0,$v[ 0],$v[ 4],$v[ 8],$v[12], $m);
-    G!($r,1,$v[ 1],$v[ 5],$v[ 9],$v[13], $m);
-    G!($r,2,$v[ 2],$v[ 6],$v[10],$v[14], $m);
-    G!($r,3,$v[ 3],$v[ 7],$v[11],$v[15], $m);
-    G!($r,4,$v[ 0],$v[ 5],$v[10],$v[15], $m);
-    G!($r,5,$v[ 1],$v[ 6],$v[11],$v[12], $m);
-    G!($r,6,$v[ 2],$v[ 7],$v[ 8],$v[13], $m);
-    G!($r,7,$v[ 3],$v[ 4],$v[ 9],$v[14], $m);
-  }
-));
-
-impl Blake2b {
-    fn set_lastnode(&mut self) {
-        self.f[1] = 0xFFFFFFFFFFFFFFFF;
-    }
-
-    fn set_lastblock(&mut self) {
-        if self.last_node!=0 {
-            self.set_lastnode();
-        }
-        self.f[0] = 0xFFFFFFFFFFFFFFFF;
-    }
-
-    fn increment_counter(&mut self, inc : u64) {
-        self.t[0] += inc;
-        self.t[1] += if self.t[0] < inc { 1 } else { 0 };
-    }
-
-    fn init0(param: Blake2bParam, digest_length: u8, key: &[u8]) -> Blake2b {
-        assert!(key.len() <= BLAKE2B_KEYBYTES);
-        let mut b = Blake2b {
-            h: IV,
-            t: [0,0],
-            f: [0,0],
-            buf: [0; 2*BLAKE2B_BLOCKBYTES],
-            buflen: 0,
-            last_node: 0,
-            digest_length: digest_length,
-            computed: false,
-            key: [0; BLAKE2B_KEYBYTES],
-            key_length: key.len() as u8,
-            param: param
-        };
-        copy_memory(key, &mut b.key);
-        b
-    }
-
-    fn apply_param(&mut self) {
-        use std::io::Write;
-        use cryptoutil::WriteExt;
-
-        let mut param_bytes : [u8; 64] = [0; 64];
-        {
-            let mut writer: &mut [u8] = &mut param_bytes;
-            writer.write_u8(self.param.digest_length).unwrap();
-            writer.write_u8(self.param.key_length).unwrap();
-            writer.write_u8(self.param.fanout).unwrap();
-            writer.write_u8(self.param.depth).unwrap();
-            writer.write_u32_le(self.param.leaf_length).unwrap();
-            writer.write_u64_le(self.param.node_offset).unwrap();
-            writer.write_u8(self.param.node_depth).unwrap();
-            writer.write_u8(self.param.inner_length).unwrap();
-            writer.write_all(&self.param.reserved).unwrap();
-            writer.write_all(&self.param.salt).unwrap();
-            writer.write_all(&self.param.personal).unwrap();
-        }
-
-        let mut param_words : [u64; 8] = [0; 8];
-        read_u64v_le(&mut param_words, &param_bytes);
-        for (h, param_word) in self.h.iter_mut().zip(param_words.iter()) {
-            *h = *h ^ *param_word;
-        }
-    }
-
-
-    // init xors IV with input parameter block
-    fn init_param( p: Blake2bParam, key: &[u8] ) -> Blake2b {
-        let mut b = Blake2b::init0(p, p.digest_length, key);
-        b.apply_param();
-        b
-    }
-
-    fn default_param(outlen: u8) -> Blake2bParam {
-        Blake2bParam {
-            digest_length: outlen,
-            key_length: 0,
-            fanout: 1,
-            depth: 1,
-            leaf_length: 0,
-            node_offset: 0,
-            node_depth: 0,
-            inner_length: 0,
-            reserved: [0; 14],
-            salt: [0; BLAKE2B_SALTBYTES],
-            personal: [0; BLAKE2B_PERSONALBYTES],
-        }
-    }
-
-    pub fn new(outlen: usize) -> Blake2b {
-        assert!(outlen > 0 && outlen <= BLAKE2B_OUTBYTES);
-        Blake2b::init_param(Blake2b::default_param(outlen as u8), &[])
-    }
-
-    fn apply_key(&mut self) {
-        let mut block : [u8; BLAKE2B_BLOCKBYTES] = [0; BLAKE2B_BLOCKBYTES];
-        copy_memory(&self.key[..self.key_length as usize], &mut block);
-        self.update(&block);
-        secure_memset(&mut block[..], 0);
-    }
-
-    pub fn new_keyed(outlen: usize, key: &[u8] ) -> Blake2b {
-        assert!(outlen > 0 && outlen <= BLAKE2B_OUTBYTES);
-        assert!(key.len() > 0 && key.len() <= BLAKE2B_KEYBYTES);
-
-        let param = Blake2bParam {
-            digest_length: outlen as u8,
-            key_length: key.len() as u8,
-            fanout: 1,
-            depth: 1,
-            leaf_length: 0,
-            node_offset: 0,
-            node_depth: 0,
-            inner_length: 0,
-            reserved: [0; 14],
-            salt: [0; BLAKE2B_SALTBYTES],
-            personal: [0; BLAKE2B_PERSONALBYTES],
-        };
-
-        let mut b = Blake2b::init_param(param, key);
-        b.apply_key();
-        b
-    }
-
-    fn compress(&mut self) {
-        let mut ms: [u64; 16] = [0; 16];
-        let mut vs: [u64; 16] = [0; 16];
-
-        read_u64v_le(&mut ms, &self.buf[0..BLAKE2B_BLOCKBYTES]);
-
-        for (v, h) in vs.iter_mut().zip(self.h.iter()) {
-            *v = *h;
-        }
-
-        vs[ 8] = IV[0];
-        vs[ 9] = IV[1];
-        vs[10] = IV[2];
-        vs[11] = IV[3];
-        vs[12] = self.t[0] ^ IV[4];
-        vs[13] = self.t[1] ^ IV[5];
-        vs[14] = self.f[0] ^ IV[6];
-        vs[15] = self.f[1] ^ IV[7];
-        round!(  0, vs, ms );
-        round!(  1, vs, ms );
-        round!(  2, vs, ms );
-        round!(  3, vs, ms );
-        round!(  4, vs, ms );
-        round!(  5, vs, ms );
-        round!(  6, vs, ms );
-        round!(  7, vs, ms );
-        round!(  8, vs, ms );
-        round!(  9, vs, ms );
-        round!( 10, vs, ms );
-        round!( 11, vs, ms );
-
-        for (h_elem, (v_low, v_high)) in self.h.iter_mut().zip( vs[0..8].iter().zip(vs[8..16].iter()) ) {
-            *h_elem = *h_elem ^ *v_low ^ *v_high;
-        }
-    }
-
-    fn update( &mut self, mut input: &[u8] ) {
-        while input.len() > 0 {
-            let left = self.buflen;
-            let fill = 2 * BLAKE2B_BLOCKBYTES - left;
-
-            if input.len() > fill {
-                copy_memory(&input[0..fill], &mut self.buf[left..]); // Fill buffer
-                self.buflen += fill;
-                self.increment_counter( BLAKE2B_BLOCKBYTES as u64);
-                self.compress();
-
-                let mut halves = self.buf.chunks_mut(BLAKE2B_BLOCKBYTES);
-                let first_half = halves.next().unwrap();
-                let second_half = halves.next().unwrap();
-                copy_memory(second_half, first_half);
-
-                self.buflen -= BLAKE2B_BLOCKBYTES;
-                input = &input[fill..input.len()];
-            } else { // inlen <= fill
-                copy_memory(input, &mut self.buf[left..]);
-                self.buflen += input.len();
-                break;
-            }
-        }
-    }
-
-    fn finalize( &mut self, out: &mut [u8] ) {
-        assert!(out.len() == self.digest_length as usize);
-        if !self.computed {
-            if self.buflen > BLAKE2B_BLOCKBYTES {
-                self.increment_counter(BLAKE2B_BLOCKBYTES as u64);
-                self.compress();
-                self.buflen -= BLAKE2B_BLOCKBYTES;
-
-                let mut halves = self.buf.chunks_mut(BLAKE2B_BLOCKBYTES);
-                let first_half = halves.next().unwrap();
-                let second_half = halves.next().unwrap();
-                copy_memory(second_half, first_half);
-            }
-
-            let incby = self.buflen as u64;
-            self.increment_counter(incby);
-            self.set_lastblock();
-            for b in self.buf[self.buflen..].iter_mut() {
-                *b = 0;
-            }
-            self.compress();
-
-            write_u64v_le(&mut self.buf[0..64], &self.h);
-            self.computed = true;
-        }
-        let outlen = out.len();
-        copy_memory(&self.buf[0..outlen], out);
-    }
-
-    pub fn reset(&mut self) {
-        for (h_elem, iv_elem) in self.h.iter_mut().zip(IV.iter()) {
-            *h_elem = *iv_elem;
-        }
-        for t_elem in self.t.iter_mut() {
-            *t_elem = 0;
-        }
-        for f_elem in self.f.iter_mut() {
-            *f_elem = 0;
-        }
-        for b in self.buf.iter_mut() {
-            *b = 0;
-        }
-        self.buflen = 0;
-        self.last_node = 0;
-        self.computed = false;
-        self.apply_param();
-        if self.key_length > 0 {
-            self.apply_key();
-        }
-    }
-
-    pub fn blake2b(out: &mut[u8], input: &[u8], key: &[u8]) {
-        let mut hasher : Blake2b = if key.len() > 0 { Blake2b::new_keyed(out.len(), key) } else { Blake2b::new(out.len()) };
-
-        hasher.update(input);
-        hasher.finalize(out);
-    }
-}
-
-impl Digest for Blake2b {
-    fn reset(&mut self) { Blake2b::reset(self); }
-    fn input(&mut self, msg: &[u8]) { self.update(msg); }
-    fn result(&mut self, out: &mut [u8]) { self.finalize(out); }
-    fn output_bits(&self) -> usize { 8 * (self.digest_length as usize) }
-    fn block_size(&self) -> usize { 8 * BLAKE2B_BLOCKBYTES }
-}
-
-impl Mac for Blake2b {
-    /**
-     * Process input data.
-     *
-     * # Arguments
-     * * data - The input data to process.
-     *
-     */
-    fn input(&mut self, data: &[u8]) {
-        self.update(data);
-    }
-
-    /**
-     * Reset the Mac state to begin processing another input stream.
-     */
-    fn reset(&mut self) {
-        Blake2b::reset(self);
-    }
-
-    /**
-     * Obtain the result of a Mac computation as a MacResult.
-     */
-    fn result(&mut self) -> MacResult {
-        let mut mac: Vec<u8> = repeat(0).take(self.digest_length as usize).collect();
-        self.raw_result(&mut mac);
-        MacResult::new_from_owned(mac)
-    }
-
-    /**
-     * Obtain the result of a Mac computation as [u8]. This method should be used very carefully
-     * since incorrect use of the Mac code could result in permitting a timing attack which defeats
-     * the security provided by a Mac function.
-     */
-    fn raw_result(&mut self, output: &mut [u8]) {
-        self.finalize(output);
-    }
-
-    /**
-     * Get the size of the Mac code, in bytes.
-     */
-    fn output_bytes(&self) -> usize { self.digest_length as usize }
-}
-
-#[cfg(test)]
-mod digest_tests {
-    //use cryptoutil::test::test_digest_1million_random;
-    use blake2b::Blake2b;
-    use digest::Digest;
-    use serialize::hex::FromHex;
-
-
-    struct Test {
-        input: Vec<u8>,
-        output: Vec<u8>,
-        key: Option<Vec<u8>>,
-    }
-
-    fn test_hash(tests: &[Test]) {
-        for t in tests {
-            let mut sh = match t.key {
-                Some(ref key) => Blake2b::new_keyed(64, &key),
-                None => Blake2b::new(64)
-            };
-
-            // Test that it works when accepting the message all at once
-            sh.input(&t.input[..]);
-
-            let mut out = [0u8; 64];
-            sh.result(&mut out);
-            assert!(&out[..] == &t.output[..]);
-
-            sh.reset();
-
-            // Test that it works when accepting the message in pieces
-            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 -= take;
-            }
-
-            let mut out = [0u8; 64];
-            sh.result(&mut out);
-            assert!(&out[..] == &t.output[..]);
-
-            sh.reset();
-        }
-    }
-
-    #[test]
-    fn test_blake2b_digest() {
-        let tests = vec![
-            // Examples from wikipedia
-            Test {
-                input: vec![],
-                output: "786a02f742015903c6c6fd852552d272\
-                         912f4740e15847618a86e217f71f5419\
-                         d25e1031afee585313896444934eb04b\
-                         903a685b1448b755d56f701afe9be2ce".from_hex().unwrap(),
-                key: None
-            },
-            Test {
-                input: "The quick brown fox jumps over the lazy dog".as_bytes().to_vec(),
-                output: "a8add4bdddfd93e4877d2746e62817b1\
-                         16364a1fa7bc148d95090bc7333b3673\
-                         f82401cf7aa2e4cb1ecd90296e3f14cb\
-                         5413f8ed77be73045b13914cdcd6a918".from_hex().unwrap(),
-                key: None
-            },
-            // from: https://github.com/BLAKE2/BLAKE2/blob/master/testvectors/blake2b-test.txt
-            Test {
-                input: vec![0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
-                            0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-                            0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
-                            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-                            0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
-                            0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
-                            0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53,
-                            0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
-                            0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
-                            0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
-                            0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
-                            0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
-                            0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
-                            0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-                            0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
-                            0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
-                            0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb,
-                            0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-                            0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
-                            0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
-                            0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
-                            0xfc, 0xfd, 0xfe],
-                output: vec![0x14, 0x27, 0x09, 0xd6, 0x2e, 0x28, 0xfc, 0xcc, 0xd0, 0xaf, 0x97,
-                             0xfa, 0xd0, 0xf8, 0x46, 0x5b, 0x97, 0x1e, 0x82, 0x20, 0x1d, 0xc5,
-                             0x10, 0x70, 0xfa, 0xa0, 0x37, 0x2a, 0xa4, 0x3e, 0x92, 0x48, 0x4b,
-                             0xe1, 0xc1, 0xe7, 0x3b, 0xa1, 0x09, 0x06, 0xd5, 0xd1, 0x85, 0x3d,
-                             0xb6, 0xa4, 0x10, 0x6e, 0x0a, 0x7b, 0xf9, 0x80, 0x0d, 0x37, 0x3d,
-                             0x6d, 0xee, 0x2d, 0x46, 0xd6, 0x2e, 0xf2, 0xa4, 0x61],
-                key: Some(vec![0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
-                               0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
-                               0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
-                               0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
-                               0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
-                               0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f])
-            },
-        ];
-
-        test_hash(&tests[..]);
-    }
-}
-
-
-#[cfg(test)]
-mod mac_tests {
-    use blake2b::Blake2b;
-    use mac::Mac;
-
-    #[test]
-    fn test_blake2b_mac() {
-        let key: Vec<u8> = (0..64).map(|i| i).collect();
-        let mut m = Blake2b::new_keyed(64, &key[..]);
-        m.input(&[1,2,4,8]);
-        let expected = [
-            0x8e, 0xc6, 0xcb, 0x71, 0xc4, 0x5c, 0x3c, 0x90,
-            0x91, 0xd0, 0x8a, 0x37, 0x1e, 0xa8, 0x5d, 0xc1,
-            0x22, 0xb5, 0xc8, 0xe2, 0xd9, 0xe5, 0x71, 0x42,
-            0xbf, 0xef, 0xce, 0x42, 0xd7, 0xbc, 0xf8, 0x8b,
-            0xb0, 0x31, 0x27, 0x88, 0x2e, 0x51, 0xa9, 0x21,
-            0x44, 0x62, 0x08, 0xf6, 0xa3, 0x58, 0xa9, 0xe0,
-            0x7d, 0x35, 0x3b, 0xd3, 0x1c, 0x41, 0x70, 0x15,
-            0x62, 0xac, 0xd5, 0x39, 0x4e, 0xee, 0x73, 0xae,
-        ];
-        assert_eq!(m.result().code().to_vec(), expected.to_vec());
-    }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use test::Bencher;
-
-    use digest::Digest;
-    use blake2b::Blake2b;
-
-
-    #[bench]
-    pub fn blake2b_10(bh: & mut Bencher) {
-        let mut sh = Blake2b::new(64);
-        let bytes = [1u8; 10];
-        bh.iter( || {
-            sh.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn blake2b_1k(bh: & mut Bencher) {
-        let mut sh = Blake2b::new(64);
-        let bytes = [1u8; 1024];
-        bh.iter( || {
-            sh.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn blake2b_64k(bh: & mut Bencher) {
-        let mut sh = Blake2b::new(64);
-        let bytes = [1u8; 65536];
-        bh.iter( || {
-            sh.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/blake2s.rs b/rustc_deps/vendor/rust-crypto/src/blake2s.rs
deleted file mode 100644
index fc8e095..0000000
--- a/rustc_deps/vendor/rust-crypto/src/blake2s.rs
+++ /dev/null
@@ -1,524 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::iter::repeat;
-use cryptoutil::{copy_memory, read_u32v_le, write_u32v_le};
-use digest::Digest;
-use mac::{Mac, MacResult};
-use util::secure_memset;
-
-static IV : [u32; 8] = [
-  0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
-  0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
-];
-
-static SIGMA : [[usize; 16]; 10] = [
-  [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 ],
-  [ 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 ],
-  [ 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4 ],
-  [  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8 ],
-  [  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13 ],
-  [  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 ],
-  [ 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11 ],
-  [ 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10 ],
-  [  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5 ],
-  [ 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 ]
-];
-
-const BLAKE2S_BLOCKBYTES : usize = 64;
-const BLAKE2S_OUTBYTES : usize = 32;
-const BLAKE2S_KEYBYTES : usize = 32;
-const BLAKE2S_SALTBYTES : usize = 8;
-const BLAKE2S_PERSONALBYTES : usize = 8;
-
-#[derive(Copy)]
-pub struct Blake2s {
-    h: [u32; 8],
-    t: [u32; 2],
-    f: [u32; 2],
-    buf: [u8; 2*BLAKE2S_BLOCKBYTES],
-    buflen: usize,
-    key: [u8; BLAKE2S_KEYBYTES],
-    key_length: u8,
-    last_node: u8,
-    digest_length: u8,
-    computed: bool, // whether the final digest has been computed
-    param: Blake2sParam
-}
-
-impl Clone for Blake2s { fn clone(&self) -> Blake2s { *self } }
-
-#[derive(Copy, Clone)]
-struct Blake2sParam {
-    digest_length: u8,
-    key_length: u8,
-    fanout: u8,
-    depth: u8,
-    leaf_length: u32,
-    node_offset: [u8; 6],
-    node_depth: u8,
-    inner_length: u8,
-    salt: [u8; BLAKE2S_SALTBYTES],
-    personal: [u8; BLAKE2S_PERSONALBYTES],
-}
-
-macro_rules! G( ($r:expr, $i:expr, $a:expr, $b:expr, $c:expr, $d:expr, $m:expr) => ({
-    $a = $a.wrapping_add($b).wrapping_add($m[SIGMA[$r][2*$i+0]]);
-    $d = ($d ^ $a).rotate_right(16);
-    $c = $c.wrapping_add($d);
-    $b = ($b ^ $c).rotate_right(12);
-    $a = $a.wrapping_add($b).wrapping_add($m[SIGMA[$r][2*$i+1]]);
-    $d = ($d ^ $a).rotate_right(8);
-    $c = $c.wrapping_add($d);
-    $b = ($b ^ $c).rotate_right(7);
-}));
-
-macro_rules! round( ($r:expr, $v:expr, $m:expr) => ( {
-    G!($r,0,$v[ 0],$v[ 4],$v[ 8],$v[12], $m);
-    G!($r,1,$v[ 1],$v[ 5],$v[ 9],$v[13], $m);
-    G!($r,2,$v[ 2],$v[ 6],$v[10],$v[14], $m);
-    G!($r,3,$v[ 3],$v[ 7],$v[11],$v[15], $m);
-    G!($r,4,$v[ 0],$v[ 5],$v[10],$v[15], $m);
-    G!($r,5,$v[ 1],$v[ 6],$v[11],$v[12], $m);
-    G!($r,6,$v[ 2],$v[ 7],$v[ 8],$v[13], $m);
-    G!($r,7,$v[ 3],$v[ 4],$v[ 9],$v[14], $m);
-  }
-));
-
-impl Blake2s {
-    fn set_lastnode(&mut self) {
-        self.f[1] = 0xFFFFFFFF;
-    }
-
-    fn set_lastblock(&mut self) {
-        if self.last_node!=0 {
-            self.set_lastnode();
-        }
-        self.f[0] = 0xFFFFFFFF;
-    }
-
-    fn increment_counter(&mut self, inc : u32) {
-        self.t[0] += inc;
-        self.t[1] += if self.t[0] < inc { 1 } else { 0 };
-    }
-
-    fn init0(param: Blake2sParam, digest_length: u8, key: &[u8]) -> Blake2s {
-        assert!(key.len() <= BLAKE2S_KEYBYTES);
-        let mut b = Blake2s {
-            h: IV,
-            t: [0,0],
-            f: [0,0],
-            buf: [0; 2*BLAKE2S_BLOCKBYTES],
-            buflen: 0,
-            last_node: 0,
-            digest_length: digest_length,
-            computed: false,
-            key: [0; BLAKE2S_KEYBYTES],
-            key_length: key.len() as u8,
-            param: param
-        };
-        copy_memory(key, &mut b.key);
-        b
-    }
-
-    fn apply_param(&mut self) {
-        use std::io::Write;
-        use cryptoutil::WriteExt;
-
-        let mut param_bytes : [u8; 32] = [0; 32];
-        {
-            let mut writer: &mut [u8] = &mut param_bytes;
-            writer.write_u8(self.param.digest_length).unwrap();
-            writer.write_u8(self.param.key_length).unwrap();
-            writer.write_u8(self.param.fanout).unwrap();
-            writer.write_u8(self.param.depth).unwrap();
-            writer.write_u32_le(self.param.leaf_length).unwrap();
-            writer.write_all(&self.param.node_offset).unwrap();
-            writer.write_u8(self.param.node_depth).unwrap();
-            writer.write_u8(self.param.inner_length).unwrap();
-            writer.write_all(&self.param.salt).unwrap();
-            writer.write_all(&self.param.personal).unwrap();
-        }
-
-        let mut param_words : [u32; 8] = [0; 8];
-        read_u32v_le(&mut param_words, &param_bytes);
-        for (h, param_word) in self.h.iter_mut().zip(param_words.iter()) {
-            *h = *h ^ *param_word;
-        }
-    }
-
-
-    // init xors IV with input parameter block
-    fn init_param( p: Blake2sParam, key: &[u8] ) -> Blake2s {
-        let mut b = Blake2s::init0(p, p.digest_length, key);
-        b.apply_param();
-        b
-    }
-
-    fn default_param(outlen: u8) -> Blake2sParam {
-        Blake2sParam {
-            digest_length: outlen,
-            key_length: 0,
-            fanout: 1,
-            depth: 1,
-            leaf_length: 0,
-            node_offset: [0; 6],
-            node_depth: 0,
-            inner_length: 0,
-            salt: [0; BLAKE2S_SALTBYTES],
-            personal: [0; BLAKE2S_PERSONALBYTES],
-        }
-    }
-
-    pub fn new(outlen: usize) -> Blake2s {
-        assert!(outlen > 0 && outlen <= BLAKE2S_OUTBYTES);
-        Blake2s::init_param(Blake2s::default_param(outlen as u8), &[])
-    }
-
-    fn apply_key(&mut self) {
-        let mut block : [u8; BLAKE2S_BLOCKBYTES] = [0; BLAKE2S_BLOCKBYTES];
-        copy_memory(&self.key[..self.key_length as usize], &mut block);
-        self.update(&block);
-        secure_memset(&mut block[..], 0);
-    }
-
-    pub fn new_keyed(outlen: usize, key: &[u8] ) -> Blake2s {
-        assert!(outlen > 0 && outlen <= BLAKE2S_OUTBYTES);
-        assert!(key.len() > 0 && key.len() <= BLAKE2S_KEYBYTES);
-
-        let param = Blake2sParam {
-            digest_length: outlen as u8,
-            key_length: key.len() as u8,
-            fanout: 1,
-            depth: 1,
-            leaf_length: 0,
-            node_offset: [0; 6],
-            node_depth: 0,
-            inner_length: 0,
-            salt: [0; BLAKE2S_SALTBYTES],
-            personal: [0; BLAKE2S_PERSONALBYTES],
-        };
-
-        let mut b = Blake2s::init_param(param, key);
-        b.apply_key();
-        b
-    }
-
-    fn compress(&mut self) {
-        let mut ms: [u32; 16] = [0; 16];
-        let mut vs: [u32; 16] = [0; 16];
-
-        read_u32v_le(&mut ms, &self.buf[0..BLAKE2S_BLOCKBYTES]);
-
-        for (v, h) in vs.iter_mut().zip(self.h.iter()) {
-            *v = *h;
-        }
-
-        vs[ 8] = IV[0];
-        vs[ 9] = IV[1];
-        vs[10] = IV[2];
-        vs[11] = IV[3];
-        vs[12] = self.t[0] ^ IV[4];
-        vs[13] = self.t[1] ^ IV[5];
-        vs[14] = self.f[0] ^ IV[6];
-        vs[15] = self.f[1] ^ IV[7];
-        round!(  0, vs, ms );
-        round!(  1, vs, ms );
-        round!(  2, vs, ms );
-        round!(  3, vs, ms );
-        round!(  4, vs, ms );
-        round!(  5, vs, ms );
-        round!(  6, vs, ms );
-        round!(  7, vs, ms );
-        round!(  8, vs, ms );
-        round!(  9, vs, ms );
-
-        for (h_elem, (v_low, v_high)) in self.h.iter_mut().zip( vs[0..8].iter().zip(vs[8..16].iter()) ) {
-            *h_elem = *h_elem ^ *v_low ^ *v_high;
-        }
-    }
-
-    fn update( &mut self, mut input: &[u8] ) {
-        while input.len() > 0 {
-            let left = self.buflen;
-            let fill = 2 * BLAKE2S_BLOCKBYTES - left;
-
-            if input.len() > fill {
-                copy_memory(&input[0..fill], &mut self.buf[left..]); // Fill buffer
-                self.buflen += fill;
-                self.increment_counter( BLAKE2S_BLOCKBYTES as u32);
-                self.compress();
-
-                let mut halves = self.buf.chunks_mut(BLAKE2S_BLOCKBYTES);
-                let first_half = halves.next().unwrap();
-                let second_half = halves.next().unwrap();
-                copy_memory(second_half, first_half);
-
-                self.buflen -= BLAKE2S_BLOCKBYTES;
-                input = &input[fill..input.len()];
-            } else { // inlen <= fill
-                copy_memory(input, &mut self.buf[left..]);
-                self.buflen += input.len();
-                break;
-            }
-        }
-    }
-
-    fn finalize( &mut self, out: &mut [u8] ) {
-        assert!(out.len() == self.digest_length as usize);
-        if !self.computed {
-            if self.buflen > BLAKE2S_BLOCKBYTES {
-                self.increment_counter(BLAKE2S_BLOCKBYTES as u32);
-                self.compress();
-                self.buflen -= BLAKE2S_BLOCKBYTES;
-
-                let mut halves = self.buf.chunks_mut(BLAKE2S_BLOCKBYTES);
-                let first_half = halves.next().unwrap();
-                let second_half = halves.next().unwrap();
-                copy_memory(second_half, first_half);
-            }
-
-            let incby = self.buflen as u32;
-            self.increment_counter(incby);
-            self.set_lastblock();
-            for b in self.buf[self.buflen..].iter_mut() {
-                *b = 0;
-            }
-            self.compress();
-
-            write_u32v_le(&mut self.buf[0..32], &self.h);
-            self.computed = true;
-        }
-        let outlen = out.len();
-        copy_memory(&self.buf[0..outlen], out);
-    }
-
-    pub fn reset(&mut self) {
-        for (h_elem, iv_elem) in self.h.iter_mut().zip(IV.iter()) {
-            *h_elem = *iv_elem;
-        }
-        for t_elem in self.t.iter_mut() {
-            *t_elem = 0;
-        }
-        for f_elem in self.f.iter_mut() {
-            *f_elem = 0;
-        }
-        for b in self.buf.iter_mut() {
-            *b = 0;
-        }
-        self.buflen = 0;
-        self.last_node = 0;
-        self.computed = false;
-        self.apply_param();
-        if self.key_length > 0 {
-            self.apply_key();
-        }
-    }
-
-    pub fn blake2s(out: &mut[u8], input: &[u8], key: &[u8]) {
-        let mut hasher : Blake2s = if key.len() > 0 { Blake2s::new_keyed(out.len(), key) } else { Blake2s::new(out.len()) };
-
-        hasher.update(input);
-        hasher.finalize(out);
-    }
-}
-
-impl Digest for Blake2s {
-    fn reset(&mut self) { Blake2s::reset(self); }
-    fn input(&mut self, msg: &[u8]) { self.update(msg); }
-    fn result(&mut self, out: &mut [u8]) { self.finalize(out); }
-    fn output_bits(&self) -> usize { 8 * (self.digest_length as usize) }
-    fn block_size(&self) -> usize { 8 * BLAKE2S_BLOCKBYTES }
-}
-
-impl Mac for Blake2s {
-    /**
-     * Process input data.
-     *
-     * # Arguments
-     * * data - The input data to process.
-     *
-     */
-    fn input(&mut self, data: &[u8]) {
-        self.update(data);
-    }
-
-    /**
-     * Reset the Mac state to begin processing another input stream.
-     */
-    fn reset(&mut self) {
-        Blake2s::reset(self);
-    }
-
-    /**
-     * Obtain the result of a Mac computation as a MacResult.
-     */
-    fn result(&mut self) -> MacResult {
-        let mut mac: Vec<u8> = repeat(0).take(self.digest_length as usize).collect();
-        self.raw_result(&mut mac);
-        MacResult::new_from_owned(mac)
-    }
-
-    /**
-     * Obtain the result of a Mac computation as [u8]. This method should be used very carefully
-     * since incorrect use of the Mac code could result in permitting a timing attack which defeats
-     * the security provided by a Mac function.
-     */
-    fn raw_result(&mut self, output: &mut [u8]) {
-        self.finalize(output);
-    }
-
-    /**
-     * Get the size of the Mac code, in bytes.
-     */
-    fn output_bytes(&self) -> usize { self.digest_length as usize }
-}
-
-#[cfg(test)]
-mod digest_tests {
-    //use cryptoutil::test::test_digest_1million_random;
-    use blake2s::Blake2s;
-    use digest::Digest;
-
-
-    struct Test {
-        input: Vec<u8>,
-        output: Vec<u8>,
-        key: Option<Vec<u8>>,
-    }
-
-    fn test_hash(tests: &[Test]) {
-        for t in tests {
-            let mut sh = match t.key {
-                Some(ref key) => Blake2s::new_keyed(32, &key),
-                None => Blake2s::new(32)
-            };
-
-            // Test that it works when accepting the message all at once
-            sh.input(&t.input[..]);
-
-            let mut out = [0u8; 32];
-            sh.result(&mut out);
-            assert!(&out[..] == &t.output[..]);
-
-            sh.reset();
-
-            // Test that it works when accepting the message in pieces
-            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 -= take;
-            }
-
-            let mut out = [0u8; 32];
-            sh.result(&mut out);
-            assert!(&out[..] == &t.output[..]);
-
-            sh.reset();
-        }
-    }
-
-    #[test]
-    fn test_blake2s_digest() {
-        let tests = vec![
-            // from: https://github.com/BLAKE2/BLAKE2/blob/master/testvectors/blake2s-test.txt
-            Test {
-                input: vec![0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
-                            0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-                            0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
-                            0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
-                            0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
-                            0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
-                            0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53,
-                            0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
-                            0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
-                            0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
-                            0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
-                            0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
-                            0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
-                            0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
-                            0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
-                            0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
-                            0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb,
-                            0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
-                            0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
-                            0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
-                            0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
-                            0xfc, 0xfd, 0xfe],
-                output: vec![0x3f, 0xb7, 0x35, 0x06, 0x1a, 0xbc, 0x51, 0x9d, 0xfe, 0x97, 0x9e,
-                             0x54, 0xc1, 0xee, 0x5b, 0xfa, 0xd0, 0xa9, 0xd8, 0x58, 0xb3, 0x31,
-                             0x5b, 0xad, 0x34, 0xbd, 0xe9, 0x99, 0xef, 0xd7, 0x24, 0xdd],
-                key: Some(vec![0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
-                               0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
-                               0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f])
-            },
-        ];
-
-        test_hash(&tests[..]);
-    }
-}
-
-
-#[cfg(test)]
-mod mac_tests {
-    use blake2s::Blake2s;
-    use mac::Mac;
-
-    #[test]
-    fn test_blake2s_mac() {
-        let key: Vec<u8> = (0..32).map(|i| i).collect();
-        let mut m = Blake2s::new_keyed(32, &key[..]);
-        m.input(&[1,2,4,8]);
-        let expected = [
-            0x0e, 0x88, 0xf6, 0x8a, 0xaa, 0x5c, 0x4e, 0xd8,
-            0xf7, 0xed, 0x28, 0xf8, 0x04, 0x45, 0x01, 0x9c,
-            0x7e, 0xf9, 0x76, 0x2b, 0x4f, 0xf1, 0xad, 0x7e,
-            0x05, 0x5b, 0xa8, 0xc8, 0x82, 0x9e, 0xe2, 0x49
-        ];
-        assert_eq!(m.result().code().to_vec(), expected.to_vec());
-    }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use test::Bencher;
-
-    use digest::Digest;
-    use blake2s::Blake2s;
-
-
-    #[bench]
-    pub fn blake2s_10(bh: & mut Bencher) {
-        let mut sh = Blake2s::new(32);
-        let bytes = [1u8; 10];
-        bh.iter( || {
-            sh.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn blake2s_1k(bh: & mut Bencher) {
-        let mut sh = Blake2s::new(32);
-        let bytes = [1u8; 1024];
-        bh.iter( || {
-            sh.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-
-    #[bench]
-    pub fn blake2s_64k(bh: & mut Bencher) {
-        let mut sh = Blake2s::new(32);
-        let bytes = [1u8; 65536];
-        bh.iter( || {
-            sh.input(&bytes);
-        });
-        bh.bytes = bytes.len() as u64;
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/blockmodes.rs b/rustc_deps/vendor/rust-crypto/src/blockmodes.rs
deleted file mode 100644
index 8fed8ed..0000000
--- a/rustc_deps/vendor/rust-crypto/src/blockmodes.rs
+++ /dev/null
@@ -1,1437 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// TODO - Optimize the XORs
-// TODO - Maybe use macros to specialize BlockEngine for encryption or decryption?
-// TODO - I think padding could be done better. Maybe macros for BlockEngine would help this too.
-
-use std::cmp;
-use std::iter::repeat;
-
-use buffer::{ReadBuffer, WriteBuffer, OwnedReadBuffer, OwnedWriteBuffer, BufferResult,
-    RefReadBuffer, RefWriteBuffer};
-use buffer::BufferResult::{BufferUnderflow, BufferOverflow};
-use cryptoutil::{self, symm_enc_or_dec};
-use symmetriccipher::{BlockEncryptor, BlockEncryptorX8, Encryptor, BlockDecryptor, Decryptor,
-    SynchronousStreamCipher, SymmetricCipherError};
-use symmetriccipher::SymmetricCipherError::{InvalidPadding, InvalidLength};
-
-/// The BlockProcessor trait is used to implement modes that require processing complete blocks of
-/// data. The methods of this trait are called by the BlockEngine which is in charge of properly
-/// buffering input data.
-trait BlockProcessor {
-    /// Process a block of data. The in_hist and out_hist parameters represent the input and output
-    /// when the last block was processed. These values are necessary for certain modes.
-    fn process_block(&mut self, in_hist: &[u8], out_hist: &[u8], input: &[u8], output: &mut [u8]);
-}
-
-/// A PaddingProcessor handles adding or removing padding
-pub trait PaddingProcessor {
-    /// Add padding to the last block of input data
-    /// If the mode can't handle a non-full block, it signals that error by simply leaving the block
-    /// as it is which will be detected as an InvalidLength error.
-    fn pad_input<W: WriteBuffer>(&mut self, input_buffer: &mut W);
-
-    /// Remove padding from the last block of output data
-    /// If false is returned, the processing fails
-    fn strip_output<R: ReadBuffer>(&mut self, output_buffer: &mut R) -> bool;
-}
-
-/// The BlockEngine is implemented as a state machine with the following states. See comments in the
-/// BlockEngine code for more information on the states.
-#[derive(Clone, Copy)]
-enum BlockEngineState {
-    FastMode,
-    NeedInput,
-    NeedOutput,
-    LastInput,
-    LastInput2,
-    Finished,
-    Error(SymmetricCipherError)
-}
-
-/// BlockEngine buffers input and output data and handles sending complete block of data to the
-/// Processor object. Additionally, BlockEngine handles logic necessary to add or remove padding by
-/// calling the appropriate methods on the Processor object.
-struct BlockEngine<P, X> {
-    /// The block sized expected by the Processor
-    block_size: usize,
-
-    /// in_hist and out_hist keep track of data that was input to and output from the last
-    /// invocation of the process_block() method of the Processor. Depending on the mode, these may
-    /// be empty vectors if history is not needed.
-    in_hist: Vec<u8>,
-    out_hist: Vec<u8>,
-
-    /// If some input data is supplied, but not a complete blocks worth, it is stored in this buffer
-    /// until enough arrives that it can be passed to the process_block() method of the Processor.
-    in_scratch: OwnedWriteBuffer,
-
-    /// If input data is processed but there isn't enough space in the output buffer to store it,
-    /// it is written into out_write_scratch. OwnedWriteBuffer's may be converted into
-    /// OwnedReaderBuffers without re-allocating, so, after being written, out_write_scratch is
-    /// turned into out_read_scratch. After that, if is written to the output as more output becomes
-    /// available. The main point is - only out_write_scratch or out_read_scratch contains a value
-    /// at any given time; never both.
-    out_write_scratch: Option<OwnedWriteBuffer>,
-    out_read_scratch: Option<OwnedReadBuffer>,
-
-    /// The processor that implements the particular block mode.
-    processor: P,
-
-    /// The padding processor
-    padding: X,
-
-    /// The current state of the operation.
-    state: BlockEngineState
-}
-
-fn update_history(in_hist: &mut [u8], out_hist: &mut [u8], last_in: &[u8], last_out: &[u8]) {
-    let in_hist_len = in_hist.len();
-    if in_hist_len > 0 {
-        cryptoutil::copy_memory(
-            &last_in[last_in.len() - in_hist_len..],
-            in_hist);
-    }
-    let out_hist_len = out_hist.len();
-    if out_hist_len > 0 {
-        cryptoutil::copy_memory(
-            &last_out[last_out.len() - out_hist_len..],
-            out_hist);
-    }
-}
-
-impl <P: BlockProcessor, X: PaddingProcessor> BlockEngine<P, X> {
-    /// Create a new BlockProcessor instance with the given processor and block_size. No history
-    /// will be saved.
-    fn new(processor: P, padding: X, block_size: usize) -> BlockEngine<P, X> {
-        BlockEngine {
-            block_size: block_size,
-            in_hist: Vec::new(),
-            out_hist: Vec::new(),
-            in_scratch: OwnedWriteBuffer::new(repeat(0).take(block_size).collect()),
-            out_write_scratch: Some(OwnedWriteBuffer::new(repeat(0).take(block_size).collect())),
-            out_read_scratch: None,
-            processor: processor,
-            padding: padding,
-            state: BlockEngineState::FastMode
-        }
-    }
-
-    /// Create a new BlockProcessor instance with the given processor, block_size, and initial input
-    /// and output history.
-    fn new_with_history(
-            processor: P,
-            padding: X,
-            block_size: usize,
-            in_hist: Vec<u8>,
-            out_hist: Vec<u8>) -> BlockEngine<P, X> {
-        BlockEngine {
-            in_hist: in_hist,
-            out_hist: out_hist,
-            ..BlockEngine::new(processor, padding, block_size)
-        }
-    }
-
-    /// This implements the FastMode state. Ideally, the encryption or decryption operation should
-    /// do the bulk of its work in FastMode. Significantly, FastMode avoids doing copies as much as
-    /// possible. The FastMode state does not handle the final block of data.
-    fn fast_mode<R: ReadBuffer, W: WriteBuffer>(
-            &mut self,
-            input: &mut R,
-            output: &mut W) -> BlockEngineState {
-        fn has_next<R: ReadBuffer, W: WriteBuffer>(
-                input: &mut R,
-                output: &mut W,
-                block_size: usize) -> bool {
-            // Not the greater than - very important since this method must never process the last
-            // block.
-            let enough_input = input.remaining() > block_size;
-            let enough_output = output.remaining() >= block_size;
-            enough_input && enough_output
-        };
-        fn split_at<'a>(vec: &'a [u8], at: usize) -> (&'a [u8], &'a [u8]) {
-            (&vec[..at], &vec[at..])
-        }
-
-        // First block processing. We have to retrieve the history information from self.in_hist and
-        // self.out_hist.
-        if !has_next(input, output, self.block_size) {
-            if input.is_empty() {
-                return BlockEngineState::FastMode;
-            } else {
-                return BlockEngineState::NeedInput;
-            }
-        } else {
-            let next_in = input.take_next(self.block_size);
-            let next_out = output.take_next(self.block_size);
-            self.processor.process_block(
-                &self.in_hist[..],
-                &self.out_hist[..],
-                next_in,
-                next_out);
-        }
-
-        // Process all remaing blocks. We can pull the history out of the buffers without having to
-        // do any copies
-        let next_in_size = self.in_hist.len() + self.block_size;
-        let next_out_size = self.out_hist.len() + self.block_size;
-        while has_next(input, output, self.block_size) {
-            input.rewind(self.in_hist.len());
-            let (in_hist, next_in) = split_at(input.take_next(next_in_size), self.in_hist.len());
-            output.rewind(self.out_hist.len());
-            let (out_hist, next_out) = output.take_next(next_out_size).split_at_mut(
-                self.out_hist.len());
-            self.processor.process_block(
-                in_hist,
-                out_hist,
-                next_in,
-                next_out);
-        }
-
-        // Save the history and then transition to the next state
-        {
-            input.rewind(self.in_hist.len());
-            let last_in = input.take_next(self.in_hist.len());
-            output.rewind(self.out_hist.len());
-            let last_out = output.take_next(self.out_hist.len());
-            update_history(
-                &mut self.in_hist,
-                &mut self.out_hist,
-                last_in,
-                last_out);
-        }
-        if input.is_empty() {
-            BlockEngineState::FastMode
-        } else {
-            BlockEngineState::NeedInput
-        }
-    }
-
-    /// This method implements the BlockEngine state machine.
-    fn process<R: ReadBuffer, W: WriteBuffer>(
-            &mut self,
-            input: &mut R,
-            output: &mut W,
-            eof: bool) -> Result<BufferResult, SymmetricCipherError> {
-        // Process a block of data from in_scratch and write the result to out_write_scratch.
-        // Finally, convert out_write_scratch into out_read_scratch.
-        fn process_scratch<P: BlockProcessor, X: PaddingProcessor>(me: &mut BlockEngine<P, X>) {
-            let mut rin = me.in_scratch.take_read_buffer();
-            let mut wout = me.out_write_scratch.take().unwrap();
-
-            {
-                let next_in = rin.take_remaining();
-                let next_out = wout.take_remaining();
-                me.processor.process_block(
-                    &me.in_hist[..],
-                    &me.out_hist[..],
-                    next_in,
-                    next_out);
-                update_history(
-                    &mut me.in_hist,
-                    &mut me.out_hist,
-                    next_in,
-                    next_out);
-            }
-
-            let rb = wout.into_read_buffer();
-            me.out_read_scratch = Some(rb);
-        };
-
-        loop {
-            match self.state {
-                // FastMode tries to process as much data as possible while minimizing copies.
-                // FastMode doesn't make use of the scratch buffers and only updates the history
-                // just before exiting.
-                BlockEngineState::FastMode => {
-                    self.state = self.fast_mode(input, output);
-                    match self.state {
-                        BlockEngineState::FastMode => {
-                            // If FastMode completes but stays in the FastMode state, it means that
-                            // we've run out of input data.
-                            return Ok(BufferUnderflow);
-                        }
-                        _ => {}
-                    }
-                }
-
-                // The NeedInput mode is entered when there isn't enough data to run in FastMode
-                // anymore. Input data is buffered in in_scratch until there is a full block or eof
-                // occurs. IF eof doesn't occur, the data is processed and then we go to the
-                // NeedOutput state. Otherwise, we go to the LastInput state. This state always
-                // writes all available data into in_scratch before transitioning to the next state.
-                BlockEngineState::NeedInput => {
-                    input.push_to(&mut self.in_scratch);
-                    if !input.is_empty() {
-                        // !is_empty() guarantees two things - in_scratch is full and its not the
-                        // last block. This state must never process the last block.
-                        process_scratch(self);
-                        self.state = BlockEngineState::NeedOutput;
-                    } else {
-                        if eof {
-                            self.state = BlockEngineState::LastInput;
-                        } else {
-                            return Ok(BufferUnderflow);
-                        }
-                    }
-                }
-
-                // The NeedOutput state just writes buffered processed data to the output stream
-                // until all of it has been written.
-                BlockEngineState::NeedOutput => {
-                    let mut rout = self.out_read_scratch.take().unwrap();
-                    rout.push_to(output);
-                    if rout.is_empty() {
-                        self.out_write_scratch = Some(rout.into_write_buffer());
-                        self.state = BlockEngineState::FastMode;
-                    } else {
-                        self.out_read_scratch = Some(rout);
-                        return Ok(BufferOverflow);
-                    }
-                }
-
-                // None of the other states are allowed to process the last block of data since
-                // last block handling is a little tricky due to modes have special needs regarding
-                // padding. When the last block of data is detected, this state is transitioned to
-                // for handling.
-                BlockEngineState::LastInput => {
-                    // We we arrive in this state, we know that all input data that is going to be
-                    // supplied has been suplied and that that data has been written to in_scratch
-                    // by the NeedInput state. Furthermore, we know that one of three things must be
-                    // true about in_scratch:
-                    // 1) It is empty. This only occurs if the input is zero length. We can do last
-                    //    block processing by executing the pad_input() method of the processor
-                    //    which may either pad out to a full block or leave it empty, process the
-                    //    data if it was padded out to a full block, and then pass it to
-                    //    strip_output().
-                    // 2) It is partially filled. This will occur if the input data was not a
-                    //    multiple of the block size. Processing proceeds identically to case #1.
-                    // 3) It is full. This case occurs when the input data was a multiple of the
-                    //    block size. This case is a little trickier, since, depending on the mode,
-                    //    we might actually have 2 blocks worth of data to process - the last user
-                    //    supplied block (currently in in_scratch) and then another block that could
-                    //    be added as padding. Processing proceeds by first processing the data in
-                    //    in_scratch and writing it to out_scratch. Then, the now-empty in_scratch
-                    //    buffer is passed to pad_input() which may leave it empty or write a block
-                    //    of padding to it. If no padding is added, processing proceeds as in cases
-                    //    #1 and #2. However, if padding is added, now have data in in_scratch and
-                    //    also in out_scratch meaning that we can't immediately process the padding
-                    //    data since we have nowhere to put it. So, we transition to the LastInput2
-                    //    state which will first write out the last non-padding block, then process
-                    //    the padding block (in in_scratch) and write it to the now-empty
-                    //    out_scratch.
-                    if !self.in_scratch.is_full() {
-                        self.padding.pad_input(&mut self.in_scratch);
-                        if self.in_scratch.is_full() {
-                            process_scratch(self);
-                            if self.padding.strip_output(self.out_read_scratch.as_mut().unwrap()) {
-                                self.state = BlockEngineState::Finished;
-                            } else {
-                                self.state = BlockEngineState::Error(InvalidPadding);
-                            }
-                        } else if self.in_scratch.is_empty() {
-                            self.state = BlockEngineState::Finished;
-                        } else {
-                            self.state = BlockEngineState::Error(InvalidLength);
-                        }
-                    } else {
-                        process_scratch(self);
-                        self.padding.pad_input(&mut self.in_scratch);
-                        if self.in_scratch.is_full() {
-                            self.state = BlockEngineState::LastInput2;
-                        } else if self.in_scratch.is_empty() {
-                            if self.padding.strip_output(self.out_read_scratch.as_mut().unwrap()) {
-                                self.state = BlockEngineState::Finished;
-                            } else {
-                                self.state = BlockEngineState::Error(InvalidPadding);
-                            }
-                        } else {
-                            self.state = BlockEngineState::Error(InvalidLength);
-                        }
-                    }
-                }
-
-                // See the comments on LastInput for more details. This state handles final blocks
-                // of data in the case that the input was a multiple of the block size and the mode
-                // decided to add a full extra block of padding.
-                BlockEngineState::LastInput2 => {
-                    let mut rout = self.out_read_scratch.take().unwrap();
-                    rout.push_to(output);
-                    if rout.is_empty() {
-                        self.out_write_scratch = Some(rout.into_write_buffer());
-                        process_scratch(self);
-                        if self.padding.strip_output(self.out_read_scratch.as_mut().unwrap()) {
-                            self.state = BlockEngineState::Finished;
-                        } else {
-                            self.state = BlockEngineState::Error(InvalidPadding);
-                        }
-                    } else {
-                        self.out_read_scratch = Some(rout);
-                        return Ok(BufferOverflow);
-                    }
-                }
-
-                // The Finished mode just writes the data in out_scratch to the output until there
-                // is no more data left.
-                BlockEngineState::Finished => {
-                    match self.out_read_scratch {
-                        Some(ref mut rout) => {
-                            rout.push_to(output);
-                            if rout.is_empty() {
-                                return Ok(BufferUnderflow);
-                            } else {
-                                return Ok(BufferOverflow);
-                            }
-                        }
-                        None => { return Ok(BufferUnderflow); }
-                    }
-                }
-
-                // The Error state is used to store error information.
-                BlockEngineState::Error(err) => {
-                    return Err(err);
-                }
-            }
-        }
-    }
-    fn reset(&mut self) {
-        self.state = BlockEngineState::FastMode;
-        self.in_scratch.reset();
-        if self.out_read_scratch.is_some() {
-            let ors = self.out_read_scratch.take().unwrap();
-            let ows = ors.into_write_buffer();
-            self.out_write_scratch = Some(ows);
-        } else {
-            self.out_write_scratch.as_mut().unwrap().reset();
-        }
-    }
-    fn reset_with_history(&mut self, in_hist: &[u8], out_hist: &[u8]) {
-        self.reset();
-        cryptoutil::copy_memory(in_hist, &mut self.in_hist);
-        cryptoutil::copy_memory(out_hist, &mut self.out_hist);
-    }
-}
-
-/// No padding mode for ECB and CBC encryption
-#[derive(Clone, Copy)]
-pub struct NoPadding;
-
-impl PaddingProcessor for NoPadding {
-    fn pad_input<W: WriteBuffer>(&mut self, _: &mut W) { }
-    fn strip_output<R: ReadBuffer>(&mut self, _: &mut R) -> bool { true }
-}
-
-/// PKCS padding mode for ECB and CBC encryption
-#[derive(Clone, Copy)]
-pub struct PkcsPadding;
-
-// This class implements both encryption padding, where padding is added, and decryption padding,
-// where padding is stripped. Since BlockEngine doesn't know if its an Encryption or Decryption
-// operation, it will call both methods if given a chance. So, this class can't be passed directly
-// to BlockEngine. Instead, it must be wrapped with EncPadding or DecPadding which will ensure that
-// only the propper methods are called. The client of the library, however, doesn't have to
-// distinguish encryption padding handling from decryption padding handline, which is the whole
-// point.
-impl PaddingProcessor for PkcsPadding {
-    fn pad_input<W: WriteBuffer>(&mut self, input_buffer: &mut W) {
-        let rem = input_buffer.remaining();
-        assert!(rem != 0 && rem <= 255);
-        for v in input_buffer.take_remaining().iter_mut() {
-            *v = rem as u8;
-        }
-    }
-    fn strip_output<R: ReadBuffer>(&mut self, output_buffer: &mut R) -> bool {
-        let last_byte: u8;
-        {
-            let data = output_buffer.peek_remaining();
-            last_byte = *data.last().unwrap();
-            for &x in data.iter().rev().take(last_byte as usize) {
-                if x != last_byte {
-                    return false;
-                }
-            }
-        }
-        output_buffer.truncate(last_byte as usize);
-        true
-    }
-}
-
-/// Wraps a PaddingProcessor so that only pad_input() will actually be called.
-pub struct EncPadding<X> {
-    padding: X
-}
-
-impl <X: PaddingProcessor> EncPadding<X> {
-    fn wrap(p: X) -> EncPadding<X> { EncPadding { padding: p } }
-}
-
-impl <X: PaddingProcessor> PaddingProcessor for EncPadding<X> {
-    fn pad_input<W: WriteBuffer>(&mut self, a: &mut W) { self.padding.pad_input(a); }
-    fn strip_output<R: ReadBuffer>(&mut self, _: &mut R) -> bool { true }
-}
-
-/// Wraps a PaddingProcessor so that only strip_output() will actually be called.
-pub struct DecPadding<X> {
-    padding: X
-}
-
-impl <X: PaddingProcessor> DecPadding<X> {
-    fn wrap(p: X) -> DecPadding<X> { DecPadding { padding: p } }
-}
-
-impl <X: PaddingProcessor> PaddingProcessor for DecPadding<X> {
-    fn pad_input<W: WriteBuffer>(&mut self, _: &mut W) { }
-    fn strip_output<R: ReadBuffer>(&mut self, a: &mut R) -> bool { self.padding.strip_output(a) }
-}
-
-struct EcbEncryptorProcessor<T> {
-    algo: T
-}
-
-impl <T: BlockEncryptor> BlockProcessor for EcbEncryptorProcessor<T> {
-    fn process_block(&mut self, _: &[u8], _: &[u8], input: &[u8], output: &mut [u8]) {
-        self.algo.encrypt_block(input, output);
-    }
-}
-
-/// ECB Encryption mode
-pub struct EcbEncryptor<T, X> {
-    block_engine: BlockEngine<EcbEncryptorProcessor<T>, X>
-}
-
-impl <T: BlockEncryptor, X: PaddingProcessor> EcbEncryptor<T, X> {
-    /// Create a new ECB encryption mode object
-    pub fn new(algo: T, padding: X) -> EcbEncryptor<T, EncPadding<X>> {
-        let block_size = algo.block_size();
-        let processor = EcbEncryptorProcessor {
-            algo: algo
-        };
-        EcbEncryptor {
-            block_engine: BlockEngine::new(processor, EncPadding::wrap(padding), block_size)
-        }
-    }
-    pub fn reset(&mut self) {
-        self.block_engine.reset();
-    }
-}
-
-impl <T: BlockEncryptor, X: PaddingProcessor> Encryptor for EcbEncryptor<T, X> {
-    fn encrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, eof: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        self.block_engine.process(input, output, eof)
-    }
-}
-
-struct EcbDecryptorProcessor<T> {
-    algo: T
-}
-
-impl <T: BlockDecryptor> BlockProcessor for EcbDecryptorProcessor<T> {
-    fn process_block(&mut self, _: &[u8], _: &[u8], input: &[u8], output: &mut [u8]) {
-        self.algo.decrypt_block(input, output);
-    }
-}
-
-/// ECB Decryption mode
-pub struct EcbDecryptor<T, X> {
-    block_engine: BlockEngine<EcbDecryptorProcessor<T>, X>
-}
-
-impl <T: BlockDecryptor, X: PaddingProcessor> EcbDecryptor<T, X> {
-    /// Create a new ECB decryption mode object
-    pub fn new(algo: T, padding: X) -> EcbDecryptor<T, DecPadding<X>> {
-        let block_size = algo.block_size();
-        let processor = EcbDecryptorProcessor {
-            algo: algo
-        };
-        EcbDecryptor {
-            block_engine: BlockEngine::new(processor, DecPadding::wrap(padding), block_size)
-        }
-    }
-    pub fn reset(&mut self) {
-        self.block_engine.reset();
-    }
-}
-
-impl <T: BlockDecryptor, X: PaddingProcessor> Decryptor for EcbDecryptor<T, X> {
-    fn decrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, eof: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        self.block_engine.process(input, output, eof)
-    }
-}
-
-struct CbcEncryptorProcessor<T> {
-    algo: T,
-    temp: Vec<u8>
-}
-
-impl <T: BlockEncryptor> BlockProcessor for CbcEncryptorProcessor<T> {
-    fn process_block(&mut self, _: &[u8], out_hist: &[u8], input: &[u8], output: &mut [u8]) {
-        for ((&x, &y), o) in input.iter().zip(out_hist.iter()).zip(self.temp.iter_mut()) {
-            *o = x ^ y;
-        }
-        self.algo.encrypt_block(&self.temp[..], output);
-    }
-}
-
-/// CBC encryption mode
-pub struct CbcEncryptor<T, X> {
-    block_engine: BlockEngine<CbcEncryptorProcessor<T>, X>
-}
-
-impl <T: BlockEncryptor, X: PaddingProcessor> CbcEncryptor<T, X> {
-    /// Create a new CBC encryption mode object
-    pub fn new(algo: T, padding: X, iv: Vec<u8>) -> CbcEncryptor<T, EncPadding<X>> {
-        let block_size = algo.block_size();
-        let processor = CbcEncryptorProcessor {
-            algo: algo,
-            temp: repeat(0).take(block_size).collect()
-        };
-        CbcEncryptor {
-            block_engine: BlockEngine::new_with_history(
-                processor,
-                EncPadding::wrap(padding),
-                block_size,
-                Vec::new(),
-                iv)
-        }
-    }
-    pub fn reset(&mut self, iv: &[u8]) {
-        self.block_engine.reset_with_history(&[], iv);
-    }
-}
-
-impl <T: BlockEncryptor, X: PaddingProcessor> Encryptor for CbcEncryptor<T, X> {
-    fn encrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, eof: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        self.block_engine.process(input, output, eof)
-    }
-}
-
-struct CbcDecryptorProcessor<T> {
-    algo: T,
-    temp: Vec<u8>
-}
-
-impl <T: BlockDecryptor> BlockProcessor for CbcDecryptorProcessor<T> {
-    fn process_block(&mut self, in_hist: &[u8], _: &[u8], input: &[u8], output: &mut [u8]) {
-        self.algo.decrypt_block(input, &mut self.temp);
-        for ((&x, &y), o) in self.temp.iter().zip(in_hist.iter()).zip(output.iter_mut()) {
-            *o = x ^ y;
-        }
-    }
-}
-
-/// CBC decryption mode
-pub struct CbcDecryptor<T, X> {
-    block_engine: BlockEngine<CbcDecryptorProcessor<T>, X>
-}
-
-impl <T: BlockDecryptor, X: PaddingProcessor> CbcDecryptor<T, X> {
-    /// Create a new CBC decryption mode object
-    pub fn new(algo: T, padding: X, iv: Vec<u8>) -> CbcDecryptor<T, DecPadding<X>> {
-        let block_size = algo.block_size();
-        let processor = CbcDecryptorProcessor {
-            algo: algo,
-            temp: repeat(0).take(block_size).collect()
-        };
-        CbcDecryptor {
-            block_engine: BlockEngine::new_with_history(
-                processor,
-                DecPadding::wrap(padding),
-                block_size,
-                iv,
-                Vec::new())
-        }
-    }
-    pub fn reset(&mut self, iv: &[u8]) {
-        self.block_engine.reset_with_history(iv, &[]);
-    }
-}
-
-impl <T: BlockDecryptor, X: PaddingProcessor> Decryptor for CbcDecryptor<T, X> {
-    fn decrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, eof: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        self.block_engine.process(input, output, eof)
-    }
-}
-
-fn add_ctr(ctr: &mut [u8], mut ammount: u8) {
-    for i in ctr.iter_mut().rev() {
-        let prev = *i;
-        *i = i.wrapping_add(ammount);
-        if *i >= prev {
-            break;
-        }
-        ammount = 1;
-    }
-}
-
-/// CTR Mode
-pub struct CtrMode<A> {
-    algo: A,
-    ctr: Vec<u8>,
-    bytes: OwnedReadBuffer
-}
-
-impl <A: BlockEncryptor> CtrMode<A> {
-    /// Create a new CTR object
-    pub fn new(algo: A, ctr: Vec<u8>) -> CtrMode<A> {
-        let block_size = algo.block_size();
-        CtrMode {
-            algo: algo,
-            ctr: ctr,
-            bytes: OwnedReadBuffer::new_with_len(repeat(0).take(block_size).collect(), 0)
-        }
-    }
-    pub fn reset(&mut self, ctr: &[u8]) {
-        cryptoutil::copy_memory(ctr, &mut self.ctr);
-        self.bytes.reset();
-    }
-    fn process(&mut self, input: &[u8], output: &mut [u8]) {
-        assert!(input.len() == output.len());
-        let len = input.len();
-        let mut i = 0;
-        while i < len {
-            if self.bytes.is_empty() {
-                let mut wb = self.bytes.borrow_write_buffer();
-                self.algo.encrypt_block(&self.ctr[..], wb.take_remaining());
-                add_ctr(&mut self.ctr, 1);
-            }
-            let count = cmp::min(self.bytes.remaining(), len - i);
-            let bytes_it = self.bytes.take_next(count).iter();
-            let in_it = input[i..].iter();
-            let out_it = output[i..].iter_mut();
-            for ((&x, &y), o) in bytes_it.zip(in_it).zip(out_it) {
-                *o = x ^ y;
-            }
-            i += count;
-        }
-    }
-}
-
-impl <A: BlockEncryptor> SynchronousStreamCipher for CtrMode<A> {
-    fn process(&mut self, input: &[u8], output: &mut [u8]) {
-        self.process(input, output);
-    }
-}
-
-impl <A: BlockEncryptor> Encryptor for CtrMode<A> {
-    fn encrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, _: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        symm_enc_or_dec(self, input, output)
-    }
-}
-
-impl <A: BlockEncryptor> Decryptor for CtrMode<A> {
-    fn decrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, _: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        symm_enc_or_dec(self, input, output)
-    }
-}
-
-/// CTR Mode that operates on 8 blocks at a time
-pub struct CtrModeX8<A> {
-    algo: A,
-    ctr_x8: Vec<u8>,
-    bytes: OwnedReadBuffer
-}
-
-fn construct_ctr_x8(in_ctr: &[u8], out_ctr_x8: &mut [u8]) {
-    for (i, ctr_i) in out_ctr_x8.chunks_mut(in_ctr.len()).enumerate() {
-        cryptoutil::copy_memory(in_ctr, ctr_i);
-        add_ctr(ctr_i, i as u8);
-    }
-}
-
-impl <A: BlockEncryptorX8> CtrModeX8<A> {
-    /// Create a new CTR object that operates on 8 blocks at a time
-    pub fn new(algo: A, ctr: &[u8]) -> CtrModeX8<A> {
-        let block_size = algo.block_size();
-        let mut ctr_x8: Vec<u8> = repeat(0).take(block_size * 8).collect();
-        construct_ctr_x8(ctr, &mut ctr_x8);
-        CtrModeX8 {
-            algo: algo,
-            ctr_x8: ctr_x8,
-            bytes: OwnedReadBuffer::new_with_len(repeat(0).take(block_size * 8).collect(), 0)
-        }
-    }
-    pub fn reset(&mut self, ctr: &[u8]) {
-        construct_ctr_x8(ctr, &mut self.ctr_x8);
-        self.bytes.reset();
-    }
-    fn process(&mut self, input: &[u8], output: &mut [u8]) {
-        // TODO - Can some of this be combined with regular CtrMode?
-        assert!(input.len() == output.len());
-        let len = input.len();
-        let mut i = 0;
-        while i < len {
-            if self.bytes.is_empty() {
-                let mut wb = self.bytes.borrow_write_buffer();
-                self.algo.encrypt_block_x8(&self.ctr_x8[..], wb.take_remaining());
-                for ctr_i in &mut self.ctr_x8.chunks_mut(self.algo.block_size()) {
-                    add_ctr(ctr_i, 8);
-                }
-            }
-            let count = cmp::min(self.bytes.remaining(), len - i);
-            let bytes_it = self.bytes.take_next(count).iter();
-            let in_it = input[i..].iter();
-            let out_it = &mut output[i..];
-            for ((&x, &y), o) in bytes_it.zip(in_it).zip(out_it.iter_mut()) {
-                *o = x ^ y;
-            }
-            i += count;
-        }
-    }
-}
-
-impl <A: BlockEncryptorX8> SynchronousStreamCipher for CtrModeX8<A> {
-    fn process(&mut self, input: &[u8], output: &mut [u8]) {
-        self.process(input, output);
-    }
-}
-
-impl <A: BlockEncryptorX8> Encryptor for CtrModeX8<A> {
-    fn encrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, _: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        symm_enc_or_dec(self, input, output)
-    }
-}
-
-impl <A: BlockEncryptorX8> Decryptor for CtrModeX8<A> {
-    fn decrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, _: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        symm_enc_or_dec(self, input, output)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::iter::repeat;
-
-    use aessafe;
-    use blockmodes::{EcbEncryptor, EcbDecryptor, CbcEncryptor, CbcDecryptor, CtrMode, CtrModeX8,
-        NoPadding, PkcsPadding};
-    use buffer::{ReadBuffer, WriteBuffer, RefReadBuffer, RefWriteBuffer, BufferResult};
-    use buffer::BufferResult::{BufferUnderflow, BufferOverflow};
-    use symmetriccipher::{Encryptor, Decryptor};
-    use symmetriccipher::SymmetricCipherError::{self, InvalidLength, InvalidPadding};
-
-    use std::cmp;
-
-    trait CipherTest {
-        fn get_plain<'a>(&'a self) -> &'a [u8];
-        fn get_cipher<'a>(&'a self) -> &'a [u8];
-    }
-
-    struct EcbTest {
-        key: Vec<u8>,
-        plain: Vec<u8>,
-        cipher: Vec<u8>
-    }
-
-    impl CipherTest for EcbTest {
-        fn get_plain<'a>(&'a self) -> &'a [u8] {
-            &self.plain[..]
-        }
-        fn get_cipher<'a>(&'a self) -> &'a [u8] {
-            &self.cipher[..]
-        }
-    }
-
-    struct CbcTest {
-        key: Vec<u8>,
-        iv: Vec<u8>,
-        plain: Vec<u8>,
-        cipher: Vec<u8>
-    }
-
-    impl CipherTest for CbcTest {
-        fn get_plain<'a>(&'a self) -> &'a [u8] {
-            &self.plain[..]
-        }
-        fn get_cipher<'a>(&'a self) -> &'a [u8] {
-            &self.cipher[..]
-        }
-    }
-
-    struct CtrTest {
-        key: Vec<u8>,
-        ctr: Vec<u8>,
-        plain: Vec<u8>,
-        cipher: Vec<u8>
-    }
-
-    impl CipherTest for CtrTest {
-        fn get_plain<'a>(&'a self) -> &'a [u8] {
-            &self.plain[..]
-        }
-        fn get_cipher<'a>(&'a self) -> &'a [u8] {
-            &self.cipher[..]
-        }
-    }
-
-    fn aes_ecb_no_padding_tests() -> Vec<EcbTest> {
-        vec![
-            EcbTest {
-                key: repeat(0).take(16).collect(),
-                plain: repeat(0).take(32).collect(),
-                cipher: vec![
-                    0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b,
-                    0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e,
-                    0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b,
-                    0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e ]
-            }
-        ]
-    }
-
-    fn aes_ecb_pkcs_padding_tests() -> Vec<EcbTest> {
-        vec![
-            EcbTest {
-                key: repeat(0).take(16).collect(),
-                plain: repeat(0).take(32).collect(),
-                cipher: vec![
-                    0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b,
-                    0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e,
-                    0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b,
-                    0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e,
-                    0x01, 0x43, 0xdb, 0x63, 0xee, 0x66, 0xb0, 0xcd,
-                    0xff, 0x9f, 0x69, 0x91, 0x76, 0x80, 0x15, 0x1e ]
-            },
-            EcbTest {
-                key: repeat(0).take(16).collect(),
-                plain: repeat(0).take(33).collect(),
-                cipher: vec![
-                    0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b,
-                    0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e,
-                    0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b,
-                    0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e,
-                    0x7a, 0xdc, 0x99, 0xb2, 0x9e, 0x82, 0xb1, 0xb2,
-                    0xb0, 0xa6, 0x5a, 0x38, 0xbc, 0x57, 0x8a, 0x01 ]
-            }
-        ]
-    }
-
-    fn aes_cbc_no_padding_tests() -> Vec<CbcTest> {
-        vec![
-            CbcTest {
-                key: repeat(1).take(16).collect(),
-                iv: repeat(3).take(16).collect(),
-                plain: repeat(2).take(32).collect(),
-                cipher: vec![
-                    0x5e, 0x77, 0xe5, 0x9f, 0x8f, 0x85, 0x94, 0x34,
-                    0x89, 0xa2, 0x41, 0x49, 0xc7, 0x5f, 0x4e, 0xc9,
-                    0xe0, 0x9a, 0x77, 0x36, 0xfb, 0xc8, 0xb2, 0xdc,
-                    0xb3, 0xfb, 0x9f, 0xc0, 0x31, 0x4c, 0xb0, 0xb1 ]
-            }
-        ]
-    }
-
-    fn aes_cbc_pkcs_padding_tests() -> Vec<CbcTest> {
-        vec![
-            CbcTest {
-                key: repeat(1).take(16).collect(),
-                iv: repeat(3).take(16).collect(),
-                plain: repeat(2).take(32).collect(),
-                cipher: vec![
-                    0x5e, 0x77, 0xe5, 0x9f, 0x8f, 0x85, 0x94, 0x34,
-                    0x89, 0xa2, 0x41, 0x49, 0xc7, 0x5f, 0x4e, 0xc9,
-                    0xe0, 0x9a, 0x77, 0x36, 0xfb, 0xc8, 0xb2, 0xdc,
-                    0xb3, 0xfb, 0x9f, 0xc0, 0x31, 0x4c, 0xb0, 0xb1,
-                    0xa4, 0xc2, 0xe4, 0x62, 0xef, 0x7a, 0xe3, 0x7e,
-                    0xef, 0x88, 0xf3, 0x27, 0xbd, 0x9c, 0xc8, 0x4d ]
-            },
-            CbcTest {
-                key: repeat(1).take(16).collect(),
-                iv: repeat(3).take(16).collect(),
-                plain: repeat(2).take(33).collect(),
-                cipher: vec![
-                    0x5e, 0x77, 0xe5, 0x9f, 0x8f, 0x85, 0x94, 0x34,
-                    0x89, 0xa2, 0x41, 0x49, 0xc7, 0x5f, 0x4e, 0xc9,
-                    0xe0, 0x9a, 0x77, 0x36, 0xfb, 0xc8, 0xb2, 0xdc,
-                    0xb3, 0xfb, 0x9f, 0xc0, 0x31, 0x4c, 0xb0, 0xb1,
-                    0x6c, 0x47, 0xcd, 0xec, 0xae, 0xbb, 0x1a, 0x65,
-                    0x04, 0xd2, 0x32, 0x23, 0xa6, 0x8d, 0x4a, 0x65 ]
-            }
-        ]
-    }
-
-    fn aes_ctr_tests() -> Vec<CtrTest> {
-        vec![
-            CtrTest {
-                key: repeat(1).take(16).collect(),
-                ctr: repeat(3).take(16).collect(),
-                plain: repeat(2).take(33).collect(),
-                cipher: vec![
-                    0x64, 0x3e, 0x05, 0x19, 0x79, 0x78, 0xd7, 0x45,
-                    0xa9, 0x10, 0x5f, 0xd8, 0x4c, 0xd7, 0xe6, 0xb1,
-                    0x5f, 0x66, 0xc6, 0x17, 0x4b, 0x25, 0xea, 0x24,
-                    0xe6, 0xf9, 0x19, 0x09, 0xb7, 0xdd, 0x84, 0xfb,
-                    0x86 ]
-            }
-        ]
-    }
-
-    // Test the mode by encrypting all of the data at once
-    fn run_full_test<T: CipherTest, E: Encryptor, D: Decryptor>(
-            test: &T,
-            enc: &mut E,
-            dec: &mut D) {
-        let mut cipher_out: Vec<u8> = repeat(0).take(test.get_cipher().len()).collect();
-        {
-            let mut buff_in = RefReadBuffer::new(test.get_plain());
-            let mut buff_out = RefWriteBuffer::new(&mut cipher_out);
-            match enc.encrypt(&mut buff_in, &mut buff_out, true) {
-                Ok(BufferUnderflow) => {}
-                Ok(BufferOverflow) => panic!("Encryption not completed"),
-                Err(_) => panic!("Error"),
-            }
-        }
-        assert!(test.get_cipher() == &cipher_out[..]);
-
-        let mut plain_out: Vec<u8> = repeat(0).take(test.get_plain().len()).collect();
-        {
-            let mut buff_in = RefReadBuffer::new(test.get_cipher());
-            let mut buff_out = RefWriteBuffer::new(&mut plain_out);
-            match dec.decrypt(&mut buff_in, &mut buff_out, true) {
-                Ok(BufferUnderflow) => {}
-                Ok(BufferOverflow) => panic!("Decryption not completed"),
-                Err(_) => panic!("Error"),
-            }
-        }
-        assert!(test.get_plain() == &plain_out[..]);
-    }
-
-    /// Run and encryption or decryption operation, passing in variable sized input and output
-    /// buffers.
-    ///
-    /// # Arguments
-    /// * input - The complete input vector
-    /// * output - The complete output vector
-    /// * op - A closure that runs either an encryption or decryption operation
-    /// * next_in_len - A closure that returns the length to use for the next input buffer; If the
-    ///                 returned value is not in a valid range, it will be fixed up by this
-    ///                 function.
-    /// * next_out_len - A closure that returns the length to use for the next output buffer; If the
-    ///                  returned value is not in a valid range, it will be fixed up by this
-    ///                  function.
-    /// * immediate_eof - Whether eof should be set immediately upon running out of input or if eof
-    ///                   should be passed only after all input has been consumed.
-    fn run_inc<OpFunc, NextInFunc, NextOutFunc>(
-            input: &[u8],
-            output: &mut [u8],
-            mut op: OpFunc,
-            mut next_in_len: NextInFunc,
-            mut next_out_len: NextOutFunc,
-            immediate_eof: bool)
-            where
-                OpFunc: FnMut(&mut RefReadBuffer, &mut RefWriteBuffer, bool) ->
-                    Result<BufferResult, SymmetricCipherError>,
-                NextInFunc: FnMut() -> usize,
-                NextOutFunc: FnMut() -> usize {
-        use std::cell::Cell;
-
-        let in_len = input.len();
-        let out_len = output.len();
-
-        let mut state: Result<BufferResult, SymmetricCipherError> = Ok(BufferUnderflow);
-        let mut in_pos: usize = 0;
-        let mut out_pos: usize = 0;
-        let eof = Cell::new(false);
-
-        let mut in_end = |in_pos: usize, primary: bool| {
-            if eof.get() {
-                return in_len;
-            }
-            let x = next_in_len();
-            if x >= in_len && immediate_eof {
-                eof.set(true);
-            }
-            cmp::min(in_len, in_pos + cmp::max(x, if primary { 1 } else { 0 }))
-        };
-
-        let mut out_end = |out_pos: usize| {
-            let x = next_out_len();
-            cmp::min(out_len, out_pos + cmp::max(x, 1))
-        };
-
-        loop {
-            match state {
-                Ok(BufferUnderflow) => {
-                    if in_pos == input.len() {
-                        break;
-                    }
-                    let mut tmp_in = RefReadBuffer::new(&input[in_pos..in_end(in_pos, true)]);
-                    let out_end = out_end(out_pos);
-                    let mut tmp_out = RefWriteBuffer::new(&mut output[out_pos..out_end]);
-                    state = op(&mut tmp_in, &mut tmp_out, eof.get());
-                    match state {
-                        Ok(BufferUnderflow) => assert!(tmp_in.is_empty()),
-                        _ => {}
-                    }
-                    in_pos += tmp_in.position();
-                    out_pos += tmp_out.position();
-                }
-                Ok(BufferOverflow) => {
-                    let mut tmp_in = RefReadBuffer::new(&input[in_pos..in_end(in_pos, false)]);
-                    let out_end = out_end(out_pos);
-                    let mut tmp_out = RefWriteBuffer::new(&mut output[out_pos..out_end]);
-                    state = op(&mut tmp_in, &mut tmp_out, eof.get());
-                    match state {
-                        Ok(BufferOverflow) => assert!(tmp_out.is_full()),
-                        _ => {}
-                    }
-                    in_pos += tmp_in.position();
-                    out_pos += tmp_out.position();
-                }
-                Err(InvalidPadding) => panic!("Invalid Padding"),
-                Err(InvalidLength) => panic!("Invalid Length")
-            }
-        }
-
-        if !eof.get() {
-            eof.set(true);
-            let mut tmp_out = RefWriteBuffer::new(&mut output[out_pos..out_end(out_pos)]);
-            state = op(&mut RefReadBuffer::new(&[]), &mut tmp_out, eof.get());
-            out_pos += tmp_out.position();
-        }
-
-        loop {
-            match state {
-                Ok(BufferUnderflow) => {
-                    break;
-                }
-                Ok(BufferOverflow) => {
-                    let out_end = out_end(out_pos);
-                    let mut tmp_out = RefWriteBuffer::new(&mut output[out_pos..out_end]);
-                    state = op(&mut RefReadBuffer::new(&[]), &mut tmp_out, eof.get());
-                    assert!(tmp_out.is_full());
-                    out_pos += tmp_out.position();
-                }
-                Err(InvalidPadding) => panic!("Invalid Padding"),
-                Err(InvalidLength) => panic!("Invalid Length")
-            }
-        }
-    }
-
-    fn run_inc1_test<T: CipherTest, E: Encryptor, D: Decryptor>(
-            test: &T,
-            enc: &mut E,
-            dec: &mut D) {
-        let mut cipher_out: Vec<u8> = repeat(0).take(test.get_cipher().len()).collect();
-        run_inc(
-            test.get_plain(),
-            &mut cipher_out,
-            |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
-                enc.encrypt(in_buff, out_buff, eof)
-            },
-            || { 0 },
-            || { 1 },
-            false);
-        assert!(test.get_cipher() == &cipher_out[..]);
-
-        let mut plain_out: Vec<u8> = repeat(0).take(test.get_plain().len()).collect();
-        run_inc(
-            test.get_cipher(),
-            &mut plain_out,
-            |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
-                dec.decrypt(in_buff, out_buff, eof)
-            },
-            || { 0 },
-            || { 1 },
-            false);
-        assert!(test.get_plain() == &plain_out[..]);
-    }
-
-    fn run_rand_test<T, E, D, NewEncFunc, NewDecFunc>(
-            test: &T,
-            mut new_enc: NewEncFunc,
-            mut new_dec: NewDecFunc)
-            where
-                T: CipherTest,
-                E: Encryptor,
-                D: Decryptor,
-                NewEncFunc: FnMut() -> E,
-                NewDecFunc: FnMut() -> D{
-        use rand;
-        use rand::Rng;
-
-        let tmp : &[_] = &[1, 2, 3, 4];
-        let mut rng1: rand::StdRng = rand::SeedableRng::from_seed(tmp);
-        let mut rng2: rand::StdRng = rand::SeedableRng::from_seed(tmp);
-        let mut rng3: rand::StdRng = rand::SeedableRng::from_seed(tmp);
-        let max_size = cmp::max(test.get_plain().len(), test.get_cipher().len());
-
-        let mut r1 = || {
-            rng1.gen_range(0, max_size)
-        };
-        let mut r2 = || {
-            rng2.gen_range(0, max_size)
-        };
-
-        for _ in 0..1000 {
-            let mut enc = new_enc();
-            let mut dec = new_dec();
-
-            let mut cipher_out: Vec<u8> = repeat(0).take(test.get_cipher().len()).collect();
-            run_inc(
-                test.get_plain(),
-                &mut cipher_out,
-                |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
-                    enc.encrypt(in_buff, out_buff, eof)
-                },
-                || { r1() },
-                || { r2() },
-                rng3.gen());
-            assert!(test.get_cipher() == &cipher_out[..]);
-
-            let mut plain_out: Vec<u8> = repeat(0).take(test.get_plain().len()).collect();
-            run_inc(
-                test.get_cipher(),
-                &mut plain_out,
-                |in_buff: &mut RefReadBuffer, out_buff: &mut RefWriteBuffer, eof: bool| {
-                    dec.decrypt(in_buff, out_buff, eof)
-                },
-                || { r1() },
-                || { r2() },
-                rng3.gen());
-            assert!(test.get_plain() == &plain_out[..]);
-        }
-    }
-
-    fn run_test<T, E, D, NewEncFunc, NewDecFunc>(
-            test: &T,
-            mut new_enc: NewEncFunc,
-            mut new_dec: NewDecFunc)
-            where
-                T: CipherTest,
-                E: Encryptor,
-                D: Decryptor,
-                NewEncFunc: FnMut() -> E,
-                NewDecFunc: FnMut() -> D{
-        run_full_test(test, &mut new_enc(), &mut new_dec());
-        run_inc1_test(test, &mut new_enc(), &mut new_dec());
-        run_rand_test(test, new_enc, new_dec);
-    }
-
-    #[test]
-    fn aes_ecb_no_padding() {
-        let tests = aes_ecb_no_padding_tests();
-        for test in tests.iter() {
-            run_test(
-                test,
-                || {
-                    let aes_enc = aessafe::AesSafe128Encryptor::new(&test.key[..]);
-                    EcbEncryptor::new(aes_enc, NoPadding)
-                },
-                || {
-                    let aes_dec = aessafe::AesSafe128Decryptor::new(&test.key[..]);
-                    EcbDecryptor::new(aes_dec, NoPadding)
-                });
-        }
-    }
-
-    #[test]
-    fn aes_ecb_pkcs_padding() {
-        let tests = aes_ecb_pkcs_padding_tests();
-        for test in tests.iter() {
-            run_test(
-                test,
-                || {
-                    let aes_enc = aessafe::AesSafe128Encryptor::new(&test.key[..]);
-                    EcbEncryptor::new(aes_enc, PkcsPadding)
-                },
-                || {
-                    let aes_dec = aessafe::AesSafe128Decryptor::new(&test.key[..]);
-                    EcbDecryptor::new(aes_dec, PkcsPadding)
-                });
-        }
-    }
-
-    #[test]
-    fn aes_cbc_no_padding() {
-        let tests = aes_cbc_no_padding_tests();
-        for test in tests.iter() {
-            run_test(
-                test,
-                || {
-                    let aes_enc = aessafe::AesSafe128Encryptor::new(&test.key[..]);
-                    CbcEncryptor::new(aes_enc, NoPadding, test.iv.clone())
-                },
-                || {
-                    let aes_dec = aessafe::AesSafe128Decryptor::new(&test.key[..]);
-                    CbcDecryptor::new(aes_dec, NoPadding, test.iv.clone())
-                });
-        }
-    }
-
-    #[test]
-    fn aes_cbc_pkcs_padding() {
-        let tests = aes_cbc_pkcs_padding_tests();
-        for test in tests.iter() {
-            run_test(
-                test,
-                || {
-                    let aes_enc = aessafe::AesSafe128Encryptor::new(&test.key[..]);
-                    CbcEncryptor::new(aes_enc, PkcsPadding, test.iv.clone())
-                },
-                || {
-                    let aes_dec = aessafe::AesSafe128Decryptor::new(&test.key[..]);
-                    CbcDecryptor::new(aes_dec, PkcsPadding, test.iv.clone())
-                });
-        }
-    }
-
-    #[test]
-    fn aes_ctr() {
-        let tests = aes_ctr_tests();
-        for test in tests.iter() {
-            run_test(
-                test,
-                || {
-                    let aes_enc = aessafe::AesSafe128Encryptor::new(&test.key[..]);
-                    CtrMode::new(aes_enc, test.ctr.clone())
-                },
-                || {
-                    let aes_enc = aessafe::AesSafe128Encryptor::new(&test.key[..]);
-                    CtrMode::new(aes_enc, test.ctr.clone())
-                });
-        }
-    }
-
-    #[test]
-    fn aes_ctr_x8() {
-        let tests = aes_ctr_tests();
-        for test in tests.iter() {
-            run_test(
-                test,
-                || {
-                    let aes_enc = aessafe::AesSafe128EncryptorX8::new(&test.key[..]);
-                    CtrModeX8::new(aes_enc, &test.ctr[..])
-                },
-                || {
-                    let aes_enc = aessafe::AesSafe128EncryptorX8::new(&test.key[..]);
-                    CtrModeX8::new(aes_enc, &test.ctr[..])
-                });
-        }
-    }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use aessafe;
-    use blockmodes::{EcbEncryptor, CbcEncryptor, CtrMode, CtrModeX8,
-        NoPadding, PkcsPadding};
-    use buffer::{ReadBuffer, WriteBuffer, RefReadBuffer, RefWriteBuffer};
-    use buffer::BufferResult::{BufferUnderflow, BufferOverflow};
-    use symmetriccipher::{Encryptor};
-
-    use test::Bencher;
-
-    #[bench]
-    pub fn aes_ecb_no_padding_bench(bh: &mut Bencher) {
-        let key = [1u8; 16];
-        let plain = [3u8; 512];
-        let mut cipher = [3u8; 528];
-
-        let aes_enc = aessafe::AesSafe128Encryptor::new(&key);
-        let mut enc = EcbEncryptor::new(aes_enc, NoPadding);
-
-        bh.iter( || {
-            enc.reset();
-
-            let mut buff_in = RefReadBuffer::new(&plain);
-            let mut buff_out = RefWriteBuffer::new(&mut cipher);
-
-            match enc.encrypt(&mut buff_in, &mut buff_out, true) {
-                Ok(BufferUnderflow) => {}
-                Ok(BufferOverflow) => panic!("Encryption not completed"),
-                Err(_) => panic!("Error"),
-            }
-        });
-
-        bh.bytes = (plain.len()) as u64;
-    }
-
-    #[bench]
-    pub fn aes_cbc_pkcs_padding_bench(bh: &mut Bencher) {
-        let key = [1u8; 16];
-        let iv = [2u8; 16];
-        let plain = [3u8; 512];
-        let mut cipher = [3u8; 528];
-
-        let aes_enc = aessafe::AesSafe128Encryptor::new(&key);
-        let mut enc = CbcEncryptor::new(aes_enc, PkcsPadding, iv.to_vec());
-
-        bh.iter( || {
-            enc.reset(&iv);
-
-            let mut buff_in = RefReadBuffer::new(&plain);
-            let mut buff_out = RefWriteBuffer::new(&mut cipher);
-
-            match enc.encrypt(&mut buff_in, &mut buff_out, true) {
-                Ok(BufferUnderflow) => {}
-                Ok(BufferOverflow) => panic!("Encryption not completed"),
-                Err(_) => panic!("Error"),
-            }
-        });
-
-        bh.bytes = (plain.len()) as u64;
-    }
-
-    #[bench]
-    pub fn aes_ctr_bench(bh: &mut Bencher) {
-        let key = [1u8; 16];
-        let ctr = [2u8; 16];
-        let plain = [3u8; 512];
-        let mut cipher = [3u8; 528];
-
-        let aes_enc = aessafe::AesSafe128Encryptor::new(&key);
-        let mut enc = CtrMode::new(aes_enc, ctr.to_vec());
-
-        bh.iter( || {
-            enc.reset(&ctr);
-
-            let mut buff_in = RefReadBuffer::new(&plain);
-            let mut buff_out = RefWriteBuffer::new(&mut cipher);
-
-            match enc.encrypt(&mut buff_in, &mut buff_out, true) {
-                Ok(BufferUnderflow) => {}
-                Ok(BufferOverflow) => panic!("Encryption not completed"),
-                Err(_) => panic!("Error"),
-            }
-        });
-
-        bh.bytes = (plain.len()) as u64;
-    }
-
-    #[bench]
-    pub fn aes_ctr_x8_bench(bh: &mut Bencher) {
-        let key = [1u8; 16];
-        let ctr = [2u8; 16];
-        let plain = [3u8; 512];
-        let mut cipher = [3u8; 528];
-
-        let aes_enc = aessafe::AesSafe128EncryptorX8::new(&key);
-        let mut enc = CtrModeX8::new(aes_enc, &ctr);
-
-        bh.iter( || {
-            enc.reset(&ctr);
-
-            let mut buff_in = RefReadBuffer::new(&plain);
-            let mut buff_out = RefWriteBuffer::new(&mut cipher);
-
-            match enc.encrypt(&mut buff_in, &mut buff_out, true) {
-                Ok(BufferUnderflow) => {}
-                Ok(BufferOverflow) => panic!("Encryption not completed"),
-                Err(_) => panic!("Error"),
-            }
-        });
-
-        bh.bytes = (plain.len()) as u64;
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/blowfish.rs b/rustc_deps/vendor/rust-crypto/src/blowfish.rs
deleted file mode 100644
index a429bbf..0000000
--- a/rustc_deps/vendor/rust-crypto/src/blowfish.rs
+++ /dev/null
@@ -1,567 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use cryptoutil::{read_u32v_be, write_u32_be};
-use symmetriccipher::{BlockEncryptor, BlockDecryptor};
-use step_by::RangeExt;
-
-#[derive(Clone,Copy)]
-pub struct Blowfish {
-    s: [[u32; 256]; 4],
-    p: [u32; 18]
-}
-
-fn next_u32_wrap(buf: &[u8], offset: &mut usize) -> u32 {
-    let mut v = 0;
-    for _ in 0..4 {
-        if *offset >= buf.len() {
-            *offset = 0;
-        }
-        v = (v << 8) | buf[*offset] as u32;
-        *offset += 1;
-    }
-    v
-}
-
-impl Blowfish {
-    pub fn new(key: &[u8]) -> Blowfish {
-        assert!(4 <= key.len() && key.len() <= 56);
-        let mut blowfish = Blowfish::init_state();
-        blowfish.expand_key(key);
-        blowfish
-    }
-
-    // For bcrypt. Use Blowfish::new instead.
-    pub fn init_state() -> Blowfish {
-        Blowfish {
-            p: [0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
-                0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
-                0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b],
-            s: [[0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96,
-                 0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
-                 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 0x0d95748f, 0x728eb658,
-                 0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
-                 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e,
-                 0x6c9e0e8b, 0xb01e8a3e, 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
-                 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 0x55ca396a, 0x2aab10b6,
-                 0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
-                 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c,
-                 0x7a325381, 0x28958677, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
-                 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0xef845d5d, 0xe98575b1,
-                 0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
-                 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a,
-                 0x670c9c61, 0xabd388f0, 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
-                 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 0xa1f1651d, 0x39af0176,
-                 0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
-                 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706,
-                 0x1bfedf72, 0x429b023d, 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
-                 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 0xe3fe501a, 0xb6794c3b,
-                 0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
-                 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c,
-                 0xcc814544, 0xaf5ebd09, 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
-                 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 0x5579c0bd, 0x1a60320a,
-                 0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
-                 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760,
-                 0x53317b48, 0x3e00df82, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
-                 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 0x695b27b0, 0xbbca58c8,
-                 0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
-                 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33,
-                 0x62fb1341, 0xcee4c6e8, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
-                 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0xd08ed1d0, 0xafc725e0,
-                 0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
-                 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777,
-                 0xea752dfe, 0x8b021fa1, 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
-                 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0x165fa266, 0x80957705,
-                 0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
-                 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e,
-                 0x226800bb, 0x57b8e0af, 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
-                 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 0x83260376, 0x6295cfa9,
-                 0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
-                 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f,
-                 0xf296ec6b, 0x2a0dd915, 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
-                 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a],
-                [0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d,
-                 0x9cee60b8, 0x8fedb266, 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
-                 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 0x3f54989a, 0x5b429d65,
-                 0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
-                 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9,
-                 0x3c971814, 0x6b6a70a1, 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
-                 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0xb03ada37, 0xf0500c0d,
-                 0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
-                 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc,
-                 0xc8b57634, 0x9af3dda7, 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
-                 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 0x4e548b38, 0x4f6db908,
-                 0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
-                 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124,
-                 0x501adde6, 0x9f84cd87, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
-                 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847, 0x3215d908,
-                 0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
-                 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b,
-                 0x3c11183b, 0x5924a509, 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
-                 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c, 0x4e3d06fa,
-                 0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
-                 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d,
-                 0x1939260f, 0x19c27960, 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
-                 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 0xc332ddef, 0xbe6c5aa5,
-                 0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
-                 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96,
-                 0x0334fe1e, 0xaa0363cf, 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
-                 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0x648b1eaf, 0x19bdf0ca,
-                 0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
-                 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77,
-                 0x11ed935f, 0x16681281, 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
-                 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 0xcdb30aeb, 0x532e3054,
-                 0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
-                 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea,
-                 0xdb6c4f15, 0xfacb4fd0, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
-                 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2, 0x5b8d2646,
-                 0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
-                 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea,
-                 0x1dadf43e, 0x233f7061, 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
-                 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084, 0x19f8509e,
-                 0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
-                 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd,
-                 0x675fda79, 0xe3674340, 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
-                 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7],
-                [0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7,
-                 0xbcf46b2e, 0xd4a20068, 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
-                 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 0x4d95fc1d, 0x96b591af,
-                 0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
-                 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4,
-                 0x0a2c86da, 0xe9b66dfb, 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
-                 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 0xaace1e7c, 0xd3375fec,
-                 0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
-                 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332,
-                 0x6841e7f7, 0xca7820fb, 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
-                 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 0x55a867bc, 0xa1159a58,
-                 0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
-                 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22,
-                 0x48c1133f, 0xc70f86dc, 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
-                 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x257b7834, 0x602a9c60,
-                 0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
-                 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99,
-                 0xde720c8c, 0x2da2f728, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
-                 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x0a476341, 0x992eff74,
-                 0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
-                 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3,
-                 0xb5390f92, 0x690fed0b, 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
-                 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979,
-                 0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
-                 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa,
-                 0x3d25bdd8, 0xe2e1c3c9, 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
-                 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086,
-                 0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
-                 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24,
-                 0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
-                 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84,
-                 0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
-                 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09,
-                 0x662d09a1, 0xc4324633, 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
-                 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 0xdcb7da83, 0x573906fe,
-                 0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
-                 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0,
-                 0x006058aa, 0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
-                 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0x6f05e409, 0x4b7c0188,
-                 0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
-                 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8,
-                 0xa28514d9, 0x6c51133c, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
-                 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0],
-                [0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742,
-                 0xd3822740, 0x99bc9bbe, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
-                 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0x5748ab2f, 0xbc946e79,
-                 0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
-                 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a,
-                 0x63ef8ce2, 0x9a86ee22, 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
-                 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x2826a2f9, 0xa73a3ae1,
-                 0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
-                 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797,
-                 0x2cf0b7d9, 0x022b8b51, 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
-                 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 0xe029ac71, 0xe019a5e6,
-                 0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
-                 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba,
-                 0x03a16125, 0x0564f0bd, 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
-                 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x7533d928, 0xb155fdf5,
-                 0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
-                 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce,
-                 0x5121ce64, 0x774fbe32, 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
-                 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 0xb39a460a, 0x6445c0dd,
-                 0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
-                 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb,
-                 0x8d6612ae, 0xbf3c6f47, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
-                 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08, 0x4eb4e2cc,
-                 0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
-                 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc,
-                 0xbb3a792b, 0x344525bd, 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
-                 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749, 0xd44fbd9a,
-                 0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
-                 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a,
-                 0x0f91fc71, 0x9b941525, 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
-                 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 0xe0ec6e0e, 0x1698db3b,
-                 0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
-                 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e,
-                 0xe60b6f47, 0x0fe3f11d, 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
-                 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0xf523f357, 0xa6327623,
-                 0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
-                 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a,
-                 0x45e1d006, 0xc3f27b9a, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
-                 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x53113ec0, 0x1640e3d3,
-                 0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
-                 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c,
-                 0x01c36ae4, 0xd6ebe1f9, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
-                 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6]]
-        }
-    }
-
-    // For bcrypt. Use Blowfish::new instead.
-    pub fn expand_key(&mut self, key: &[u8]) {
-        let mut key_pos = 0;
-        for i in 0..18 {
-            self.p[i] ^= next_u32_wrap(key, &mut key_pos);
-        }
-        let mut l = 0u32;
-        let mut r = 0u32;
-        for i in (0..18).step_up(2) {
-            let (new_l, new_r) = self.encrypt(l, r);
-            l = new_l;
-            r = new_r;
-            self.p[i] = l;
-            self.p[i+1] = r;
-        }
-        for i in 0..4 {
-            for j in (0..256).step_up(2) {
-                let (new_l, new_r) = self.encrypt(l, r);
-                l = new_l;
-                r = new_r;
-                self.s[i][j] = l;
-                self.s[i][j+1] = r;
-            }
-        }
-    }
-
-    // Bcrypt key schedule.
-    pub fn salted_expand_key(&mut self, salt: &[u8], key: &[u8]) {
-        let mut key_pos = 0;
-        for i in 0..18 {
-            self.p[i] ^= next_u32_wrap(key, &mut key_pos);
-        }
-        let mut l = 0u32;
-        let mut r = 0u32;
-        let mut salt_pos = 0;
-        for i in (0..18).step_up(2) {
-            let (new_l, new_r) = self.encrypt(l ^ next_u32_wrap(salt, &mut salt_pos), r ^ next_u32_wrap(salt, &mut salt_pos));
-            l = new_l;
-            r = new_r;
-            self.p[i] = l;
-            self.p[i+1] = r;
-        }
-        for i in 0..4 {
-            for j in (0..256).step_up(4) {
-                let (new_l, new_r) = self.encrypt(l ^ next_u32_wrap(salt, &mut salt_pos), r ^ next_u32_wrap(salt, &mut salt_pos));
-                l = new_l;
-                r = new_r;
-                self.s[i][j] = l;
-                self.s[i][j+1] = r;
-
-                let (new_l, new_r) = self.encrypt(l ^ next_u32_wrap(salt, &mut salt_pos), r ^ next_u32_wrap(salt, &mut salt_pos));
-                l = new_l;
-                r = new_r;
-                self.s[i][j+2] = l;
-                self.s[i][j+3] = r;
-            }
-        }
-    }
-
-    fn round_function(&self, x: u32) -> u32 {
-        ((self.s[0][(x >> 24) as usize].wrapping_add(self.s[1][((x >> 16) & 0xff) as usize])) ^ self.s[2][((x >> 8) & 0xff) as usize]).wrapping_add(self.s[3][(x & 0xff) as usize])
-    }
-
-    // Public for bcrypt.
-    pub fn encrypt(&self, mut l: u32, mut r: u32) -> (u32, u32) {
-        for i in (0..16).step_up(2) {
-            l ^= self.p[i];
-            r ^= self.round_function(l);
-            r ^= self.p[i+1];
-            l ^= self.round_function(r);
-        }
-        l ^= self.p[16];
-        r ^= self.p[17];
-        (r, l)
-    }
-
-    fn decrypt(&self, mut l: u32, mut r: u32) -> (u32, u32) {
-        let mut i = 16;
-        while i > 0 {
-            l ^= self.p[i+1];
-            r ^= self.round_function(l);
-            r ^= self.p[i];
-            l ^= self.round_function(r);
-            i -= 2;
-        }
-        l ^= self.p[1];
-        r ^= self.p[0];
-        (r, l)
-    }
-}
-
-impl BlockEncryptor for Blowfish {
-    fn block_size(&self) -> usize {
-        8
-    }
-
-    fn encrypt_block(&self, input: &[u8], output: &mut [u8]) {
-        assert!(input.len() == 8);
-        assert!(output.len() == 8);
-        let mut block = [0u32, 0u32];
-        read_u32v_be(&mut block, input);
-        let (l, r) = self.encrypt(block[0], block[1]);
-        write_u32_be(&mut output[0..4], l);
-        write_u32_be(&mut output[4..8], r);
-    }
-}
-
-impl BlockDecryptor for Blowfish {
-    fn block_size(&self) -> usize {
-        8
-    }
-
-    fn decrypt_block(&self, input: &[u8], output: &mut [u8]) {
-        assert!(input.len() == 8);
-        assert!(output.len() == 8);
-        let mut block = [0u32, 0u32];
-        read_u32v_be(&mut block, input);
-        let (l, r) = self.decrypt(block[0], block[1]);
-        write_u32_be(&mut output[0..4], l);
-        write_u32_be(&mut output[4..8], r);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use blowfish::Blowfish;
-    use symmetriccipher::{BlockEncryptor, BlockDecryptor};
-    struct Test {
-        key: Vec<u8>,
-        plaintext: Vec<u8>,
-        ciphertext: Vec<u8>
-    }
-
-    fn eay_test_vectors() -> Vec<Test> {
-        vec![
-            Test {
-                    key: vec![0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8],
-                    plaintext: vec![0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8],
-                    ciphertext: vec![0x4Eu8, 0xF9u8, 0x97u8, 0x45u8, 0x61u8, 0x98u8, 0xDDu8, 0x78u8]
-            },
-            Test {
-                    key: vec![0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8],
-                    plaintext: vec![0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8],
-                    ciphertext: vec![0x51u8, 0x86u8, 0x6Fu8, 0xD5u8, 0xB8u8, 0x5Eu8, 0xCBu8, 0x8Au8]
-            },
-            Test {
-                    key: vec![0x30u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8],
-                    plaintext: vec![0x10u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x01u8],
-                    ciphertext: vec![0x7Du8, 0x85u8, 0x6Fu8, 0x9Au8, 0x61u8, 0x30u8, 0x63u8, 0xF2u8]
-            },
-            Test {
-                    key: vec![0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8],
-                    plaintext: vec![0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8],
-                    ciphertext: vec![0x24u8, 0x66u8, 0xDDu8, 0x87u8, 0x8Bu8, 0x96u8, 0x3Cu8, 0x9Du8]
-            },
-            Test {
-                    key: vec![0x01u8, 0x23u8, 0x45u8, 0x67u8, 0x89u8, 0xABu8, 0xCDu8, 0xEFu8],
-                    plaintext: vec![0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8],
-                    ciphertext: vec![0x61u8, 0xF9u8, 0xC3u8, 0x80u8, 0x22u8, 0x81u8, 0xB0u8, 0x96u8]
-            },
-            Test {
-                    key: vec![0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8, 0x11u8],
-                    plaintext: vec![0x01u8, 0x23u8, 0x45u8, 0x67u8, 0x89u8, 0xABu8, 0xCDu8, 0xEFu8],
-                    ciphertext: vec![0x7Du8, 0x0Cu8, 0xC6u8, 0x30u8, 0xAFu8, 0xDAu8, 0x1Eu8, 0xC7u8]
-            },
-            Test {
-                    key: vec![0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8],
-                    plaintext: vec![0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8],
-                    ciphertext: vec![0x4Eu8, 0xF9u8, 0x97u8, 0x45u8, 0x61u8, 0x98u8, 0xDDu8, 0x78u8]
-            },
-            Test {
-                    key: vec![0xFEu8, 0xDCu8, 0xBAu8, 0x98u8, 0x76u8, 0x54u8, 0x32u8, 0x10u8],
-                    plaintext: vec![0x01u8, 0x23u8, 0x45u8, 0x67u8, 0x89u8, 0xABu8, 0xCDu8, 0xEFu8],
-                    ciphertext: vec![0x0Au8, 0xCEu8, 0xABu8, 0x0Fu8, 0xC6u8, 0xA0u8, 0xA2u8, 0x8Du8]
-            },
-            Test {
-                    key: vec![0x7Cu8, 0xA1u8, 0x10u8, 0x45u8, 0x4Au8, 0x1Au8, 0x6Eu8, 0x57u8],
-                    plaintext: vec![0x01u8, 0xA1u8, 0xD6u8, 0xD0u8, 0x39u8, 0x77u8, 0x67u8, 0x42u8],
-                    ciphertext: vec![0x59u8, 0xC6u8, 0x82u8, 0x45u8, 0xEBu8, 0x05u8, 0x28u8, 0x2Bu8]
-            },
-            Test {
-                    key: vec![0x01u8, 0x31u8, 0xD9u8, 0x61u8, 0x9Du8, 0xC1u8, 0x37u8, 0x6Eu8],
-                    plaintext: vec![0x5Cu8, 0xD5u8, 0x4Cu8, 0xA8u8, 0x3Du8, 0xEFu8, 0x57u8, 0xDAu8],
-                    ciphertext: vec![0xB1u8, 0xB8u8, 0xCCu8, 0x0Bu8, 0x25u8, 0x0Fu8, 0x09u8, 0xA0u8]
-            },
-            Test {
-                    key: vec![0x07u8, 0xA1u8, 0x13u8, 0x3Eu8, 0x4Au8, 0x0Bu8, 0x26u8, 0x86u8],
-                    plaintext: vec![0x02u8, 0x48u8, 0xD4u8, 0x38u8, 0x06u8, 0xF6u8, 0x71u8, 0x72u8],
-                    ciphertext: vec![0x17u8, 0x30u8, 0xE5u8, 0x77u8, 0x8Bu8, 0xEAu8, 0x1Du8, 0xA4u8]
-            },
-            Test {
-                    key: vec![0x38u8, 0x49u8, 0x67u8, 0x4Cu8, 0x26u8, 0x02u8, 0x31u8, 0x9Eu8],
-                    plaintext: vec![0x51u8, 0x45u8, 0x4Bu8, 0x58u8, 0x2Du8, 0xDFu8, 0x44u8, 0x0Au8],
-                    ciphertext: vec![0xA2u8, 0x5Eu8, 0x78u8, 0x56u8, 0xCFu8, 0x26u8, 0x51u8, 0xEBu8]
-            },
-            Test {
-                    key: vec![0x04u8, 0xB9u8, 0x15u8, 0xBAu8, 0x43u8, 0xFEu8, 0xB5u8, 0xB6u8],
-                    plaintext: vec![0x42u8, 0xFDu8, 0x44u8, 0x30u8, 0x59u8, 0x57u8, 0x7Fu8, 0xA2u8],
-                    ciphertext: vec![0x35u8, 0x38u8, 0x82u8, 0xB1u8, 0x09u8, 0xCEu8, 0x8Fu8, 0x1Au8]
-            },
-            Test {
-                    key: vec![0x01u8, 0x13u8, 0xB9u8, 0x70u8, 0xFDu8, 0x34u8, 0xF2u8, 0xCEu8],
-                    plaintext: vec![0x05u8, 0x9Bu8, 0x5Eu8, 0x08u8, 0x51u8, 0xCFu8, 0x14u8, 0x3Au8],
-                    ciphertext: vec![0x48u8, 0xF4u8, 0xD0u8, 0x88u8, 0x4Cu8, 0x37u8, 0x99u8, 0x18u8]
-            },
-            Test {
-                    key: vec![0x01u8, 0x70u8, 0xF1u8, 0x75u8, 0x46u8, 0x8Fu8, 0xB5u8, 0xE6u8],
-                    plaintext: vec![0x07u8, 0x56u8, 0xD8u8, 0xE0u8, 0x77u8, 0x47u8, 0x61u8, 0xD2u8],
-                    ciphertext: vec![0x43u8, 0x21u8, 0x93u8, 0xB7u8, 0x89u8, 0x51u8, 0xFCu8, 0x98u8]
-            },
-            Test {
-                    key: vec![0x43u8, 0x29u8, 0x7Fu8, 0xADu8, 0x38u8, 0xE3u8, 0x73u8, 0xFEu8],
-                    plaintext: vec![0x76u8, 0x25u8, 0x14u8, 0xB8u8, 0x29u8, 0xBFu8, 0x48u8, 0x6Au8],
-                    ciphertext: vec![0x13u8, 0xF0u8, 0x41u8, 0x54u8, 0xD6u8, 0x9Du8, 0x1Au8, 0xE5u8]
-            },
-            Test {
-                    key: vec![0x07u8, 0xA7u8, 0x13u8, 0x70u8, 0x45u8, 0xDAu8, 0x2Au8, 0x16u8],
-                    plaintext: vec![0x3Bu8, 0xDDu8, 0x11u8, 0x90u8, 0x49u8, 0x37u8, 0x28u8, 0x02u8],
-                    ciphertext: vec![0x2Eu8, 0xEDu8, 0xDAu8, 0x93u8, 0xFFu8, 0xD3u8, 0x9Cu8, 0x79u8]
-            },
-            Test {
-                    key: vec![0x04u8, 0x68u8, 0x91u8, 0x04u8, 0xC2u8, 0xFDu8, 0x3Bu8, 0x2Fu8],
-                    plaintext: vec![0x26u8, 0x95u8, 0x5Fu8, 0x68u8, 0x35u8, 0xAFu8, 0x60u8, 0x9Au8],
-                    ciphertext: vec![0xD8u8, 0x87u8, 0xE0u8, 0x39u8, 0x3Cu8, 0x2Du8, 0xA6u8, 0xE3u8]
-            },
-            Test {
-                    key: vec![0x37u8, 0xD0u8, 0x6Bu8, 0xB5u8, 0x16u8, 0xCBu8, 0x75u8, 0x46u8],
-                    plaintext: vec![0x16u8, 0x4Du8, 0x5Eu8, 0x40u8, 0x4Fu8, 0x27u8, 0x52u8, 0x32u8],
-                    ciphertext: vec![0x5Fu8, 0x99u8, 0xD0u8, 0x4Fu8, 0x5Bu8, 0x16u8, 0x39u8, 0x69u8]
-            },
-            Test {
-                    key: vec![0x1Fu8, 0x08u8, 0x26u8, 0x0Du8, 0x1Au8, 0xC2u8, 0x46u8, 0x5Eu8],
-                    plaintext: vec![0x6Bu8, 0x05u8, 0x6Eu8, 0x18u8, 0x75u8, 0x9Fu8, 0x5Cu8, 0xCAu8],
-                    ciphertext: vec![0x4Au8, 0x05u8, 0x7Au8, 0x3Bu8, 0x24u8, 0xD3u8, 0x97u8, 0x7Bu8]
-            },
-            Test {
-                    key: vec![0x58u8, 0x40u8, 0x23u8, 0x64u8, 0x1Au8, 0xBAu8, 0x61u8, 0x76u8],
-                    plaintext: vec![0x00u8, 0x4Bu8, 0xD6u8, 0xEFu8, 0x09u8, 0x17u8, 0x60u8, 0x62u8],
-                    ciphertext: vec![0x45u8, 0x20u8, 0x31u8, 0xC1u8, 0xE4u8, 0xFAu8, 0xDAu8, 0x8Eu8]
-            },
-            Test {
-                    key: vec![0x02u8, 0x58u8, 0x16u8, 0x16u8, 0x46u8, 0x29u8, 0xB0u8, 0x07u8],
-                    plaintext: vec![0x48u8, 0x0Du8, 0x39u8, 0x00u8, 0x6Eu8, 0xE7u8, 0x62u8, 0xF2u8],
-                    ciphertext: vec![0x75u8, 0x55u8, 0xAEu8, 0x39u8, 0xF5u8, 0x9Bu8, 0x87u8, 0xBDu8]
-            },
-            Test {
-                    key: vec![0x49u8, 0x79u8, 0x3Eu8, 0xBCu8, 0x79u8, 0xB3u8, 0x25u8, 0x8Fu8],
-                    plaintext: vec![0x43u8, 0x75u8, 0x40u8, 0xC8u8, 0x69u8, 0x8Fu8, 0x3Cu8, 0xFAu8],
-                    ciphertext: vec![0x53u8, 0xC5u8, 0x5Fu8, 0x9Cu8, 0xB4u8, 0x9Fu8, 0xC0u8, 0x19u8]
-            },
-            Test {
-                    key: vec![0x4Fu8, 0xB0u8, 0x5Eu8, 0x15u8, 0x15u8, 0xABu8, 0x73u8, 0xA7u8],
-                    plaintext: vec![0x07u8, 0x2Du8, 0x43u8, 0xA0u8, 0x77u8, 0x07u8, 0x52u8, 0x92u8],
-                    ciphertext: vec![0x7Au8, 0x8Eu8, 0x7Bu8, 0xFAu8, 0x93u8, 0x7Eu8, 0x89u8, 0xA3u8]
-            },
-            Test {
-                    key: vec![0x49u8, 0xE9u8, 0x5Du8, 0x6Du8, 0x4Cu8, 0xA2u8, 0x29u8, 0xBFu8],
-                    plaintext: vec![0x02u8, 0xFEu8, 0x55u8, 0x77u8, 0x81u8, 0x17u8, 0xF1u8, 0x2Au8],
-                    ciphertext: vec![0xCFu8, 0x9Cu8, 0x5Du8, 0x7Au8, 0x49u8, 0x86u8, 0xADu8, 0xB5u8]
-            },
-            Test {
-                    key: vec![0x01u8, 0x83u8, 0x10u8, 0xDCu8, 0x40u8, 0x9Bu8, 0x26u8, 0xD6u8],
-                    plaintext: vec![0x1Du8, 0x9Du8, 0x5Cu8, 0x50u8, 0x18u8, 0xF7u8, 0x28u8, 0xC2u8],
-                    ciphertext: vec![0xD1u8, 0xABu8, 0xB2u8, 0x90u8, 0x65u8, 0x8Bu8, 0xC7u8, 0x78u8]
-            },
-            Test {
-                    key: vec![0x1Cu8, 0x58u8, 0x7Fu8, 0x1Cu8, 0x13u8, 0x92u8, 0x4Fu8, 0xEFu8],
-                    plaintext: vec![0x30u8, 0x55u8, 0x32u8, 0x28u8, 0x6Du8, 0x6Fu8, 0x29u8, 0x5Au8],
-                    ciphertext: vec![0x55u8, 0xCBu8, 0x37u8, 0x74u8, 0xD1u8, 0x3Eu8, 0xF2u8, 0x01u8]
-            },
-            Test {
-                    key: vec![0x01u8, 0x01u8, 0x01u8, 0x01u8, 0x01u8, 0x01u8, 0x01u8, 0x01u8],
-                    plaintext: vec![0x01u8, 0x23u8, 0x45u8, 0x67u8, 0x89u8, 0xABu8, 0xCDu8, 0xEFu8],
-                    ciphertext: vec![0xFAu8, 0x34u8, 0xECu8, 0x48u8, 0x47u8, 0xB2u8, 0x68u8, 0xB2u8]
-            },
-            Test {
-                    key: vec![0x1Fu8, 0x1Fu8, 0x1Fu8, 0x1Fu8, 0x0Eu8, 0x0Eu8, 0x0Eu8, 0x0Eu8],
-                    plaintext: vec![0x01u8, 0x23u8, 0x45u8, 0x67u8, 0x89u8, 0xABu8, 0xCDu8, 0xEFu8],
-                    ciphertext: vec![0xA7u8, 0x90u8, 0x79u8, 0x51u8, 0x08u8, 0xEAu8, 0x3Cu8, 0xAEu8]
-            },
-            Test {
-                    key: vec![0xE0u8, 0xFEu8, 0xE0u8, 0xFEu8, 0xF1u8, 0xFEu8, 0xF1u8, 0xFEu8],
-                    plaintext: vec![0x01u8, 0x23u8, 0x45u8, 0x67u8, 0x89u8, 0xABu8, 0xCDu8, 0xEFu8],
-                    ciphertext: vec![0xC3u8, 0x9Eu8, 0x07u8, 0x2Du8, 0x9Fu8, 0xACu8, 0x63u8, 0x1Du8]
-            },
-            Test {
-                    key: vec![0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8],
-                    plaintext: vec![0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8],
-                    ciphertext: vec![0x01u8, 0x49u8, 0x33u8, 0xE0u8, 0xCDu8, 0xAFu8, 0xF6u8, 0xE4u8]
-            },
-            Test {
-                    key: vec![0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8],
-                    plaintext: vec![0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8],
-                    ciphertext: vec![0xF2u8, 0x1Eu8, 0x9Au8, 0x77u8, 0xB7u8, 0x1Cu8, 0x49u8, 0xBCu8]
-            },
-            Test {
-                    key: vec![0x01u8, 0x23u8, 0x45u8, 0x67u8, 0x89u8, 0xABu8, 0xCDu8, 0xEFu8],
-                    plaintext: vec![0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8, 0x00u8],
-                    ciphertext: vec![0x24u8, 0x59u8, 0x46u8, 0x88u8, 0x57u8, 0x54u8, 0x36u8, 0x9Au8]
-            },
-            Test {
-                    key: vec![0xFEu8, 0xDCu8, 0xBAu8, 0x98u8, 0x76u8, 0x54u8, 0x32u8, 0x10u8],
-                    plaintext: vec![0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8, 0xFFu8],
-                    ciphertext: vec![0x6Bu8, 0x5Cu8, 0x5Au8, 0x9Cu8, 0x5Du8, 0x9Eu8, 0x0Au8, 0x5Au8]
-            }
-        ]
-    }
-
-    #[test]
-    fn encrypt_eay_test_vectors() {
-        let tests = eay_test_vectors();
-        let mut output = [0u8; 8];
-        for test in tests.iter() {
-            let state = Blowfish::new(&test.key[..]);
-            state.encrypt_block(&test.plaintext[..], &mut output[..]);
-            assert!(test.ciphertext[..] == output[..]);
-        }
-    }
-
-    #[test]
-    fn decrypt_eay_test_vectors() {
-        let tests = eay_test_vectors();
-        let mut output = [0u8; 8];
-        for test in tests.iter() {
-            let state = Blowfish::new(&test.key[..]);
-            state.decrypt_block(&test.ciphertext[..], &mut output[..]);
-            assert!(test.plaintext[..] == output[..]);
-        }
-    }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use blowfish::Blowfish;
-    use symmetriccipher::BlockEncryptor;
-    use test::Bencher;
-
-    #[bench]
-    fn blowfish(bh: &mut Bencher) {
-        let key = [0u8; 16];
-        let plaintext = [1u8; 8];
-        let state = Blowfish::new(&key);
-        let mut ciphertext = [0u8; 8];
-
-        bh.iter(|| {
-            state.encrypt_block(&plaintext, &mut ciphertext);
-        });
-        bh.bytes = 8u64;
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/buffer.rs b/rustc_deps/vendor/rust-crypto/src/buffer.rs
deleted file mode 100644
index c9ad3e9..0000000
--- a/rustc_deps/vendor/rust-crypto/src/buffer.rs
+++ /dev/null
@@ -1,288 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::cmp;
-
-use cryptoutil;
-
-#[derive(Clone,Copy)]
-pub enum BufferResult {
-    BufferUnderflow,
-    BufferOverflow
-}
-
-pub trait ReadBuffer {
-    fn is_empty(&self) -> bool;
-    fn is_full(&self) -> bool;
-    fn remaining(&self) -> usize;
-    fn capacity(&self) -> usize;
-    fn position(&self) -> usize { self.capacity() - self.remaining() }
-
-    fn rewind(&mut self, distance: usize);
-    fn truncate(&mut self, amount: usize);
-    fn reset(&mut self);
-
-    fn peek_next(&self, count: usize) -> &[u8];
-    fn peek_remaining(&self) -> &[u8] {
-        self.peek_next(self.remaining())
-    }
-
-    fn take_next(&mut self, count: usize) -> &[u8];
-    fn take_remaining(&mut self) -> &[u8] {
-        let rem = self.remaining();
-        self.take_next(rem)
-    }
-
-    fn push_to<W: WriteBuffer>(&mut self, output: &mut W) {
-        let count = cmp::min(output.remaining(), self.remaining());
-        cryptoutil::copy_memory(self.take_next(count), output.take_next(count));
-    }
-}
-
-pub trait WriteBuffer {
-    fn is_empty(&self) -> bool;
-    fn is_full(&self) -> bool;
-    fn remaining(&self) -> usize;
-    fn capacity(&self) -> usize;
-    fn position(&self) -> usize { self.capacity() - self.remaining() }
-
-    fn rewind(&mut self, distance: usize);
-    fn reset(&mut self);
-
-    // FIXME - Shouldn't need mut self
-    fn peek_read_buffer(&mut self) -> RefReadBuffer;
-
-    fn take_next(&mut self, count: usize) -> &mut [u8];
-    fn take_remaining(&mut self) -> &mut [u8] {
-        let rem = self.remaining();
-        self.take_next(rem)
-    }
-    fn take_read_buffer(&mut self) -> RefReadBuffer;
-}
-
-pub struct RefReadBuffer<'a> {
-    buff: &'a [u8],
-    pos: usize
-}
-
-impl <'a> RefReadBuffer<'a> {
-    pub fn new(buff: &[u8]) -> RefReadBuffer {
-        RefReadBuffer {
-            buff: buff,
-            pos: 0
-        }
-    }
-}
-
-impl <'a> ReadBuffer for RefReadBuffer<'a> {
-    fn is_empty(&self) -> bool { self.pos == self.buff.len() }
-    fn is_full(&self) -> bool { self.pos == 0 }
-    fn remaining(&self) -> usize { self.buff.len() - self.pos }
-    fn capacity(&self) -> usize { self.buff.len() }
-
-    fn rewind(&mut self, distance: usize) { self.pos -= distance; }
-    fn truncate(&mut self, amount: usize) {
-        self.buff = &self.buff[..self.buff.len() - amount];
-    }
-    fn reset(&mut self) { self.pos = 0; }
-
-    fn peek_next(&self, count: usize) -> &[u8] { &self.buff[self.pos..count] }
-
-    fn take_next(&mut self, count: usize) -> &[u8] {
-        let r = &self.buff[self.pos..self.pos + count];
-        self.pos += count;
-        r
-    }
-}
-
-pub struct OwnedReadBuffer {
-    buff: Vec<u8>,
-    len: usize,
-    pos: usize
-}
-
-impl OwnedReadBuffer {
-    pub fn new(buff: Vec<u8>) -> OwnedReadBuffer {
-        let len = buff.len();
-        OwnedReadBuffer {
-            buff: buff,
-            len: len,
-            pos: 0
-        }
-    }
-    pub fn new_with_len<'a>(buff: Vec<u8>, len: usize) -> OwnedReadBuffer {
-        OwnedReadBuffer {
-            buff: buff,
-            len: len,
-            pos: 0
-        }
-    }
-    pub fn into_write_buffer(self) -> OwnedWriteBuffer {
-        OwnedWriteBuffer::new(self.buff)
-    }
-    pub fn borrow_write_buffer(&mut self) -> BorrowedWriteBuffer {
-        self.pos = 0;
-        self.len = 0;
-        BorrowedWriteBuffer::new(self)
-    }
-}
-
-impl ReadBuffer for OwnedReadBuffer {
-    fn is_empty(&self) -> bool { self.pos == self.len }
-    fn is_full(&self) -> bool { self.pos == 0 }
-    fn remaining(&self) -> usize { self.len - self.pos }
-    fn capacity(&self) -> usize { self.len }
-
-    fn rewind(&mut self, distance: usize) { self.pos -= distance; }
-    fn truncate(&mut self, amount: usize) { self.len -= amount; }
-    fn reset(&mut self) { self.pos = 0; }
-
-    fn peek_next(&self, count: usize) -> &[u8] { &self.buff[self.pos..count] }
-
-    fn take_next(&mut self, count: usize) -> &[u8] {
-        let r = &self.buff[self.pos..self.pos + count];
-        self.pos += count;
-        r
-    }
-}
-
-pub struct RefWriteBuffer<'a> {
-    buff: &'a mut [u8],
-    len: usize,
-    pos: usize
-}
-
-impl <'a> RefWriteBuffer<'a> {
-    pub fn new(buff: &mut [u8]) -> RefWriteBuffer {
-        let len = buff.len();
-        RefWriteBuffer {
-            buff: buff,
-            len: len,
-            pos: 0
-        }
-    }
-}
-
-impl <'a> WriteBuffer for RefWriteBuffer<'a> {
-    fn is_empty(&self) -> bool { self.pos == 0 }
-    fn is_full(&self) -> bool { self.pos == self.len }
-    fn remaining(&self) -> usize { self.len - self.pos }
-    fn capacity(&self) -> usize { self.len }
-
-    fn rewind(&mut self, distance: usize) { self.pos -= distance; }
-    fn reset(&mut self) { self.pos = 0; }
-
-    fn peek_read_buffer(&mut self) -> RefReadBuffer {
-        RefReadBuffer::new(&mut self.buff[..self.pos])
-    }
-
-    fn take_next(&mut self, count: usize) -> &mut [u8] {
-        let r = &mut self.buff[self.pos..self.pos + count];
-        self.pos += count;
-        r
-    }
-    fn take_read_buffer(&mut self) -> RefReadBuffer {
-        let r = RefReadBuffer::new(&mut self.buff[..self.pos]);
-        self.pos = 0;
-        r
-    }
-}
-
-pub struct BorrowedWriteBuffer<'a> {
-    parent: &'a mut OwnedReadBuffer,
-    pos: usize,
-    len: usize
-}
-
-impl <'a> BorrowedWriteBuffer<'a> {
-    fn new(parent: &mut OwnedReadBuffer) -> BorrowedWriteBuffer {
-        let buff_len = parent.buff.len();
-        BorrowedWriteBuffer {
-            parent: parent,
-            pos: 0,
-            len: buff_len
-        }
-    }
-}
-
-impl <'a> WriteBuffer for BorrowedWriteBuffer<'a> {
-    fn is_empty(&self) -> bool { self.pos == 0 }
-    fn is_full(&self) -> bool { self.pos == self.len }
-    fn remaining(&self) -> usize { self.len - self.pos }
-    fn capacity(&self) -> usize { self.len }
-
-    fn rewind(&mut self, distance: usize) {
-        self.pos -= distance;
-        self.parent.len -= distance;
-    }
-    fn reset(&mut self) {
-        self.pos = 0;
-        self.parent.len = 0;
-    }
-
-    fn peek_read_buffer(&mut self) -> RefReadBuffer {
-        RefReadBuffer::new(&self.parent.buff[..self.pos])
-    }
-
-    fn take_next<>(&mut self, count: usize) -> &mut [u8] {
-        let r = &mut self.parent.buff[self.pos..self.pos + count];
-        self.pos += count;
-        self.parent.len += count;
-        r
-    }
-    fn take_read_buffer(&mut self) -> RefReadBuffer {
-        let r = RefReadBuffer::new(&self.parent.buff[..self.pos]);
-        self.pos = 0;
-        self.parent.len = 0;
-        r
-    }
-}
-
-pub struct OwnedWriteBuffer {
-    buff: Vec<u8>,
-    len: usize,
-    pos: usize
-}
-
-impl OwnedWriteBuffer {
-    pub fn new(buff: Vec<u8>) -> OwnedWriteBuffer {
-        let len = buff.len();
-        OwnedWriteBuffer {
-            buff: buff,
-            len: len,
-            pos: 0
-        }
-    }
-    pub fn into_read_buffer(self) -> OwnedReadBuffer {
-        let pos = self.pos;
-        OwnedReadBuffer::new_with_len(self.buff, pos)
-    }
-}
-
-impl WriteBuffer for OwnedWriteBuffer {
-    fn is_empty(&self) -> bool { self.pos == 0 }
-    fn is_full(&self) -> bool { self.pos == self.len }
-    fn remaining(&self) -> usize { self.len - self.pos }
-    fn capacity(&self) -> usize { self.len }
-
-    fn rewind(&mut self, distance: usize) { self.pos -= distance; }
-    fn reset(&mut self) { self.pos = 0; }
-
-    fn peek_read_buffer<'a>(&'a mut self) -> RefReadBuffer<'a> {
-        RefReadBuffer::new(&self.buff[..self.pos])
-    }
-
-    fn take_next<'a>(&'a mut self, count: usize) -> &'a mut [u8] {
-        let r = &mut self.buff[self.pos..self.pos + count];
-        self.pos += count;
-        r
-    }
-    fn take_read_buffer<'a>(&'a mut self) -> RefReadBuffer<'a> {
-        let r = RefReadBuffer::new(&self.buff[..self.pos]);
-        self.pos = 0;
-        r
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/chacha20.rs b/rustc_deps/vendor/rust-crypto/src/chacha20.rs
deleted file mode 100644
index 0167970..0000000
--- a/rustc_deps/vendor/rust-crypto/src/chacha20.rs
+++ /dev/null
@@ -1,634 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-use std::cmp;
-
-use buffer::{BufferResult, RefReadBuffer, RefWriteBuffer};
-use symmetriccipher::{Encryptor, Decryptor, SynchronousStreamCipher, SymmetricCipherError};
-use cryptoutil::{read_u32_le, symm_enc_or_dec, write_u32_le, xor_keystream};
-use simd::u32x4;
-
-#[derive(Clone,Copy)]
-struct ChaChaState {
-  a: u32x4,
-  b: u32x4,
-  c: u32x4,
-  d: u32x4
-}
-
-#[derive(Copy)]
-pub struct ChaCha20 {
-    state  : ChaChaState,
-    output : [u8; 64],
-    offset : usize,
-}
-
-impl Clone for ChaCha20 { fn clone(&self) -> ChaCha20 { *self } }
-
-macro_rules! swizzle{
-    ($b: expr, $c: expr, $d: expr) => {{
-        let u32x4(b10, b11, b12, b13) = $b;
-        $b = u32x4(b11, b12, b13, b10);
-        let u32x4(c10, c11, c12, c13) = $c;
-        $c = u32x4(c12, c13,c10, c11);
-        let u32x4(d10, d11, d12, d13) = $d;
-        $d = u32x4(d13, d10, d11, d12);
-    }}
-}
-
-macro_rules! state_to_buffer {
-    ($state: expr, $output: expr) => {{
-        let u32x4(a1, a2, a3, a4) = $state.a;
-        let u32x4(b1, b2, b3, b4) = $state.b;
-        let u32x4(c1, c2, c3, c4) = $state.c;
-        let u32x4(d1, d2, d3, d4) = $state.d;
-        let lens = [
-            a1,a2,a3,a4,
-            b1,b2,b3,b4,
-            c1,c2,c3,c4,
-            d1,d2,d3,d4
-        ];
-        for i in 0..lens.len() {
-            write_u32_le(&mut $output[i*4..(i+1)*4], lens[i]);
-        }
-    }}
-}
-
-macro_rules! round{
-    ($state: expr) => {{
-      $state.a = $state.a + $state.b;
-      rotate!($state.d, $state.a, S16);
-      $state.c = $state.c + $state.d;
-      rotate!($state.b, $state.c, S12);
-      $state.a = $state.a + $state.b;
-      rotate!($state.d, $state.a, S8);
-      $state.c = $state.c + $state.d;
-      rotate!($state.b, $state.c, S7);
-    }}
-}
-
-macro_rules! rotate {
-    ($a: expr, $b: expr, $c:expr) => {{
-      let v = $a ^ $b;
-      let r = S32 - $c;
-      let right = v >> r;
-      $a = (v << $c) ^ right
-    }}
-}
-
-static S32:u32x4 = u32x4(32, 32, 32, 32);
-static S16:u32x4 = u32x4(16, 16, 16, 16);
-static S12:u32x4 = u32x4(12, 12, 12, 12);
-static S8:u32x4 = u32x4(8, 8, 8, 8);
-static S7:u32x4 = u32x4(7, 7, 7, 7);
-
-impl ChaCha20 {
-    pub fn new(key: &[u8], nonce: &[u8]) -> ChaCha20 {
-        assert!(key.len() == 16 || key.len() == 32);
-        assert!(nonce.len() == 8 || nonce.len() == 12);
-
-        ChaCha20{ state: ChaCha20::expand(key, nonce), output: [0u8; 64], offset: 64 }
-    }
-
-    pub fn new_xchacha20(key: &[u8], nonce: &[u8]) -> ChaCha20 {
-        assert!(key.len() == 32);
-        assert!(nonce.len() == 24);
-
-        // HChaCha20 produces a 256-bit output block starting from a 512 bit
-        // input block where (x0,x1,...,x15) where
-        //
-        //  * (x0, x1, x2, x3) is the ChaCha20 constant.
-        //  * (x4, x5, ... x11) is a 256 bit key.
-        //  * (x12, x13, x14, x15) is a 128 bit nonce.
-        let mut xchacha20 = ChaCha20{ state: ChaCha20::expand(key, &nonce[0..16]), output: [0u8; 64], offset: 64 };
-
-        // Use HChaCha to derive the subkey, and initialize a ChaCha20 instance
-        // with the subkey and the remaining 8 bytes of the nonce.
-        let mut new_key = [0; 32];
-        xchacha20.hchacha20(&mut new_key);
-        xchacha20.state = ChaCha20::expand(&new_key, &nonce[16..24]);
-
-        xchacha20
-    }
-
-    fn expand(key: &[u8], nonce: &[u8]) -> ChaChaState {
-
-        let constant = match key.len() {
-            16 => b"expand 16-byte k",
-            32 => b"expand 32-byte k",
-            _  => unreachable!(),
-        };
-        ChaChaState {
-            a: u32x4(
-                read_u32_le(&constant[0..4]),
-                read_u32_le(&constant[4..8]),
-                read_u32_le(&constant[8..12]),
-                read_u32_le(&constant[12..16])
-            ),
-            b: u32x4(
-                read_u32_le(&key[0..4]),
-                read_u32_le(&key[4..8]),
-                read_u32_le(&key[8..12]),
-                read_u32_le(&key[12..16])
-            ),
-            c: if key.len() == 16 {
-                    u32x4(
-                        read_u32_le(&key[0..4]),
-                        read_u32_le(&key[4..8]),
-                        read_u32_le(&key[8..12]),
-                        read_u32_le(&key[12..16])
-                    )
-                } else {
-                    u32x4(
-                        read_u32_le(&key[16..20]),
-                        read_u32_le(&key[20..24]),
-                        read_u32_le(&key[24..28]),
-                        read_u32_le(&key[28..32])
-                    )
-                },
-            d: if nonce.len() == 16 {
-                   u32x4(
-                        read_u32_le(&nonce[0..4]),
-                        read_u32_le(&nonce[4..8]),
-                        read_u32_le(&nonce[8..12]),
-                        read_u32_le(&nonce[12..16])
-                    )
-               } else if nonce.len() == 12 {
-                   u32x4(
-                        0,
-                        read_u32_le(&nonce[0..4]),
-                        read_u32_le(&nonce[4..8]),
-                        read_u32_le(&nonce[8..12])
-                    )
-               } else {
-                   u32x4(
-                        0,
-                        0,
-                        read_u32_le(&nonce[0..4]),
-                        read_u32_le(&nonce[4..8])
-                    )
-               }
-        }
-    }
-
-    fn hchacha20(&mut self, out: &mut [u8]) -> () {
-        let mut state = self.state;
-
-        // Apply r/2 iterations of the same "double-round" function,
-        // obtaining (z0, z1, ... z15) = doubleround r/2 (x0, x1, ... x15).
-        for _ in 0..10 {
-            round!(state);
-            let u32x4(b10, b11, b12, b13) = state.b;
-            state.b = u32x4(b11, b12, b13, b10);
-            let u32x4(c10, c11, c12, c13) = state.c;
-            state.c = u32x4(c12, c13,c10, c11);
-            let u32x4(d10, d11, d12, d13) = state.d;
-            state.d = u32x4(d13, d10, d11, d12);
-            round!(state);
-            let u32x4(b20, b21, b22, b23) = state.b;
-            state.b = u32x4(b23, b20, b21, b22);
-            let u32x4(c20, c21, c22, c23) = state.c;
-            state.c = u32x4(c22, c23, c20, c21);
-            let u32x4(d20, d21, d22, d23) = state.d;
-            state.d = u32x4(d21, d22, d23, d20);
-        }
-
-        // HChaCha20 then outputs the 256-bit block (z0, z1, z2, z3, z12, z13,
-        // z14, z15).  These correspond to the constant and input positions in
-        // the ChaCha matrix.
-        let u32x4(a1, a2, a3, a4) = state.a;
-        let u32x4(d1, d2, d3, d4) = state.d;
-        let lens = [
-            a1,a2,a3,a4,
-            d1,d2,d3,d4
-        ];
-        for i in 0..lens.len() {
-            write_u32_le(&mut out[i*4..(i+1)*4], lens[i]);
-        }
-    }
-
-    // put the the next 64 keystream bytes into self.output
-    fn update(&mut self) {
-        let mut state = self.state;
-
-        for _ in 0..10 {
-            round!(state);
-            swizzle!(state.b, state.c, state.d);
-            round!(state);
-            swizzle!(state.d, state.c, state.b);
-        }
-        state.a = state.a + self.state.a;
-        state.b = state.b + self.state.b;
-        state.c = state.c + self.state.c;
-        state.d = state.d + self.state.d;
-
-        state_to_buffer!(state, self.output);
-
-        self.state.d = self.state.d + u32x4(1, 0, 0, 0);
-        let u32x4(c12, _, _, _) = self.state.d;
-        if c12 == 0 {
-            // we could increment the other counter word with an 8 byte nonce
-            // but other implementations like boringssl have this same
-            // limitation
-            panic!("counter is exhausted");
-        }
-
-        self.offset = 0;
-    }
-}
-
-impl SynchronousStreamCipher for ChaCha20 {
-    fn process(&mut self, input: &[u8], output: &mut [u8]) {
-        assert!(input.len() == output.len());
-        let len = input.len();
-        let mut i = 0;
-        while i < len {
-            // If there is no keystream available in the output buffer,
-            // generate the next block.
-            if self.offset == 64 {
-                self.update();
-            }
-
-            // Process the min(available keystream, remaining input length).
-            let count = cmp::min(64 - self.offset, len - i);
-            xor_keystream(&mut output[i..i+count], &input[i..i+count], &self.output[self.offset..]);
-            i += count;
-            self.offset += count;
-        }
-    }
-}
-
-impl Encryptor for ChaCha20 {
-    fn encrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, _: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        symm_enc_or_dec(self, input, output)
-    }
-}
-
-impl Decryptor for ChaCha20 {
-    fn decrypt(&mut self, input: &mut RefReadBuffer, output: &mut RefWriteBuffer, _: bool)
-            -> Result<BufferResult, SymmetricCipherError> {
-        symm_enc_or_dec(self, input, output)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::iter::repeat;
-
-    use chacha20::ChaCha20;
-    use symmetriccipher::SynchronousStreamCipher;
-
-    #[test]
-    fn test_chacha20_256_tls_vectors() {
-        struct TestVector {
-            key:   [u8; 32],
-            nonce: [u8; 8],
-            keystream: Vec<u8>,
-        };
-        // taken from http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04
-        let test_vectors = vec!(
-            TestVector{
-                key: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ],
-                nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                keystream: vec!(
-                    0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90,
-                    0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
-                    0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a,
-                    0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7,
-                    0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d,
-                    0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
-                    0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c,
-                    0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
-                ),
-            }, TestVector{
-                key: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-                ],
-                nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                keystream: vec!(
-                    0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,
-                    0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,
-                    0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60,
-                    0x4f, 0x45, 0x09, 0x52, 0xed, 0x43, 0x2d, 0x41,
-                    0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66, 0xd2,
-                    0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c,
-                    0x53, 0xd7, 0x92, 0xb1, 0xc4, 0x3f, 0xea, 0x81,
-                    0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
-                ),
-            }, TestVector{
-                key: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ],
-                nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ],
-                keystream: vec!(
-                    0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,
-                    0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,
-                    0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13,
-                    0x4f, 0xcb, 0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31,
-                    0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08, 0x45,
-                    0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b,
-                    0x52, 0x77, 0x06, 0x2e, 0xb7, 0xa0, 0x43, 0x3e,
-                    0x44, 0x5f, 0x41, 0xe3,
-                ),
-            }, TestVector{
-                key: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ],
-                nonce: [ 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                keystream: vec!(
-                    0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,
-                    0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,
-                    0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac,
-                    0x33, 0x96, 0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32,
-                    0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5, 0x3c,
-                    0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54,
-                    0x5d, 0xdc, 0x49, 0x7a, 0x0b, 0x46, 0x6e, 0x7d,
-                    0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
-                ),
-            }, TestVector{
-                key: [
-                    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-                    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-                    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-                    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-                ],
-                nonce: [ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 ],
-                keystream: vec!(
-                    0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,
-                    0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,
-                    0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93,
-                    0xec, 0x01, 0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1,
-                    0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46, 0x41,
-                    0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69,
-                    0x05, 0xd3, 0xbe, 0x59, 0xea, 0x1c, 0x53, 0xf1,
-                    0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a,
-                    0x38, 0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94,
-                    0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a, 0xde, 0x66,
-                    0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58,
-                    0x89, 0xfb, 0x60, 0xe8, 0x46, 0x29, 0xc9, 0xbd,
-                    0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
-                    0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e,
-                    0x09, 0xa7, 0xe7, 0x78, 0x49, 0x2b, 0x56, 0x2e,
-                    0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7,
-                    0x9d, 0xb9, 0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15,
-                    0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f, 0xc3,
-                    0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a,
-                    0x97, 0xa5, 0xf5, 0x76, 0xfe, 0x06, 0x40, 0x25,
-                    0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5,
-                    0x07, 0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69,
-                    0x59, 0x66, 0x09, 0x96, 0x54, 0x6c, 0xc9, 0xc4,
-                    0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7,
-                    0x0e, 0xaf, 0x46, 0xf7, 0x6d, 0xad, 0x39, 0x79,
-                    0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
-                    0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a,
-                    0x94, 0xdf, 0x76, 0x28, 0xfe, 0x4e, 0xaa, 0xf2,
-                    0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a,
-                    0xd0, 0xf9, 0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09,
-                    0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40, 0x7a,
-                    0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
-                ),
-            },
-        );
-
-        for tv in test_vectors.iter() {
-            let mut c = ChaCha20::new(&tv.key, &tv.nonce);
-            let input: Vec<u8> = repeat(0).take(tv.keystream.len()).collect();
-            let mut output: Vec<u8> = repeat(0).take(input.len()).collect();
-            c.process(&input[..], &mut output[..]);
-            assert_eq!(output, tv.keystream);
-        }
-    }
-
-    #[test]
-    fn test_xchacha20_basic() {
-        // There aren't any convenient test vectors for XChaCha/20,
-        // so, a simple test case was generated using Andrew Moon's
-        // chacha-opt library, with the key/nonce from test_salsa20_cryptopp().
-        let key =
-            [0x1b, 0x27, 0x55, 0x64, 0x73, 0xe9, 0x85, 0xd4,
-             0x62, 0xcd, 0x51, 0x19, 0x7a, 0x9a, 0x46, 0xc7,
-             0x60, 0x09, 0x54, 0x9e, 0xac, 0x64, 0x74, 0xf2,
-             0x06, 0xc4, 0xee, 0x08, 0x44, 0xf6, 0x83, 0x89];
-        let nonce =
-            [0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6, 0x2b, 0x73,
-             0xcd, 0x62, 0xbd, 0xa8, 0x75, 0xfc, 0x73, 0xd6,
-             0x82, 0x19, 0xe0, 0x03, 0x6b, 0x7a, 0x0b, 0x37];
-        let input = [0u8; 139];
-        let mut stream = [0u8; 139];
-        let result =
-            [0x4f, 0xeb, 0xf2, 0xfe, 0x4b, 0x35, 0x9c, 0x50,
-             0x8d, 0xc5, 0xe8, 0xb5, 0x98, 0x0c, 0x88, 0xe3,
-             0x89, 0x46, 0xd8, 0xf1, 0x8f, 0x31, 0x34, 0x65,
-             0xc8, 0x62, 0xa0, 0x87, 0x82, 0x64, 0x82, 0x48,
-             0x01, 0x8d, 0xac, 0xdc, 0xb9, 0x04, 0x17, 0x88,
-             0x53, 0xa4, 0x6d, 0xca, 0x3a, 0x0e, 0xaa, 0xee,
-             0x74, 0x7c, 0xba, 0x97, 0x43, 0x4e, 0xaf, 0xfa,
-             0xd5, 0x8f, 0xea, 0x82, 0x22, 0x04, 0x7e, 0x0d,
-             0xe6, 0xc3, 0xa6, 0x77, 0x51, 0x06, 0xe0, 0x33,
-             0x1a, 0xd7, 0x14, 0xd2, 0xf2, 0x7a, 0x55, 0x64,
-             0x13, 0x40, 0xa1, 0xf1, 0xdd, 0x9f, 0x94, 0x53,
-             0x2e, 0x68, 0xcb, 0x24, 0x1c, 0xbd, 0xd1, 0x50,
-             0x97, 0x0d, 0x14, 0xe0, 0x5c, 0x5b, 0x17, 0x31,
-             0x93, 0xfb, 0x14, 0xf5, 0x1c, 0x41, 0xf3, 0x93,
-             0x83, 0x5b, 0xf7, 0xf4, 0x16, 0xa7, 0xe0, 0xbb,
-             0xa8, 0x1f, 0xfb, 0x8b, 0x13, 0xaf, 0x0e, 0x21,
-             0x69, 0x1d, 0x7e, 0xce, 0xc9, 0x3b, 0x75, 0xe6,
-             0xe4, 0x18, 0x3a];
-
-        let mut xchacha20 = ChaCha20::new_xchacha20(&key, &nonce);
-        xchacha20.process(&input, &mut stream);
-        assert!(stream[..] == result[..]);
-    }
-
-    #[test]
-    fn test_chacha20_256_tls_vectors_96_nonce() {
-        struct TestVector {
-            key:   [u8; 32],
-            nonce: [u8; 12],
-            keystream: Vec<u8>,
-        };
-        // taken from http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04
-        let test_vectors = vec!(
-            TestVector{
-                key: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ],
-                nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                keystream: vec!(
-                    0x76, 0xb8, 0xe0, 0xad, 0xa0, 0xf1, 0x3d, 0x90,
-                    0x40, 0x5d, 0x6a, 0xe5, 0x53, 0x86, 0xbd, 0x28,
-                    0xbd, 0xd2, 0x19, 0xb8, 0xa0, 0x8d, 0xed, 0x1a,
-                    0xa8, 0x36, 0xef, 0xcc, 0x8b, 0x77, 0x0d, 0xc7,
-                    0xda, 0x41, 0x59, 0x7c, 0x51, 0x57, 0x48, 0x8d,
-                    0x77, 0x24, 0xe0, 0x3f, 0xb8, 0xd8, 0x4a, 0x37,
-                    0x6a, 0x43, 0xb8, 0xf4, 0x15, 0x18, 0xa1, 0x1c,
-                    0xc3, 0x87, 0xb6, 0x69, 0xb2, 0xee, 0x65, 0x86,
-                ),
-            }, TestVector{
-                key: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-                ],
-                nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                keystream: vec!(
-                    0x45, 0x40, 0xf0, 0x5a, 0x9f, 0x1f, 0xb2, 0x96,
-                    0xd7, 0x73, 0x6e, 0x7b, 0x20, 0x8e, 0x3c, 0x96,
-                    0xeb, 0x4f, 0xe1, 0x83, 0x46, 0x88, 0xd2, 0x60,
-                    0x4f, 0x45, 0x09, 0x52, 0xed, 0x43, 0x2d, 0x41,
-                    0xbb, 0xe2, 0xa0, 0xb6, 0xea, 0x75, 0x66, 0xd2,
-                    0xa5, 0xd1, 0xe7, 0xe2, 0x0d, 0x42, 0xaf, 0x2c,
-                    0x53, 0xd7, 0x92, 0xb1, 0xc4, 0x3f, 0xea, 0x81,
-                    0x7e, 0x9a, 0xd2, 0x75, 0xae, 0x54, 0x69, 0x63,
-                ),
-            }, TestVector{
-                key: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ],
-                nonce: [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ],
-                keystream: vec!(
-                    0xde, 0x9c, 0xba, 0x7b, 0xf3, 0xd6, 0x9e, 0xf5,
-                    0xe7, 0x86, 0xdc, 0x63, 0x97, 0x3f, 0x65, 0x3a,
-                    0x0b, 0x49, 0xe0, 0x15, 0xad, 0xbf, 0xf7, 0x13,
-                    0x4f, 0xcb, 0x7d, 0xf1, 0x37, 0x82, 0x10, 0x31,
-                    0xe8, 0x5a, 0x05, 0x02, 0x78, 0xa7, 0x08, 0x45,
-                    0x27, 0x21, 0x4f, 0x73, 0xef, 0xc7, 0xfa, 0x5b,
-                    0x52, 0x77, 0x06, 0x2e, 0xb7, 0xa0, 0x43, 0x3e,
-                    0x44, 0x5f, 0x41, 0xe3,
-                ),
-            }, TestVector{
-                key: [
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ],
-                nonce: [ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 ],
-                keystream: vec!(
-                    0xef, 0x3f, 0xdf, 0xd6, 0xc6, 0x15, 0x78, 0xfb,
-                    0xf5, 0xcf, 0x35, 0xbd, 0x3d, 0xd3, 0x3b, 0x80,
-                    0x09, 0x63, 0x16, 0x34, 0xd2, 0x1e, 0x42, 0xac,
-                    0x33, 0x96, 0x0b, 0xd1, 0x38, 0xe5, 0x0d, 0x32,
-                    0x11, 0x1e, 0x4c, 0xaf, 0x23, 0x7e, 0xe5, 0x3c,
-                    0xa8, 0xad, 0x64, 0x26, 0x19, 0x4a, 0x88, 0x54,
-                    0x5d, 0xdc, 0x49, 0x7a, 0x0b, 0x46, 0x6e, 0x7d,
-                    0x6b, 0xbd, 0xb0, 0x04, 0x1b, 0x2f, 0x58, 0x6b,
-                ),
-            }, TestVector{
-                key: [
-                    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-                    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-                    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
-                    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
-                ],
-                nonce: [0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 ],
-                keystream: vec!(
-                    0xf7, 0x98, 0xa1, 0x89, 0xf1, 0x95, 0xe6, 0x69,
-                    0x82, 0x10, 0x5f, 0xfb, 0x64, 0x0b, 0xb7, 0x75,
-                    0x7f, 0x57, 0x9d, 0xa3, 0x16, 0x02, 0xfc, 0x93,
-                    0xec, 0x01, 0xac, 0x56, 0xf8, 0x5a, 0xc3, 0xc1,
-                    0x34, 0xa4, 0x54, 0x7b, 0x73, 0x3b, 0x46, 0x41,
-                    0x30, 0x42, 0xc9, 0x44, 0x00, 0x49, 0x17, 0x69,
-                    0x05, 0xd3, 0xbe, 0x59, 0xea, 0x1c, 0x53, 0xf1,
-                    0x59, 0x16, 0x15, 0x5c, 0x2b, 0xe8, 0x24, 0x1a,
-                    0x38, 0x00, 0x8b, 0x9a, 0x26, 0xbc, 0x35, 0x94,
-                    0x1e, 0x24, 0x44, 0x17, 0x7c, 0x8a, 0xde, 0x66,
-                    0x89, 0xde, 0x95, 0x26, 0x49, 0x86, 0xd9, 0x58,
-                    0x89, 0xfb, 0x60, 0xe8, 0x46, 0x29, 0xc9, 0xbd,
-                    0x9a, 0x5a, 0xcb, 0x1c, 0xc1, 0x18, 0xbe, 0x56,
-                    0x3e, 0xb9, 0xb3, 0xa4, 0xa4, 0x72, 0xf8, 0x2e,
-                    0x09, 0xa7, 0xe7, 0x78, 0x49, 0x2b, 0x56, 0x2e,
-                    0xf7, 0x13, 0x0e, 0x88, 0xdf, 0xe0, 0x31, 0xc7,
-                    0x9d, 0xb9, 0xd4, 0xf7, 0xc7, 0xa8, 0x99, 0x15,
-                    0x1b, 0x9a, 0x47, 0x50, 0x32, 0xb6, 0x3f, 0xc3,
-                    0x85, 0x24, 0x5f, 0xe0, 0x54, 0xe3, 0xdd, 0x5a,
-                    0x97, 0xa5, 0xf5, 0x76, 0xfe, 0x06, 0x40, 0x25,
-                    0xd3, 0xce, 0x04, 0x2c, 0x56, 0x6a, 0xb2, 0xc5,
-                    0x07, 0xb1, 0x38, 0xdb, 0x85, 0x3e, 0x3d, 0x69,
-                    0x59, 0x66, 0x09, 0x96, 0x54, 0x6c, 0xc9, 0xc4,
-                    0xa6, 0xea, 0xfd, 0xc7, 0x77, 0xc0, 0x40, 0xd7,
-                    0x0e, 0xaf, 0x46, 0xf7, 0x6d, 0xad, 0x39, 0x79,
-                    0xe5, 0xc5, 0x36, 0x0c, 0x33, 0x17, 0x16, 0x6a,
-                    0x1c, 0x89, 0x4c, 0x94, 0xa3, 0x71, 0x87, 0x6a,
-                    0x94, 0xdf, 0x76, 0x28, 0xfe, 0x4e, 0xaa, 0xf2,
-                    0xcc, 0xb2, 0x7d, 0x5a, 0xaa, 0xe0, 0xad, 0x7a,
-                    0xd0, 0xf9, 0xd4, 0xb6, 0xad, 0x3b, 0x54, 0x09,
-                    0x87, 0x46, 0xd4, 0x52, 0x4d, 0x38, 0x40, 0x7a,
-                    0x6d, 0xeb, 0x3a, 0xb7, 0x8f, 0xab, 0x78, 0xc9,
-                ),
-            },
-        );
-
-        for tv in test_vectors.iter() {
-            let mut c = ChaCha20::new(&tv.key, &tv.nonce);
-            let input: Vec<u8> = repeat(0).take(tv.keystream.len()).collect();
-            let mut output: Vec<u8> = repeat(0).take(input.len()).collect();
-            c.process(&input[..], &mut output[..]);
-            assert_eq!(output, tv.keystream);
-        }
-    }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use test::Bencher;
-    use symmetriccipher::SynchronousStreamCipher;
-    use chacha20::ChaCha20;
-
-    #[bench]
-    pub fn chacha20_10(bh: & mut Bencher) {
-        let mut chacha20 = ChaCha20::new(&[0; 32], &[0; 8]);
-        let input = [1u8; 10];
-        let mut output = [0u8; 10];
-        bh.iter( || {
-            chacha20.process(&input, &mut output);
-        });
-        bh.bytes = input.len() as u64;
-    }
-
-    #[bench]
-    pub fn chacha20_1k(bh: & mut Bencher) {
-        let mut chacha20 = ChaCha20::new(&[0; 32], &[0; 8]);
-        let input = [1u8; 1024];
-        let mut output = [0u8; 1024];
-        bh.iter( || {
-            chacha20.process(&input, &mut output);
-        });
-        bh.bytes = input.len() as u64;
-    }
-
-    #[bench]
-    pub fn chacha20_64k(bh: & mut Bencher) {
-        let mut chacha20 = ChaCha20::new(&[0; 32], &[0; 8]);
-        let input = [1u8; 65536];
-        let mut output = [0u8; 65536];
-        bh.iter( || {
-            chacha20.process(&input, &mut output);
-        });
-        bh.bytes = input.len() as u64;
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/chacha20poly1305.rs b/rustc_deps/vendor/rust-crypto/src/chacha20poly1305.rs
deleted file mode 100644
index 816d186..0000000
--- a/rustc_deps/vendor/rust-crypto/src/chacha20poly1305.rs
+++ /dev/null
@@ -1,801 +0,0 @@
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use aead::{AeadEncryptor,AeadDecryptor};
-
-use chacha20::ChaCha20;
-use symmetriccipher::SynchronousStreamCipher;
-use poly1305::Poly1305;
-use mac::Mac;
-use cryptoutil::{write_u64_le};
-use util::fixed_time_eq;
-#[derive(Clone, Copy)]
-pub struct ChaCha20Poly1305 {
-    cipher  : ChaCha20,
-    mac: Poly1305,
-    finished: bool,
-    data_len: usize
-}
-
-impl ChaCha20Poly1305 {
-  pub fn new(key: &[u8], nonce: &[u8], aad: &[u8]) -> ChaCha20Poly1305 {
-      assert!(key.len() == 16 || key.len() == 32);
-      assert!(nonce.len() == 8);
-
-      let mut cipher = ChaCha20::new(key, nonce);
-      let mut mac_key = [0u8; 64];
-      let zero_key = [0u8; 64];
-      cipher.process(&zero_key, &mut mac_key);
-
-      let mut mac = Poly1305::new(&mac_key[..32]);
-      mac.input(aad);
-      let mut aad_len = [0u8; 8];
-      let aad_len_uint: u64 = aad.len() as u64;
-      write_u64_le(&mut aad_len, aad_len_uint);
-      mac.input(&aad_len);
-      ChaCha20Poly1305 {
-        cipher: cipher,
-        mac: mac,
-        finished: false,
-        data_len: 0
-      }
-  }
-}
-
-impl AeadEncryptor for ChaCha20Poly1305 {
-    fn encrypt(&mut self, input: &[u8], output: &mut [u8], out_tag: &mut [u8]) {
-        assert!(input.len() == output.len());
-        assert!(self.finished == false);
-        self.cipher.process(input, output);
-        self.data_len += input.len();
-        self.mac.input(output);
-        self.finished = true;
-        let mut data_len_buf = [0u8; 8];
-        write_u64_le(&mut data_len_buf, self.data_len as u64);
-        self.mac.input(&data_len_buf);
-        self.mac.raw_result(out_tag);
-    }
-}
-
-impl AeadDecryptor for ChaCha20Poly1305 {
-    fn decrypt(&mut self, input: &[u8], output: &mut [u8], tag: &[u8]) -> bool {
-        assert!(input.len() == output.len());
-        assert!(self.finished == false);
-
-        self.finished = true;
-
-        self.mac.input(input);
-
-        self.data_len += input.len();
-        let mut data_len_buf = [0u8; 8];
-
-        write_u64_le(&mut data_len_buf, self.data_len as u64);
-        self.mac.input(&data_len_buf);
-
-        let mut calc_tag =  [0u8; 16];
-        self.mac.raw_result(&mut calc_tag);
-        if fixed_time_eq(&calc_tag, tag) {
-            self.cipher.process(input, output);
-            true
-        } else {
-            false
-        }
-    }
-}
-#[cfg(test)]
-mod test {
-  use std::iter::repeat;
-
-  use chacha20poly1305::ChaCha20Poly1305;
-  use aead::{AeadEncryptor,AeadDecryptor};
-  struct TestVector {
-    key:   [u8; 32],
-    nonce: [u8; 8],
-    plain_text: Vec<u8>,
-    cipher_text: Vec<u8>,
-    aad: Vec<u8>,
-    tag: Vec<u8>
-  }
-
-  #[test]
-  fn test_chacha20_256_poly1305_boringssl_vectors_encrypt() {
-
-    for tv in get_test_vectors().iter() {
-      if tv.tag.len() < 16 {
-        continue;
-      }
-      let mut c = ChaCha20Poly1305::new(&tv.key, &tv.nonce, &tv.aad[..]);
-      let mut output: Vec<u8> = repeat(0).take(tv.plain_text.len()).collect();
-      let mut tag: Vec<u8> = repeat(0).take(tv.tag.len()).collect();
-      c.encrypt(&tv.plain_text[..], &mut output[..], &mut tag[..]);
-      assert_eq!(output, tv.cipher_text);
-      assert_eq!(tag, tv.tag);
-    }
-  }
-  #[test]
-  fn test_chacha20_256_poly1305_boringssl_vectors_decrypt() {
-
-    for tv in get_test_vectors().iter() {
-      if tv.tag.len() < 16 {
-        continue;
-      }
-      let mut c = ChaCha20Poly1305::new(&tv.key, &tv.nonce, &tv.aad[..]);
-      let mut output: Vec<u8> = repeat(0).take(tv.plain_text.len()).collect();
-      let result = c.decrypt(&tv.cipher_text[..], &mut output[..], &tv.tag[..]);
-      assert_eq!(output, tv.plain_text);
-      assert!(result);
-    }
-  }
-  fn get_test_vectors()-> Vec<TestVector>{
-    vec!(
-      TestVector {
-        key: [0x9a, 0x97, 0xf6, 0x5b, 0x9b, 0x4c, 0x72, 0x1b, 0x96, 0x0a, 0x67, 0x21, 0x45, 0xfc, 0xa8, 0xd4, 0xe3, 0x2e, 0x67, 0xf9, 0x11, 0x1e, 0xa9, 0x79, 0xce, 0x9c, 0x48, 0x26, 0x80, 0x6a, 0xee, 0xe6],
-        nonce: [0x3d, 0xe9, 0xc0, 0xda, 0x2b, 0xd7, 0xf9, 0x1e],
-        aad: vec!(),
-        plain_text: vec!(),
-        cipher_text: vec!(),
-        tag: vec!(0x5a, 0x6e, 0x21, 0xf4, 0xba, 0x6d, 0xbe, 0xe5, 0x73, 0x80, 0xe7, 0x9e, 0x79, 0xc3, 0x0d, 0xef)
-      },
-      TestVector{
-        key: [0xbc, 0xb2, 0x63, 0x9b, 0xf9, 0x89, 0xc6, 0x25, 0x1b, 0x29, 0xbf, 0x38, 0xd3, 0x9a, 0x9b, 0xdc, 0xe7, 0xc5, 0x5f, 0x4b, 0x2a, 0xc1, 0x2a, 0x39, 0xc8, 0xa3, 0x7b, 0x5d, 0x0a, 0x5c, 0xc2, 0xb5],
-        nonce: [0x1e, 0x8b, 0x4c, 0x51, 0x0f, 0x5c, 0xa0, 0x83],
-        plain_text: vec!(0x8c, 0x84, 0x19, 0xbc, 0x27),
-        aad: vec!(0x34, 0xab, 0x88, 0xc2, 0x65),
-        cipher_text: vec!(0x1a, 0x7c, 0x2f, 0x33, 0xf5),
-        tag: vec!(0x28, 0x75, 0xc6, 0x59, 0xd0, 0xf2, 0x80, 0x8d, 0xe3, 0xa4, 0x00, 0x27, 0xfe, 0xff, 0x91, 0xa4)
-      },
-      TestVector{
-        key: [0x42, 0x90, 0xbc, 0xb1, 0x54, 0x17, 0x35, 0x31, 0xf3, 0x14, 0xaf, 0x57, 0xf3, 0xbe, 0x3b, 0x50, 0x06, 0xda, 0x37, 0x1e, 0xce, 0x27, 0x2a, 0xfa, 0x1b, 0x5d, 0xbd, 0xd1, 0x10, 0x0a, 0x10, 0x07],
-        nonce: [0xcd, 0x7c, 0xf6, 0x7b, 0xe3, 0x9c, 0x79, 0x4a],
-        plain_text: vec!(0x86, 0xd0, 0x99, 0x74, 0x84, 0x0b, 0xde, 0xd2, 0xa5, 0xca),
-        aad: vec!(0x87, 0xe2, 0x29, 0xd4, 0x50, 0x08, 0x45, 0xa0, 0x79, 0xc0),
-        cipher_text: vec!(0xe3, 0xe4, 0x46, 0xf7, 0xed, 0xe9, 0xa1, 0x9b, 0x62, 0xa4),
-        tag: vec!(0x67, 0x7d, 0xab, 0xf4, 0xe3, 0xd2, 0x4b, 0x87, 0x6b, 0xb2, 0x84, 0x75, 0x38, 0x96, 0xe1, 0xd6)
-      },
-      TestVector{
-        key: [0x42, 0x2a, 0x53, 0x55, 0xb5, 0x6d, 0xcf, 0x2b, 0x43, 0x6a, 0xa8, 0x15, 0x28, 0x58, 0x10, 0x6a, 0x88, 0xd9, 0xba, 0x23, 0xcd, 0xfe, 0x08, 0x7b, 0x5e, 0x74, 0xe8, 0x17, 0xa5, 0x23, 0x88, 0xb3],
-        nonce: [0x1d, 0x12, 0xd6, 0xd9, 0x18, 0x48, 0xf2, 0xea],
-        plain_text: vec!(0x53, 0x7a, 0x64, 0x53, 0x87, 0xf2, 0x2d, 0x6f, 0x6d, 0xbb, 0xea, 0x56, 0x8d, 0x3f, 0xeb),
-        aad: vec!(0xbe, 0xf2, 0x67, 0xc9, 0x9a, 0xec, 0x8a, 0xf5, 0x6b, 0xc2, 0x38, 0x61, 0x2b, 0xfe, 0xa6),
-        cipher_text: vec!(0x28, 0x1a, 0x36, 0x67, 0x05, 0xc5, 0xa2, 0x4b, 0x94, 0xe5, 0x61, 0x46, 0x68, 0x1e, 0x44),
-        tag: vec!(0x38, 0xf2, 0xb8, 0xee, 0x3b, 0xe4, 0x4a, 0xbb, 0xa3, 0xc0, 0x10, 0xd9, 0xca, 0xb6, 0xe0, 0x42)
-      },
-      TestVector{
-        key: [0xec, 0x7b, 0x86, 0x4a, 0x07, 0x8c, 0x3d, 0x05, 0xd9, 0x70, 0xb6, 0xea, 0x3b, 0xa6, 0xd3, 0x3d, 0x6b, 0xb7, 0x3d, 0xfa, 0x64, 0xc6, 0x22, 0xa4, 0x72, 0x7a, 0x96, 0xed, 0xe8, 0x76, 0xf6, 0x85],
-        nonce: [0x2b, 0xca, 0x0e, 0x59, 0xe3, 0x95, 0x08, 0xd3],
-        plain_text: vec!(0xb7, 0x67, 0x33, 0x89, 0x5c, 0x87, 0x1e, 0xdd, 0x72, 0x8a, 0x45, 0xed, 0x1a, 0x21, 0xf1, 0x5a, 0x95, 0x97, 0xd4, 0x9d),
-        aad: vec!(0xcc, 0x12, 0x43, 0xea, 0x54, 0x27, 0x2d, 0xb6, 0x02, 0xfb, 0x08, 0x53, 0xc8, 0xe7, 0x02, 0x7c, 0x56, 0x33, 0x8b, 0x6c),
-        cipher_text: vec!(0x1f, 0xb9, 0xb2, 0x95, 0x8f, 0xce, 0x47, 0xa5, 0xca, 0xda, 0x9d, 0x89, 0x5f, 0xbb, 0x0c, 0x00, 0xd3, 0x56, 0x98, 0x58),
-        tag: vec!(0x04, 0x2a, 0xd5, 0x04, 0x2c, 0x89, 0xeb, 0xc1, 0xaa, 0xd5, 0x7d, 0x3f, 0xb7, 0x03, 0xd3, 0x14)
-      },
-      // TestVector{
-      //   key: [0x2c, 0x4c, 0x0f, 0xdb, 0x61, 0x1d, 0xf2, 0xd4, 0xd5, 0xe7, 0x89, 0x8c, 0x6a, 0xf0, 0x02, 0x27, 0x95, 0x36, 0x4a, 0xdb, 0x87, 0x49, 0x15, 0x5e, 0x2c, 0x68, 0x77, 0x6a, 0x09, 0x0e, 0x7d, 0x5c],
-      //   nonce: [0x13, 0xce, 0x73, 0x82, 0x73, 0x4c, 0x4a, 0x71],
-      //   plain_text: vec!(0x0d, 0xc6, 0xff, 0x21, 0xa3, 0x46, 0xe1, 0x33, 0x7d, 0xd0, 0xdb, 0x81, 0xd8, 0xf7, 0xd9, 0xf6, 0xfd, 0x18, 0x64, 0x41, 0x8b, 0x98, 0xaa, 0xdc, 0xdb),
-      //   aad: vec!(0x01, 0x15, 0xed, 0xcb, 0x17, 0x6a, 0xb8, 0xbf, 0xa9, 0x47, 0xd1, 0xf7, 0xc3, 0xa8, 0x6a, 0x84, 0x5d, 0x31, 0x0b, 0xf6, 0x70, 0x6c, 0x59, 0xa8, 0xf9),
-      //   cipher_text: vec!(0xda, 0xd6, 0x5e, 0x42, 0x44, 0xa1, 0xa1, 0x7c, 0xe5, 0x9d, 0x88, 0xb0, 0x0a, 0xf4, 0xf7, 0x43, 0x4b, 0xd7, 0x83, 0x0f, 0xfd, 0xd4, 0xc5, 0x55, 0x8f),
-      //   tag: vec!(0xac, 0x14, 0x37, 0xb4, 0x5d, 0x8e, 0xac, 0xf9, 0xc0, 0xfe, 0x54, 0x7c, 0x84, 0xfb, 0x82, 0xa2)
-      // },
-      // TestVector{
-      //   key: [0xc6, 0x6e, 0x89, 0xfb, 0xab, 0x01, 0x20, 0x8f, 0x6a, 0x60, 0x84, 0x7f, 0x4f, 0x34, 0xb3, 0x8d, 0x27, 0xb5, 0x54, 0xc1, 0x19, 0xcf, 0x8d, 0x9e, 0x0b, 0x11, 0x8a, 0xa7, 0x26, 0x6a, 0xb8, 0x65],
-      //   nonce: [0x5d, 0x98, 0x56, 0x06, 0x0c, 0x54, 0xab, 0x06],
-      //   plain_text: vec!(0xf9, 0xe3, 0xe9, 0xb5, 0xed, 0x07, 0xb2, 0x08, 0x0d, 0xb8, 0xc1, 0xff, 0xc3, 0x7e, 0x4a, 0x6c, 0xb3, 0xcd, 0x54, 0x46, 0x08, 0x92, 0x1e, 0x18, 0x61, 0x0d, 0x00, 0xb1, 0x7c, 0x6e),
-      //   aad: vec!(0x85, 0xc1, 0x12, 0xa1, 0xef, 0xe0, 0xa2, 0x0e, 0xf3, 0xa5, 0x50, 0x52, 0x6a, 0x7a, 0xfb, 0xc9, 0x8f, 0x63, 0x67, 0xeb, 0xbe, 0xde, 0x4e, 0x70, 0x30, 0x99, 0xab, 0xd7, 0x8f, 0x51),
-      //   cipher_text: vec!(0xb5, 0xcc, 0x75, 0x4f, 0x6d, 0xd1, 0x9e, 0xf2, 0xd6, 0x6f, 0x90, 0xe6, 0xbc, 0x9a, 0x32, 0x2d, 0xdf, 0x21, 0x6e, 0xf2, 0x48, 0xcb, 0xe7, 0x6b, 0x5a, 0xb6, 0xdd, 0x53, 0xbc, 0x36),
-      //   tag: vec!(0x6d, 0xd9, 0x87, 0x10, 0xd8, 0xa8, 0x89, 0xdc, 0xee, 0xa0, 0xd0, 0xa9, 0x36, 0xf9, 0x86, 0x17)
-      // },
-      // TestVector{
-      //   key: [0xa8, 0xb9, 0x76, 0x6f, 0x40, 0x4d, 0xea, 0x8c, 0xf7, 0xd7, 0xdf, 0xaf, 0x58, 0x22, 0xf5, 0x3d, 0xf9, 0xcc, 0xd0, 0x92, 0xe3, 0x32, 0xa5, 0x7f, 0x00, 0x7b, 0x30, 0x1b, 0x50, 0x7d, 0x5e, 0x14],
-      //   nonce: [0xc7, 0xf2, 0xf7, 0xa2, 0x33, 0x10, 0x4a, 0x2d],
-      //   plain_text: vec!(0x4d, 0x6f, 0xae, 0xae, 0xe3, 0x91, 0x79, 0xa7, 0xc8, 0x92, 0xfa, 0xae, 0x37, 0x19, 0x65, 0x6c, 0xc6, 0x14, 0xc7, 0xe6, 0xec, 0xd8, 0xfc, 0xb5, 0x70, 0xa3, 0xb8, 0x2c, 0x4d, 0xac, 0xe9, 0x69, 0x09, 0x03, 0x38),
-      //   aad: vec!(0xc6, 0xd8, 0x3b, 0x6a, 0x56, 0x40, 0x8a, 0x35, 0x6e, 0x68, 0xd0, 0x49, 0x4d, 0x4e, 0xff, 0x15, 0x05, 0x30, 0xb0, 0x95, 0x51, 0xd0, 0x08, 0x37, 0x3d, 0x6d, 0xee, 0x2b, 0x8d, 0x6b, 0x56, 0x19, 0xd6, 0x7f, 0xdb),
-      //   cipher_text: vec!(0xa1, 0x54, 0x43, 0xf0, 0x83, 0x31, 0x6e, 0xef, 0x62, 0x7a, 0x37, 0x1f, 0x4c, 0x9a, 0xc6, 0x54, 0xd0, 0xdd, 0x75, 0x25, 0x5d, 0x8a, 0x30, 0x31, 0x25, 0xe9, 0xf5, 0x1a, 0xf4, 0x23, 0x3f, 0xf4, 0xce, 0xb7, 0xfe),
-      //   tag: vec!(0x52, 0x50, 0x4e, 0x88, 0x0f, 0x67, 0x92, 0xa6, 0x07, 0x08, 0xcc, 0x6d, 0xb7, 0x2e, 0xae, 0x42)
-      // },
-      // TestVector{
-      //   key: [0x5e, 0x8d, 0x0e, 0x5f, 0x14, 0x67, 0xf7, 0xa7, 0x50, 0xc5, 0x51, 0x44, 0xd0, 0xc6, 0x70, 0xf7, 0xd9, 0x10, 0x75, 0xf3, 0x86, 0x79, 0x5b, 0x23, 0x0c, 0x9b, 0xf1, 0xc0, 0x4b, 0xa2, 0x50, 0xbc],
-      //   nonce: [0x88, 0x04, 0x9f, 0x44, 0xba, 0x61, 0xb8, 0x8f],
-      //   plain_text: vec!(0x51, 0xa1, 0xee, 0xbc, 0xc3, 0x48, 0xe0, 0x58, 0x21, 0x96, 0xa0, 0xbc, 0xe1, 0x6e, 0xd1, 0xf8, 0xac, 0x2e, 0x91, 0xc3, 0xe8, 0xa6, 0x90, 0xe0, 0x4a, 0x9f, 0x4b, 0x5c, 0xf6, 0x33, 0x13, 0xd7, 0xad, 0x08, 0xd1, 0xef, 0xbf, 0xf8, 0x5c, 0x89),
-      //   aad: vec!(0x5d, 0x09, 0xbf, 0x0b, 0xe9, 0x00, 0x26, 0xf9, 0xfc, 0x51, 0xf7, 0x34, 0x18, 0xd6, 0xd8, 0x64, 0xb6, 0xd1, 0x97, 0xea, 0x03, 0x0b, 0x3d, 0xe0, 0x72, 0xbd, 0x2c, 0x2f, 0x5c, 0xab, 0x58, 0x60, 0xa3, 0x42, 0xab, 0xbd, 0x29, 0xdb, 0xa9, 0xdc),
-      //   cipher_text: vec!(0x35, 0xaa, 0x4b, 0xd4, 0x53, 0x7a, 0xa6, 0x11, 0xfd, 0x75, 0x78, 0xfc, 0x22, 0x7d, 0xf5, 0x0e, 0xbc, 0xb0, 0x0c, 0x69, 0x2a, 0x1c, 0xf6, 0xf0, 0x2e, 0x50, 0xed, 0x92, 0x70, 0xbd, 0x93, 0xaf, 0x3b, 0xc6, 0x8f, 0x4c, 0x75, 0xb9, 0x66, 0x38),
-      //   tag: vec!(0xcc, 0xea, 0x1c, 0xbb, 0xc8, 0x39, 0x44, 0xcc, 0x66, 0xdf, 0x4d, 0xbf, 0x6f, 0xb7, 0xfc, 0x46)
-      // },
-      // TestVector{
-      //   key: [0x21, 0xa9, 0xf0, 0x7e, 0xc8, 0x91, 0xd4, 0x88, 0x80, 0x5e, 0x9b, 0x92, 0xbb, 0x1b, 0x22, 0x86, 0xf3, 0xf0, 0x41, 0x0c, 0x32, 0x3b, 0x07, 0xfe, 0xe1, 0xdc, 0x6f, 0x73, 0x79, 0xe2, 0x2e, 0x48],
-      //   nonce: [0x06, 0x62, 0x15, 0xbe, 0x65, 0x67, 0x37, 0x7a],
-      //   plain_text: vec!(0xc1, 0xb0, 0xaf, 0xfa, 0xf2, 0xb8, 0xd7, 0xef, 0x51, 0xcc, 0xa9, 0xaa, 0xcf, 0x79, 0x69, 0xf9, 0x2f, 0x92, 0x8c, 0x2e, 0x3c, 0xc7, 0xdb, 0x2e, 0x15, 0xf4, 0x7e, 0xe1, 0xf6, 0x50, 0x23, 0x91, 0x0d, 0x09, 0xf2, 0x09, 0xd0, 0x07, 0xb7, 0x43, 0x6e, 0xe8, 0x98, 0x13, 0x3d),
-      //   aad: vec!(0xdf, 0xdf, 0xdf, 0x4d, 0x3a, 0x68, 0xb4, 0x7a, 0xd0, 0xd4, 0x88, 0x28, 0xdc, 0x17, 0xb2, 0x58, 0x5d, 0xa9, 0xc8, 0x1c, 0x3a, 0x8d, 0x71, 0xd8, 0x26, 0xb5, 0xfa, 0x80, 0x20, 0xfe, 0xe0, 0x02, 0x39, 0x7e, 0x91, 0xfc, 0x96, 0x58, 0xe9, 0xd6, 0x1d, 0x72, 0x8b, 0x93, 0xeb),
-      //   cipher_text: vec!(0x8f, 0xf4, 0xce, 0xb6, 0x00, 0xe7, 0xd4, 0x56, 0x96, 0xd0, 0x24, 0x67, 0xf8, 0xe3, 0x0d, 0xf0, 0xd3, 0x38, 0x64, 0xa0, 0x40, 0xa4, 0x1f, 0xfb, 0x9e, 0x4c, 0x2d, 0xa0, 0x9b, 0x92, 0xe8, 0x8b, 0x6f, 0x6b, 0x85, 0x0e, 0x9f, 0x72, 0x58, 0xd8, 0x27, 0xb9, 0xaa, 0xf3, 0x46),
-      //   tag: vec!(0x4e, 0xed, 0xdc, 0x99, 0x78, 0x40, 0x11, 0xf0, 0x75, 0x8b, 0xa5, 0xeb, 0xfb, 0xa6, 0x18, 0x27)
-      // },
-      // TestVector{
-      //   key: [0x54, 0xc9, 0x3d, 0xb9, 0xaa, 0x0e, 0x00, 0xd1, 0x0b, 0x45, 0x04, 0x1c, 0x7a, 0x7e, 0x41, 0xee, 0x9f, 0x90, 0xab, 0x78, 0xae, 0x4c, 0x1b, 0xba, 0x18, 0xd6, 0x73, 0xc3, 0xb3, 0x70, 0xab, 0xde],
-      //   nonce: [0x3f, 0x2d, 0x44, 0xe7, 0xb3, 0x52, 0x36, 0x0f],
-      //   plain_text: vec!(0x12, 0x41, 0xe7, 0xd6, 0xfb, 0xe5, 0xee, 0xf5, 0xd8, 0xaf, 0x9c, 0x2f, 0xb8, 0xb5, 0x16, 0xe0, 0xf1, 0xdd, 0x49, 0xaa, 0x4e, 0xbe, 0x54, 0x91, 0x20, 0x51, 0x94, 0xfe, 0x5a, 0xea, 0x37, 0x04, 0xef, 0xaf, 0x30, 0xd3, 0x92, 0xf4, 0x4c, 0xc9, 0x9e, 0x09, 0x25, 0xb8, 0x44, 0x60, 0xd4, 0x87, 0x33, 0x44),
-      //   aad: vec!(0xf1, 0xd1, 0xb0, 0x8d, 0xd6, 0xfe, 0x96, 0xc4, 0x65, 0x78, 0xc1, 0xd1, 0xad, 0x38, 0x88, 0x18, 0x40, 0xb1, 0x0c, 0xb5, 0xea, 0xe4, 0x1e, 0x5f, 0x05, 0xfe, 0x52, 0x87, 0x22, 0x3f, 0xa7, 0x22, 0x42, 0xae, 0xa4, 0x8c, 0xb3, 0x74, 0xa8, 0x0b, 0xe9, 0x37, 0xb5, 0x41, 0xf9, 0x38, 0x1e, 0xfa, 0x66, 0xbb),
-      //   cipher_text: vec!(0x02, 0x7b, 0x86, 0x86, 0x5b, 0x80, 0xb4, 0xc4, 0xda, 0x82, 0x3a, 0x7d, 0x3d, 0xbc, 0xf5, 0x84, 0x5b, 0xf5, 0x7d, 0x58, 0xee, 0x33, 0x4e, 0xb3, 0x57, 0xe8, 0x23, 0x69, 0xcc, 0x62, 0x89, 0x79, 0xe2, 0x94, 0x78, 0x30, 0xd9, 0xd4, 0x81, 0x7e, 0xfd, 0x3d, 0x0b, 0xc4, 0x77, 0x9f, 0x0b, 0x38, 0x89, 0x43),
-      //   tag: vec!(0x43, 0x03, 0xfa, 0x01, 0x74, 0xac, 0x2b, 0x99, 0x16, 0xbf, 0x89, 0xc5, 0x93, 0xba, 0xee, 0x37)
-      // },
-      // TestVector{
-      //   key: [0x80, 0x8e, 0x0e, 0x73, 0xe9, 0xbc, 0xd2, 0x74, 0xd4, 0xc6, 0xf6, 0x5d, 0xf2, 0xfe, 0x95, 0x78, 0x22, 0xa6, 0x02, 0xf0, 0x39, 0xd4, 0x75, 0x26, 0x16, 0xba, 0x29, 0xa2, 0x89, 0x26, 0xef, 0x4a],
-      //   nonce: [0x1b, 0x9c, 0xd7, 0x3d, 0x2f, 0xc3, 0xcb, 0x8e],
-      //   plain_text: vec!(0x34, 0x36, 0xc7, 0xb5, 0xbe, 0x23, 0x94, 0xaf, 0x7e, 0x88, 0x32, 0x0c, 0x82, 0x32, 0x6a, 0x6d, 0xb3, 0x78, 0x87, 0xff, 0x9d, 0xe4, 0x19, 0x61, 0xc7, 0xd6, 0x54, 0xdd, 0x22, 0xdd, 0x1f, 0x7d, 0x40, 0x44, 0x4d, 0x48, 0xf5, 0xc6, 0x63, 0xb8, 0x6f, 0xf4, 0x1f, 0x3e, 0x15, 0xb5, 0xc8, 0xca, 0x13, 0x37, 0xf9, 0x76, 0x35, 0x85, 0x8f),
-      //   aad: vec!(0xd5, 0x7c, 0xfb, 0xe5, 0xf2, 0x53, 0x80, 0x44, 0x28, 0x2e, 0x53, 0xb2, 0xf0, 0xbb, 0x4e, 0x86, 0xea, 0x22, 0x33, 0x04, 0x1f, 0xb3, 0x6a, 0xdb, 0x83, 0x38, 0xde, 0xd0, 0x92, 0x14, 0x8f, 0x8c, 0x2e, 0x89, 0x4e, 0xf8, 0x76, 0x6a, 0x7e, 0xc2, 0xdd, 0x02, 0xc6, 0xac, 0x5d, 0xba, 0xb0, 0xc3, 0x70, 0x3c, 0x5e, 0x91, 0x19, 0xe3, 0x7c),
-      //   cipher_text: vec!(0x9b, 0x95, 0x0b, 0x3c, 0xaf, 0x7d, 0x25, 0xea, 0xf5, 0xfc, 0xa6, 0xfa, 0x3f, 0xe1, 0x2e, 0xd0, 0x77, 0xd8, 0x0d, 0xcd, 0x55, 0x79, 0x85, 0x12, 0x33, 0xc7, 0x66, 0xbb, 0x8b, 0xb6, 0x13, 0xec, 0x91, 0xd9, 0x25, 0xa9, 0x39, 0xbb, 0x52, 0xfb, 0x88, 0xd5, 0xed, 0xa8, 0x03, 0xcf, 0xe2, 0xa8, 0xcd, 0xa2, 0xe0, 0x55, 0xb9, 0x62, 0xfd),
-      //   tag: vec!(0x6b, 0xf5, 0xb7, 0x18, 0xf5, 0xbb, 0xe1, 0x39, 0x5a, 0x5f, 0xdf, 0xcb, 0xbe, 0xf7, 0x52, 0xf5)
-      // },
-      // TestVector{
-      //   key: [0x4a, 0xdf, 0xe1, 0xa2, 0x6c, 0x56, 0x36, 0x53, 0x6c, 0xd7, 0xcb, 0x72, 0xaa, 0x5b, 0xde, 0xd0, 0xb1, 0xaa, 0x64, 0x48, 0x7a, 0xd0, 0xe4, 0x07, 0x8f, 0x31, 0x1e, 0x87, 0x82, 0x76, 0x8e, 0x97],
-      //   nonce: [0xd6, 0x9e, 0x54, 0xba, 0xde, 0xc1, 0x15, 0x60],
-      //   plain_text: vec!(0x19, 0xb3, 0xf9, 0x41, 0x1c, 0xe8, 0x75, 0xfc, 0xb6, 0x84, 0xcb, 0xdc, 0x07, 0x93, 0x8c, 0x4c, 0x13, 0x47, 0xe1, 0x64, 0xf9, 0x64, 0x0d, 0x37, 0xb2, 0x2f, 0x97, 0x5b, 0x4b, 0x9a, 0x37, 0x3c, 0x43, 0x02, 0xae, 0x0e, 0x7d, 0xfd, 0xeb, 0xa1, 0xe0, 0xd0, 0x0c, 0xed, 0x44, 0x6e, 0x33, 0x8f, 0x4c, 0x5b, 0xc0, 0x1b, 0x4b, 0xec, 0xef, 0x51, 0x15, 0x82, 0x52, 0x76),
-      //   aad: vec!(0xbd, 0xa1, 0xb0, 0xf6, 0xc2, 0xf4, 0xeb, 0x81, 0x21, 0xdc, 0xbd, 0x2e, 0xeb, 0xd9, 0x1a, 0x03, 0xae, 0x1d, 0x6e, 0x05, 0x23, 0xb9, 0xb6, 0xf3, 0x4b, 0x6f, 0x16, 0xce, 0xca, 0x0d, 0x08, 0x66, 0x54, 0xfb, 0x05, 0x52, 0xbf, 0xd5, 0xc8, 0xe1, 0x88, 0x77, 0x30, 0xe1, 0x44, 0x9e, 0xa0, 0x2d, 0x7f, 0x64, 0x7a, 0xe8, 0x35, 0xbc, 0x2d, 0xab, 0x4b, 0xbc, 0x65, 0xb9),
-      //   cipher_text: vec!(0xea, 0x76, 0x5a, 0x82, 0x9d, 0x96, 0x1e, 0x08, 0xba, 0xca, 0xed, 0x80, 0x12, 0x37, 0xef, 0x40, 0x67, 0xdf, 0x38, 0xad, 0x37, 0x37, 0xb7, 0xc6, 0xde, 0x4d, 0xb5, 0x87, 0xa1, 0x02, 0xa8, 0x6f, 0xc4, 0xab, 0xba, 0xab, 0xea, 0x0e, 0xe9, 0x7c, 0x95, 0xca, 0x7f, 0x57, 0x1c, 0x7b, 0xab, 0x6f, 0x38, 0xcb, 0xae, 0x60, 0xcd, 0x6e, 0x6a, 0x4c, 0xe3, 0xc7, 0xa3, 0x20),
-      //   tag: vec!(0xb4, 0x25, 0xcd, 0xf1, 0x0c, 0xd0, 0x12, 0x3a, 0x7e, 0x64, 0xb3, 0x47, 0xc6, 0xb4, 0xb1, 0xf0)
-      // },
-      // TestVector{
-      //   key: [0xeb, 0x3d, 0xb8, 0x6c, 0x14, 0xb7, 0xcc, 0x2e, 0x49, 0x43, 0x45, 0xd0, 0xdf, 0xb4, 0x84, 0x1b, 0xbd, 0x3a, 0xa1, 0xe2, 0xbc, 0x64, 0x0c, 0xca, 0x0c, 0x6c, 0x40, 0x55, 0x20, 0x68, 0x56, 0x39],
-      //   nonce: [0x88, 0xb5, 0x4b, 0x28, 0xd6, 0xda, 0x8c, 0x81],
-      //   plain_text: vec!(0xf7, 0x5c, 0x0a, 0x35, 0x72, 0x71, 0x43, 0x0b, 0x1e, 0xcf, 0xf0, 0x7a, 0x30, 0x7b, 0x6c, 0x29, 0x32, 0x5c, 0x6e, 0x66, 0x93, 0x50, 0x46, 0x70, 0x4a, 0x19, 0x84, 0x5e, 0x62, 0x9f, 0x87, 0xa9, 0xe3, 0xb8, 0xaa, 0x6c, 0x1d, 0xf5, 0x5d, 0xd4, 0x26, 0xa4, 0x87, 0xd5, 0x33, 0xbb, 0x33, 0x3e, 0x46, 0xf0, 0xd3, 0x41, 0x84, 0x64, 0xac, 0x1b, 0xef, 0x05, 0x92, 0x31, 0xf8, 0xe8, 0x7e, 0x62, 0x84),
-      //   aad: vec!(0x34, 0xb0, 0x8b, 0xb0, 0xdf, 0x82, 0x1c, 0x57, 0x3d, 0xcb, 0x56, 0xf5, 0xb8, 0xb4, 0xa9, 0x92, 0x04, 0x65, 0x06, 0x7f, 0x3b, 0x5b, 0xf3, 0xe3, 0x25, 0x4e, 0xa1, 0xda, 0x1a, 0x7f, 0xc9, 0x84, 0x7f, 0xd3, 0x8b, 0xdf, 0xe6, 0xb3, 0x09, 0x27, 0x94, 0x52, 0x63, 0xa9, 0x1f, 0xa2, 0x88, 0xc7, 0xcf, 0x1b, 0xee, 0x0f, 0xdd, 0xb0, 0xfa, 0xdf, 0x59, 0x48, 0xc5, 0xd8, 0x3e, 0xb4, 0x62, 0x35, 0x75),
-      //   cipher_text: vec!(0x14, 0x6e, 0xc8, 0x4f, 0x5d, 0xc1, 0xc9, 0xfe, 0x9d, 0xe3, 0x30, 0x7a, 0x91, 0x82, 0xdb, 0xaa, 0x75, 0x96, 0x5b, 0xf8, 0x5f, 0x5e, 0x64, 0x56, 0x3e, 0x68, 0xd0, 0x39, 0xa5, 0xb6, 0x59, 0xaa, 0x88, 0x63, 0xb8, 0x92, 0x28, 0xed, 0xb9, 0x3f, 0xf3, 0xd8, 0xc3, 0x32, 0x3a, 0xb0, 0xd0, 0x33, 0x00, 0x47, 0x6a, 0xa4, 0xac, 0xa2, 0x06, 0xd4, 0x62, 0x6a, 0x6b, 0x26, 0x9b, 0x20, 0x78, 0x91, 0x2d),
-      //   tag: vec!(0x00, 0x58, 0xa8, 0xdf, 0xf3, 0x2c, 0x29, 0x93, 0x5c, 0x62, 0x21, 0x0c, 0x35, 0x9b, 0xd2, 0x81)
-      // },
-      // TestVector{
-      //   key: [0xdd, 0x5b, 0x49, 0xb5, 0x95, 0x3e, 0x04, 0xd9, 0x26, 0xd6, 0x64, 0xda, 0x3b, 0x65, 0xeb, 0xcf, 0xfb, 0xbf, 0x06, 0xab, 0xbe, 0x93, 0xa3, 0x81, 0x9d, 0xfc, 0x1a, 0xbb, 0xec, 0xba, 0xab, 0x13],
-      //   nonce: [0xc5, 0xc8, 0x00, 0x94, 0x59, 0xb9, 0xe3, 0x1a],
-      //   plain_text: vec!(0xf2, 0x1f, 0x67, 0x06, 0xa4, 0xdc, 0x33, 0xa3, 0x61, 0x36, 0x2c, 0x21, 0x4d, 0xef, 0xd5, 0x6d, 0x35, 0x3b, 0xcb, 0x29, 0x81, 0x1e, 0x58, 0x19, 0xab, 0x3c, 0x5c, 0x2c, 0x13, 0x95, 0x0c, 0x7a, 0xa0, 0x00, 0x0b, 0x9d, 0x1f, 0xe6, 0x9b, 0xb4, 0x64, 0x54, 0x51, 0x4d, 0xcc, 0xe8, 0x8a, 0x4a, 0x5e, 0xda, 0x09, 0x7c, 0x28, 0x1b, 0x81, 0xe5, 0x1d, 0x6a, 0x4d, 0xba, 0x47, 0xc8, 0x03, 0x26, 0xba, 0x6c, 0xea, 0x8e, 0x2b, 0xab),
-      //   aad: vec!(0xfe, 0x6f, 0x4c, 0xbb, 0x00, 0x79, 0x4a, 0xde, 0xa5, 0x9e, 0x9d, 0xe8, 0xb0, 0x3c, 0x7f, 0xdf, 0x48, 0x2e, 0x46, 0xf6, 0xc4, 0x7a, 0x35, 0xf9, 0x69, 0x97, 0x66, 0x9c, 0x73, 0x5e, 0xd5, 0xe7, 0x29, 0xa4, 0x94, 0x16, 0xb4, 0x24, 0x68, 0x77, 0x7e, 0x6a, 0x8d, 0x7a, 0xa1, 0x73, 0xc1, 0x8b, 0x81, 0x77, 0x41, 0x8d, 0xed, 0x60, 0x01, 0x24, 0xa9, 0x8c, 0xbb, 0x65, 0x48, 0x9f, 0x9c, 0x24, 0xa0, 0x4f, 0x1e, 0x71, 0x27, 0xce),
-      //   cipher_text: vec!(0x91, 0x1e, 0xad, 0x61, 0xb2, 0xaa, 0x81, 0xd0, 0x0c, 0x5e, 0xff, 0x53, 0xae, 0xea, 0x3a, 0xb7, 0x13, 0x70, 0x9e, 0xd5, 0x71, 0x76, 0x58, 0x90, 0xd5, 0x58, 0xfb, 0x59, 0xd3, 0x99, 0x3b, 0x45, 0xf5, 0x98, 0xa3, 0x9e, 0x5e, 0xff, 0x4b, 0xe8, 0x44, 0xc4, 0xd4, 0xbd, 0x1e, 0xf9, 0x62, 0x2e, 0x60, 0x41, 0x2b, 0x21, 0x14, 0x00, 0x07, 0xd5, 0x4d, 0xcf, 0x31, 0xb2, 0xc0, 0xe3, 0xe9, 0x8c, 0xf3, 0x3a, 0x00, 0xfd, 0x27, 0xf0),
-      //   tag: vec!(0xd3, 0x8d, 0x67, 0x26, 0x65, 0xe2, 0xc8, 0xc4, 0xa0, 0x79, 0x54, 0xb1, 0x0e, 0xcf, 0xf7, 0xd9)
-      // },
-      // TestVector{
-      //   key: [0x3b, 0x31, 0x9e, 0x40, 0x14, 0x8a, 0x67, 0xdc, 0x0b, 0xb1, 0x92, 0x71, 0xd9, 0x27, 0x2b, 0x32, 0x7b, 0xc5, 0xee, 0xe0, 0x87, 0x17, 0x3d, 0x3d, 0x13, 0x4a, 0xd5, 0x6c, 0x8c, 0x7d, 0xc0, 0x20],
-      //   nonce: [0xce, 0x5c, 0xf6, 0xfe, 0xf8, 0x4d, 0x00, 0x10],
-      //   plain_text: vec!(0x27, 0xb5, 0x62, 0x7b, 0x17, 0xa2, 0xde, 0x31, 0xad, 0x00, 0xfc, 0x2e, 0xcb, 0x34, 0x7d, 0xa0, 0xa3, 0x99, 0xbb, 0x75, 0xcc, 0x6e, 0xad, 0xd4, 0xd6, 0xee, 0x02, 0xde, 0x8f, 0xbd, 0x6a, 0x21, 0x68, 0xd4, 0x76, 0x3b, 0xa9, 0x36, 0x8b, 0xa9, 0x82, 0xe9, 0x7a, 0x2d, 0xb8, 0x12, 0x6d, 0xf0, 0x34, 0x3c, 0xda, 0xd0, 0x6d, 0x2b, 0xc7, 0xd7, 0xe1, 0x2e, 0xec, 0x73, 0x1d, 0x13, 0x0f, 0x8b, 0x87, 0x45, 0xc1, 0x95, 0x4b, 0xfd, 0x1d, 0x71, 0x7b, 0x4e, 0xa2),
-      //   aad: vec!(0xa0, 0x26, 0xb6, 0x63, 0x8f, 0x29, 0x39, 0xec, 0x9c, 0xc2, 0x8d, 0x93, 0x5f, 0xb7, 0x11, 0x31, 0x57, 0xf3, 0xb5, 0xb7, 0xe2, 0x6c, 0x12, 0xf8, 0xf2, 0x5b, 0x36, 0x41, 0x2b, 0x0c, 0xd5, 0x60, 0xb7, 0xf1, 0x1b, 0x62, 0x78, 0x8a, 0x76, 0xbd, 0x17, 0x13, 0x42, 0xe2, 0xae, 0x85, 0x8b, 0xce, 0xcb, 0x82, 0x66, 0xff, 0x84, 0x82, 0xbb, 0xae, 0xd5, 0x93, 0xaf, 0xe8, 0x18, 0xb9, 0x82, 0x9e, 0x05, 0xe8, 0xe2, 0xb2, 0x81, 0xae, 0x77, 0x99, 0x58, 0x01, 0x42),
-      //   cipher_text: vec!(0x36, 0x8f, 0xb6, 0x98, 0x92, 0x44, 0x7b, 0x75, 0x77, 0x8f, 0x1c, 0x52, 0x36, 0xe1, 0xe9, 0xd5, 0xd8, 0x92, 0x55, 0xc3, 0xd6, 0x8d, 0x56, 0x5a, 0x5b, 0xba, 0x4f, 0x52, 0x4d, 0x6a, 0xd2, 0x7d, 0xe1, 0x30, 0x87, 0xf3, 0x01, 0xe2, 0xef, 0x4c, 0x08, 0xf5, 0xe2, 0xc6, 0x12, 0x8b, 0x1d, 0x3e, 0x26, 0xde, 0x84, 0x5c, 0x4a, 0xc4, 0x86, 0x9e, 0x4c, 0x8b, 0xd8, 0x85, 0x8a, 0xd0, 0xd2, 0x6d, 0xec, 0x3b, 0x5d, 0x61, 0xa9, 0xe3, 0x66, 0x6a, 0x39, 0x11, 0xba),
-      //   tag: vec!(0x2e, 0x70, 0x56, 0x4c, 0x39, 0x99, 0xc4, 0x48, 0xd9, 0x2c, 0xc6, 0xdf, 0x29, 0xd0, 0x95, 0xc4)
-      // },
-      // TestVector{
-      //   key: [0x43, 0xbf, 0x97, 0x40, 0x7a, 0x82, 0xd0, 0xf6, 0x84, 0xbb, 0x85, 0x34, 0x23, 0x80, 0xd6, 0x6b, 0x85, 0xfc, 0xc8, 0x1c, 0x3e, 0x22, 0xf1, 0xc0, 0xd9, 0x72, 0xcd, 0x5b, 0xfd, 0xf4, 0x07, 0xf4],
-      //   nonce: [0x8b, 0x6b, 0xa4, 0x94, 0xc5, 0x40, 0xfb, 0xa4],
-      //   plain_text: vec!(0x4b, 0x4c, 0x7e, 0x29, 0x2a, 0x35, 0x7f, 0x56, 0xfd, 0xf5, 0x67, 0xc3, 0x2f, 0xc0, 0xf3, 0x36, 0x08, 0x11, 0x0d, 0x7c, 0xe5, 0xc6, 0x91, 0x12, 0x98, 0x7d, 0x7b, 0x5a, 0x0b, 0xd4, 0x6d, 0x86, 0x27, 0xa7, 0x21, 0xb0, 0xae, 0xd0, 0x70, 0xb5, 0x4e, 0xa9, 0x72, 0x60, 0x84, 0x18, 0x8c, 0x51, 0x8c, 0xba, 0x82, 0x9f, 0x39, 0x20, 0x36, 0x5a, 0xfc, 0x93, 0x82, 0xc6, 0xa5, 0xeb, 0x0d, 0xd3, 0x32, 0xb8, 0x46, 0x12, 0x36, 0x67, 0x35, 0xbe, 0x24, 0x79, 0xb6, 0x3c, 0x9e, 0xfc, 0x7f, 0xf5),
-      //   aad: vec!(0x1e, 0x0a, 0xcf, 0x40, 0x70, 0xe8, 0xd6, 0x75, 0x8b, 0x60, 0xd8, 0x1b, 0x6d, 0x28, 0x9a, 0x4e, 0xcd, 0xc3, 0x0e, 0x3d, 0xe4, 0xf9, 0x09, 0x0c, 0x13, 0x69, 0x1d, 0x5b, 0x93, 0xd5, 0xbb, 0xce, 0xf9, 0x84, 0xf9, 0x09, 0x56, 0xde, 0x53, 0xc5, 0xcf, 0x44, 0xbe, 0x6c, 0x70, 0x44, 0x06, 0x61, 0xfa, 0x58, 0xe6, 0x5d, 0xec, 0x27, 0x34, 0xff, 0x51, 0xd6, 0xd0, 0x3f, 0x57, 0xbd, 0xdd, 0xa1, 0xf4, 0x78, 0x07, 0x24, 0x7e, 0x31, 0x94, 0xe2, 0xf7, 0xdd, 0xd5, 0xf3, 0xca, 0xfd, 0x25, 0x0f),
-      //   cipher_text: vec!(0xd0, 0x07, 0x6c, 0x88, 0xad, 0x4b, 0xc1, 0x2d, 0x77, 0xeb, 0x8a, 0xe8, 0xd9, 0xb5, 0xbf, 0x3a, 0x2c, 0x58, 0x88, 0xa8, 0xd4, 0xc1, 0x52, 0x97, 0xb3, 0x8e, 0xce, 0x5d, 0x64, 0xf6, 0x73, 0x19, 0x1d, 0xc8, 0x15, 0x47, 0x24, 0x0a, 0x0c, 0xbe, 0x06, 0x6c, 0x9c, 0x56, 0x3f, 0x5c, 0x34, 0x24, 0x80, 0x99, 0x71, 0xb5, 0xa0, 0x7d, 0xcc, 0x70, 0xb1, 0x07, 0x30, 0x55, 0x61, 0xce, 0x85, 0xae, 0xcb, 0x0b, 0x0e, 0xa0, 0xe8, 0xb4, 0xff, 0x4d, 0x1e, 0x4f, 0x84, 0x83, 0x69, 0x55, 0xa9, 0x45),
-      //   tag: vec!(0x75, 0xc9, 0x34, 0x74, 0x25, 0xb4, 0x59, 0xaf, 0x6d, 0x99, 0xb1, 0x73, 0x45, 0xc6, 0x1f, 0xf7)
-      // },
-      // TestVector{
-      //   key: [0x12, 0xfc, 0x0b, 0xc9, 0x41, 0x04, 0xed, 0x81, 0x50, 0xbd, 0xe1, 0xe5, 0x68, 0x56, 0xce, 0x3c, 0x57, 0xcd, 0x1c, 0xf6, 0x33, 0x95, 0x4d, 0x22, 0x55, 0x21, 0x40, 0xe1, 0xf4, 0xe7, 0xc6, 0x5d],
-      //   nonce: [0xd3, 0x87, 0x5d, 0x1b, 0x6c, 0x80, 0x83, 0x53],
-      //   plain_text: vec!(0x24, 0x59, 0x20, 0x82, 0xd6, 0xe7, 0x3e, 0xb6, 0x5c, 0x40, 0x9b, 0x26, 0xce, 0xae, 0x03, 0x2e, 0x57, 0xf6, 0x87, 0x75, 0x14, 0x94, 0x7f, 0xc4, 0x5e, 0xb0, 0x07, 0xb8, 0xa6, 0x03, 0x44, 0x94, 0xdd, 0xe5, 0x56, 0x3a, 0xc5, 0x86, 0xea, 0x08, 0x1d, 0xc1, 0x2f, 0xa6, 0xcd, 0xa3, 0x22, 0x66, 0xbe, 0x85, 0x8e, 0x47, 0x48, 0xbe, 0x40, 0xbb, 0x20, 0xf7, 0x13, 0x20, 0x71, 0x1b, 0xf8, 0x4c, 0x3f, 0x0e, 0x27, 0x83, 0xa6, 0x3a, 0xd6, 0xe2, 0x5a, 0x63, 0xb4, 0x4c, 0x37, 0x3a, 0x99, 0xaf, 0x84, 0x5c, 0xdf, 0x45, 0x2c),
-      //   aad: vec!(0xb8, 0xbe, 0x08, 0x46, 0x3e, 0x84, 0xa9, 0x09, 0xd0, 0x71, 0xf5, 0xff, 0x87, 0x21, 0x33, 0x91, 0xb7, 0xda, 0x88, 0x9d, 0xc5, 0x6f, 0xd2, 0xf1, 0xe3, 0xcf, 0x86, 0xa0, 0xa0, 0x3e, 0x2c, 0x8e, 0xaa, 0x2f, 0x53, 0x9b, 0xf7, 0x3f, 0x90, 0xf5, 0x29, 0x8c, 0x26, 0xf2, 0x7e, 0xf4, 0xa6, 0x73, 0xa1, 0x27, 0x84, 0x83, 0x3a, 0xcb, 0x4d, 0x08, 0x61, 0x56, 0x21, 0x42, 0xc9, 0x74, 0xee, 0x37, 0xb0, 0x9a, 0xe7, 0x70, 0x8a, 0x19, 0xf1, 0x4d, 0x1a, 0xd8, 0xc4, 0x02, 0xbd, 0x1e, 0xcf, 0x5e, 0xa2, 0x80, 0xfa, 0xb2, 0x80),
-      //   cipher_text: vec!(0x9d, 0x9a, 0xe6, 0x32, 0x87, 0x11, 0xfb, 0x89, 0x7a, 0x88, 0x46, 0x2d, 0x20, 0xb8, 0xaa, 0x1b, 0x27, 0x81, 0x34, 0xcd, 0xf7, 0xb2, 0x3e, 0x1f, 0x1c, 0x80, 0x9f, 0xa4, 0x08, 0xb6, 0x8a, 0x7b, 0xfc, 0x2b, 0xe6, 0x1a, 0x79, 0x00, 0x08, 0xed, 0xaa, 0x98, 0x82, 0x33, 0x81, 0xf4, 0x5a, 0xe6, 0x5f, 0x71, 0x04, 0x26, 0x89, 0xd8, 0x8a, 0xcf, 0xa5, 0xf6, 0x33, 0x32, 0xf0, 0xfb, 0xa7, 0x37, 0xc4, 0x77, 0x2c, 0x97, 0x2e, 0xba, 0x26, 0x66, 0x40, 0x05, 0x64, 0x52, 0x90, 0x3d, 0x65, 0x22, 0xce, 0xfd, 0x3f, 0x26, 0x4e),
-      //   tag: vec!(0xe9, 0xc9, 0x82, 0xd4, 0xad, 0xe7, 0x39, 0x7b, 0xcf, 0xaa, 0x1e, 0x4c, 0x5a, 0x6c, 0xd5, 0x78)
-      // },
-      // TestVector{
-      //   key: [0x7b, 0x63, 0x00, 0xf7, 0xdc, 0x21, 0xc9, 0xfd, 0xde, 0xaa, 0x71, 0xf4, 0x39, 0xd5, 0x3b, 0x55, 0x3a, 0x7b, 0xf3, 0xe6, 0x9f, 0xf5, 0x15, 0xb5, 0xcb, 0x64, 0x95, 0xd6, 0x52, 0xa0, 0xf9, 0x9c],
-      //   nonce: [0x40, 0xb3, 0x2e, 0x3f, 0xdc, 0x64, 0x64, 0x53],
-      //   plain_text: vec!(0x57, 0x2f, 0x60, 0xd9, 0x8c, 0x8b, 0xec, 0xc8, 0xba, 0x80, 0xdd, 0x6b, 0x8d, 0x2d, 0x0f, 0x7b, 0x7b, 0xbf, 0xd7, 0xe4, 0xab, 0xc2, 0x35, 0xf3, 0x74, 0xab, 0xd4, 0x4d, 0x90, 0x35, 0xc7, 0x65, 0x0a, 0x79, 0xd1, 0xdd, 0x54, 0x5f, 0xa2, 0xf6, 0xfb, 0x0b, 0x5e, 0xba, 0x27, 0x17, 0x79, 0x91, 0x3e, 0x5c, 0x5e, 0xb4, 0x50, 0x52, 0x8e, 0x41, 0x28, 0x90, 0x9a, 0x96, 0xd1, 0x1a, 0x65, 0x2b, 0xf3, 0xf7, 0xae, 0x9d, 0x0d, 0x17, 0xad, 0xbf, 0x61, 0x2e, 0xc9, 0xca, 0x32, 0xe7, 0x3e, 0xf6, 0xe8, 0x7d, 0x7f, 0x4e, 0x21, 0xfe, 0x34, 0x12, 0xce, 0x14),
-      //   aad: vec!(0x9f, 0xf3, 0x77, 0x54, 0x5a, 0x35, 0xcf, 0x1b, 0xfb, 0x77, 0xc7, 0x34, 0xad, 0x90, 0x0c, 0x70, 0x3a, 0xee, 0x6c, 0x31, 0x74, 0xfd, 0xb3, 0x73, 0x66, 0x64, 0x86, 0x30, 0x36, 0xa3, 0xa9, 0xd0, 0x91, 0x63, 0xc2, 0x99, 0x2f, 0x09, 0x3e, 0x24, 0x08, 0x91, 0x1b, 0x87, 0x51, 0xf0, 0x01, 0xe4, 0x93, 0xde, 0xcc, 0x41, 0xe4, 0xee, 0xee, 0xd0, 0x4f, 0x69, 0x8b, 0x6d, 0xae, 0xd4, 0x84, 0x52, 0xa7, 0xe1, 0xa7, 0x4e, 0xc3, 0xb4, 0xf3, 0xdc, 0xf2, 0x15, 0x1c, 0xa2, 0x49, 0xfa, 0x56, 0x8a, 0xa0, 0x84, 0xc8, 0x42, 0x8a, 0x41, 0xf2, 0x0b, 0xe5, 0xfd),
-      //   cipher_text: vec!(0x22, 0x9d, 0xa7, 0x68, 0x44, 0x42, 0x66, 0x39, 0xe2, 0xfd, 0x3e, 0xf2, 0x53, 0xa1, 0x95, 0xe0, 0xa9, 0x3f, 0x08, 0x45, 0x2b, 0xa3, 0x72, 0x19, 0xb6, 0x77, 0x3f, 0x10, 0x31, 0x34, 0xf3, 0xf8, 0x7b, 0x13, 0x45, 0xf9, 0xb4, 0xbf, 0x8c, 0xfc, 0x11, 0x27, 0x7c, 0x31, 0x17, 0x80, 0xa2, 0xb6, 0xe1, 0x9a, 0x36, 0x3b, 0x6a, 0xc2, 0xef, 0xe6, 0xc4, 0xcc, 0x54, 0xa3, 0x9b, 0x14, 0x4e, 0x29, 0xc9, 0x4b, 0x9e, 0xbb, 0xde, 0x6f, 0xd0, 0x94, 0xc3, 0x0f, 0x59, 0xd1, 0xb7, 0x70, 0xeb, 0xf9, 0xfc, 0xad, 0x2a, 0x5c, 0x69, 0x5d, 0xc0, 0x03, 0xbf, 0x51),
-      //   tag: vec!(0xb7, 0x2a, 0xca, 0xb5, 0x01, 0x31, 0xa2, 0x95, 0x58, 0xd5, 0x6a, 0xe7, 0xb9, 0xd4, 0x8e, 0x4e)
-      // },
-      // TestVector{
-      //   key: [0x4a, 0xeb, 0x62, 0xf0, 0x24, 0xe1, 0x87, 0x60, 0x6e, 0xe7, 0xcc, 0x9f, 0x58, 0x65, 0xc3, 0x91, 0xc4, 0x3d, 0xf1, 0x96, 0x3f, 0x45, 0x9c, 0x87, 0xba, 0x00, 0xe4, 0x4b, 0xb1, 0x63, 0xa8, 0x66],
-      //   nonce: [0x95, 0x59, 0xbd, 0x08, 0x71, 0x8b, 0x75, 0xaf],
-      //   plain_text: vec!(0xc5, 0xd5, 0x86, 0xce, 0xec, 0xe6, 0xf4, 0x18, 0x12, 0xc9, 0x69, 0xbc, 0xf1, 0xe7, 0x27, 0xfe, 0x6f, 0xf8, 0xd1, 0xae, 0x8c, 0x8c, 0x52, 0x36, 0x7c, 0x61, 0x2c, 0xaa, 0x7c, 0xdf, 0x50, 0xe0, 0x66, 0x2f, 0x5d, 0xff, 0xc5, 0xea, 0x7d, 0x3c, 0xc3, 0x94, 0x00, 0xdf, 0xe3, 0xdc, 0x18, 0x97, 0x90, 0x5f, 0x64, 0x90, 0xfd, 0x77, 0x47, 0xb5, 0xf5, 0xf9, 0x84, 0x27, 0x39, 0xc6, 0x7d, 0x07, 0xce, 0x7c, 0x33, 0x9a, 0x5b, 0x39, 0x97, 0xa7, 0xfb, 0x4c, 0xd0, 0xd8, 0xe4, 0x81, 0x7f, 0xf8, 0x91, 0x6b, 0x25, 0x1c, 0x11, 0xef, 0x91, 0x91, 0x67, 0xf8, 0x58, 0xe4, 0x15, 0x04, 0xb9),
-      //   aad: vec!(0x51, 0xf5, 0xb5, 0x03, 0xb7, 0x3a, 0x5d, 0xe8, 0xb9, 0x65, 0x34, 0xc2, 0xa3, 0xf2, 0xd8, 0x59, 0xec, 0xe0, 0xbd, 0x06, 0x3e, 0xa6, 0xdf, 0xa4, 0x86, 0xa7, 0xee, 0xc9, 0x9f, 0x6c, 0x02, 0x09, 0x83, 0xf7, 0x14, 0x8c, 0xcc, 0xb8, 0x62, 0x02, 0xcf, 0x96, 0x85, 0xcc, 0x1c, 0xc2, 0x66, 0x93, 0x0f, 0x04, 0xe5, 0x36, 0xad, 0x8b, 0xc2, 0x60, 0x94, 0x25, 0x2b, 0xaa, 0x46, 0x06, 0xd8, 0x83, 0xbd, 0x2a, 0xee, 0xd6, 0xb4, 0x30, 0x15, 0x22, 0x02, 0xe9, 0xb6, 0xcc, 0x79, 0x7f, 0xf2, 0x4f, 0xc3, 0x65, 0x31, 0x5e, 0xd6, 0x73, 0x91, 0x37, 0x4c, 0x13, 0x57, 0xc9, 0xa8, 0x45, 0xf2),
-      //   cipher_text: vec!(0x25, 0x2e, 0xa4, 0x2b, 0x6e, 0x57, 0x40, 0x30, 0x68, 0x16, 0x97, 0x4a, 0x4f, 0xe6, 0x7b, 0x66, 0xe7, 0x93, 0xeb, 0xe0, 0x91, 0x47, 0x78, 0xef, 0x48, 0x5d, 0x55, 0x28, 0x8e, 0xb6, 0xc9, 0xc4, 0x5f, 0xa3, 0x4a, 0xc8, 0x53, 0xdc, 0x7a, 0x39, 0x25, 0x25, 0x20, 0x51, 0x4c, 0x3c, 0xb3, 0x4c, 0x72, 0xb9, 0x73, 0xb1, 0x4b, 0x32, 0xbc, 0x25, 0x76, 0x87, 0xd3, 0x98, 0xf3, 0x6f, 0x64, 0xcc, 0x2a, 0x66, 0x8f, 0xaf, 0xfa, 0x73, 0x05, 0xab, 0x24, 0x01, 0x71, 0x34, 0x3b, 0x5f, 0x9f, 0x49, 0xb6, 0xc2, 0x19, 0x7e, 0x4f, 0xbe, 0x18, 0x7b, 0x10, 0x54, 0x0d, 0x7c, 0xdc, 0xfa, 0x37),
-      //   tag: vec!(0x71, 0x1f, 0xf3, 0x3e, 0xf8, 0xd2, 0xb0, 0x67, 0xa1, 0xb8, 0x5c, 0x64, 0xf3, 0x2f, 0x18, 0x14)
-      // },
-      // TestVector{
-      //   key: [0x9a, 0x19, 0xe7, 0x2f, 0x00, 0x5c, 0xae, 0x1a, 0xe7, 0x8b, 0x8e, 0x35, 0x0d, 0x7a, 0xab, 0xe5, 0x9f, 0xc8, 0x84, 0x59, 0x99, 0xe8, 0xc5, 0x2f, 0xad, 0x54, 0x5b, 0x94, 0x2c, 0x22, 0x5e, 0xaf],
-      //   nonce: [0xd9, 0xda, 0xe2, 0xea, 0x8d, 0x2f, 0xfc, 0x31],
-      //   plain_text: vec!(0x21, 0x10, 0x37, 0x8d, 0x85, 0x6d, 0xed, 0x07, 0xeb, 0x2b, 0xe8, 0xe8, 0xf4, 0x33, 0x08, 0xe0, 0xc7, 0x5b, 0xc8, 0xa3, 0xfc, 0xc7, 0xb1, 0x77, 0x3b, 0x07, 0x25, 0xb7, 0xde, 0x49, 0xf6, 0xa1, 0x66, 0xc4, 0x52, 0x8e, 0x64, 0x12, 0x0b, 0xdf, 0x7c, 0x97, 0x76, 0x61, 0x5d, 0x3c, 0xe6, 0xfe, 0xeb, 0x03, 0xde, 0x96, 0x4a, 0x7b, 0x91, 0x92, 0x06, 0xa7, 0x73, 0x92, 0xf8, 0x04, 0x37, 0xfa, 0xce, 0xb6, 0x74, 0x58, 0x45, 0xca, 0xfc, 0x16, 0x6e, 0x1c, 0x13, 0xb6, 0x8e, 0x70, 0xca, 0x2a, 0x1d, 0x00, 0xc7, 0x17, 0x37, 0xb8, 0xfc, 0xbb, 0xbd, 0x50, 0x90, 0x25, 0x65, 0xc3, 0x21, 0x59, 0xe0, 0x5f, 0xcd, 0x23),
-      //   aad: vec!(0x1c, 0xd7, 0x3b, 0x72, 0xc4, 0xe1, 0x03, 0xaf, 0xbe, 0xfd, 0x7c, 0x77, 0x7e, 0x04, 0x80, 0xf3, 0xf5, 0xe6, 0x8c, 0x60, 0xb8, 0x5b, 0xd2, 0xe7, 0x1e, 0xf5, 0xca, 0xeb, 0xb1, 0x75, 0xd7, 0xfc, 0x65, 0x35, 0xd3, 0x9f, 0x38, 0xf9, 0x2c, 0x24, 0xf2, 0xeb, 0x0f, 0xe9, 0x7d, 0x87, 0x8e, 0xd3, 0xd5, 0x96, 0x7c, 0x0b, 0xb4, 0x39, 0x4a, 0x5d, 0x41, 0xf7, 0xd3, 0x4c, 0xda, 0x6e, 0x15, 0x23, 0xd3, 0x84, 0x8f, 0x04, 0x9c, 0xde, 0x55, 0x4a, 0x7d, 0x31, 0xe1, 0xaf, 0xea, 0xb5, 0xd3, 0xe6, 0x15, 0x0f, 0x85, 0x85, 0x83, 0x35, 0xcb, 0xd2, 0x8c, 0x8a, 0x7f, 0x87, 0xd5, 0x28, 0x05, 0x8d, 0xf5, 0x0e, 0xea, 0x06),
-      //   cipher_text: vec!(0x5f, 0x00, 0x9f, 0xbc, 0xe4, 0xec, 0x8e, 0x4c, 0xa9, 0xd8, 0xd4, 0x22, 0x58, 0xb1, 0xa3, 0xe4, 0xe9, 0x20, 0xb2, 0xfb, 0xad, 0x33, 0xd5, 0xe9, 0xf0, 0x75, 0x57, 0xd9, 0x59, 0x5e, 0x84, 0x10, 0x25, 0x19, 0x3b, 0x52, 0x1b, 0xa4, 0x40, 0x11, 0x0d, 0xd8, 0x39, 0x58, 0xe8, 0xee, 0x30, 0x21, 0x9d, 0x95, 0x2b, 0x41, 0x8e, 0x98, 0xa6, 0xc6, 0x24, 0x89, 0x4a, 0xa2, 0x48, 0xae, 0xdc, 0x06, 0x78, 0xf2, 0xd2, 0x63, 0xe7, 0xbf, 0xaf, 0x54, 0xca, 0x37, 0x9f, 0xef, 0x6c, 0x5d, 0x2f, 0x7a, 0xc4, 0x22, 0xea, 0x4b, 0x43, 0x69, 0x40, 0x8b, 0x82, 0xd6, 0x22, 0x5a, 0x7a, 0x2c, 0xf9, 0xa9, 0xf4, 0x6f, 0xd4, 0xef),
-      //   tag: vec!(0xaa, 0x0a, 0x5f, 0xa7, 0xd3, 0xcf, 0x71, 0x7a, 0x47, 0x04, 0xa5, 0x99, 0x73, 0xb1, 0xcd, 0x15)
-      // },
-      // TestVector{
-      //   key: [0xba, 0x1d, 0x0b, 0x33, 0x29, 0xec, 0xc0, 0x09, 0xf1, 0xda, 0x0f, 0xab, 0x4c, 0x85, 0x4b, 0x00, 0xad, 0x94, 0x48, 0x70, 0xfd, 0xca, 0x56, 0x18, 0x38, 0xe3, 0x8b, 0xad, 0x36, 0x4d, 0xa5, 0x07],
-      //   nonce: [0x8a, 0x81, 0xc9, 0x2b, 0x37, 0x22, 0x1f, 0x2f],
-      //   plain_text: vec!(0x62, 0x89, 0x94, 0x4f, 0xfa, 0x3c, 0xce, 0xa4, 0xbf, 0x25, 0xcd, 0x60, 0x1b, 0x27, 0x1f, 0x64, 0xe6, 0xde, 0xb0, 0xeb, 0xa7, 0x7d, 0x65, 0xef, 0xb4, 0xd6, 0x9c, 0xa9, 0x3e, 0x01, 0x99, 0x6e, 0x47, 0x27, 0x16, 0x8b, 0x6f, 0x74, 0xf3, 0xcc, 0xf1, 0x7b, 0xd4, 0x47, 0x15, 0xf2, 0x3c, 0xeb, 0x8f, 0xc0, 0x30, 0xc0, 0xe0, 0x35, 0xe7, 0x7f, 0x53, 0x26, 0x3d, 0xb0, 0x25, 0x02, 0x1f, 0xd2, 0xd0, 0x4b, 0x87, 0xa1, 0xb5, 0x4b, 0x12, 0x22, 0x9c, 0x5e, 0x86, 0x04, 0x81, 0x45, 0x2a, 0x80, 0xa1, 0x25, 0xcb, 0x06, 0x93, 0xa2, 0xba, 0x1b, 0x47, 0xe2, 0x8e, 0xe7, 0xcb, 0xaf, 0x9e, 0x68, 0x3c, 0x17, 0x82, 0x32, 0xc7, 0xf6, 0xd3, 0x4f, 0x97),
-      //   aad: vec!(0xe5, 0x78, 0x83, 0x96, 0x1b, 0x8d, 0x04, 0x1d, 0x9b, 0x9e, 0xea, 0xdd, 0xcf, 0xd6, 0x1f, 0xa9, 0xf5, 0x92, 0x13, 0xf6, 0x65, 0x71, 0xfa, 0xdf, 0xff, 0xfd, 0xd1, 0x49, 0x8b, 0x9b, 0x01, 0x4f, 0x1e, 0xf2, 0xe7, 0xe5, 0x6c, 0x30, 0x44, 0xd7, 0xf9, 0xfa, 0x7a, 0x14, 0x03, 0xa1, 0x16, 0x9e, 0x86, 0x43, 0x0a, 0x2a, 0x78, 0x21, 0x37, 0x09, 0x3f, 0x54, 0x56, 0xe1, 0x42, 0xaa, 0xd0, 0x3a, 0x5f, 0x7a, 0x66, 0xd3, 0x80, 0x09, 0xdd, 0x01, 0xb7, 0xfc, 0x02, 0xc9, 0xcf, 0x61, 0x64, 0x2d, 0xed, 0xaf, 0x7c, 0xc8, 0xd4, 0x60, 0x66, 0xc2, 0x81, 0xee, 0x17, 0x78, 0x06, 0x74, 0xc3, 0xa3, 0x6e, 0xae, 0x66, 0xc5, 0x8d, 0x2d, 0x76, 0x50, 0x75),
-      //   cipher_text: vec!(0x9c, 0x44, 0xd9, 0x13, 0x5d, 0xb0, 0xdb, 0xf8, 0x1c, 0x86, 0x2c, 0x1f, 0x69, 0xbe, 0xc5, 0x5a, 0x27, 0x97, 0x94, 0xcd, 0xd2, 0x9a, 0x58, 0xe6, 0x19, 0x09, 0xaa, 0x29, 0xec, 0x4c, 0x12, 0x0c, 0x9c, 0x5a, 0x50, 0x8d, 0x85, 0x6b, 0x9e, 0x56, 0x13, 0x80, 0x95, 0x71, 0x4a, 0x4b, 0xb5, 0x84, 0x02, 0xa1, 0xad, 0x06, 0x77, 0x4c, 0xf4, 0xec, 0xdf, 0x22, 0x73, 0x83, 0x9c, 0x00, 0x07, 0xcb, 0x88, 0xb5, 0x44, 0x4b, 0x25, 0xc7, 0x6f, 0x6d, 0x24, 0x24, 0x28, 0x11, 0x01, 0xd0, 0x43, 0xfc, 0x63, 0x69, 0xeb, 0xb3, 0xb2, 0xff, 0x63, 0xcd, 0xb0, 0xf1, 0x1a, 0x6e, 0xa1, 0xb8, 0xa7, 0xda, 0xfc, 0x80, 0xcd, 0xae, 0xf2, 0x81, 0x3f, 0xa6, 0x61),
-      //   tag: vec!(0x65, 0xc7, 0x46, 0xf6, 0x59, 0xbc, 0xbd, 0xcd, 0x05, 0x4e, 0x76, 0x8c, 0x57, 0xc8, 0x48, 0xc9)
-      // },
-      // TestVector{
-      //   key: [0x0c, 0xf8, 0xc7, 0x3a, 0x6c, 0xff, 0xc1, 0xb8, 0xb2, 0xf5, 0xd3, 0x20, 0xda, 0x1d, 0x85, 0x9d, 0x31, 0x43, 0x74, 0xe4, 0xa9, 0x46, 0x8d, 0xb7, 0xfd, 0x42, 0xc8, 0xd2, 0x70, 0xb7, 0x61, 0x3a],
-      //   nonce: [0x3c, 0x4c, 0x6f, 0x02, 0x81, 0x84, 0x1a, 0xff],
-      //   plain_text: vec!(0x44, 0x34, 0x72, 0x8d, 0x23, 0x46, 0x03, 0xc9, 0x16, 0xe2, 0xfa, 0xa0, 0x6b, 0x25, 0xd8, 0x3b, 0xad, 0x33, 0x48, 0x99, 0x0e, 0xcd, 0xe2, 0x34, 0x43, 0x68, 0xd1, 0xa7, 0xaf, 0x13, 0x09, 0xbd, 0x04, 0x25, 0x1b, 0xb2, 0xe0, 0xb7, 0x20, 0x44, 0x94, 0x8f, 0x8d, 0xea, 0x33, 0xcc, 0xe2, 0x61, 0x82, 0x83, 0xb6, 0xaf, 0x74, 0x20, 0x73, 0xa9, 0x58, 0x6b, 0x26, 0xc1, 0x08, 0x93, 0x35, 0xfe, 0x73, 0x51, 0x41, 0xe0, 0x99, 0x78, 0x5a, 0x12, 0x35, 0x81, 0x0a, 0x3a, 0x67, 0xff, 0x30, 0x9e, 0x2f, 0x0c, 0xe6, 0x82, 0x20, 0xba, 0x00, 0x77, 0xad, 0x1a, 0x5d, 0xc1, 0xa4, 0xae, 0xf8, 0x98, 0xa3, 0xb9, 0xff, 0x8f, 0x5a, 0xd7, 0xfe, 0x60, 0x14, 0x9b, 0xd0, 0xbd, 0x6d, 0x83),
-      //   aad: vec!(0xa3, 0x8d, 0x09, 0xa4, 0xf1, 0xc9, 0x24, 0x16, 0x23, 0xc6, 0x39, 0xb7, 0x68, 0x8d, 0x8d, 0x35, 0x34, 0x5e, 0xa5, 0x82, 0x40, 0x80, 0xc9, 0xd7, 0x4e, 0x43, 0x52, 0x91, 0x9d, 0xb6, 0x3c, 0x74, 0xd3, 0x18, 0xf1, 0x9e, 0x1c, 0xbb, 0x9b, 0x14, 0xee, 0xbd, 0x7c, 0x74, 0xb0, 0xad, 0x01, 0x19, 0x24, 0x76, 0x51, 0x91, 0x1f, 0x35, 0x51, 0x58, 0x3e, 0x74, 0x9e, 0xa5, 0x0f, 0xf6, 0x48, 0x85, 0x8d, 0xca, 0xaa, 0x78, 0x9b, 0x74, 0x19, 0xd9, 0xe9, 0x3a, 0x5b, 0xf6, 0xc8, 0x16, 0x71, 0x88, 0xdb, 0xac, 0x2f, 0x36, 0x80, 0x43, 0x80, 0xdb, 0x32, 0x52, 0x01, 0x98, 0x2b, 0x8b, 0x06, 0x59, 0x7e, 0xfe, 0xb7, 0x68, 0x45, 0x46, 0xb2, 0x72, 0x64, 0x29, 0x41, 0x59, 0x1e, 0x92),
-      //   cipher_text: vec!(0xbd, 0xfb, 0xfe, 0xa2, 0x61, 0xb1, 0xf4, 0xc1, 0x34, 0x44, 0x53, 0x21, 0xdb, 0x9e, 0x6e, 0x40, 0x47, 0x6e, 0x2d, 0xd2, 0xf4, 0xe4, 0xdb, 0xe8, 0x6e, 0x31, 0xd6, 0xa1, 0x16, 0xd2, 0x58, 0x30, 0x76, 0x2e, 0x06, 0x5b, 0x07, 0xb1, 0x1a, 0x37, 0x99, 0xaa, 0xb9, 0x3a, 0x94, 0xb4, 0xf9, 0x8c, 0x31, 0xc0, 0xfa, 0xeb, 0x77, 0xec, 0x52, 0xc0, 0x20, 0x48, 0xe9, 0x57, 0x92, 0x57, 0xe6, 0x7f, 0x5a, 0x6b, 0xae, 0x9b, 0xc6, 0x52, 0x10, 0xc2, 0x5b, 0x37, 0xfc, 0x16, 0xee, 0x93, 0xbd, 0xa8, 0x8f, 0xd5, 0xf3, 0x0a, 0x53, 0x3e, 0x47, 0x0b, 0x61, 0x88, 0xc6, 0xce, 0x57, 0x39, 0xfa, 0x3e, 0x90, 0xf7, 0x71, 0x20, 0xb4, 0x90, 0xfc, 0x10, 0x27, 0x96, 0x4f, 0x27, 0x7f, 0x40),
-      //   tag: vec!(0x49, 0x93, 0xee, 0x95, 0x82, 0xf5, 0x8e, 0xab, 0xdb, 0x26, 0xb9, 0x8c, 0x4d, 0x56, 0xa2, 0x44)
-      // },
-      // TestVector{
-      //   key: [0x69, 0xf4, 0xe5, 0x78, 0x8d, 0x48, 0x6a, 0x75, 0xad, 0xf9, 0x20, 0x7d, 0xf1, 0xbd, 0x26, 0x2d, 0xd2, 0xfe, 0x3d, 0xd3, 0xa0, 0x23, 0x64, 0x20, 0x39, 0x0d, 0x16, 0xe2, 0xa3, 0x04, 0x04, 0x66],
-      //   nonce: [0x62, 0x55, 0xbf, 0x5c, 0x71, 0xbb, 0x27, 0xd1],
-      //   plain_text: vec!(0xc1, 0x50, 0x48, 0xca, 0x29, 0x41, 0xef, 0x96, 0x00, 0xe7, 0x67, 0xa5, 0x04, 0x5a, 0xa9, 0x8a, 0xc6, 0x15, 0x22, 0x5b, 0x80, 0x5a, 0x9f, 0xbd, 0xa3, 0xac, 0x63, 0x01, 0xcd, 0x5a, 0x66, 0xae, 0xf6, 0x11, 0x40, 0x0f, 0xa3, 0xbc, 0x04, 0x83, 0x8e, 0xad, 0x99, 0x24, 0xd3, 0x82, 0xbe, 0xf8, 0x25, 0x1a, 0x47, 0xf1, 0xe4, 0x87, 0xd2, 0xf3, 0xca, 0x4b, 0xcc, 0xd3, 0x47, 0x6a, 0x6c, 0xa7, 0xf1, 0x3e, 0x94, 0xfd, 0x63, 0x9a, 0x25, 0x9e, 0xf2, 0x3c, 0xc2, 0xf8, 0xb8, 0xd2, 0x48, 0xa4, 0x71, 0xd3, 0x0a, 0xc9, 0x21, 0x96, 0x31, 0xc3, 0xe6, 0x98, 0x51, 0x00, 0xdc, 0x45, 0xe0, 0xb5, 0x9b, 0x8f, 0xc6, 0x20, 0x46, 0x30, 0x91, 0x65, 0xdd, 0xb6, 0xf0, 0x92, 0xda, 0x3a, 0x4f, 0x06, 0x7c, 0x8a, 0x44),
-      //   aad: vec!(0x0c, 0x83, 0x03, 0x95, 0x04, 0xc8, 0x46, 0x4b, 0x49, 0xd6, 0x3b, 0x7f, 0x94, 0x48, 0x02, 0xf0, 0xd3, 0x9c, 0x85, 0xe9, 0xf3, 0x74, 0x5e, 0x25, 0x0f, 0x10, 0x11, 0x9f, 0xa2, 0xc9, 0x60, 0x49, 0x0f, 0x75, 0xae, 0x4d, 0xce, 0xd8, 0x50, 0x3b, 0x15, 0x6d, 0x07, 0x2a, 0x69, 0xf2, 0x04, 0x00, 0xe9, 0x49, 0x4a, 0xb2, 0xfa, 0x58, 0x44, 0x6c, 0x25, 0x5d, 0x82, 0xff, 0x0b, 0xe4, 0xb7, 0xe4, 0x30, 0x46, 0x58, 0x0b, 0xc1, 0xcf, 0x34, 0x06, 0x0c, 0x6f, 0x07, 0x6c, 0x72, 0xea, 0x45, 0x5c, 0x36, 0x87, 0x38, 0x1a, 0x3b, 0x90, 0x8e, 0x15, 0x2b, 0x10, 0xc9, 0x5c, 0x7b, 0x94, 0x15, 0x5b, 0x0b, 0x4b, 0x30, 0x3b, 0x77, 0x64, 0xa8, 0xa2, 0x7d, 0x1d, 0xb0, 0xa8, 0x85, 0xf1, 0x04, 0x0d, 0x5d, 0xbc, 0xc3),
-      //   cipher_text: vec!(0xf0, 0xbb, 0x2b, 0x73, 0xd9, 0x4f, 0x2a, 0x7c, 0xef, 0x70, 0xfe, 0x77, 0xe0, 0x54, 0xf2, 0x06, 0x99, 0x8e, 0xac, 0xf2, 0xb8, 0x6c, 0x05, 0xc4, 0xfa, 0x3f, 0x40, 0xf2, 0xb8, 0xce, 0xbf, 0x03, 0x4f, 0xe1, 0x7b, 0xcb, 0xee, 0x4d, 0xea, 0x82, 0x1f, 0x51, 0xc1, 0x8c, 0x0a, 0xa8, 0x5b, 0x16, 0x0f, 0x85, 0x08, 0xbd, 0x1d, 0xc4, 0x55, 0xcc, 0x7f, 0x49, 0x66, 0x8b, 0x1f, 0xb2, 0x55, 0x57, 0xcd, 0xae, 0x14, 0x7b, 0xf2, 0x39, 0x9e, 0x07, 0xfc, 0xac, 0xac, 0xa1, 0x8e, 0xcc, 0xde, 0xd7, 0x41, 0xe0, 0x26, 0xef, 0x25, 0x36, 0x5a, 0x6b, 0x0f, 0x44, 0xa6, 0xb3, 0xdd, 0x97, 0x5e, 0xe6, 0xbb, 0x58, 0x0f, 0x5f, 0xcc, 0xd0, 0x40, 0xb7, 0x3c, 0x18, 0xb0, 0xfb, 0xf8, 0xf6, 0x31, 0x99, 0xba, 0x10, 0xfe),
-      //   tag: vec!(0x42, 0x36, 0xa8, 0x75, 0x0f, 0x0c, 0xaf, 0xee, 0x3c, 0x4a, 0x06, 0xa5, 0x77, 0xa8, 0x5c, 0xb3)
-      // },
-      // TestVector{
-      //   key: [0xad, 0x7b, 0x94, 0x09, 0x14, 0x7a, 0x89, 0x66, 0x48, 0xa2, 0xa2, 0xfe, 0x21, 0x28, 0xf7, 0x90, 0x22, 0xa7, 0x0d, 0x96, 0xdc, 0x48, 0x27, 0x30, 0xcd, 0x85, 0xc7, 0x0d, 0xb4, 0x92, 0xb6, 0x38],
-      //   nonce: [0xa2, 0x8a, 0x6d, 0xed, 0xf3, 0xf2, 0xb0, 0x1a],
-      //   plain_text: vec!(0x79, 0x1d, 0x29, 0x3f, 0xf0, 0xa3, 0xb8, 0x51, 0x0b, 0x4d, 0x49, 0x4b, 0x30, 0xf5, 0x0b, 0x38, 0xa0, 0x16, 0x38, 0xbf, 0x13, 0x0e, 0x58, 0xc7, 0x60, 0x19, 0x04, 0xf1, 0x2c, 0xb8, 0x90, 0x08, 0x71, 0xe8, 0xcf, 0x3d, 0x50, 0xab, 0xd4, 0xd3, 0x4f, 0xda, 0x12, 0x2c, 0x76, 0xdf, 0xee, 0x5b, 0x7f, 0x82, 0xcd, 0x6e, 0x85, 0x90, 0x64, 0x75, 0x35, 0xc9, 0x15, 0xae, 0x08, 0x71, 0x4e, 0x42, 0x7d, 0xa5, 0x2f, 0x80, 0xae, 0xf0, 0x9f, 0x40, 0x04, 0x00, 0x36, 0x03, 0x4c, 0xa5, 0x27, 0x18, 0xea, 0x68, 0x31, 0x3c, 0x53, 0x4e, 0x7a, 0x04, 0x5c, 0xd5, 0x17, 0x45, 0xec, 0x52, 0xf2, 0xe1, 0xb5, 0x94, 0x63, 0xdb, 0x07, 0xde, 0x7c, 0xa4, 0x01, 0xc6, 0xf6, 0x45, 0x38, 0x41, 0xd2, 0x47, 0xf3, 0x70, 0x34, 0x1b, 0x2d, 0xbc, 0x12, 0x12),
-      //   aad: vec!(0x9a, 0x6d, 0xef, 0xdd, 0xb9, 0xb8, 0xd5, 0xc2, 0x4a, 0x26, 0xdd, 0x80, 0x96, 0xf5, 0xb8, 0xc3, 0xaf, 0x7a, 0x89, 0xe1, 0xf7, 0xd8, 0x86, 0xf5, 0x60, 0xfa, 0xbb, 0xe6, 0x4f, 0x14, 0xdb, 0x83, 0x8d, 0x6e, 0xb9, 0xd6, 0x87, 0x9f, 0x4f, 0x0b, 0x76, 0x9f, 0xe1, 0xf9, 0xee, 0xbf, 0x67, 0xfc, 0xd4, 0x7b, 0x6f, 0x9c, 0xeb, 0x48, 0x40, 0xb2, 0xdb, 0xa7, 0x58, 0x7e, 0x98, 0xdc, 0x5c, 0xae, 0x18, 0x6e, 0xf2, 0xa0, 0xf8, 0x60, 0x10, 0x60, 0xe8, 0x05, 0x8d, 0x9d, 0xda, 0x81, 0x2d, 0x91, 0x38, 0x7c, 0x58, 0x3d, 0xa7, 0x01, 0xd2, 0xba, 0x33, 0x47, 0xf2, 0x85, 0xc5, 0xd4, 0x43, 0x85, 0xa2, 0xb0, 0xbf, 0x07, 0x15, 0x0c, 0xbc, 0x95, 0xe7, 0xfc, 0xfa, 0x8a, 0xe0, 0x71, 0x32, 0x84, 0x9a, 0x02, 0x3c, 0x98, 0x81, 0x7c, 0x03, 0xd2),
-      //   cipher_text: vec!(0xc2, 0xf1, 0x09, 0xd6, 0xd9, 0x4f, 0x77, 0xa7, 0x28, 0x9c, 0x8a, 0x2a, 0xb3, 0x3b, 0xc6, 0xa9, 0x8d, 0x97, 0x65, 0x54, 0x72, 0x1b, 0x0c, 0x72, 0x6c, 0xbf, 0x41, 0x21, 0x06, 0x94, 0x73, 0xe6, 0x2b, 0xa3, 0x6e, 0x70, 0x90, 0xe0, 0x24, 0x14, 0xf3, 0xed, 0xc2, 0x5c, 0x5d, 0x83, 0xac, 0x80, 0xb4, 0x9a, 0xd5, 0x28, 0xcd, 0xa1, 0xe3, 0xad, 0x81, 0x5b, 0x5a, 0x8c, 0x8a, 0xe9, 0xad, 0x07, 0x53, 0xde, 0x72, 0x53, 0x19, 0xdf, 0x23, 0x69, 0x83, 0xab, 0xd3, 0xf6, 0x9a, 0xb4, 0x46, 0x5d, 0x9b, 0x80, 0x6c, 0x07, 0x5b, 0x18, 0x96, 0xd4, 0x0b, 0xdb, 0xa7, 0x2d, 0x73, 0xba, 0x84, 0xc4, 0xa5, 0x30, 0x89, 0x6e, 0xb9, 0x4f, 0xfc, 0xcf, 0x5f, 0xb6, 0x7e, 0xb5, 0x91, 0x19, 0xe6, 0x6a, 0x18, 0x61, 0x87, 0x22, 0x18, 0xf9, 0x28, 0xcf),
-      //   tag: vec!(0xe4, 0x8d, 0xc0, 0x15, 0x3d, 0x5b, 0x0f, 0x7e, 0xdb, 0x76, 0xfc, 0x97, 0xa0, 0x22, 0x49, 0x87)
-      // },
-      // TestVector{
-      //   key: [0x48, 0x47, 0x0d, 0xa9, 0x82, 0x28, 0xc9, 0xb5, 0x3f, 0x58, 0x74, 0x76, 0x73, 0x50, 0x4f, 0x74, 0xca, 0x17, 0x37, 0xd7, 0xd4, 0xbb, 0x6d, 0xbf, 0x7c, 0x0c, 0xba, 0x6c, 0xa4, 0x2f, 0x80, 0xb9],
-      //   nonce: [0x56, 0xfb, 0x49, 0x23, 0xa9, 0x7e, 0x93, 0x20],
-      //   plain_text: vec!(0xbc, 0x66, 0x26, 0xd6, 0x51, 0xe2, 0xb2, 0x37, 0xf2, 0x2e, 0xe5, 0x16, 0x08, 0xdd, 0xcf, 0xfe, 0xba, 0x5f, 0x31, 0xc2, 0x6d, 0xf7, 0x2f, 0x44, 0x3f, 0x70, 0x1f, 0x2b, 0x08, 0x5d, 0x6f, 0x34, 0xf8, 0x06, 0xe2, 0x96, 0x73, 0x58, 0x4c, 0xb2, 0x15, 0x22, 0x17, 0x9e, 0xdb, 0x62, 0xa8, 0x24, 0x27, 0xd9, 0x46, 0xac, 0xab, 0xce, 0x06, 0x5b, 0x88, 0xb2, 0x87, 0x8e, 0x9e, 0xb8, 0x7e, 0xd1, 0x00, 0x4e, 0x55, 0xef, 0x58, 0xf5, 0x1e, 0xc4, 0x63, 0x75, 0xac, 0x54, 0x2c, 0x57, 0x82, 0x72, 0x5f, 0xf0, 0x13, 0x13, 0x6c, 0xb5, 0x06, 0xfc, 0xf9, 0x94, 0x96, 0xe1, 0x3f, 0xcd, 0x22, 0x4b, 0x8a, 0x74, 0xa9, 0x71, 0xcc, 0x8d, 0xdb, 0x8b, 0x39, 0x3c, 0xcc, 0x6a, 0xc9, 0x10, 0xbd, 0x19, 0x06, 0xea, 0x9f, 0x2e, 0xd8, 0xa5, 0xd0, 0x66, 0xdc, 0x63, 0x9c, 0x20, 0xcd),
-      //   aad: vec!(0xdf, 0x8a, 0xb6, 0x34, 0xd3, 0xdc, 0xa1, 0x4e, 0x2e, 0x09, 0x1b, 0x15, 0xec, 0xc7, 0x8f, 0x91, 0xe2, 0x29, 0xa1, 0xa1, 0x3c, 0xba, 0x5e, 0xdd, 0x65, 0x26, 0xd1, 0x82, 0x52, 0x5e, 0xc5, 0x75, 0xaa, 0x45, 0xbc, 0x70, 0xfb, 0x61, 0x93, 0xff, 0xcd, 0x59, 0xba, 0xd3, 0xc3, 0x47, 0x15, 0x90, 0x99, 0xc4, 0xf1, 0x39, 0xc3, 0x23, 0xc3, 0x0a, 0x23, 0x07, 0x53, 0xd0, 0x70, 0x01, 0x87, 0x86, 0xb2, 0xe5, 0x9b, 0x75, 0x8d, 0xd4, 0xa9, 0x7d, 0x1a, 0x88, 0xe8, 0xf6, 0x72, 0x09, 0x2b, 0xef, 0x78, 0x0b, 0x45, 0x1f, 0xd6, 0x6b, 0xa7, 0x43, 0x1c, 0xbb, 0x56, 0x60, 0xea, 0x78, 0x16, 0xcd, 0xf2, 0x6e, 0x19, 0xa6, 0xeb, 0xb9, 0xaa, 0xdc, 0x30, 0x88, 0xe6, 0x92, 0x3f, 0x29, 0xf5, 0x3f, 0x87, 0x7a, 0x67, 0x58, 0x06, 0x8f, 0x79, 0xa6, 0xf2, 0xa1, 0x82, 0xb4, 0xbf),
-      //   cipher_text: vec!(0xa6, 0x2e, 0x31, 0x3e, 0xcf, 0x25, 0x8c, 0xc9, 0x08, 0x7c, 0xbb, 0x94, 0xfc, 0xc1, 0x26, 0x43, 0xeb, 0x72, 0x2d, 0x25, 0x5c, 0x3f, 0x98, 0xc3, 0x9f, 0x13, 0x0e, 0x10, 0x05, 0x8a, 0x37, 0x5f, 0x08, 0x09, 0x66, 0x24, 0x42, 0xc7, 0xb1, 0x80, 0x44, 0xfe, 0xb1, 0x60, 0x2d, 0x89, 0xbe, 0x40, 0xfa, 0xca, 0xe8, 0xe8, 0x9c, 0xa9, 0x67, 0x01, 0x5f, 0x0b, 0x7f, 0x8c, 0x2e, 0x4e, 0x4a, 0x38, 0x55, 0xdb, 0xb4, 0x6a, 0x06, 0x6e, 0x49, 0xab, 0xf9, 0xce, 0xf6, 0x7e, 0x60, 0x36, 0x40, 0x0c, 0x8f, 0xf4, 0x6b, 0x24, 0x1f, 0xc9, 0x9b, 0xa1, 0x97, 0x4b, 0xa3, 0xba, 0x6e, 0xa2, 0x0d, 0xc5, 0x2e, 0xc6, 0x75, 0x3f, 0x6f, 0xc7, 0x69, 0x7a, 0xdb, 0xcc, 0xd0, 0x2b, 0x0b, 0xbe, 0xa1, 0xdf, 0x83, 0x52, 0x62, 0x9b, 0x03, 0xb4, 0x3c, 0xc3, 0xd6, 0x32, 0x57, 0x67, 0x87),
-      //   tag: vec!(0x67, 0x52, 0x87, 0xf8, 0x14, 0x3b, 0x9b, 0x97, 0x6e, 0x50, 0xa8, 0x0f, 0x85, 0x31, 0xbd, 0x39)
-      // },
-      // TestVector{
-      //   key: [0xb6, 0x2f, 0xb8, 0x5c, 0x1d, 0xec, 0xd0, 0xfa, 0xf2, 0x42, 0xce, 0x66, 0x21, 0x40, 0xad, 0x1b, 0x82, 0x97, 0x5e, 0x99, 0xa3, 0xfa, 0x01, 0x66, 0x6c, 0xac, 0x23, 0x85, 0xab, 0x91, 0xda, 0x54],
-      //   nonce: [0x2f, 0x4a, 0x5c, 0xa0, 0x96, 0xa4, 0xfa, 0xf8],
-      //   plain_text: vec!(0x03, 0xb1, 0x4f, 0x13, 0xc0, 0x06, 0x5e, 0x4a, 0x44, 0x21, 0xde, 0x62, 0xab, 0x1d, 0x84, 0x2b, 0xff, 0xb8, 0x0f, 0x3d, 0xa3, 0x0b, 0xf4, 0x7d, 0x11, 0x5c, 0x09, 0x85, 0x7f, 0x5b, 0xdd, 0x57, 0x56, 0xfd, 0x7c, 0x9a, 0xc3, 0xd9, 0xaf, 0x1c, 0x9f, 0xb9, 0x4f, 0x26, 0x40, 0xf7, 0xf4, 0x38, 0x6c, 0xfb, 0xa7, 0x4d, 0xb4, 0x68, 0xe5, 0x28, 0x8d, 0xbe, 0x4d, 0xd7, 0x8b, 0xfe, 0x4f, 0x69, 0xe4, 0x14, 0x80, 0xca, 0x61, 0x38, 0xe8, 0xbe, 0xac, 0xc6, 0xea, 0xa3, 0x37, 0x41, 0x57, 0xc7, 0x13, 0xcf, 0xa9, 0x00, 0xc0, 0x7d, 0xd8, 0x36, 0xea, 0xec, 0xc8, 0x82, 0x7f, 0xa3, 0xe7, 0x0e, 0x05, 0x2a, 0xe0, 0x9e, 0x84, 0x73, 0xe2, 0xae, 0x1a, 0x10, 0xb1, 0xbb, 0x66, 0x9e, 0xf6, 0x0a, 0x8d, 0xd9, 0x57, 0xf6, 0x55, 0x3d, 0xaa, 0x81, 0x14, 0x91, 0x8e, 0x17, 0x37, 0x1f, 0x2a, 0xc3, 0x27, 0xbd),
-      //   aad: vec!(0xcf, 0xe3, 0xb7, 0xab, 0x75, 0x50, 0xb0, 0xe8, 0xe2, 0xe8, 0x23, 0x5f, 0xa0, 0xdc, 0xef, 0x95, 0x64, 0x7c, 0xe6, 0x81, 0x4a, 0xbd, 0x3d, 0xc3, 0xf5, 0xa3, 0xbd, 0x7d, 0x6d, 0x28, 0x25, 0x04, 0x66, 0x0c, 0x34, 0xad, 0x83, 0x41, 0xe4, 0xd1, 0x14, 0x02, 0xc7, 0xd4, 0x6c, 0x83, 0xa4, 0x94, 0xd7, 0xdd, 0xb1, 0x05, 0xe1, 0x00, 0x29, 0x79, 0x02, 0x3e, 0x0e, 0x3d, 0xc2, 0x97, 0x8c, 0x9a, 0xe5, 0x3e, 0x10, 0xeb, 0x85, 0x67, 0xe7, 0xa0, 0x2b, 0x60, 0xe5, 0x1e, 0x94, 0x5c, 0x70, 0x40, 0xd8, 0x32, 0xca, 0x90, 0x0d, 0x13, 0x2b, 0x42, 0x05, 0xa3, 0x50, 0x34, 0xfe, 0xd9, 0x39, 0xa1, 0xb7, 0x96, 0x51, 0x83, 0xc2, 0x56, 0x54, 0x93, 0x1a, 0x9b, 0x74, 0x44, 0x01, 0xc4, 0x64, 0x9c, 0x94, 0x57, 0x10, 0xb0, 0xd9, 0x73, 0x3b, 0x87, 0x45, 0x13, 0x48, 0xb3, 0x2b, 0xa8, 0x1d, 0xe3, 0x0e, 0xa7),
-      //   cipher_text: vec!(0x89, 0x65, 0xdb, 0x3d, 0x3a, 0xe4, 0xfb, 0x48, 0x32, 0x08, 0xf1, 0x47, 0x27, 0x6e, 0x7d, 0x81, 0xb7, 0x1a, 0x86, 0xe7, 0x20, 0x2f, 0xfc, 0x9b, 0x1e, 0xaa, 0xde, 0x00, 0x9b, 0xc0, 0x16, 0x83, 0x8d, 0xc0, 0x9c, 0xa4, 0xbc, 0xf3, 0x08, 0x87, 0xb2, 0xf4, 0x24, 0x3f, 0xbd, 0x65, 0x2c, 0xd9, 0x0e, 0xbe, 0xd1, 0xce, 0xef, 0x81, 0x51, 0xff, 0x17, 0xea, 0x70, 0x51, 0x8d, 0x03, 0xb0, 0xf2, 0xa2, 0x49, 0x60, 0xaa, 0x7d, 0xe9, 0xb3, 0x0f, 0xa6, 0x5c, 0x2e, 0x2d, 0x57, 0x36, 0x00, 0x61, 0xaa, 0xe6, 0xd9, 0x37, 0x6e, 0x98, 0x4e, 0x9f, 0xcd, 0x5e, 0x5d, 0xd0, 0x91, 0x1a, 0x4b, 0xc8, 0xde, 0xca, 0x83, 0x2f, 0xfb, 0x76, 0xf2, 0x52, 0xbd, 0x7d, 0xa5, 0x23, 0x07, 0x65, 0x93, 0xba, 0x6b, 0x17, 0x4f, 0x7d, 0x9f, 0xb0, 0x37, 0x7e, 0x06, 0x6e, 0xcb, 0xb6, 0x63, 0x80, 0x36, 0x24, 0x1e, 0x86),
-      //   tag: vec!(0x3d, 0x0f, 0xc5, 0x3e, 0x90, 0x58, 0xc2, 0xbe, 0x32, 0xaa, 0x08, 0x50, 0xe0, 0xfa, 0xb5, 0xa6)
-      // },
-      // TestVector{
-      //   key: [0xde, 0x9c, 0x65, 0x72, 0x58, 0x77, 0x4d, 0x4e, 0xbc, 0x09, 0xd1, 0x09, 0xa0, 0xfc, 0x79, 0xd6, 0x64, 0x93, 0xae, 0x57, 0x87, 0x97, 0xca, 0xc4, 0xeb, 0x88, 0x30, 0xa6, 0xa4, 0xb5, 0x47, 0xe0],
-      //   nonce: [0xb5, 0xe3, 0x5f, 0xe3, 0x39, 0x8e, 0xfa, 0x34],
-      //   plain_text: vec!(0x4d, 0x68, 0xfb, 0x68, 0x3a, 0xa4, 0xf4, 0xc7, 0xa1, 0x6b, 0xa1, 0x11, 0x4f, 0xc0, 0xb1, 0xb8, 0xd8, 0x89, 0x86, 0x10, 0xfa, 0x27, 0x63, 0xe4, 0x35, 0xde, 0xd8, 0x77, 0x1b, 0x36, 0x51, 0x07, 0x8b, 0xef, 0x73, 0xd4, 0xdf, 0xd1, 0x4e, 0x76, 0xa3, 0x4c, 0xd5, 0xeb, 0x9e, 0xf4, 0xdb, 0x4e, 0xad, 0x4d, 0xa9, 0xe8, 0x3f, 0x4c, 0xe5, 0x0f, 0xe0, 0x59, 0x97, 0x7b, 0x2d, 0x17, 0xd6, 0x87, 0xc2, 0x93, 0x35, 0xa0, 0x4d, 0x87, 0x38, 0x9d, 0x21, 0x1f, 0x82, 0x15, 0x44, 0x97, 0x49, 0x96, 0x9f, 0x76, 0x52, 0xdc, 0x19, 0x35, 0xa0, 0xf9, 0xa9, 0x45, 0x38, 0xdc, 0x81, 0xdc, 0x9a, 0x39, 0xaf, 0x63, 0x44, 0x6a, 0x65, 0x17, 0x60, 0x90, 0x76, 0x98, 0x79, 0x20, 0x54, 0x7d, 0x00, 0x98, 0xa9, 0xc6, 0x76, 0x6c, 0xf5, 0xe7, 0x04, 0x88, 0x3e, 0xa3, 0x2f, 0xea, 0xea, 0x18, 0x89, 0xb1, 0x55, 0x4b, 0x5e, 0xb0, 0xce, 0x5e, 0xcc),
-      //   aad: vec!(0x43, 0x6e, 0xa5, 0xa5, 0xfe, 0xe8, 0x29, 0x3b, 0x93, 0xe4, 0xe8, 0x48, 0x81, 0x16, 0xc9, 0x4d, 0x32, 0x69, 0xc1, 0x9f, 0x1d, 0x50, 0x50, 0xde, 0xf2, 0x3d, 0x28, 0x05, 0x15, 0x45, 0x7b, 0x93, 0x1b, 0xbe, 0xd6, 0x4a, 0x54, 0x2b, 0x31, 0x7c, 0xc5, 0x02, 0x3d, 0x64, 0x83, 0x30, 0xa4, 0xb7, 0xad, 0xca, 0x14, 0xdd, 0x6f, 0x37, 0x83, 0x20, 0x7b, 0x94, 0xf8, 0x6c, 0xca, 0xa0, 0xa0, 0xac, 0x39, 0xb7, 0xdb, 0x00, 0xac, 0x87, 0xa9, 0x9e, 0x3c, 0xd8, 0xa7, 0x64, 0xed, 0x9c, 0x75, 0xda, 0x84, 0x54, 0x47, 0x96, 0x36, 0xab, 0x2b, 0x29, 0xe7, 0x70, 0xb1, 0x66, 0xa5, 0xb7, 0x5c, 0xac, 0xc4, 0x25, 0xc9, 0x19, 0xbf, 0x1c, 0xe9, 0xac, 0x34, 0xaf, 0xe6, 0xb4, 0x42, 0x5c, 0x3d, 0x9f, 0xd2, 0xe4, 0x8b, 0xc8, 0x1e, 0x7d, 0x15, 0x51, 0x6d, 0x60, 0xe5, 0x92, 0xbf, 0xcc, 0x2e, 0xbe, 0xfb, 0x66, 0x0f, 0x09, 0x95, 0xf2, 0xb5),
-      //   cipher_text: vec!(0x97, 0xa9, 0x7b, 0x8f, 0x0f, 0x54, 0x20, 0x84, 0x5a, 0xe8, 0xd5, 0x75, 0x67, 0xf9, 0xbb, 0xa6, 0x93, 0xd3, 0x0e, 0x6d, 0xb9, 0x16, 0xfa, 0xd0, 0xb9, 0x71, 0xf5, 0x53, 0xad, 0x7d, 0x99, 0x3f, 0x80, 0x6f, 0x27, 0xab, 0x8b, 0x45, 0x8d, 0x80, 0x46, 0x06, 0x2c, 0xed, 0x47, 0x78, 0xc0, 0x04, 0xb4, 0xf9, 0x58, 0xa4, 0x43, 0x61, 0x41, 0x63, 0x7c, 0x60, 0x39, 0x96, 0x33, 0x08, 0xde, 0xa2, 0xf5, 0x40, 0x08, 0xb7, 0xfe, 0xab, 0x79, 0x65, 0x02, 0x95, 0xed, 0x41, 0xbf, 0x9e, 0x65, 0xe1, 0xa2, 0xd7, 0x5a, 0xb1, 0xc7, 0xb2, 0xa7, 0x0e, 0xbb, 0x9e, 0x9f, 0x38, 0xd0, 0x7a, 0x9a, 0x67, 0x2d, 0x3e, 0x95, 0xea, 0x78, 0xaf, 0xe9, 0xac, 0x02, 0xf2, 0x56, 0x6b, 0x48, 0xb0, 0x25, 0x1a, 0xef, 0x6e, 0xee, 0xca, 0x8b, 0xd1, 0x5b, 0xd8, 0xd4, 0x3b, 0x55, 0x94, 0x26, 0xaa, 0x9d, 0x15, 0xd9, 0x60, 0xee, 0x35, 0xcb, 0x3e, 0xdf),
-      //   tag: vec!(0xe5, 0x5d, 0xbb, 0x21, 0x85, 0x1e, 0x8a, 0x5b, 0x36, 0x5f, 0x86, 0xd0, 0x25, 0x18, 0x33, 0x1c)
-      // },
-      // TestVector{
-      //   key: [0x68, 0x85, 0xbd, 0x33, 0x3c, 0x33, 0x6c, 0x76, 0x72, 0xdb, 0x8e, 0xbd, 0xf2, 0x4c, 0x1a, 0x1b, 0x60, 0x5c, 0x5a, 0x4a, 0xe2, 0x79, 0xf0, 0xf6, 0x98, 0x16, 0x2f, 0x47, 0xe6, 0xc7, 0x34, 0x01],
-      //   nonce: [0xf0, 0xc4, 0xa2, 0x13, 0xa6, 0x16, 0x8a, 0xab],
-      //   plain_text: vec!(0xfa, 0x90, 0x5a, 0x2b, 0xfa, 0x5b, 0x5b, 0xad, 0x76, 0x72, 0x39, 0xfb, 0x07, 0x0a, 0x7b, 0xc0, 0xb3, 0x03, 0xd1, 0x50, 0x3e, 0xcd, 0x2b, 0x42, 0x94, 0x18, 0xcc, 0x8f, 0xeb, 0xa8, 0x43, 0xe5, 0x44, 0x4e, 0xd8, 0x90, 0x22, 0xfd, 0xb3, 0x79, 0xc3, 0xb1, 0x55, 0xa0, 0xf9, 0xce, 0xab, 0x29, 0x79, 0x00, 0x0a, 0x0f, 0x60, 0x29, 0x2a, 0x63, 0x17, 0x71, 0xf2, 0xfd, 0xe4, 0xef, 0x06, 0x5a, 0xa7, 0x46, 0x42, 0x66, 0x09, 0x08, 0x29, 0x69, 0x53, 0x0a, 0x9c, 0x70, 0xad, 0x14, 0x53, 0x08, 0xc3, 0x0b, 0xa3, 0x89, 0xea, 0x12, 0x2f, 0xd7, 0x66, 0x08, 0x15, 0x11, 0xa0, 0x31, 0xce, 0x3a, 0x0b, 0xd9, 0xf9, 0xf5, 0x83, 0xc7, 0x00, 0x0b, 0x33, 0x3b, 0x79, 0xac, 0x00, 0x4f, 0xbd, 0xe6, 0xec, 0x3e, 0xb2, 0xd9, 0x05, 0x97, 0x7f, 0xf9, 0x5d, 0xcf, 0xf7, 0x78, 0x58, 0xe3, 0xc4, 0x24, 0xfe, 0x89, 0x32, 0xa6, 0xa1, 0x21, 0x39, 0xe6, 0xec, 0x8d, 0x5e, 0x98),
-      //   aad: vec!(0x8d, 0xed, 0x36, 0x8f, 0x91, 0x9e, 0xfb, 0x52, 0x2b, 0xb6, 0xa9, 0xad, 0x00, 0x9e, 0x02, 0xff, 0xbc, 0x6a, 0x16, 0x53, 0x6e, 0x34, 0xd9, 0x5c, 0xdb, 0x34, 0xf1, 0x15, 0x3d, 0x7c, 0xb7, 0xb0, 0xf3, 0xc2, 0xb1, 0x3d, 0xd0, 0x5c, 0xed, 0xae, 0x27, 0xcf, 0xe6, 0x8e, 0xc3, 0xac, 0xa8, 0x04, 0x7e, 0x09, 0x30, 0xa2, 0x9c, 0x9d, 0x07, 0x70, 0xc1, 0xb8, 0x3c, 0x23, 0x4d, 0xcb, 0x03, 0x85, 0xde, 0xae, 0x7a, 0xe8, 0x5d, 0xa7, 0x3a, 0x5f, 0x8d, 0xe3, 0xdf, 0xb2, 0x86, 0x12, 0xa0, 0x01, 0xf4, 0xe5, 0x52, 0xc4, 0xf6, 0x7a, 0xe0, 0xe2, 0xec, 0x53, 0x85, 0x32, 0x89, 0xb7, 0x01, 0x7a, 0x58, 0x59, 0x1f, 0xd6, 0xf7, 0x0b, 0x0e, 0x95, 0x48, 0x76, 0xbb, 0x2f, 0x7e, 0xc3, 0x30, 0x01, 0xe2, 0x98, 0x85, 0x6a, 0x64, 0xbb, 0x16, 0x18, 0x10, 0x17, 0xba, 0x92, 0x46, 0x48, 0xc0, 0x9f, 0xc6, 0x3c, 0x62, 0xef, 0xf2, 0x62, 0xc8, 0x0d, 0x61, 0x46, 0x79, 0xbd),
-      //   cipher_text: vec!(0x0c, 0xb3, 0xd6, 0xc3, 0x1e, 0x0f, 0x40, 0x29, 0xec, 0xa5, 0x52, 0x4f, 0x95, 0x12, 0x44, 0xdf, 0x04, 0x2f, 0xc6, 0x37, 0xc4, 0x16, 0x25, 0x11, 0xfe, 0xa5, 0x12, 0xa5, 0x2d, 0x3f, 0x75, 0x81, 0xaf, 0x09, 0x7e, 0xb6, 0x42, 0xe7, 0x9e, 0x48, 0x66, 0x6c, 0xb1, 0x08, 0x6e, 0xdb, 0xd3, 0x8c, 0x47, 0x77, 0xc5, 0x35, 0xa2, 0x09, 0x45, 0xfa, 0xbc, 0x23, 0xe7, 0xc9, 0x27, 0x7e, 0x2b, 0x96, 0x0a, 0xac, 0x46, 0x86, 0x5f, 0x10, 0x26, 0xeb, 0x6d, 0xa8, 0x27, 0x59, 0x10, 0x8b, 0x9b, 0xae, 0xce, 0x5d, 0xa9, 0x30, 0xcc, 0xfc, 0x10, 0x52, 0xb1, 0x65, 0x6b, 0x0e, 0xad, 0xaa, 0x12, 0x0e, 0xd0, 0xc4, 0x5a, 0xd0, 0x4b, 0x24, 0xae, 0x8c, 0xdb, 0x22, 0xce, 0xab, 0x76, 0xc5, 0xf1, 0x80, 0xb4, 0x6a, 0x39, 0x2a, 0xb4, 0x5b, 0x1b, 0x99, 0xc6, 0x12, 0x54, 0x6e, 0x6b, 0x94, 0x7f, 0x4d, 0x5c, 0x06, 0xad, 0x5a, 0xbe, 0xe9, 0x2f, 0xf9, 0x63, 0x45, 0xad, 0x43),
-      //   tag: vec!(0xd3, 0xb5, 0x41, 0xac, 0x44, 0x6c, 0x84, 0x62, 0x6d, 0xaf, 0x80, 0x0c, 0x01, 0x72, 0xee, 0xc6)
-      // },
-      // TestVector{
-      //   key: [0xfb, 0xc9, 0x78, 0xab, 0xb1, 0x24, 0x0a, 0x69, 0x37, 0xcc, 0xc1, 0x67, 0x35, 0xb8, 0xd6, 0xed, 0x54, 0x11, 0xcd, 0xbc, 0x18, 0x97, 0x21, 0x41, 0x65, 0xa1, 0x74, 0xe1, 0x6f, 0x4e, 0x69, 0x9b],
-      //   nonce: [0x79, 0x68, 0x37, 0x9a, 0x8c, 0xe8, 0x81, 0x17],
-      //   plain_text: vec!(0x1a, 0x81, 0x96, 0xcd, 0x4a, 0x13, 0x89, 0xec, 0x91, 0x6e, 0xf8, 0xb7, 0xda, 0x50, 0x78, 0xa2, 0xaf, 0xa8, 0xe9, 0xf1, 0x08, 0x12, 0x23, 0xfa, 0x72, 0xf6, 0x52, 0x4a, 0xc0, 0xa1, 0xa8, 0x01, 0x9e, 0x44, 0xa0, 0x95, 0x63, 0xa9, 0x53, 0x61, 0x55, 0x87, 0x42, 0x92, 0x95, 0x05, 0x2c, 0xc9, 0x04, 0xb8, 0x9f, 0x77, 0x8e, 0xf4, 0x46, 0xed, 0x34, 0x14, 0x30, 0xd7, 0xd8, 0xf7, 0x47, 0xcf, 0x2d, 0xb4, 0x30, 0x84, 0x78, 0x52, 0x46, 0x39, 0xf4, 0x44, 0x57, 0x25, 0x3a, 0xe5, 0xa4, 0x45, 0x1c, 0x7e, 0xfc, 0xa8, 0xae, 0x0b, 0x6c, 0x5c, 0x05, 0x1a, 0xaa, 0x78, 0x1e, 0x9c, 0x50, 0x54, 0x89, 0xb3, 0x81, 0xa6, 0xdc, 0xba, 0x87, 0xb1, 0x57, 0xed, 0xc7, 0xf8, 0x20, 0xa8, 0xfb, 0xaf, 0x2a, 0x52, 0xe4, 0x84, 0xdc, 0x12, 0x1f, 0x33, 0xd9, 0xd8, 0xb9, 0xac, 0x59, 0xd4, 0x90, 0x1d, 0x6e, 0xd8, 0x99, 0x6e, 0xd4, 0xf6, 0x2d, 0x9d, 0x4d, 0x82, 0x27, 0x4c, 0x44, 0x9c, 0xd7, 0x4e, 0xfa),
-      //   aad: vec!(0x39, 0x13, 0xcd, 0x01, 0x29, 0x9b, 0x8a, 0x4e, 0x50, 0x7f, 0x06, 0x7d, 0x88, 0x7d, 0x7e, 0x9a, 0x6d, 0xed, 0x16, 0xdd, 0x9f, 0x9b, 0xb3, 0x11, 0x5c, 0x57, 0x79, 0xaa, 0x14, 0x23, 0x9f, 0xd3, 0x3e, 0xe9, 0xf2, 0x57, 0x56, 0xd4, 0x52, 0x62, 0xdc, 0x30, 0x11, 0x06, 0x93, 0x56, 0x42, 0x5b, 0x5c, 0x81, 0xa4, 0x72, 0x95, 0x94, 0xe1, 0x7c, 0x97, 0x47, 0x11, 0x9f, 0x81, 0x46, 0x3e, 0x85, 0x62, 0x5d, 0x56, 0x03, 0xd0, 0x5e, 0x00, 0xf5, 0x68, 0xb0, 0xc8, 0x00, 0xbb, 0x18, 0x1e, 0xb7, 0x17, 0xbe, 0x8d, 0x7a, 0x93, 0x16, 0x6a, 0x50, 0x4c, 0xe1, 0xbc, 0x81, 0x7e, 0x15, 0x53, 0x0c, 0x5b, 0xd2, 0xb3, 0xdf, 0x1d, 0x42, 0x22, 0x24, 0x5e, 0xa7, 0x8a, 0x38, 0xbc, 0x10, 0xf6, 0x6c, 0x5c, 0xf6, 0x8d, 0x66, 0x15, 0x03, 0x13, 0x1f, 0x11, 0xaf, 0x88, 0x5c, 0x8a, 0x91, 0x0b, 0x6d, 0xce, 0x70, 0xbc, 0x3a, 0x74, 0x48, 0xdf, 0xae, 0x00, 0x59, 0x5b, 0xeb, 0x70, 0x7f, 0xe0, 0x54, 0xd3),
-      //   cipher_text: vec!(0xd1, 0x52, 0xbc, 0xb4, 0xc2, 0x4c, 0x37, 0x11, 0xb0, 0xfa, 0xd2, 0x85, 0x48, 0xdc, 0x4d, 0xb6, 0x05, 0xbb, 0xc8, 0x92, 0x37, 0xcd, 0xbe, 0xa7, 0xdb, 0xf9, 0x56, 0xb8, 0x85, 0x5d, 0x11, 0x61, 0xa0, 0x78, 0x1f, 0x27, 0xbd, 0x56, 0xd7, 0x98, 0x14, 0x1e, 0x2a, 0xce, 0x33, 0x99, 0x55, 0xef, 0xb9, 0x8f, 0xe0, 0x5d, 0x9b, 0x44, 0xcd, 0x01, 0x1e, 0x64, 0x51, 0x06, 0xbf, 0x47, 0x72, 0x61, 0x83, 0x95, 0x8c, 0xb6, 0xdf, 0x34, 0xce, 0x57, 0x66, 0x69, 0x5f, 0x60, 0xbc, 0x70, 0xb6, 0xfe, 0x0f, 0xab, 0xb9, 0xaf, 0xa0, 0x09, 0xa8, 0xef, 0x04, 0x3d, 0xbf, 0x75, 0xf8, 0x61, 0x88, 0x13, 0x68, 0xfa, 0x07, 0x72, 0x66, 0x25, 0x44, 0x8f, 0xe6, 0x08, 0xd5, 0x78, 0xcd, 0xc4, 0x82, 0x77, 0xf2, 0xdc, 0x53, 0xea, 0xaf, 0x1b, 0xdc, 0x07, 0x52, 0x69, 0xa4, 0x2f, 0x93, 0x02, 0xa5, 0x7c, 0xad, 0x38, 0x7a, 0x82, 0xc6, 0x96, 0x96, 0x08, 0xac, 0xac, 0xda, 0x20, 0xe1, 0xca, 0xc4, 0x59, 0x6c),
-      //   tag: vec!(0x94, 0x5d, 0xca, 0x73, 0xcf, 0x2f, 0x00, 0x7a, 0xe2, 0x43, 0x99, 0x1c, 0x4f, 0xbe, 0x04, 0x79)
-      // },
-      // TestVector{
-      //   key: [0x77, 0xd1, 0xa8, 0x57, 0xfb, 0xad, 0xfe, 0x01, 0xab, 0xa7, 0x97, 0x4e, 0xea, 0x2d, 0xfb, 0x3d, 0xc7, 0xbf, 0x41, 0xde, 0x73, 0x68, 0x6a, 0xec, 0xe4, 0x03, 0x99, 0x3e, 0x50, 0x16, 0xc7, 0x14],
-      //   nonce: [0xfd, 0xd9, 0x13, 0xa3, 0x21, 0xc4, 0x0e, 0xb0],
-      //   plain_text: vec!(0xdb, 0x89, 0x15, 0xbf, 0xe6, 0x51, 0xe2, 0xec, 0xb3, 0xce, 0x0b, 0x27, 0xd9, 0x9a, 0x6b, 0xfa, 0x7a, 0x7c, 0x50, 0x7c, 0xfc, 0xb2, 0x98, 0x72, 0x93, 0x01, 0x86, 0x36, 0xc3, 0x65, 0xa4, 0x59, 0xc6, 0xa1, 0x38, 0xb4, 0x42, 0x8b, 0xe5, 0x38, 0x41, 0x3d, 0xb1, 0x5b, 0xda, 0x69, 0xe6, 0x97, 0xcb, 0xb9, 0x2b, 0x15, 0x4b, 0x7f, 0x4d, 0x2c, 0xbb, 0x07, 0x96, 0x52, 0x25, 0xaa, 0x68, 0x65, 0xd7, 0xdc, 0xd1, 0xba, 0x2c, 0x17, 0xc4, 0x84, 0xb0, 0x0b, 0x19, 0x86, 0xfe, 0xd6, 0x3e, 0x88, 0x9f, 0x25, 0xa4, 0x96, 0x6d, 0xc3, 0xed, 0x42, 0x73, 0xf1, 0x57, 0x77, 0x68, 0xf6, 0x65, 0x36, 0x2d, 0x7d, 0x3e, 0x82, 0x44, 0x84, 0xf0, 0xdd, 0xed, 0x7f, 0x82, 0xb8, 0xbe, 0x87, 0x97, 0xad, 0x95, 0x17, 0x19, 0x71, 0x93, 0x65, 0xe4, 0x5a, 0xbb, 0xf7, 0x63, 0x24, 0xbc, 0x7d, 0x65, 0x77, 0x99, 0xd4, 0xd4, 0xf4, 0xbb, 0x1d, 0xba, 0x67, 0xd9, 0x6a, 0xb1, 0xc8, 0x85, 0x19, 0xa5, 0xbe, 0xe7, 0x04, 0xf7, 0x21, 0x48, 0x14),
-      //   aad: vec!(0x3c, 0xb2, 0xc0, 0x6c, 0x20, 0xcb, 0x08, 0x32, 0xbb, 0xac, 0xeb, 0xfc, 0x20, 0x5d, 0x77, 0x39, 0x3c, 0xa1, 0x81, 0x63, 0x46, 0xea, 0x26, 0x81, 0xde, 0x4d, 0x3a, 0xb1, 0xfa, 0xdb, 0x77, 0x4a, 0xd2, 0x73, 0xe4, 0x71, 0x32, 0x90, 0x45, 0x44, 0x96, 0xf5, 0x28, 0x1e, 0xbc, 0x65, 0xe0, 0x4c, 0xfe, 0x84, 0xed, 0x37, 0xcd, 0x0a, 0xed, 0xc4, 0xbb, 0xe3, 0xde, 0xcb, 0xd8, 0xd7, 0x9d, 0x04, 0xa4, 0xe4, 0x34, 0x87, 0x66, 0x50, 0xe0, 0xd6, 0x43, 0x09, 0xe3, 0x36, 0xbf, 0xb1, 0x0e, 0x92, 0x40, 0x66, 0xa6, 0x4a, 0xcb, 0x92, 0x26, 0x0b, 0x2d, 0xbd, 0x96, 0x73, 0x5d, 0x03, 0xaf, 0x03, 0x90, 0x9a, 0xa6, 0xa8, 0x0a, 0x6e, 0x89, 0xfd, 0xa8, 0x10, 0x37, 0x25, 0x7a, 0xec, 0x21, 0xfe, 0x9b, 0xe7, 0xe9, 0x1a, 0x64, 0xe8, 0x8e, 0x0a, 0x58, 0xfa, 0x38, 0xec, 0xba, 0x4c, 0x4c, 0x4c, 0xff, 0xb6, 0x19, 0x58, 0xf3, 0xc4, 0x86, 0xcb, 0xb0, 0xb1, 0xd0, 0xb0, 0x01, 0x4a, 0x2d, 0x1d, 0x3d, 0xf2, 0x48, 0xee, 0xc1, 0xca),
-      //   cipher_text: vec!(0xac, 0xb8, 0x25, 0xe6, 0x02, 0x3b, 0x44, 0xb0, 0x3b, 0x2e, 0xfc, 0x26, 0x56, 0x03, 0xe8, 0x87, 0x95, 0x4e, 0x86, 0x12, 0xb2, 0xee, 0x13, 0x4b, 0xdc, 0xb6, 0x15, 0x01, 0xcf, 0xb9, 0x49, 0x29, 0x52, 0xbf, 0x67, 0xbe, 0x59, 0x7c, 0x3a, 0x00, 0x5b, 0x09, 0xaf, 0x74, 0xd9, 0xe4, 0x21, 0xa5, 0x76, 0xd2, 0xc6, 0x5e, 0x98, 0x10, 0x47, 0x80, 0xfe, 0xab, 0x83, 0x8d, 0x8c, 0xb1, 0xbd, 0x13, 0x54, 0x52, 0xea, 0x39, 0xdc, 0x89, 0x07, 0xa4, 0xc1, 0xa6, 0xa9, 0x16, 0x18, 0x05, 0xe4, 0xfa, 0x3e, 0x16, 0x98, 0x9e, 0x6a, 0x41, 0x8a, 0x7e, 0xea, 0x25, 0x82, 0xbf, 0x89, 0x5d, 0xa9, 0x67, 0x02, 0x8e, 0xab, 0x7c, 0x95, 0xd8, 0x46, 0xa6, 0xde, 0x4b, 0x99, 0x80, 0x78, 0x58, 0x14, 0xcf, 0x00, 0x48, 0x4b, 0xaa, 0x2f, 0x6d, 0xe6, 0x09, 0x91, 0x2f, 0xff, 0x68, 0x9b, 0xce, 0x6e, 0x85, 0x42, 0x61, 0xff, 0xe8, 0x66, 0xbd, 0x8e, 0x63, 0x27, 0x46, 0x05, 0xc7, 0xc5, 0xad, 0x67, 0x7b, 0xd7, 0x89, 0x7a, 0xde, 0x54, 0x3e),
-      //   tag: vec!(0x93, 0x84, 0x78, 0xa4, 0x1a, 0x32, 0x23, 0xa2, 0x19, 0x9f, 0x92, 0x76, 0xd1, 0x16, 0x21, 0x0f)
-      // },
-      // TestVector{
-      //   key: [0xb7, 0xe9, 0xb9, 0x0d, 0xc0, 0x2b, 0x5c, 0xd6, 0xdf, 0x5d, 0xf7, 0x28, 0x3e, 0xf2, 0x93, 0xed, 0x4d, 0xc0, 0x75, 0x13, 0xd9, 0xe6, 0x73, 0x31, 0xb6, 0x06, 0xf4, 0xd4, 0x2d, 0xec, 0x7d, 0x29],
-      //   nonce: [0xa6, 0xc1, 0x91, 0xf6, 0xd1, 0x81, 0x8f, 0x8e],
-      //   plain_text: vec!(0x2a, 0xda, 0x0e, 0x3c, 0x7c, 0xa6, 0xdb, 0x1f, 0x78, 0x0c, 0xe8, 0xc7, 0x94, 0x72, 0xaf, 0x4e, 0x8e, 0x95, 0x1d, 0xdc, 0x82, 0x8e, 0x0d, 0x6e, 0x8a, 0x67, 0xdf, 0x52, 0x06, 0x38, 0xff, 0x5f, 0x14, 0xa2, 0xf9, 0x5a, 0x5e, 0x59, 0x31, 0x74, 0x9a, 0xe2, 0xc4, 0xe9, 0x94, 0x6a, 0xe4, 0xd5, 0xeb, 0x5d, 0xe4, 0x2f, 0xb5, 0xb7, 0x7d, 0x22, 0x36, 0xe2, 0xe2, 0xbd, 0x81, 0x7d, 0xf5, 0x1b, 0xe4, 0x0b, 0x1b, 0x8a, 0x6c, 0x21, 0x01, 0x5a, 0x7c, 0x79, 0xfe, 0x06, 0xdb, 0xa4, 0xa0, 0x8b, 0x34, 0x01, 0x3d, 0xfa, 0x02, 0x74, 0x7b, 0x5f, 0x03, 0x93, 0x02, 0x68, 0x40, 0x4c, 0x45, 0x5d, 0xc5, 0x4a, 0x74, 0xd9, 0xc6, 0xe3, 0x54, 0x85, 0xe1, 0x00, 0x26, 0xda, 0x57, 0x3c, 0xb4, 0x1c, 0xd5, 0x0b, 0x64, 0xcf, 0xaf, 0xe4, 0xcf, 0xcd, 0xf3, 0xc9, 0x68, 0x4e, 0xf8, 0x77, 0xe4, 0x5d, 0x84, 0xe2, 0x2b, 0xd5, 0xe1, 0x5f, 0xa6, 0xc8, 0xfd, 0x5b, 0xe9, 0x21, 0x36, 0x6f, 0xf0, 0xdc, 0x6f, 0xe2, 0xdf, 0x45, 0xf7, 0x25, 0x29, 0x72, 0xc9, 0xb3, 0x03),
-      //   aad: vec!(0x0f, 0x42, 0x69, 0xed, 0x5e, 0xf0, 0xbf, 0xff, 0x7b, 0xe3, 0x99, 0x46, 0xa4, 0xe8, 0x6e, 0x8b, 0xf7, 0x9f, 0x84, 0xb7, 0x0c, 0xd0, 0xb1, 0x4f, 0xec, 0xb7, 0xbe, 0x3c, 0x07, 0x13, 0x16, 0xce, 0x86, 0xde, 0x3d, 0x99, 0xd6, 0x87, 0x1e, 0x0b, 0xa5, 0x66, 0x7d, 0x9d, 0x7b, 0xba, 0x7d, 0xca, 0xba, 0x10, 0xcb, 0x2a, 0x36, 0x66, 0x8b, 0x6c, 0x3e, 0x2f, 0xb6, 0xc1, 0x02, 0x93, 0x8b, 0x75, 0x00, 0x8b, 0xb9, 0xc2, 0x13, 0xeb, 0xf9, 0xb8, 0x5b, 0x5e, 0x91, 0xa8, 0x02, 0xdf, 0x0d, 0x31, 0xd7, 0xf1, 0x1d, 0x76, 0x4b, 0x22, 0x89, 0xf6, 0x22, 0x52, 0x12, 0x69, 0x4a, 0xb6, 0xb7, 0xc0, 0xe3, 0xff, 0x36, 0xe8, 0x42, 0x45, 0xd9, 0xf4, 0xf4, 0x3f, 0xc5, 0xf9, 0x8e, 0x65, 0x4d, 0xea, 0x7b, 0xa9, 0xbd, 0x91, 0x86, 0x58, 0x87, 0x9c, 0x5b, 0xb4, 0xa1, 0x64, 0x2a, 0xf0, 0xd8, 0x31, 0x13, 0xe3, 0xcf, 0x93, 0x5d, 0x3c, 0x0d, 0x52, 0x08, 0x31, 0x8f, 0x66, 0xf6, 0x54, 0xeb, 0x17, 0xd8, 0xc2, 0x8a, 0x60, 0x25, 0x43, 0xe7, 0x7a, 0xd3, 0xe8, 0x15),
-      //   cipher_text: vec!(0x22, 0x58, 0x6f, 0xe7, 0x33, 0x8e, 0x99, 0xcd, 0xaa, 0xd9, 0xf8, 0x5b, 0xd7, 0x24, 0xba, 0x4c, 0xfe, 0x62, 0x49, 0xb8, 0xa7, 0x13, 0x99, 0xf9, 0xa3, 0x70, 0x7b, 0x5c, 0x43, 0x23, 0xb8, 0xd9, 0x66, 0x79, 0x56, 0x8d, 0xfc, 0x8d, 0x23, 0x0a, 0xef, 0xb4, 0x53, 0xdf, 0x59, 0x6e, 0x13, 0xeb, 0x3e, 0x8a, 0x43, 0x92, 0x49, 0xbd, 0x64, 0xbc, 0x93, 0xa5, 0x8f, 0x95, 0x08, 0x9a, 0x62, 0xb9, 0x4f, 0x65, 0x62, 0xb8, 0x21, 0xc8, 0x3d, 0x91, 0xf5, 0x6c, 0x55, 0x14, 0x73, 0x81, 0xe9, 0xde, 0x4b, 0xeb, 0x4a, 0xe8, 0x1b, 0xd6, 0xfe, 0x7c, 0xae, 0xf7, 0xe7, 0xe9, 0xa2, 0x07, 0x8f, 0x2f, 0xba, 0x8f, 0x3e, 0x70, 0xd4, 0x91, 0x0d, 0xa9, 0xac, 0xcc, 0x92, 0xb8, 0xe8, 0x1a, 0x61, 0xb0, 0xfe, 0xfb, 0xec, 0xe4, 0xbd, 0x89, 0x44, 0x3e, 0x66, 0xe8, 0xdd, 0xda, 0x8e, 0x47, 0xa6, 0x6a, 0x62, 0xf1, 0x7f, 0xd0, 0xe7, 0xd0, 0xa4, 0x85, 0x2c, 0xe1, 0xa4, 0xd4, 0x3d, 0x72, 0xa0, 0xb5, 0xe8, 0x91, 0x4b, 0xbe, 0xc6, 0x98, 0xf0, 0x60, 0xf2, 0xb0, 0x92),
-      //   tag: vec!(0xc0, 0x82, 0x47, 0x02, 0x97, 0xda, 0x8c, 0x5f, 0x68, 0x2a, 0x16, 0x9d, 0x28, 0xbc, 0x02, 0x39)
-      // },
-      // TestVector{
-      //   key: [0x6b, 0x2c, 0xb2, 0x67, 0x8d, 0x11, 0x02, 0xf2, 0xfb, 0xbd, 0x02, 0x87, 0x94, 0xa7, 0x9f, 0x14, 0x58, 0x5c, 0x22, 0x3d, 0x40, 0x5e, 0x1a, 0xe9, 0x04, 0xc0, 0x36, 0x1e, 0x9b, 0x24, 0x1e, 0x99],
-      //   nonce: [0x7b, 0x3a, 0xe3, 0x1f, 0x8f, 0x93, 0x82, 0x51],
-      //   plain_text: vec!(0xb3, 0xcb, 0x74, 0x59, 0x30, 0xe0, 0x5f, 0x3a, 0xb8, 0xc9, 0x26, 0xc0, 0xa3, 0x43, 0xa6, 0xeb, 0x14, 0x80, 0x9f, 0xd2, 0x1b, 0x83, 0x90, 0xa6, 0xfc, 0xc5, 0x8a, 0xdb, 0x55, 0x79, 0xe5, 0x43, 0x20, 0x21, 0x76, 0x5b, 0x2d, 0x24, 0x9a, 0x0e, 0xcf, 0x6b, 0xa6, 0x78, 0x63, 0x4c, 0x4f, 0x53, 0xf7, 0x14, 0x95, 0x86, 0x5f, 0x03, 0x1e, 0xe9, 0x7a, 0xa1, 0x59, 0xf9, 0xea, 0xd3, 0xa3, 0xfc, 0xb8, 0x23, 0xee, 0x52, 0x38, 0xbd, 0xf1, 0x27, 0x06, 0xa9, 0xc6, 0x13, 0x7d, 0x23, 0x6e, 0x2e, 0x71, 0x10, 0xce, 0x65, 0x0c, 0x32, 0x1e, 0x41, 0xda, 0xf0, 0xaf, 0xd6, 0x2b, 0xab, 0x2a, 0x8f, 0xe5, 0x5d, 0x70, 0x18, 0xde, 0x49, 0xa1, 0x4e, 0xfe, 0x6d, 0x83, 0xa1, 0x5b, 0x2f, 0x25, 0x6d, 0x59, 0x5e, 0x99, 0x8d, 0x25, 0x30, 0x9f, 0x23, 0x63, 0x33, 0x60, 0xf5, 0x74, 0x5c, 0x50, 0xc4, 0xe5, 0xaf, 0x8c, 0xcc, 0x9a, 0x8a, 0x2c, 0xb4, 0x70, 0x64, 0x10, 0x5a, 0x02, 0x3e, 0x91, 0x9c, 0x77, 0x95, 0xd2, 0xdc, 0x33, 0x1d, 0x3f, 0x2a, 0xfb, 0x8c, 0x42, 0xe5, 0xc0, 0xbc, 0xc2, 0x6d),
-      //   aad: vec!(0x1c, 0x32, 0xfd, 0x3d, 0xf2, 0x2b, 0x3e, 0x44, 0x0e, 0x2a, 0x3c, 0x7a, 0x76, 0x24, 0x99, 0x01, 0x94, 0xcb, 0x16, 0xa5, 0xf7, 0x4a, 0xf3, 0x6f, 0x87, 0xfd, 0x6c, 0xa7, 0xd4, 0x10, 0xce, 0x90, 0x64, 0x31, 0x6a, 0x2d, 0x09, 0x19, 0x45, 0xde, 0xef, 0x7d, 0x9b, 0x35, 0xce, 0xec, 0x83, 0x96, 0x06, 0x93, 0x07, 0xca, 0xce, 0xd2, 0xb8, 0x0a, 0xfd, 0x7d, 0x53, 0xec, 0x47, 0x9c, 0x35, 0xce, 0xdf, 0x2d, 0xfd, 0x4c, 0x95, 0xc3, 0xdd, 0x84, 0x00, 0xf7, 0x1a, 0xd3, 0x40, 0x28, 0xc6, 0xe4, 0xf8, 0x68, 0x1d, 0x93, 0xd0, 0x77, 0x40, 0x64, 0xba, 0x38, 0xf3, 0xfb, 0x9b, 0x0c, 0x1d, 0xfa, 0x1f, 0x5f, 0x0c, 0x7d, 0x20, 0x67, 0x6a, 0x59, 0x11, 0xd9, 0x99, 0xfb, 0x6a, 0x1d, 0x41, 0x36, 0x7a, 0x8e, 0x99, 0xd8, 0x52, 0xbf, 0x3d, 0x3b, 0x7b, 0x3f, 0x4c, 0x23, 0x32, 0x49, 0xed, 0x1c, 0xa1, 0x35, 0x38, 0x9a, 0x67, 0x4f, 0xf4, 0x82, 0x32, 0xde, 0xd3, 0xf6, 0x80, 0x0a, 0x97, 0xb6, 0xd4, 0x09, 0xc4, 0x0e, 0x6c, 0xd7, 0x0d, 0x09, 0xbf, 0x9d, 0x2a, 0xd2, 0x5d, 0x9b, 0x94, 0x85),
-      //   cipher_text: vec!(0xef, 0x70, 0xc7, 0xde, 0x98, 0xab, 0x1d, 0x4a, 0xd8, 0x17, 0x02, 0x4a, 0x97, 0x0b, 0xe4, 0x63, 0x44, 0x36, 0x40, 0xeb, 0x0c, 0xd7, 0xff, 0x23, 0x4b, 0xdd, 0x00, 0xe6, 0x53, 0x07, 0x4a, 0x77, 0xa1, 0xd5, 0x74, 0x9e, 0x69, 0x8b, 0xd5, 0x26, 0xdc, 0x70, 0x9f, 0x82, 0xdf, 0x06, 0xf4, 0xc0, 0xe6, 0x40, 0x46, 0xb3, 0xdc, 0x5f, 0x3c, 0x70, 0x44, 0xae, 0xf5, 0x3a, 0xeb, 0xb8, 0x07, 0xd3, 0x22, 0x39, 0xd0, 0x65, 0x2d, 0xd9, 0x90, 0x36, 0x2c, 0x44, 0xec, 0x25, 0xbf, 0x5a, 0xea, 0xe6, 0x41, 0xe2, 0x7b, 0xf7, 0x16, 0xe0, 0xc4, 0xa1, 0xc9, 0xfb, 0xd3, 0x7b, 0xbf, 0x60, 0x2b, 0xb0, 0xd0, 0xc3, 0x5b, 0x06, 0x38, 0xbe, 0x20, 0xdd, 0x5d, 0x58, 0x91, 0xd4, 0x46, 0x13, 0x7e, 0x84, 0x2f, 0x92, 0xc0, 0xee, 0x07, 0x5c, 0x68, 0x22, 0x5e, 0x4d, 0xba, 0xcb, 0x63, 0xcc, 0x6f, 0xb3, 0x24, 0x42, 0xb4, 0xbc, 0xda, 0x5e, 0x62, 0xcb, 0x50, 0x0a, 0x4d, 0xf2, 0x74, 0x1a, 0x40, 0x59, 0x03, 0x4d, 0x2c, 0xcb, 0x71, 0xb0, 0xb8, 0xb0, 0x11, 0x2b, 0xf1, 0xc4, 0xca, 0x6e, 0xec, 0x74),
-      //   tag: vec!(0x39, 0x3a, 0xe2, 0x33, 0x84, 0x80, 0x34, 0x24, 0x8c, 0x19, 0x1a, 0xc0, 0xe3, 0x6b, 0x61, 0x23)
-      // },
-      // TestVector{
-      //   key: [0x4d, 0xbc, 0x80, 0xa4, 0x02, 0xc9, 0xfc, 0xea, 0xa7, 0x55, 0xe1, 0x10, 0x5d, 0xc4, 0x9e, 0xf6, 0x48, 0x90, 0x16, 0x77, 0x68, 0x83, 0xe0, 0x6f, 0xcf, 0x3a, 0xed, 0x93, 0xbf, 0x7f, 0x6a, 0xf7],
-      //   nonce: [0x23, 0x58, 0xae, 0x0c, 0xe3, 0xfb, 0x8e, 0x9f],
-      //   plain_text: vec!(0x19, 0x7c, 0x06, 0x40, 0x3e, 0xb8, 0x96, 0xd2, 0xfa, 0x64, 0x65, 0xe4, 0xd6, 0x44, 0x26, 0xd2, 0x4c, 0xc7, 0x47, 0x6a, 0xa1, 0xae, 0x41, 0x27, 0xcd, 0x2b, 0xd8, 0xa4, 0x8c, 0xe2, 0xc9, 0x9c, 0x16, 0xb1, 0xcb, 0xf3, 0x06, 0x48, 0x56, 0xe8, 0x40, 0x73, 0xb6, 0xcf, 0x12, 0xe7, 0x40, 0x66, 0x98, 0xef, 0x3d, 0xd1, 0x24, 0x0c, 0x02, 0x6c, 0xbd, 0x1a, 0xb0, 0x4e, 0xe6, 0x03, 0xe1, 0xe6, 0xe7, 0x35, 0xc9, 0xb7, 0x55, 0x1f, 0xd0, 0xd3, 0x55, 0x20, 0x2b, 0x4f, 0x64, 0xb4, 0x82, 0xdd, 0x4a, 0x7c, 0x7d, 0x82, 0xc4, 0xfe, 0x2e, 0xb4, 0x94, 0xd0, 0xd5, 0xe1, 0x77, 0x88, 0x98, 0x2d, 0x70, 0x4c, 0x13, 0x56, 0xc4, 0x1a, 0x94, 0x65, 0x55, 0x30, 0xde, 0xda, 0x23, 0x11, 0x8c, 0xba, 0x28, 0x1d, 0x0f, 0x71, 0x7e, 0x14, 0x9f, 0xbe, 0xb2, 0xc5, 0x9b, 0x22, 0xd0, 0xc0, 0x57, 0x4c, 0x1a, 0x2e, 0x64, 0x0a, 0xfa, 0xd1, 0xa6, 0xce, 0xb9, 0x2e, 0x1b, 0xf1, 0xdd, 0xe7, 0x17, 0x52, 0xa1, 0xc9, 0x91, 0xe9, 0xa5, 0x51, 0x7f, 0xe9, 0x86, 0x88, 0xa1, 0x6b, 0x07, 0x3d, 0xbf, 0x68, 0x84, 0xcf, 0xde, 0x61, 0xac),
-      //   aad: vec!(0xcf, 0x6c, 0xe7, 0xb8, 0x99, 0xfb, 0x70, 0x0a, 0x90, 0xd2, 0xa5, 0x46, 0x6d, 0x54, 0xd3, 0x13, 0x58, 0xec, 0xf0, 0x56, 0x2e, 0x02, 0xb3, 0x30, 0xa2, 0x7b, 0xa0, 0x13, 0x80, 0x06, 0xb3, 0x42, 0xb7, 0xed, 0x63, 0x49, 0xd7, 0x3c, 0x4c, 0x5c, 0x6d, 0x29, 0xbd, 0xe7, 0x5a, 0x25, 0x08, 0x9b, 0x11, 0xda, 0xc5, 0xb2, 0x7a, 0xde, 0xa7, 0xe7, 0x64, 0x0c, 0xa1, 0xa7, 0xce, 0xb0, 0x50, 0xe3, 0xaa, 0xe8, 0x4a, 0x47, 0xe1, 0x16, 0x40, 0xa6, 0xe4, 0x85, 0xbd, 0x54, 0xae, 0x9f, 0xdb, 0x54, 0x7e, 0xdc, 0x73, 0x13, 0xd2, 0x4a, 0x03, 0x28, 0x42, 0x9f, 0xcf, 0xfd, 0x8b, 0x18, 0xf3, 0x98, 0x80, 0xed, 0xd6, 0x16, 0x44, 0x73, 0x44, 0xeb, 0xee, 0xc9, 0xea, 0xdb, 0x2d, 0xcb, 0x1f, 0xa7, 0xe6, 0x71, 0x79, 0xe7, 0xf9, 0x13, 0xc1, 0x94, 0xeb, 0xd8, 0xf5, 0xa5, 0x8a, 0xea, 0x73, 0xb0, 0xc5, 0xd1, 0x13, 0x35, 0x61, 0x24, 0x5b, 0x6d, 0x9c, 0x5c, 0xfd, 0x8b, 0xb0, 0xc2, 0x5b, 0x38, 0xff, 0xb3, 0x7d, 0xb5, 0xe2, 0xde, 0x5c, 0xdd, 0xed, 0x6b, 0x57, 0x35, 0x5e, 0x9d, 0x21, 0x5c, 0xb0, 0x95, 0xb8, 0x73, 0x1f),
-      //   cipher_text: vec!(0xaa, 0x87, 0xf9, 0xa8, 0x30, 0x48, 0xb6, 0x91, 0x9c, 0x8f, 0x2b, 0x05, 0x03, 0x15, 0xdb, 0x4e, 0x2a, 0xda, 0xe4, 0xa9, 0xc2, 0xca, 0x01, 0x09, 0xb8, 0x19, 0x61, 0xb5, 0x20, 0xe6, 0x32, 0x99, 0xdc, 0xb0, 0x28, 0xce, 0xc0, 0xb9, 0xd3, 0x24, 0x9a, 0x94, 0x5e, 0xe6, 0x7d, 0xd0, 0x29, 0xb4, 0x0f, 0x36, 0x12, 0x45, 0xc7, 0x40, 0xf0, 0x04, 0xf8, 0xcf, 0x0d, 0x22, 0x14, 0xfc, 0xfa, 0x65, 0xe6, 0x12, 0x4a, 0x3e, 0x74, 0xb7, 0x8a, 0xa9, 0x43, 0x45, 0xc4, 0x6f, 0xdc, 0x15, 0x8d, 0x34, 0x82, 0x3e, 0xd2, 0x49, 0xee, 0x55, 0x04, 0x31, 0xea, 0xae, 0x92, 0x18, 0x36, 0x73, 0x21, 0xcd, 0xd6, 0xe6, 0xa4, 0x77, 0x65, 0x04, 0x69, 0xbb, 0x3c, 0xc1, 0x37, 0xa8, 0xf4, 0x8d, 0x9c, 0xf2, 0x79, 0x34, 0xb1, 0x67, 0x03, 0x60, 0x8b, 0x38, 0x3d, 0x21, 0x45, 0x65, 0x99, 0x22, 0xfb, 0x83, 0xbb, 0x2e, 0x7e, 0xe2, 0xef, 0x93, 0x8a, 0x90, 0xf2, 0xff, 0x84, 0x6a, 0x4a, 0x94, 0x91, 0x29, 0xb1, 0xfb, 0x74, 0xdd, 0xe5, 0x5c, 0x5a, 0xe0, 0x13, 0xc2, 0xf2, 0x85, 0xde, 0x84, 0xf7, 0xda, 0xc7, 0xd1, 0x66, 0x2f, 0x23),
-      //   tag: vec!(0x06, 0xb4, 0x31, 0x8a, 0xc7, 0xf6, 0x5d, 0x55, 0x6f, 0x78, 0x14, 0x28, 0xa0, 0x51, 0x4f, 0xfe)
-      // },
-      // TestVector{
-      //   key: [0x9e, 0x4a, 0x62, 0x01, 0x6d, 0xae, 0x4b, 0x32, 0x23, 0xfe, 0xd1, 0xd0, 0x1d, 0x07, 0x87, 0xe3, 0x1d, 0x30, 0x69, 0x4f, 0x79, 0xe8, 0x14, 0x22, 0x24, 0xfe, 0x4c, 0x47, 0x35, 0x24, 0x8a, 0x83],
-      //   nonce: [0x26, 0x3a, 0x2f, 0xc0, 0x6a, 0x28, 0x72, 0xe7],
-      //   plain_text: vec!(0x5a, 0x46, 0x94, 0x66, 0x01, 0xf9, 0x3a, 0x0c, 0xee, 0x59, 0x93, 0xc6, 0x95, 0x75, 0xe5, 0x99, 0xcc, 0x24, 0xf5, 0x1a, 0xaf, 0xa2, 0xd7, 0xc2, 0x8d, 0x81, 0x6a, 0x5b, 0x9b, 0x4d, 0xec, 0xda, 0x2e, 0x59, 0xc1, 0x11, 0x07, 0x5f, 0xb6, 0x0a, 0x90, 0x3d, 0x70, 0x1a, 0xd2, 0x68, 0x0b, 0xb1, 0x4a, 0xed, 0xa1, 0x4a, 0xf2, 0xae, 0x9c, 0x07, 0xa7, 0x59, 0xd8, 0x38, 0x8b, 0x30, 0x44, 0x6f, 0x28, 0xb8, 0x5f, 0x0a, 0x05, 0xcd, 0x15, 0x00, 0x50, 0xbd, 0x2e, 0x71, 0x5f, 0xf5, 0x50, 0xeb, 0xbd, 0x24, 0xda, 0x3e, 0xbb, 0x1e, 0xac, 0x15, 0xab, 0xa2, 0x3d, 0x44, 0x86, 0x59, 0xde, 0x34, 0xbe, 0x96, 0x2a, 0xb3, 0xab, 0x31, 0xcb, 0x17, 0x58, 0xdb, 0x76, 0xc4, 0x68, 0xb5, 0xbb, 0x8c, 0xe4, 0x4b, 0x06, 0xc4, 0xe4, 0xdb, 0x9b, 0xd2, 0xf0, 0x61, 0x5b, 0x1e, 0x72, 0x7f, 0x05, 0x3f, 0x6b, 0x4f, 0xfb, 0x63, 0x58, 0xd2, 0x48, 0xf0, 0x22, 0xbc, 0xad, 0x6c, 0xa9, 0x73, 0x04, 0x4b, 0xed, 0x23, 0xd3, 0x92, 0x09, 0x06, 0xa8, 0x9a, 0x9a, 0x9c, 0x5d, 0x80, 0x24, 0xec, 0x67, 0xd7, 0xf0, 0x61, 0xf6, 0x45, 0x29, 0xa9, 0x55, 0xce, 0x16, 0xb3),
-      //   aad: vec!(0x4c, 0xd6, 0x5f, 0x68, 0xf9, 0xf8, 0x8c, 0x05, 0x16, 0x23, 0x1f, 0x2a, 0x42, 0x5c, 0x8f, 0x8a, 0x28, 0x7d, 0xe4, 0x7d, 0x40, 0x9d, 0x5e, 0xcd, 0xe3, 0xad, 0x15, 0x1e, 0x90, 0x6b, 0x38, 0x39, 0xfb, 0x01, 0xbb, 0x91, 0xa4, 0x56, 0xf2, 0x0e, 0xa9, 0xd3, 0x94, 0xd4, 0xb0, 0x66, 0x04, 0xab, 0x1f, 0x90, 0x09, 0xef, 0x29, 0x01, 0x9a, 0xf7, 0x96, 0x8d, 0x96, 0x5d, 0x16, 0x43, 0x16, 0x1a, 0xb3, 0x3a, 0x53, 0x54, 0xcd, 0xa2, 0xfd, 0xc9, 0xf1, 0xd2, 0x1e, 0xc9, 0xcb, 0x71, 0xc3, 0x25, 0xc6, 0x59, 0x64, 0xa1, 0x4f, 0x9b, 0x26, 0xeb, 0x16, 0x56, 0x0b, 0xeb, 0x97, 0x92, 0x07, 0x5a, 0x15, 0x97, 0x39, 0x40, 0x00, 0xfd, 0x5f, 0x33, 0x1b, 0xd8, 0xb7, 0xd2, 0x0d, 0x88, 0xe5, 0xf8, 0x9c, 0xf8, 0xd0, 0xb3, 0x3e, 0x4e, 0x78, 0xe4, 0x90, 0x4b, 0xb5, 0x9c, 0x9c, 0x8d, 0x5d, 0x31, 0xac, 0x86, 0xb8, 0x93, 0xe4, 0xa0, 0x66, 0x7a, 0xf1, 0xbe, 0x85, 0xfd, 0xb7, 0x7f, 0x7e, 0xc3, 0xe2, 0x59, 0x4a, 0x68, 0x04, 0x8d, 0x20, 0xc2, 0xfb, 0x94, 0x22, 0xf5, 0x87, 0x90, 0x78, 0x77, 0x2e, 0xe2, 0x6a, 0x1c, 0x56, 0x0c, 0xbc, 0xbb, 0x21, 0x13),
-      //   cipher_text: vec!(0xe9, 0x44, 0xbb, 0x2a, 0xb0, 0x6d, 0x13, 0x8a, 0xd6, 0x33, 0xc1, 0x6c, 0xe8, 0x27, 0x06, 0xec, 0xf0, 0xef, 0x5d, 0x11, 0x9b, 0xe1, 0xf3, 0x46, 0x0c, 0x9c, 0xe1, 0x01, 0xd9, 0xc4, 0xe0, 0x4e, 0xf1, 0x67, 0x77, 0x07, 0xfc, 0xa4, 0x0d, 0x1f, 0x8c, 0xa1, 0x81, 0xe0, 0x72, 0x73, 0x70, 0x7b, 0x06, 0x62, 0x4d, 0x6d, 0x70, 0x63, 0xc3, 0xb7, 0xb0, 0xbb, 0x01, 0x51, 0xb7, 0x57, 0xb3, 0xe5, 0x23, 0x7f, 0xb8, 0x00, 0x4c, 0x16, 0x12, 0x33, 0xd8, 0xbc, 0x7e, 0x5f, 0x28, 0xea, 0x1c, 0x18, 0xda, 0x18, 0x74, 0xb3, 0xd5, 0x4c, 0x5a, 0xd6, 0xff, 0x08, 0x35, 0xee, 0xd3, 0x5c, 0x88, 0x53, 0x70, 0x45, 0x85, 0xcf, 0x83, 0x99, 0x6e, 0x5e, 0x7c, 0xec, 0x68, 0x18, 0x0a, 0xf4, 0x14, 0xe0, 0x4f, 0x08, 0x13, 0x4d, 0x3b, 0x03, 0x84, 0xeb, 0xdf, 0x03, 0x93, 0xc9, 0x31, 0x0b, 0x55, 0xd8, 0x69, 0x8f, 0xe1, 0x0c, 0xb3, 0x62, 0xde, 0xfc, 0x09, 0x95, 0xe9, 0xa1, 0x3b, 0x48, 0xb4, 0x2c, 0xff, 0x61, 0xff, 0xd9, 0xfe, 0x4c, 0x3c, 0x8c, 0x6d, 0xab, 0x35, 0x57, 0x13, 0xb8, 0x8f, 0x6e, 0x98, 0xa0, 0x2e, 0x72, 0x31, 0xa0, 0xc6, 0x64, 0x4e, 0xc4),
-      //   tag: vec!(0x27, 0xde, 0x0d, 0x4c, 0xa7, 0x64, 0x8f, 0x63, 0x96, 0xd5, 0x41, 0x9a, 0x7b, 0x12, 0x43, 0xb7)
-      // },
-      // TestVector{
-      //   key: [0x18, 0xca, 0x3e, 0xa3, 0xe8, 0xba, 0xee, 0xd1, 0xb3, 0x41, 0x18, 0x92, 0x97, 0xd3, 0x3c, 0xef, 0x7f, 0x4e, 0x0a, 0x2f, 0xab, 0x40, 0xec, 0x3b, 0x6b, 0xb6, 0x73, 0x85, 0xd0, 0x96, 0x9c, 0xfe],
-      //   nonce: [0xb6, 0xae, 0xf3, 0x4c, 0x75, 0x81, 0x8e, 0x7c],
-      //   plain_text: vec!(0xef, 0x6d, 0x1b, 0xb4, 0x09, 0x47, 0x82, 0xf6, 0x02, 0xfc, 0xf4, 0x15, 0x61, 0xcb, 0xa4, 0x97, 0x06, 0x79, 0x66, 0x1c, 0x63, 0xbe, 0xfe, 0x35, 0xff, 0x2c, 0xa7, 0xad, 0x1a, 0x28, 0x0b, 0xf6, 0xb1, 0xe7, 0xf1, 0x53, 0xfa, 0x84, 0x8e, 0xdf, 0xef, 0xfe, 0x25, 0x15, 0x3f, 0x54, 0x0b, 0x71, 0x25, 0x3e, 0x8b, 0xab, 0xa9, 0xae, 0xb7, 0x19, 0xa0, 0x27, 0x52, 0xcd, 0xa6, 0x0e, 0xa5, 0x93, 0x8a, 0xab, 0x33, 0x9e, 0xea, 0xd5, 0xaa, 0xbf, 0x81, 0xb1, 0x9b, 0x0f, 0xc5, 0xc1, 0xed, 0x55, 0x6b, 0xe6, 0xad, 0x89, 0x70, 0xea, 0x43, 0xc3, 0x03, 0xd3, 0x04, 0x62, 0x05, 0xb1, 0x2c, 0x41, 0x9d, 0xea, 0x71, 0xc4, 0x24, 0x5c, 0xfe, 0xdd, 0x0a, 0x31, 0xb0, 0xf4, 0x15, 0x0b, 0x5a, 0x9f, 0xe8, 0x00, 0x52, 0x79, 0x01, 0x88, 0x52, 0x9a, 0xb3, 0x2f, 0x5e, 0x61, 0xd8, 0xcc, 0xde, 0x59, 0x73, 0xed, 0x30, 0xbd, 0xf2, 0x90, 0xcb, 0xfb, 0xd5, 0xf0, 0x73, 0xc0, 0xc6, 0xa0, 0x20, 0xea, 0xc0, 0x33, 0x2f, 0xce, 0xd1, 0x7a, 0x9a, 0x08, 0xce, 0xf6, 0xf9, 0x21, 0x7b, 0xd6, 0xbe, 0xf6, 0x8c, 0x15, 0x05, 0xd6, 0xee, 0xd4, 0x09, 0x53, 0xe1, 0x55, 0x08, 0xd8, 0x7f, 0x08, 0xfc),
-      //   aad: vec!(0xf4, 0x0f, 0x03, 0xbe, 0xaa, 0x02, 0x3d, 0xb6, 0x31, 0x1b, 0xad, 0x9b, 0x4d, 0x5d, 0x0d, 0x66, 0xa5, 0x8d, 0x97, 0x8e, 0x0b, 0xcb, 0xbf, 0x78, 0xac, 0xeb, 0xde, 0x1f, 0x4e, 0xb9, 0xa2, 0x84, 0x09, 0x56, 0x28, 0x95, 0x5a, 0x0b, 0x15, 0xaf, 0xc4, 0x54, 0x15, 0x2f, 0x96, 0x2e, 0xc3, 0xea, 0x2b, 0x9a, 0x3b, 0x08, 0x9b, 0x99, 0x65, 0x8e, 0x68, 0xed, 0xe4, 0xde, 0xe5, 0xac, 0xd5, 0x66, 0x72, 0x02, 0x5e, 0xb7, 0x32, 0x3b, 0xcb, 0xc6, 0xba, 0x5d, 0x91, 0xc9, 0x43, 0x10, 0xf1, 0x8c, 0x91, 0x8e, 0x39, 0x14, 0xbb, 0xbf, 0x86, 0x9e, 0x1b, 0x87, 0x21, 0x47, 0x6f, 0x9d, 0xef, 0x31, 0xb9, 0xd3, 0x2c, 0x47, 0x1a, 0x54, 0x13, 0x24, 0x81, 0xaa, 0x89, 0xf6, 0xc7, 0x35, 0xab, 0x19, 0x33, 0x69, 0x49, 0x6d, 0x8d, 0xbe, 0xb4, 0x9b, 0x13, 0x0d, 0x85, 0xfb, 0xff, 0x3f, 0x9c, 0xb7, 0xdc, 0xce, 0xa4, 0xc1, 0xda, 0x7a, 0x28, 0x46, 0xee, 0xf5, 0xe6, 0x92, 0x9d, 0x90, 0x09, 0xa9, 0x14, 0x9e, 0x39, 0xc6, 0xc8, 0xec, 0x15, 0x0c, 0x9a, 0xb4, 0x9a, 0x09, 0xc1, 0x8c, 0x47, 0x49, 0xa0, 0xa9, 0xfc, 0xba, 0x77, 0x05, 0x7c, 0xde, 0xa6, 0xef, 0xd4, 0xd1, 0x42, 0x25, 0x6c),
-      //   cipher_text: vec!(0xc5, 0x31, 0x63, 0x3c, 0x0c, 0x98, 0x23, 0x0d, 0xcf, 0x05, 0x9c, 0x10, 0x81, 0xd1, 0xd6, 0x9c, 0x96, 0xba, 0xb7, 0x1c, 0x31, 0x43, 0xae, 0x60, 0xf9, 0xfc, 0x2b, 0x9c, 0xd1, 0x87, 0x62, 0x31, 0x44, 0x96, 0xab, 0x6e, 0x90, 0xbf, 0x67, 0x96, 0x25, 0x2c, 0xb9, 0xf6, 0x67, 0xa1, 0xf0, 0x8d, 0xa4, 0x7f, 0xc2, 0xb0, 0xee, 0xcd, 0xa8, 0x13, 0x22, 0x8c, 0xae, 0x00, 0xd4, 0xc0, 0xd7, 0x1f, 0x5e, 0x01, 0xb6, 0xce, 0x76, 0x2f, 0xa6, 0x36, 0xef, 0xff, 0xe5, 0x5d, 0x0e, 0x89, 0xfd, 0xc8, 0x9b, 0xa4, 0x25, 0x21, 0xcc, 0x01, 0x9a, 0xb9, 0xd4, 0x08, 0xfc, 0xd7, 0x9c, 0x14, 0x91, 0x4e, 0x8b, 0xbf, 0x0e, 0xa4, 0x4d, 0x8a, 0x1d, 0x35, 0x74, 0x3a, 0xd6, 0x28, 0x32, 0x7e, 0x43, 0x2f, 0xdc, 0xfe, 0xb0, 0xb6, 0x67, 0x9d, 0xdc, 0xa8, 0xc9, 0x2b, 0x99, 0x84, 0x73, 0x73, 0x2a, 0xbd, 0x55, 0xdb, 0xa5, 0x4e, 0xef, 0xff, 0x83, 0xc7, 0x84, 0x88, 0xee, 0xe5, 0xf9, 0x2b, 0x14, 0x5a, 0x74, 0xb6, 0x86, 0x65, 0x31, 0x47, 0x6f, 0xc4, 0x62, 0x79, 0xd4, 0xfd, 0xe2, 0x4d, 0x04, 0x9c, 0x1c, 0xe2, 0xb4, 0x23, 0x58, 0xff, 0x3a, 0xb2, 0xba, 0x3a, 0x88, 0x66, 0xe5, 0x47, 0xaf),
-      //   tag: vec!(0xa0, 0xa5, 0x24, 0x27, 0x59, 0xa6, 0xd9, 0xb1, 0xaa, 0x5b, 0xaf, 0x9a, 0x4e, 0xf8, 0x95, 0xa2)
-      // },
-      // TestVector{
-      //   key: [0x95, 0xfd, 0xd2, 0xd3, 0xd4, 0x29, 0x60, 0x69, 0x05, 0x5b, 0x6b, 0x79, 0xe5, 0xd1, 0x38, 0x76, 0x28, 0x25, 0x4a, 0x7b, 0xe6, 0x47, 0xba, 0xaf, 0xdf, 0x99, 0xdd, 0x8a, 0xf3, 0x54, 0xd8, 0x17],
-      //   nonce: [0xcd, 0x7e, 0xd9, 0xe7, 0x0f, 0x60, 0x86, 0x13],
-      //   plain_text: vec!(0x02, 0x48, 0x28, 0x4a, 0xcf, 0xfa, 0x4b, 0x2c, 0x46, 0x63, 0x6b, 0xdf, 0x8c, 0xc7, 0x00, 0x28, 0xdd, 0x15, 0x1a, 0x6d, 0x8e, 0x7a, 0x5a, 0x5b, 0xc2, 0xd3, 0x9a, 0xcc, 0x10, 0x20, 0xe7, 0x36, 0x88, 0x50, 0x31, 0xb2, 0x52, 0xbf, 0xe9, 0xf9, 0x64, 0x90, 0x92, 0x1f, 0x41, 0xd1, 0xe1, 0x74, 0xbf, 0x1a, 0xc0, 0x37, 0x07, 0xbc, 0x2a, 0xe5, 0x08, 0x8a, 0x12, 0x08, 0xa7, 0xc6, 0x64, 0x58, 0x38, 0x35, 0xe8, 0xbb, 0x93, 0xc7, 0x87, 0xb9, 0x6d, 0xea, 0x9f, 0xc4, 0xb8, 0x84, 0x93, 0x0c, 0x57, 0x79, 0x9e, 0x7b, 0x7a, 0x66, 0x49, 0xc6, 0x13, 0x40, 0x37, 0x6d, 0x04, 0x2b, 0x9f, 0x5f, 0xae, 0xe8, 0x95, 0x6c, 0x70, 0xa6, 0x3c, 0xf1, 0xcf, 0xf4, 0xfc, 0x2c, 0x7c, 0xb8, 0x53, 0x5c, 0x10, 0x21, 0x4e, 0x73, 0xce, 0xc6, 0xb7, 0x96, 0x69, 0xd8, 0x24, 0xf2, 0x3f, 0xf8, 0xc8, 0xa2, 0xca, 0x1c, 0x05, 0x97, 0x4d, 0xd6, 0x18, 0x9c, 0xfe, 0xe4, 0x84, 0xd0, 0x90, 0x6d, 0xf4, 0x87, 0xb6, 0xbd, 0x85, 0x67, 0x1c, 0xe2, 0xb2, 0x38, 0x25, 0x05, 0x2e, 0x44, 0xb8, 0x48, 0x03, 0xe2, 0x83, 0x9a, 0x96, 0x39, 0x1a, 0xbc, 0x25, 0x94, 0x5c, 0xb8, 0x67, 0xb5, 0x27, 0xcd, 0xd9, 0xb3, 0x73, 0xfb, 0xfb, 0x83),
-      //   aad: vec!(0x24, 0xa4, 0x5a, 0x3a, 0x00, 0x76, 0xa5, 0xbc, 0xfd, 0x5a, 0xfe, 0x1c, 0x54, 0xf7, 0xb7, 0x74, 0x96, 0x11, 0x7d, 0x29, 0xf4, 0xc0, 0x90, 0x9f, 0x1e, 0x69, 0x40, 0xb8, 0x1d, 0xde, 0x3a, 0xba, 0xcb, 0x71, 0xec, 0x71, 0xf0, 0xf4, 0xdb, 0x8a, 0x7e, 0x54, 0x0b, 0xd4, 0xc2, 0xc6, 0x0f, 0xae, 0xe2, 0x1d, 0xd3, 0xce, 0x72, 0x96, 0x38, 0x55, 0xbe, 0x1b, 0x0c, 0xe5, 0x4f, 0xb2, 0x0a, 0xd8, 0x2d, 0xbc, 0x45, 0xbe, 0x20, 0xcd, 0x6c, 0x17, 0x1e, 0x2b, 0xeb, 0xb7, 0x9e, 0x65, 0xe7, 0xd0, 0x15, 0x67, 0xad, 0x0e, 0xeb, 0x86, 0x98, 0x83, 0xe4, 0xe8, 0x14, 0xc9, 0x36, 0x88, 0x60, 0x7a, 0x12, 0xb3, 0xb7, 0x32, 0xc1, 0x70, 0x3b, 0x09, 0x56, 0x6c, 0x30, 0x8d, 0x29, 0xce, 0x67, 0x6a, 0x5c, 0x76, 0x2a, 0x85, 0x70, 0x06, 0x39, 0xb7, 0x0d, 0x82, 0xaa, 0xef, 0x40, 0x8c, 0xf9, 0x88, 0x21, 0xa3, 0x72, 0xc6, 0xa0, 0x61, 0x4a, 0x73, 0xba, 0x99, 0x18, 0xa7, 0x95, 0x1e, 0xa8, 0xb2, 0xbb, 0x77, 0xcd, 0x98, 0x96, 0xd2, 0x69, 0x88, 0x08, 0x6d, 0x85, 0x86, 0xd7, 0x2e, 0xdc, 0x92, 0xaf, 0x20, 0x42, 0xff, 0x5e, 0x5f, 0x14, 0x29, 0xa2, 0x2f, 0x61, 0x06, 0x5e, 0x03, 0xcf, 0xcd, 0x7e, 0xdc, 0x2a, 0x93),
-      //   cipher_text: vec!(0x40, 0xc6, 0x31, 0x8d, 0x9e, 0x38, 0x3e, 0x10, 0x7c, 0xdd, 0x3e, 0x1c, 0x89, 0x51, 0x56, 0x21, 0x93, 0xc3, 0xef, 0x64, 0xee, 0x44, 0x24, 0x32, 0xa6, 0x3e, 0x2e, 0xde, 0xfc, 0x78, 0xf3, 0x2a, 0xb0, 0x77, 0x72, 0xae, 0xac, 0x17, 0x2c, 0xb6, 0x7e, 0xcf, 0x4d, 0x21, 0xf8, 0xb4, 0x48, 0x42, 0x35, 0x27, 0xbb, 0xeb, 0x9d, 0x8d, 0xdd, 0x0b, 0x46, 0xbd, 0xb2, 0x7f, 0x74, 0x09, 0x6c, 0xeb, 0x24, 0xe4, 0x19, 0x63, 0xb4, 0xcd, 0xca, 0x17, 0x66, 0x76, 0xa7, 0x5b, 0xdb, 0xe3, 0xab, 0xc2, 0x70, 0xb3, 0x49, 0xac, 0x0c, 0x6c, 0xbd, 0x9c, 0x3a, 0x5c, 0xd5, 0xbc, 0xe2, 0x02, 0x02, 0xfc, 0x5c, 0xc0, 0xc1, 0xbd, 0xd4, 0xfd, 0x25, 0xe1, 0x21, 0xe0, 0xa2, 0x4b, 0xd7, 0xbb, 0xeb, 0x9b, 0x19, 0xb1, 0x91, 0x24, 0x67, 0xbf, 0x53, 0x38, 0xee, 0x2c, 0xe8, 0x8a, 0xa3, 0x83, 0xc0, 0x82, 0xb4, 0x2c, 0xc3, 0x99, 0xc9, 0x65, 0x4c, 0xa3, 0x25, 0xf3, 0x55, 0x23, 0xe8, 0x14, 0x38, 0xbe, 0xb3, 0xf8, 0x92, 0x6b, 0xe7, 0x9c, 0x37, 0x88, 0x22, 0xd7, 0xc8, 0xf7, 0x85, 0x61, 0x44, 0x08, 0xa5, 0xf7, 0xca, 0xc4, 0x9e, 0x45, 0x43, 0x18, 0x87, 0x25, 0x64, 0x3e, 0x6c, 0x1a, 0x70, 0xb4, 0x6d, 0x0e, 0xc4, 0x00),
-      //   tag: vec!(0x58, 0x01, 0xe8, 0x41, 0x92, 0xc7, 0x26, 0x7f, 0x66, 0xb0, 0xe0, 0x46, 0x07, 0xa3, 0x9a, 0x3e)
-      // },
-      // TestVector{
-      //   key: [0x6a, 0xe1, 0x10, 0x2f, 0x84, 0xed, 0x4d, 0xc1, 0x14, 0xbb, 0x9d, 0x63, 0xf4, 0xdc, 0x78, 0xd7, 0xdb, 0xb1, 0xab, 0x63, 0xf1, 0x65, 0x9d, 0xd9, 0x5f, 0x47, 0x94, 0x0a, 0x7b, 0x7a, 0x81, 0x1f],
-      //   nonce: [0xc9, 0x65, 0xd5, 0x78, 0xba, 0x91, 0xd2, 0x27],
-      //   plain_text: vec!(0xb8, 0x2a, 0x8a, 0x92, 0x09, 0x61, 0x8f, 0x1f, 0x5b, 0xe9, 0xc2, 0xc3, 0x2a, 0xba, 0x3d, 0xc4, 0x5b, 0x49, 0x47, 0x00, 0x7b, 0x14, 0xc8, 0x51, 0xcd, 0x69, 0x44, 0x56, 0xb3, 0x03, 0xad, 0x59, 0xa4, 0x65, 0x66, 0x28, 0x03, 0x00, 0x67, 0x05, 0x67, 0x3d, 0x6c, 0x3e, 0x29, 0xf1, 0xd3, 0x51, 0x0d, 0xfc, 0x04, 0x05, 0x46, 0x3c, 0x03, 0x41, 0x4e, 0x0e, 0x07, 0xe3, 0x59, 0xf1, 0xf1, 0x81, 0x6c, 0x68, 0xb2, 0x43, 0x4a, 0x19, 0xd3, 0xee, 0xe0, 0x46, 0x48, 0x73, 0xe2, 0x3c, 0x43, 0xf3, 0xab, 0x60, 0xa3, 0xf6, 0x06, 0xa0, 0xe5, 0xbe, 0x81, 0xe3, 0xab, 0x4a, 0xa2, 0x7f, 0xb7, 0x70, 0x7a, 0x57, 0xb9, 0x49, 0xf0, 0x0d, 0x6c, 0xd3, 0xa1, 0x1a, 0xe4, 0x82, 0x7d, 0x48, 0x89, 0xdd, 0x45, 0x5a, 0x0b, 0x6d, 0x39, 0xe9, 0x90, 0x12, 0xfd, 0x40, 0xdb, 0x23, 0xfb, 0x50, 0xe7, 0x9e, 0x11, 0xf8, 0xa6, 0x45, 0x16, 0x69, 0xbe, 0xb2, 0xfb, 0xd9, 0x13, 0xef, 0xfd, 0x49, 0xad, 0x1b, 0x43, 0x92, 0x63, 0x11, 0xf6, 0xe1, 0x3a, 0x6e, 0x7a, 0x09, 0xcf, 0x4b, 0xeb, 0xb1, 0xc0, 0xbf, 0x63, 0xce, 0x59, 0xcd, 0x5a, 0x08, 0xe4, 0xb8, 0xd8, 0xdb, 0xf9, 0xd0, 0x02, 0xe8, 0xa3, 0xd9, 0xe8, 0x0c, 0x79, 0x95, 0xbb, 0x0b, 0x48, 0x52, 0x80),
-      //   aad: vec!(0xdf, 0xd4, 0xac, 0x3e, 0x80, 0xb2, 0x90, 0x46, 0x23, 0xff, 0x79, 0xea, 0x8e, 0xe8, 0x78, 0x62, 0x26, 0x89, 0x39, 0xde, 0xcf, 0x53, 0x06, 0xc0, 0x7a, 0x17, 0x5b, 0x6b, 0x9d, 0xa0, 0xeb, 0x13, 0xac, 0x20, 0x9b, 0x4d, 0x16, 0x47, 0x55, 0x92, 0x9e, 0x03, 0x24, 0x0a, 0x0f, 0xe2, 0x65, 0x99, 0xf1, 0x36, 0xfb, 0x2a, 0xfd, 0xff, 0xd1, 0x2b, 0xb2, 0x03, 0x54, 0xaa, 0x1d, 0x20, 0xe5, 0x79, 0x98, 0x39, 0xab, 0xb6, 0x8a, 0xe4, 0x6d, 0x50, 0xc8, 0x97, 0x4e, 0x13, 0xe3, 0x61, 0xd8, 0x7e, 0xf5, 0x50, 0xfe, 0x6d, 0x82, 0xe8, 0xb5, 0xb1, 0x72, 0xcf, 0x5c, 0xd0, 0x84, 0x82, 0xef, 0xde, 0xf7, 0x93, 0xed, 0xe3, 0x53, 0x0d, 0x24, 0x66, 0x7f, 0xaf, 0x3a, 0x1e, 0x96, 0x34, 0x88, 0x67, 0xc2, 0x94, 0x26, 0x41, 0xf4, 0xc0, 0x36, 0x98, 0x1b, 0x83, 0xf5, 0x02, 0x36, 0xb8, 0xe8, 0xa1, 0x0b, 0x83, 0xeb, 0xf6, 0x90, 0x9a, 0xad, 0x00, 0x76, 0x30, 0x2f, 0x10, 0x83, 0xf7, 0x2d, 0xe4, 0xcf, 0x4a, 0x1a, 0x31, 0x83, 0xfe, 0x6e, 0xc6, 0xbf, 0xe2, 0xe7, 0x3e, 0x2a, 0xf8, 0xe1, 0xe8, 0xc9, 0xd8, 0x50, 0x79, 0x08, 0x3f, 0xd1, 0x79, 0xcc, 0xc2, 0xee, 0x9f, 0xf0, 0x02, 0xf2, 0x13, 0xdb, 0xd7, 0x33, 0x30, 0x53, 0xa4, 0x6c, 0x5e, 0x43),
-      //   cipher_text: vec!(0xa9, 0xae, 0xb8, 0xf0, 0xa2, 0xb3, 0xca, 0x14, 0x1a, 0xc7, 0x1a, 0x80, 0x8d, 0xcc, 0x0c, 0x97, 0x98, 0xac, 0x11, 0x7c, 0x5d, 0x2b, 0xd0, 0x9b, 0x3c, 0xfe, 0x62, 0x26, 0x93, 0xa9, 0xf8, 0xca, 0x62, 0xe8, 0x41, 0xb5, 0x8b, 0xdd, 0xb2, 0x04, 0x2f, 0x88, 0x8e, 0x30, 0x99, 0xb5, 0x36, 0x38, 0xb8, 0x8d, 0xfc, 0x93, 0x0b, 0x7a, 0x6e, 0xe4, 0x27, 0x2d, 0x77, 0xe4, 0xb1, 0xd7, 0xe4, 0x42, 0xba, 0xb6, 0xaf, 0xbd, 0xe9, 0x6a, 0xb0, 0xb4, 0x32, 0xf0, 0x09, 0x2d, 0x9c, 0xa5, 0x0e, 0xef, 0x42, 0xf6, 0x3c, 0x60, 0xc0, 0x9e, 0x7b, 0x8d, 0xe0, 0x19, 0xb3, 0x2e, 0xbe, 0x40, 0x30, 0xc3, 0x7b, 0x81, 0x83, 0xcc, 0x1e, 0x3b, 0x91, 0x3b, 0x0c, 0xe4, 0xee, 0x4d, 0x74, 0x43, 0x98, 0xfa, 0x03, 0xf9, 0xaf, 0x1c, 0x07, 0x0b, 0xed, 0x8c, 0xda, 0xfd, 0x65, 0xb3, 0xa8, 0x41, 0x40, 0xcb, 0x4d, 0xea, 0xdc, 0x70, 0x18, 0x4d, 0xe7, 0x57, 0x33, 0x2c, 0xe3, 0x78, 0x0a, 0xf8, 0x43, 0x53, 0xf5, 0x40, 0x75, 0x52, 0x27, 0xe8, 0x86, 0xa8, 0xd7, 0xad, 0x98, 0x0f, 0x3d, 0xd6, 0xfd, 0x68, 0x26, 0x3d, 0x82, 0xe9, 0x3f, 0x88, 0x33, 0x81, 0xde, 0xc8, 0x88, 0xbc, 0x9f, 0x4f, 0x48, 0x34, 0x9a, 0xa2, 0xb4, 0xc3, 0x42, 0xcb, 0x9f, 0x48, 0xc6),
-      //   tag: vec!(0xf2, 0x6b, 0x3a, 0xf8, 0xa4, 0x5c, 0x41, 0x62, 0x91, 0xce, 0x66, 0x33, 0x07, 0x33, 0xb2, 0xf8)
-      // },
-      // TestVector{
-      //   key: [0x40, 0x5b, 0xb7, 0xb9, 0x47, 0x15, 0xb8, 0x75, 0xdf, 0x06, 0x86, 0x55, 0xf0, 0x05, 0x13, 0xcb, 0x1a, 0xe2, 0x3f, 0xfa, 0xac, 0x97, 0x7c, 0xe2, 0x73, 0xe5, 0x7d, 0x3f, 0x83, 0xb4, 0x36, 0x63],
-      //   nonce: [0x5c, 0x6d, 0xa1, 0x25, 0x94, 0x51, 0x11, 0x9a],
-      //   plain_text: vec!(0xf9, 0xf1, 0x43, 0xc0, 0xc5, 0x2c, 0x94, 0xb4, 0xba, 0x7b, 0x06, 0x08, 0xb1, 0x44, 0x15, 0x6a, 0x49, 0xe7, 0xb5, 0xd2, 0x7c, 0x97, 0x31, 0x57, 0x43, 0xd1, 0x71, 0x91, 0x1e, 0x36, 0x45, 0xab, 0x79, 0x57, 0xc8, 0x09, 0x24, 0xe3, 0xc6, 0xb9, 0xc2, 0x2a, 0xb7, 0xa1, 0xca, 0xc4, 0xb7, 0xe9, 0xc0, 0xde, 0x84, 0xe4, 0x9f, 0xd5, 0xe4, 0xa2, 0xd1, 0xab, 0x51, 0xd7, 0x64, 0xfc, 0x56, 0x70, 0x31, 0x86, 0x88, 0xec, 0x94, 0x2f, 0x7a, 0xb3, 0x4c, 0x33, 0x1d, 0xce, 0x8f, 0x90, 0xfe, 0xa6, 0x97, 0x2e, 0x07, 0xf0, 0xda, 0xde, 0xc2, 0x9d, 0x8e, 0xb3, 0xb7, 0xb6, 0x52, 0x1d, 0xdd, 0x67, 0x8a, 0x65, 0x27, 0xa9, 0x62, 0xf4, 0xd8, 0xaf, 0x78, 0xc0, 0x77, 0xe2, 0x7f, 0x7a, 0x0b, 0x2e, 0xf7, 0xea, 0xbd, 0x19, 0xe9, 0x2b, 0x7f, 0x8c, 0x1e, 0x8f, 0xb1, 0x66, 0xd4, 0x76, 0x3c, 0xe9, 0xc4, 0x0c, 0x88, 0x8c, 0xf4, 0x9a, 0xa9, 0xcd, 0xfc, 0x3e, 0x99, 0x7c, 0x8f, 0xe1, 0xcc, 0xe3, 0xfe, 0x80, 0x24, 0x41, 0xbb, 0xd6, 0x98, 0xde, 0x26, 0x9f, 0xf3, 0x16, 0xf3, 0x1c, 0x19, 0x6e, 0x62, 0xd1, 0x2c, 0x6b, 0xb5, 0xcd, 0x93, 0xfb, 0x3c, 0x79, 0xca, 0x63, 0x69, 0xf8, 0xc1, 0xac, 0x91, 0x02, 0xda, 0xf8, 0x18, 0x97, 0x5e, 0xa7, 0xf5, 0x13, 0xbb, 0x38, 0x57, 0x6a),
-      //   aad: vec!(0x6f, 0xe6, 0x44, 0x65, 0x05, 0x67, 0x7b, 0xf0, 0x8b, 0x38, 0x5e, 0x2f, 0x6d, 0x83, 0xef, 0x70, 0xe1, 0x54, 0x77, 0x12, 0x20, 0x8d, 0x9c, 0xeb, 0xc0, 0x10, 0xcb, 0xa8, 0xc1, 0x6e, 0xa4, 0xec, 0xe0, 0x58, 0xd7, 0x3c, 0x72, 0x27, 0x3e, 0xed, 0x65, 0x0a, 0xfd, 0xc9, 0xf9, 0x54, 0xf3, 0x5a, 0xa1, 0xbd, 0xf9, 0x0f, 0x11, 0x18, 0xb1, 0x17, 0x33, 0x68, 0xac, 0xbc, 0x8d, 0x38, 0xd9, 0x3e, 0xbf, 0x85, 0xbd, 0x30, 0xd6, 0xdc, 0x6d, 0x1b, 0x90, 0x91, 0x37, 0x90, 0xc3, 0xef, 0xa5, 0x5f, 0x34, 0xd3, 0x15, 0x31, 0xf7, 0x0c, 0x95, 0x87, 0x59, 0xb2, 0xba, 0x6f, 0x95, 0x6c, 0x6f, 0xcd, 0xd2, 0x89, 0xb5, 0x8c, 0xb4, 0xc2, 0x6e, 0x95, 0x15, 0xbf, 0x55, 0x0f, 0x0f, 0xd7, 0x1a, 0xb8, 0x52, 0x7f, 0x06, 0x2c, 0x95, 0x05, 0xcb, 0xb1, 0x6e, 0x8e, 0x03, 0x7d, 0x34, 0xde, 0x17, 0x56, 0xbe, 0xf0, 0x2a, 0x13, 0x3d, 0xbf, 0x4a, 0x9c, 0x00, 0xac, 0x03, 0xbe, 0xfc, 0x3f, 0xb7, 0xf1, 0x37, 0xaf, 0x04, 0xe1, 0x25, 0x95, 0xce, 0x95, 0x60, 0xf9, 0x8b, 0x61, 0x24, 0x80, 0xfc, 0xdb, 0xa3, 0xb8, 0xbe, 0x01, 0xdb, 0x56, 0xeb, 0xec, 0x40, 0xf9, 0xde, 0xae, 0x53, 0x2c, 0x3b, 0x03, 0x70, 0xb5, 0xc2, 0x3a, 0x2a, 0x6b, 0x02, 0xa4, 0xde, 0x69, 0xef, 0xa8, 0x90, 0x0c),
-      //   cipher_text: vec!(0x1a, 0x4b, 0x07, 0x38, 0x81, 0x92, 0x2c, 0x63, 0x66, 0x68, 0x0c, 0xc9, 0xc2, 0xa1, 0x27, 0xb2, 0x6f, 0x26, 0x41, 0x48, 0x65, 0x1b, 0x29, 0xab, 0xb0, 0xc3, 0x88, 0xcf, 0x6c, 0x9b, 0x18, 0x65, 0xdb, 0xa5, 0xa9, 0x91, 0xe1, 0xf8, 0x30, 0x9e, 0xfb, 0xdb, 0x91, 0xbc, 0xe4, 0x4b, 0x27, 0x87, 0x72, 0xc5, 0x8f, 0xd4, 0x12, 0x73, 0x52, 0x6c, 0x33, 0xfe, 0xc8, 0x4b, 0xeb, 0x53, 0xd1, 0x68, 0x9b, 0x9d, 0xa8, 0x48, 0x3f, 0x71, 0xbe, 0x6d, 0xb7, 0x3a, 0x73, 0x41, 0x70, 0x69, 0xbb, 0x4c, 0xd3, 0xf1, 0x95, 0x23, 0x6e, 0x8d, 0x0a, 0x00, 0xd1, 0x24, 0xee, 0xd3, 0xa6, 0xb6, 0xf8, 0x94, 0x15, 0xb1, 0x9a, 0x27, 0xfb, 0xe3, 0x57, 0x74, 0xf6, 0xa1, 0xa6, 0xee, 0x4b, 0xd4, 0x35, 0x0b, 0x25, 0x2b, 0x97, 0x5f, 0x0d, 0xb2, 0xd2, 0xee, 0xa8, 0x2f, 0x48, 0x36, 0x35, 0x08, 0x50, 0xd6, 0x29, 0x09, 0x01, 0xe7, 0x26, 0xe8, 0xaf, 0x13, 0x64, 0x4e, 0x2d, 0x98, 0xbc, 0x1d, 0x56, 0x9c, 0x20, 0x80, 0x05, 0x21, 0xe6, 0xaf, 0xfe, 0x97, 0x6b, 0xd4, 0x07, 0x04, 0x9a, 0x2e, 0x6d, 0x9d, 0xd2, 0x3f, 0x88, 0xd5, 0x2e, 0x65, 0x13, 0x91, 0xec, 0xd2, 0xfc, 0x45, 0xb8, 0x64, 0x31, 0x08, 0x24, 0xaa, 0xad, 0xfa, 0x20, 0x37, 0x62, 0xa7, 0x7c, 0x1d, 0x64, 0x56, 0x2d, 0xae),
-      //   tag: vec!(0x00, 0x60, 0x02, 0x6d, 0x3e, 0xfc, 0x12, 0x0f, 0x11, 0xc0, 0x73, 0x99, 0x59, 0xae, 0x00, 0x66)
-      // },
-      // TestVector{
-      //   key: [0x8c, 0x60, 0x2b, 0xd9, 0x4c, 0x63, 0x0c, 0xd0, 0x0c, 0x7a, 0x9c, 0x50, 0x80, 0x67, 0xa5, 0xa9, 0xf1, 0x33, 0xd1, 0x2f, 0x06, 0xd9, 0xf6, 0xfe, 0x2a, 0x7b, 0x68, 0xdc, 0xe4, 0x78, 0x6d, 0x8a],
-      //   nonce: [0x76, 0x0d, 0xe0, 0xf7, 0xb7, 0xcb, 0x67, 0xe2],
-      //   plain_text: vec!(0xc3, 0xff, 0x55, 0x9c, 0xf1, 0xd6, 0xba, 0x6c, 0x0c, 0xc7, 0x93, 0xca, 0x09, 0xa0, 0xba, 0x57, 0x3a, 0x28, 0x35, 0x93, 0x86, 0xa6, 0xec, 0x93, 0xe1, 0xba, 0xcd, 0x8e, 0x63, 0x02, 0x09, 0xe0, 0xb4, 0x77, 0xa2, 0x0a, 0xed, 0xec, 0x3c, 0x9c, 0xbf, 0x51, 0x3e, 0xe6, 0xa1, 0xe3, 0x88, 0x71, 0x12, 0x21, 0x8d, 0x61, 0x55, 0xb9, 0x87, 0x5f, 0x7e, 0x6c, 0x4b, 0xbb, 0xa2, 0xc3, 0x19, 0x72, 0xe9, 0x05, 0xd1, 0x9f, 0x52, 0x9f, 0x4f, 0x0f, 0x95, 0x02, 0x99, 0x61, 0x99, 0xf9, 0x4f, 0x87, 0x28, 0xba, 0x8d, 0x64, 0x24, 0xbb, 0x15, 0xf8, 0x7f, 0xca, 0xcd, 0x88, 0xbb, 0x42, 0xc6, 0x3f, 0xcc, 0x51, 0x37, 0x59, 0x71, 0x2b, 0xd0, 0x17, 0x2b, 0x1e, 0x87, 0xc9, 0xda, 0x12, 0x2f, 0x19, 0x93, 0xff, 0xb7, 0xef, 0xd3, 0xa5, 0xc3, 0x4b, 0x24, 0x0d, 0xd3, 0xdb, 0x89, 0xdd, 0xde, 0xa3, 0x6d, 0xbe, 0xb2, 0x83, 0x6d, 0x9f, 0x86, 0x48, 0xf8, 0xe7, 0xcd, 0x42, 0x8c, 0x0f, 0x94, 0x80, 0x97, 0xaf, 0x75, 0x3b, 0x35, 0xf9, 0x87, 0x60, 0x59, 0xe7, 0x70, 0x20, 0x27, 0xbb, 0x00, 0xdc, 0x69, 0x07, 0x12, 0x06, 0xe7, 0x85, 0xf4, 0x8f, 0xcb, 0xf8, 0x1b, 0x39, 0xcc, 0x03, 0x43, 0x97, 0x4a, 0xc7, 0x07, 0x84, 0xa2, 0xe6, 0x0c, 0x0d, 0xf9, 0x3b, 0x40, 0x37, 0x9b, 0xea, 0x4a, 0xd8, 0xca, 0xc6, 0x25),
-      //   aad: vec!(0x9e, 0x14, 0x90, 0x7c, 0x3a, 0x8e, 0x96, 0xc2, 0x63, 0x6d, 0xb1, 0xf3, 0xd7, 0x8e, 0xb1, 0xf6, 0x73, 0xd6, 0xef, 0x04, 0x3c, 0xbb, 0xb3, 0x49, 0x46, 0x7f, 0x1f, 0xe2, 0x9b, 0xf6, 0x0f, 0x23, 0xd5, 0xd5, 0xd1, 0xc3, 0xb1, 0x33, 0xa8, 0xad, 0x72, 0x06, 0x5d, 0x82, 0x23, 0x47, 0x54, 0x1c, 0x13, 0xd1, 0x57, 0x4b, 0xaf, 0x73, 0x7e, 0xb3, 0xcc, 0x33, 0x82, 0xfb, 0x47, 0x9e, 0x6d, 0x51, 0x93, 0xb9, 0xc8, 0xe7, 0xd2, 0x44, 0x4c, 0x66, 0x97, 0x1e, 0xf0, 0x99, 0xdc, 0x7f, 0x37, 0xf6, 0xcd, 0x97, 0xb9, 0xf7, 0x95, 0x9d, 0x46, 0xe2, 0xcf, 0x25, 0xe8, 0xa5, 0xb3, 0x11, 0x1b, 0x4d, 0x9e, 0x2e, 0xf9, 0x06, 0xd9, 0x05, 0xf0, 0xee, 0x2d, 0x17, 0x58, 0x7f, 0x70, 0x82, 0xd7, 0xc8, 0xe9, 0xa5, 0x15, 0x09, 0xbd, 0xe0, 0x3d, 0x3d, 0x64, 0x33, 0x8e, 0x18, 0x38, 0xd7, 0x17, 0x00, 0xf1, 0xb4, 0xfc, 0xb1, 0x00, 0xb5, 0xe0, 0x40, 0x29, 0x69, 0xda, 0x46, 0x2f, 0x26, 0xf9, 0x74, 0xb4, 0xf9, 0xe7, 0x66, 0x12, 0x1f, 0x8f, 0xd5, 0x4b, 0xe9, 0x9f, 0xc1, 0x0b, 0xeb, 0x9a, 0x60, 0x6e, 0x13, 0xfb, 0xb1, 0xf9, 0x60, 0x06, 0x28, 0x15, 0xd1, 0x9e, 0x67, 0xf8, 0x00, 0x93, 0x36, 0x03, 0x24, 0x01, 0x30, 0x95, 0x71, 0x92, 0x73, 0xc6, 0x55, 0x42, 0xb0, 0xe3, 0x1b, 0x1a, 0x2a, 0x3d, 0x92, 0x8f),
-      //   cipher_text: vec!(0x27, 0x94, 0xe6, 0xe1, 0x33, 0xf6, 0x89, 0x2f, 0x23, 0x83, 0x7f, 0xff, 0x60, 0xcf, 0x7c, 0x28, 0xee, 0x99, 0x42, 0xf8, 0x98, 0x2e, 0xf8, 0x08, 0x9d, 0xb1, 0x17, 0x90, 0x3d, 0x01, 0x43, 0x29, 0x3f, 0xdf, 0x12, 0xea, 0x1c, 0xc0, 0x14, 0xbc, 0xd8, 0x80, 0x6f, 0xb8, 0x3c, 0x19, 0x57, 0x0e, 0xed, 0x7a, 0xf5, 0x22, 0xdb, 0x0d, 0xe4, 0x89, 0xbb, 0xc8, 0x71, 0x33, 0xa1, 0x34, 0x34, 0x51, 0x8b, 0xcf, 0xb9, 0xcd, 0xa4, 0xd9, 0xf6, 0xd8, 0x32, 0xa6, 0x92, 0x09, 0x65, 0x7a, 0x44, 0x7a, 0xbf, 0x8a, 0xfd, 0x81, 0x6a, 0xe1, 0x5f, 0x31, 0x3c, 0x7e, 0xa9, 0x5e, 0xc4, 0xbc, 0x69, 0x4e, 0xfc, 0x23, 0x86, 0xcd, 0xd8, 0xd9, 0x15, 0xdc, 0x47, 0x5e, 0x8f, 0xad, 0xf3, 0x42, 0x1f, 0xbb, 0x03, 0x19, 0xa3, 0xc0, 0xb3, 0xb6, 0xdf, 0xa8, 0x0c, 0xa3, 0xbb, 0x22, 0xc7, 0xaa, 0xb0, 0x7f, 0xe1, 0x4a, 0x3f, 0xea, 0x5f, 0x0a, 0xee, 0x17, 0xab, 0x13, 0x02, 0x33, 0x8e, 0xea, 0xc0, 0x10, 0xa0, 0x4e, 0x50, 0x5e, 0x20, 0x09, 0x6a, 0x95, 0xf3, 0x34, 0x7d, 0xc2, 0xb4, 0x51, 0x0f, 0x62, 0xd6, 0xa4, 0xc1, 0xfa, 0xe6, 0xb3, 0x69, 0x39, 0x50, 0x3a, 0x6a, 0xc2, 0x27, 0x80, 0xa6, 0x2d, 0x72, 0xf2, 0xfc, 0x38, 0x49, 0xd4, 0xef, 0x21, 0x26, 0x7f, 0xff, 0xde, 0xf2, 0x31, 0x96, 0xd8, 0x8f, 0xbb, 0x9b),
-      //   tag: vec!(0x45, 0x7c, 0xce, 0x6e, 0x07, 0x5f, 0xfd, 0xb1, 0x80, 0x76, 0x5a, 0xb2, 0xe1, 0x05, 0xc7, 0x07)
-      // },
-      // TestVector{
-      //   key: [0xbd, 0x68, 0xff, 0x5e, 0xb2, 0x96, 0xc7, 0x1c, 0xfe, 0x6b, 0xc9, 0x03, 0xc1, 0x49, 0x07, 0xf7, 0x72, 0x6b, 0xcb, 0x13, 0x31, 0xf0, 0xc7, 0x5f, 0x78, 0x01, 0xcd, 0x1b, 0x79, 0x48, 0xf3, 0xa1],
-      //   nonce: [0x65, 0xa7, 0x48, 0x00, 0x4b, 0x35, 0x2b, 0xa6],
-      //   plain_text: vec!(0x52, 0xbf, 0x78, 0xc0, 0x0f, 0x6e, 0x5d, 0xca, 0x2f, 0xc6, 0x0e, 0x2e, 0x9a, 0x52, 0xe8, 0x27, 0xdf, 0x97, 0x80, 0x8e, 0x9c, 0xf7, 0x27, 0x77, 0x38, 0x60, 0xca, 0xfc, 0x89, 0xf4, 0xb6, 0x41, 0x78, 0xa1, 0x9b, 0x30, 0xb4, 0x6e, 0xd8, 0x13, 0xfe, 0x00, 0xc8, 0xf0, 0x9b, 0x25, 0xa6, 0xa1, 0xb6, 0xe3, 0x50, 0xd5, 0xb0, 0x05, 0x12, 0x29, 0x34, 0xa5, 0x9b, 0xfb, 0xd5, 0xe6, 0xe0, 0xc6, 0x35, 0xc8, 0x4a, 0x52, 0x26, 0xc3, 0xf2, 0xf7, 0xdc, 0xf9, 0x51, 0x56, 0x0f, 0x18, 0xac, 0x22, 0x04, 0x53, 0xd5, 0x83, 0x01, 0x5f, 0xdb, 0x2e, 0x44, 0x6c, 0x69, 0xc6, 0xe6, 0xfd, 0xec, 0xf2, 0xe5, 0x95, 0xe0, 0x4f, 0xab, 0x1b, 0x0c, 0x50, 0x6e, 0x3c, 0x6b, 0xd5, 0xe4, 0x41, 0x4a, 0x35, 0xf1, 0x50, 0x21, 0xe9, 0x7f, 0x44, 0x7a, 0xa3, 0x34, 0xf5, 0x4a, 0x8f, 0x1e, 0xf9, 0x42, 0xde, 0xc6, 0x27, 0x35, 0x11, 0xb5, 0x66, 0x8b, 0x69, 0x6f, 0xca, 0x97, 0x18, 0x8f, 0xf1, 0x5e, 0xd8, 0x4b, 0x2f, 0x46, 0x14, 0x5c, 0xce, 0x03, 0x1c, 0x1a, 0x7f, 0x00, 0xbd, 0x88, 0xbb, 0x83, 0xd9, 0x07, 0x97, 0xed, 0xc4, 0x61, 0x61, 0xb3, 0xfd, 0xa7, 0xa2, 0x29, 0x91, 0x73, 0x49, 0x6d, 0x73, 0xb8, 0x12, 0x13, 0x95, 0x56, 0xe8, 0xb4, 0xeb, 0x31, 0x80, 0x78, 0xb9, 0xeb, 0x2a, 0xe5, 0x04, 0x6e, 0x83, 0xb7, 0x9d, 0xd3, 0xd4, 0x59, 0x50),
-      //   aad: vec!(0x55, 0x57, 0xb0, 0x8a, 0x50, 0x10, 0xcb, 0xc9, 0xf4, 0x6b, 0xb1, 0x40, 0xc2, 0x50, 0x5f, 0x68, 0x68, 0x4e, 0xb2, 0x48, 0x89, 0x32, 0x4b, 0xff, 0x44, 0xb2, 0x72, 0x34, 0xfd, 0x7a, 0x95, 0xa9, 0x9c, 0xfb, 0x4f, 0xf9, 0x0a, 0x8f, 0x99, 0x82, 0x08, 0x5b, 0x72, 0x5f, 0x78, 0xac, 0x42, 0xec, 0xa6, 0xce, 0x7f, 0x33, 0x14, 0xe4, 0x57, 0xdc, 0x41, 0xf4, 0x04, 0x00, 0x86, 0x81, 0xa9, 0xd2, 0x9b, 0xa7, 0x65, 0x66, 0x0d, 0xe2, 0xe0, 0x5b, 0xb6, 0x79, 0xd6, 0x5b, 0x81, 0xf5, 0xe7, 0x97, 0xd8, 0x41, 0x7b, 0x94, 0xeb, 0x9a, 0xab, 0xbd, 0x05, 0x76, 0xb5, 0xc5, 0x7f, 0x86, 0xea, 0xe2, 0x5f, 0x60, 0x50, 0xa7, 0x91, 0x8e, 0x4c, 0x80, 0x21, 0xa8, 0x5b, 0x47, 0xf7, 0xa8, 0x3b, 0x4c, 0x84, 0x46, 0x89, 0x84, 0x41, 0xc5, 0xcc, 0x4e, 0x02, 0x29, 0x77, 0x6e, 0xf3, 0xe8, 0x09, 0xcb, 0x08, 0x5d, 0x71, 0xf3, 0xc7, 0x5e, 0xc0, 0x33, 0x78, 0x73, 0x0c, 0xb0, 0x66, 0x15, 0x0f, 0x07, 0xe6, 0x0f, 0x96, 0xae, 0xc9, 0x83, 0xc0, 0xe7, 0xe7, 0x2b, 0xf6, 0xbf, 0x87, 0xae, 0x42, 0x22, 0x8d, 0xfd, 0xa1, 0x95, 0xf9, 0x78, 0x55, 0xfc, 0xdf, 0x4e, 0x6d, 0x1c, 0x44, 0x79, 0xd9, 0x78, 0xab, 0xcf, 0xa2, 0x76, 0xd1, 0x6e, 0xd6, 0x0e, 0xcb, 0xfb, 0xfc, 0x66, 0x40, 0x41, 0x33, 0x5c, 0xe6, 0x5a, 0x40, 0xa2, 0xca, 0x34, 0x24, 0xdf),
-      //   cipher_text: vec!(0xa5, 0xc8, 0xcf, 0x42, 0x28, 0x7d, 0x47, 0x60, 0xfc, 0xa7, 0x55, 0xe2, 0x11, 0x18, 0x17, 0xb9, 0x81, 0xc4, 0x7e, 0x85, 0xb0, 0x04, 0x7d, 0xe2, 0x70, 0xec, 0x30, 0x1c, 0xa5, 0xf7, 0xb3, 0x67, 0x9f, 0x47, 0x49, 0x21, 0x08, 0x92, 0xb6, 0xea, 0x65, 0x68, 0xf3, 0xa6, 0xa4, 0x34, 0x47, 0x34, 0xa0, 0xef, 0xc0, 0x12, 0x0f, 0xfe, 0xde, 0xcf, 0x21, 0x2d, 0x55, 0xcb, 0xcb, 0xb6, 0x78, 0x15, 0xac, 0x96, 0x48, 0x75, 0xaf, 0x45, 0xf7, 0x35, 0xb7, 0x00, 0x92, 0xa8, 0xf8, 0x43, 0x5f, 0x52, 0xfc, 0x01, 0xb9, 0x81, 0xae, 0x97, 0x1d, 0x48, 0x60, 0x26, 0xfb, 0x69, 0xa9, 0xc3, 0x92, 0x7a, 0xcf, 0xe1, 0xf2, 0xea, 0xb0, 0x34, 0x0a, 0xe9, 0x5f, 0x8d, 0xbe, 0xe4, 0x1b, 0x25, 0x48, 0xe4, 0x00, 0x80, 0x5e, 0xce, 0x19, 0x1d, 0xb5, 0xfd, 0x1f, 0x08, 0x04, 0x05, 0x3f, 0x1d, 0xbf, 0xaf, 0x7f, 0x8d, 0x6f, 0xde, 0xd3, 0x87, 0x4c, 0xb9, 0x2d, 0x99, 0xa2, 0x72, 0x9d, 0x3f, 0xaa, 0xa6, 0x05, 0x22, 0x06, 0x0c, 0xf0, 0xb8, 0x10, 0x1b, 0x46, 0x3b, 0x3e, 0xb3, 0x5b, 0x38, 0x0f, 0xcd, 0xdb, 0x64, 0x06, 0xc0, 0x27, 0xd7, 0x3f, 0xe7, 0x01, 0xa5, 0x09, 0x0c, 0x8d, 0xd5, 0x31, 0xc2, 0x03, 0xce, 0x97, 0x9e, 0x26, 0xb9, 0xce, 0xd3, 0x43, 0x1e, 0x2b, 0x72, 0x6a, 0x72, 0x44, 0xa2, 0x0d, 0x93, 0x77, 0xbd, 0x62, 0x95, 0x1b, 0xf5),
-      //   tag: vec!(0x45, 0x79, 0xfa, 0x1f, 0xdb, 0x4c, 0x67, 0x4c, 0xc3, 0xcd, 0x23, 0x2b, 0x8d, 0xa5, 0x2a, 0x97)
-      // },
-      // TestVector{
-      //   key: [0x93, 0x4f, 0xd0, 0x43, 0xc3, 0x2d, 0x16, 0xa8, 0x8f, 0xad, 0x01, 0xc3, 0x50, 0x64, 0x69, 0xb0, 0x77, 0xcb, 0x79, 0xd2, 0x58, 0xb5, 0x66, 0x4f, 0xa5, 0x5a, 0xd8, 0x52, 0x1a, 0xfd, 0xca, 0xa2],
-      //   nonce: [0xc7, 0x09, 0x1f, 0x6a, 0xfb, 0xbe, 0xb3, 0x60],
-      //   plain_text: vec!(0x2b, 0xdd, 0x1f, 0xc4, 0xf0, 0x11, 0xef, 0x97, 0xea, 0x52, 0xec, 0x64, 0x38, 0x19, 0x94, 0x1c, 0x7e, 0x0f, 0xb3, 0x90, 0x23, 0xc2, 0xf3, 0xc7, 0x68, 0x38, 0x04, 0xa0, 0xdd, 0xee, 0x14, 0xa5, 0xd1, 0x78, 0x4a, 0x52, 0x46, 0x96, 0x6d, 0x53, 0x3b, 0x35, 0x38, 0xed, 0xc7, 0xd8, 0x74, 0x2d, 0x27, 0x06, 0x1c, 0x3c, 0xab, 0x88, 0xdf, 0x03, 0x18, 0xab, 0x24, 0x21, 0x02, 0xde, 0x3a, 0x54, 0xd0, 0x36, 0x32, 0xee, 0xb8, 0x71, 0xb7, 0x2c, 0x7e, 0x8f, 0x80, 0x65, 0xb4, 0x9f, 0x4a, 0x91, 0xe9, 0x5e, 0x15, 0xf3, 0xf4, 0x6b, 0x29, 0xfd, 0x76, 0xb8, 0xfc, 0xea, 0x0d, 0x23, 0x57, 0x0c, 0x55, 0x30, 0xe3, 0xbb, 0xb8, 0xa6, 0xaa, 0xfa, 0x9a, 0xe3, 0x2c, 0x1b, 0x3e, 0xac, 0x65, 0x3c, 0x5e, 0xd5, 0xfd, 0xb2, 0xda, 0x5a, 0x98, 0x60, 0x75, 0x80, 0x8f, 0x63, 0x85, 0x87, 0x0c, 0x85, 0xb1, 0x91, 0x3e, 0x26, 0x04, 0x2a, 0x9d, 0x8e, 0x78, 0xf5, 0xbc, 0x2e, 0xa6, 0xde, 0x5a, 0x64, 0xf8, 0xae, 0xaf, 0xa2, 0x2a, 0xdc, 0xff, 0xc7, 0xf6, 0x93, 0x2d, 0x54, 0x3c, 0x29, 0xbb, 0x3a, 0x04, 0x61, 0x47, 0x83, 0xf9, 0x48, 0x68, 0x0e, 0x43, 0x3a, 0x71, 0x57, 0x35, 0x68, 0xd2, 0xce, 0x98, 0x4d, 0x24, 0x9f, 0xb4, 0xfc, 0x06, 0xa9, 0xf3, 0x58, 0xc7, 0x6a, 0xa3, 0xe6, 0x4a, 0x35, 0x7f, 0x4e, 0xae, 0x92, 0x4c, 0x13, 0x56, 0xbd, 0x5b, 0xac, 0xcf, 0x7e, 0x0f),
-      //   aad: vec!(0xf7, 0x37, 0xdd, 0x85, 0x63, 0x8e, 0xb3, 0x24, 0xdd, 0x38, 0x91, 0x21, 0x9c, 0x5e, 0xef, 0x7c, 0x2d, 0xd0, 0x53, 0xcf, 0xd0, 0x55, 0xd4, 0x47, 0xa4, 0x11, 0xeb, 0xa3, 0x04, 0xa4, 0xb2, 0x7d, 0xce, 0x98, 0x1d, 0x11, 0x2c, 0x45, 0x40, 0x59, 0x09, 0x33, 0xc1, 0x53, 0xd6, 0x03, 0x02, 0x2c, 0x91, 0xeb, 0xd2, 0xb4, 0xa5, 0x80, 0x69, 0xd2, 0x7e, 0x6c, 0xa1, 0x7a, 0x46, 0x2e, 0xf8, 0x22, 0xca, 0x41, 0xbf, 0xfa, 0x80, 0xb4, 0x3a, 0x68, 0xb1, 0xb5, 0x64, 0x64, 0x4c, 0xb3, 0xc5, 0xa7, 0xf0, 0xfd, 0xdf, 0x7a, 0x13, 0xa3, 0x0f, 0xf2, 0x44, 0x37, 0xfd, 0xdd, 0x8e, 0xf9, 0x3c, 0x6f, 0x6f, 0x20, 0x5d, 0x05, 0x4f, 0x81, 0x89, 0x0d, 0x98, 0x2b, 0xd4, 0xd4, 0xec, 0xe0, 0xb1, 0x56, 0x36, 0x77, 0xe8, 0x43, 0xfe, 0x48, 0xc1, 0xf5, 0x4e, 0x9a, 0x57, 0xed, 0x4d, 0xa6, 0x60, 0x61, 0x48, 0x27, 0x12, 0xe7, 0x10, 0xa4, 0x01, 0x07, 0x3b, 0xe5, 0x08, 0x0d, 0x5b, 0x8b, 0x96, 0x52, 0x5b, 0xff, 0xa6, 0x7d, 0xe5, 0xaf, 0x31, 0xd5, 0x03, 0x85, 0xfb, 0xbf, 0x1a, 0x87, 0xc2, 0x1b, 0xf0, 0xe0, 0xa1, 0xfd, 0xff, 0x69, 0xec, 0x32, 0xc7, 0xb7, 0x10, 0x3e, 0x0b, 0x8e, 0xe6, 0xc8, 0x44, 0x24, 0x5e, 0x0f, 0xc8, 0x4b, 0x9f, 0x89, 0xfc, 0xce, 0x62, 0x96, 0x6c, 0xea, 0x68, 0xe2, 0x87, 0x1d, 0x3b, 0x82, 0xe8, 0xdf, 0x42, 0x4c, 0x76, 0x30, 0x9f, 0xc8, 0x8d),
-      //   cipher_text: vec!(0xdd, 0x13, 0xfb, 0xf2, 0x2c, 0x8d, 0x18, 0x35, 0x4d, 0x77, 0x4b, 0xcd, 0x18, 0xf7, 0xeb, 0x81, 0x4e, 0x9b, 0x52, 0x8e, 0x9e, 0x42, 0x4a, 0xbc, 0x4e, 0x3f, 0x24, 0x63, 0x19, 0x5e, 0x80, 0x18, 0x57, 0x65, 0x65, 0xd1, 0x6a, 0xb4, 0x88, 0x45, 0xd1, 0x1c, 0x92, 0x77, 0xf2, 0x86, 0x5e, 0xbb, 0x4d, 0xc4, 0x12, 0xfd, 0x5b, 0x27, 0x07, 0x8f, 0x83, 0x25, 0xea, 0xdf, 0x97, 0x1e, 0x69, 0x44, 0xc6, 0x65, 0x42, 0xe3, 0x4d, 0x9d, 0xda, 0x97, 0x1e, 0x2a, 0xba, 0x70, 0xdb, 0xd3, 0xe9, 0x4a, 0x1e, 0x63, 0x8d, 0x52, 0x14, 0x77, 0xa0, 0x27, 0x77, 0x6b, 0x52, 0xac, 0xf9, 0x05, 0x20, 0xca, 0x22, 0x9e, 0xbc, 0x76, 0x0b, 0x73, 0x12, 0x88, 0x79, 0x47, 0x5d, 0x1c, 0xbe, 0x1f, 0x70, 0xfc, 0x59, 0x8b, 0x54, 0x9c, 0xd9, 0x2d, 0x8a, 0x9a, 0xc6, 0x83, 0x3e, 0x50, 0x0c, 0x13, 0x8c, 0x56, 0x47, 0x4d, 0xb8, 0x4c, 0xb3, 0xd7, 0x0b, 0x7a, 0xa4, 0xf2, 0x93, 0xa4, 0xc2, 0xb4, 0xd8, 0x18, 0xb0, 0xff, 0x9f, 0xd8, 0x59, 0x18, 0xdc, 0x59, 0x0a, 0x12, 0xa8, 0xc0, 0xe3, 0x75, 0xc4, 0xd9, 0x8b, 0x7f, 0xc8, 0x75, 0x96, 0x54, 0x7e, 0xb9, 0x60, 0x67, 0x6a, 0xad, 0x55, 0x59, 0x83, 0x45, 0x88, 0xf0, 0x0f, 0x25, 0x1a, 0x9d, 0x53, 0xf9, 0x5c, 0x47, 0xaf, 0x4d, 0xf3, 0xc4, 0x29, 0x91, 0x75, 0xd5, 0x21, 0x17, 0x79, 0xc1, 0x48, 0xcf, 0xc9, 0x88, 0xa5, 0xe9, 0xd9),
-      //   tag: vec!(0x47, 0x66, 0x16, 0xea, 0x15, 0x19, 0x0c, 0x10, 0x93, 0xfd, 0xc4, 0xa0, 0x87, 0x64, 0x3c, 0xae)
-      // },
-      // TestVector{
-      //   key: [0xf9, 0xf6, 0xeb, 0x9a, 0xd7, 0x36, 0xa8, 0xf6, 0x6e, 0x74, 0x59, 0xfe, 0xf5, 0xec, 0x28, 0x90, 0x18, 0x8d, 0xc2, 0x6b, 0xaf, 0x34, 0xa9, 0x5f, 0x6f, 0x03, 0x84, 0xe7, 0x9f, 0x5c, 0x65, 0x59],
-      //   nonce: [0x78, 0x58, 0xdf, 0xc0, 0x84, 0xfe, 0x4b, 0x0f],
-      //   plain_text: vec!(0xa6, 0x44, 0xca, 0x6e, 0x7c, 0xc0, 0x76, 0xe8, 0x7e, 0xb2, 0x92, 0x9f, 0xd2, 0x57, 0x69, 0x3f, 0xce, 0x0f, 0x6f, 0xb6, 0x4f, 0xd6, 0x32, 0xf7, 0xf0, 0x7c, 0x64, 0x8e, 0xbd, 0x03, 0x69, 0x6c, 0x8e, 0x26, 0x2e, 0x6a, 0x81, 0x0d, 0x7b, 0x7c, 0x4e, 0x5e, 0xef, 0x8c, 0x65, 0xb5, 0x32, 0x3c, 0x99, 0xdb, 0xba, 0x50, 0xa7, 0x0b, 0x4a, 0x9e, 0x5c, 0x2a, 0x9e, 0x73, 0x15, 0x97, 0x3c, 0xd6, 0x7f, 0x35, 0xd8, 0x05, 0x2c, 0xe9, 0xa8, 0x5a, 0x20, 0x64, 0x16, 0xdd, 0x30, 0x31, 0x92, 0x9f, 0x4f, 0x92, 0x9b, 0x13, 0xd0, 0xa5, 0xfb, 0x10, 0xcb, 0x73, 0xc6, 0x5f, 0x6c, 0x0a, 0xce, 0x01, 0x9d, 0xa1, 0x46, 0xb5, 0x1c, 0x52, 0x74, 0xa0, 0x99, 0xf4, 0x4e, 0x36, 0x69, 0xd2, 0x6a, 0xdd, 0x6f, 0x2f, 0xf0, 0x81, 0xe8, 0x86, 0xf3, 0xcf, 0x95, 0x2f, 0xe0, 0xdb, 0xbe, 0x6b, 0x05, 0x34, 0xc2, 0x3e, 0x30, 0x75, 0x74, 0xbd, 0x35, 0xfb, 0xd6, 0x57, 0xf5, 0xfc, 0xbd, 0x5d, 0xc1, 0x9f, 0xb3, 0x82, 0xa1, 0xdc, 0x0a, 0x2d, 0xc8, 0x28, 0x5a, 0x03, 0x50, 0xf7, 0x15, 0x54, 0xe4, 0xc6, 0x01, 0x49, 0x77, 0x49, 0xe3, 0x55, 0x67, 0xdd, 0x4a, 0x27, 0x3c, 0xdd, 0xc9, 0xa4, 0x8c, 0xe5, 0x3a, 0x5f, 0x1d, 0x29, 0x7f, 0xd8, 0xba, 0xf8, 0xd1, 0xb9, 0xfe, 0xb3, 0x5d, 0x91, 0x51, 0x11, 0x43, 0x45, 0xab, 0xad, 0xa4, 0xd9, 0x0d, 0xb9, 0x47, 0xbb, 0x9a, 0x74, 0x3c, 0x17, 0x5f, 0x56, 0x53, 0xd1),
-      //   aad: vec!(0x20, 0x48, 0xd1, 0xc2, 0xdd, 0xfb, 0x5e, 0xc3, 0x85, 0xb2, 0x01, 0x83, 0x2c, 0x7a, 0x99, 0x3f, 0x22, 0x9b, 0xa7, 0x2e, 0xc1, 0x6d, 0x6e, 0xbf, 0x72, 0x3e, 0xf0, 0xc5, 0x03, 0x2b, 0x99, 0x66, 0x20, 0x9a, 0x9e, 0x8a, 0x63, 0x15, 0x1b, 0x40, 0x41, 0x2e, 0x96, 0xb8, 0x2f, 0x86, 0x72, 0x8e, 0xa6, 0x58, 0x8c, 0x7e, 0x8e, 0x11, 0xac, 0x71, 0xcc, 0x8e, 0xab, 0xab, 0x8c, 0x4b, 0x54, 0xde, 0x86, 0x66, 0x58, 0xd9, 0xc5, 0x01, 0x1d, 0xef, 0x61, 0xfb, 0x3d, 0xbe, 0x4e, 0x63, 0x01, 0x58, 0xa4, 0x5e, 0xa4, 0x1a, 0x2e, 0xd5, 0x5e, 0xbd, 0x1e, 0xfb, 0x1a, 0xbe, 0xda, 0x76, 0x37, 0xde, 0x6f, 0xa5, 0xfd, 0x2f, 0x15, 0x1c, 0x6d, 0x2f, 0x38, 0x5b, 0xf6, 0xcd, 0x00, 0x2c, 0xa8, 0xb4, 0xa2, 0x89, 0x6e, 0x0d, 0x65, 0x94, 0x4e, 0xe9, 0x13, 0xe3, 0xc7, 0x84, 0x66, 0x9d, 0xd2, 0x01, 0xb1, 0x98, 0x5e, 0xf3, 0x57, 0x7f, 0x7f, 0x12, 0x3a, 0x5f, 0x9b, 0xcf, 0xfa, 0x17, 0x6c, 0x8f, 0x55, 0x7c, 0x4f, 0x72, 0x91, 0x33, 0xca, 0xc5, 0x18, 0x64, 0x2f, 0x27, 0xd9, 0xb2, 0x2c, 0xa9, 0xb9, 0x7f, 0xaa, 0xaf, 0xe5, 0xb6, 0x69, 0xa1, 0x0b, 0x79, 0xac, 0xe4, 0xa7, 0xd5, 0x72, 0x7d, 0xf1, 0x46, 0xc7, 0x7c, 0xe6, 0x81, 0x35, 0x7d, 0x69, 0xf9, 0xc2, 0xd6, 0x5b, 0x44, 0x01, 0xbd, 0x73, 0xcd, 0x11, 0x33, 0x87, 0xe3, 0xb3, 0xa0, 0x5d, 0x89, 0x7a, 0xda, 0xd7, 0xa2, 0x4c, 0x48, 0x5e, 0x7b),
-      //   cipher_text: vec!(0x41, 0x46, 0xfa, 0xff, 0xd7, 0x31, 0x3f, 0x5d, 0x9f, 0x62, 0x53, 0x70, 0xd2, 0x04, 0x13, 0xcc, 0x62, 0xab, 0x65, 0xf4, 0xac, 0xfa, 0x3c, 0x7e, 0xe1, 0x12, 0x5b, 0x93, 0x7d, 0xd7, 0xa3, 0x9f, 0x63, 0x8f, 0xc4, 0x6c, 0x8e, 0xd0, 0x04, 0xfb, 0x52, 0x56, 0x98, 0xde, 0x5d, 0x86, 0x20, 0xec, 0x15, 0x34, 0x35, 0x57, 0x18, 0x17, 0xc3, 0xde, 0x25, 0x7b, 0x0d, 0x0e, 0x64, 0x8e, 0xbb, 0x92, 0x94, 0x0c, 0x86, 0xa9, 0x82, 0x62, 0xd5, 0x4e, 0x76, 0x4f, 0x28, 0xcb, 0xdd, 0x4f, 0x7d, 0x9b, 0xea, 0x97, 0x02, 0x91, 0xf2, 0x11, 0x04, 0x14, 0xf6, 0x20, 0x64, 0xd7, 0x22, 0x9c, 0x63, 0x32, 0x23, 0x6c, 0x50, 0x7b, 0x3d, 0xac, 0x74, 0x2e, 0x65, 0x1d, 0x85, 0xa2, 0xa2, 0x2f, 0xb2, 0x43, 0xc0, 0xcc, 0x7c, 0xc2, 0xd0, 0x16, 0xe5, 0xbe, 0xa3, 0x8f, 0x33, 0xf9, 0xa9, 0xce, 0x04, 0x89, 0x44, 0xa5, 0xfe, 0x8b, 0x07, 0x8d, 0x71, 0xd2, 0x31, 0x68, 0xe1, 0x2d, 0xfe, 0x5a, 0x0f, 0x0b, 0x82, 0x97, 0x71, 0xed, 0xc7, 0x07, 0x3f, 0xb9, 0x60, 0x32, 0xb7, 0xbe, 0x47, 0x13, 0x37, 0xa3, 0x7a, 0xca, 0x0c, 0xf7, 0xc0, 0xcd, 0xd5, 0x43, 0xee, 0xd6, 0x86, 0xcd, 0x34, 0x93, 0x47, 0x17, 0xfd, 0x79, 0xa3, 0xf1, 0x84, 0x92, 0xee, 0xf7, 0x2f, 0x9f, 0x45, 0x0b, 0x88, 0x0a, 0xa7, 0xe2, 0xe1, 0xb6, 0x5e, 0x3b, 0x04, 0xc2, 0x2e, 0x72, 0x30, 0x13, 0x38, 0xb4, 0x3a, 0xa3, 0x2c, 0xee, 0xc2, 0xe6),
-      //   tag: vec!(0x10, 0xff, 0xaf, 0x2b, 0xe3, 0x16, 0x67, 0x6d, 0xa0, 0x2d, 0x74, 0x73, 0xa9, 0xdf, 0x87, 0xb9)
-      // },
-      // TestVector{
-      //   key: [0x29, 0xb1, 0x96, 0x36, 0xcd, 0xd3, 0x25, 0x07, 0xfd, 0x98, 0xec, 0x4e, 0xe2, 0x6c, 0xaa, 0xb1, 0xa9, 0x17, 0x64, 0x6f, 0xb8, 0xf0, 0x5b, 0x0d, 0xc0, 0x17, 0x28, 0xa9, 0xf4, 0xa1, 0x27, 0xf0],
-      //   nonce: [0x06, 0x69, 0x9d, 0x24, 0x59, 0x16, 0x68, 0x6d],
-      //   plain_text: vec!(0x5f, 0xdf, 0x91, 0x3a, 0xce, 0xab, 0x1d, 0x6d, 0xba, 0xf7, 0xd9, 0xa2, 0x93, 0x52, 0xfa, 0x8a, 0x3e, 0xb2, 0x27, 0x18, 0x04, 0x3a, 0x79, 0xcf, 0xfa, 0x2f, 0xe8, 0xc3, 0x5c, 0x82, 0x0a, 0xec, 0x7c, 0x07, 0x64, 0x4b, 0x87, 0x85, 0xdc, 0xf7, 0xa4, 0x33, 0xb4, 0x18, 0x9a, 0xbb, 0x25, 0x7f, 0xb1, 0x2b, 0x06, 0xfa, 0xe0, 0x66, 0x26, 0x41, 0x01, 0x1a, 0x06, 0x98, 0x73, 0xc3, 0xe3, 0xc5, 0xcc, 0xc7, 0x8e, 0x73, 0x58, 0x18, 0x4a, 0x62, 0xc2, 0x00, 0x5c, 0x44, 0xb8, 0xa9, 0x22, 0x54, 0x95, 0x8e, 0xb5, 0xff, 0x46, 0x0d, 0x73, 0xcd, 0x80, 0x28, 0x4d, 0x6d, 0xab, 0xa2, 0x2c, 0x3f, 0xab, 0xa0, 0x46, 0xc5, 0x42, 0x6f, 0xe8, 0xb7, 0xca, 0xce, 0xc6, 0x4b, 0x23, 0x5a, 0x8f, 0x8d, 0x3e, 0x26, 0x41, 0xe5, 0xbc, 0x37, 0x88, 0x30, 0x59, 0x4b, 0xcf, 0xb2, 0x7c, 0x17, 0x7a, 0xea, 0x74, 0x59, 0x51, 0xee, 0x57, 0x80, 0xa6, 0x37, 0x05, 0x72, 0x7e, 0xf4, 0x2c, 0x4a, 0xd3, 0xab, 0xf5, 0x56, 0xd8, 0x8e, 0x38, 0x30, 0xf3, 0xdb, 0x6b, 0x09, 0xe9, 0x3e, 0xdd, 0x09, 0x48, 0x5c, 0xbf, 0x90, 0x7f, 0x79, 0xde, 0x61, 0xf8, 0xdc, 0x5c, 0xb5, 0xfb, 0x76, 0x65, 0xff, 0xa0, 0xef, 0x53, 0xcb, 0x48, 0x70, 0x2f, 0x6a, 0x81, 0xd8, 0xad, 0x42, 0x1c, 0xef, 0x20, 0xc1, 0xdb, 0xdf, 0x40, 0x2b, 0x8f, 0xaf, 0xed, 0x56, 0xa5, 0x36, 0x1b, 0x2f, 0x93, 0xf9, 0x14, 0xa2, 0x38, 0x0f, 0xdd, 0x05, 0x57, 0xfa, 0xf1, 0xf4, 0xde),
-      //   aad: vec!(0x39, 0x11, 0x6c, 0x49, 0xcc, 0x13, 0xad, 0xb0, 0x65, 0xb9, 0x2c, 0xb7, 0x63, 0x5f, 0x73, 0xd5, 0xf6, 0xbf, 0x6b, 0x5c, 0xcb, 0xf7, 0x2a, 0x3f, 0x65, 0xa5, 0xdf, 0x6b, 0xd4, 0xa6, 0x61, 0x10, 0x50, 0x15, 0x35, 0x8d, 0x9e, 0x69, 0xf4, 0x2e, 0x98, 0xae, 0xd7, 0x95, 0xe8, 0x16, 0x12, 0x82, 0xbc, 0x11, 0x30, 0x58, 0xb7, 0xef, 0x3b, 0x9e, 0x23, 0xfc, 0xd8, 0xee, 0xab, 0x34, 0xa3, 0x92, 0xe0, 0x3f, 0x4d, 0x63, 0x29, 0xc1, 0x12, 0xcb, 0x96, 0x83, 0x85, 0xec, 0x52, 0xa7, 0xaf, 0xc9, 0x8b, 0xb8, 0x69, 0x57, 0x85, 0xaf, 0x6b, 0x27, 0xb7, 0x00, 0x97, 0x3c, 0xc9, 0x52, 0x63, 0x0b, 0x72, 0x47, 0xce, 0x22, 0x6b, 0x4f, 0xbb, 0x99, 0xb8, 0xa4, 0x86, 0x37, 0x0b, 0xf6, 0x34, 0x5d, 0x45, 0x16, 0xc5, 0x2c, 0x64, 0xe3, 0x3f, 0x40, 0x7c, 0x4f, 0x2d, 0x1b, 0xa9, 0x05, 0x45, 0xc8, 0x87, 0x32, 0xd9, 0x8b, 0xbd, 0x97, 0x97, 0x2a, 0xc5, 0xe9, 0x4c, 0x69, 0x46, 0x24, 0xa9, 0xb3, 0x78, 0x2b, 0x00, 0x99, 0x82, 0x46, 0x51, 0xcb, 0x75, 0x67, 0x91, 0x4d, 0x25, 0xb3, 0xe1, 0x31, 0x81, 0xa7, 0x91, 0xdb, 0xcd, 0x40, 0xe7, 0x6e, 0x83, 0x6b, 0x33, 0x50, 0xd3, 0x10, 0xa5, 0x21, 0x51, 0xbf, 0x83, 0x5d, 0x3c, 0x35, 0x7c, 0x98, 0x71, 0x48, 0x2c, 0x29, 0x28, 0xe8, 0x40, 0x4c, 0x6e, 0x53, 0x34, 0x06, 0xd4, 0xd6, 0xfa, 0x8f, 0x63, 0x36, 0x6f, 0x2c, 0x4e, 0xd8, 0x28, 0x14, 0x1f, 0x1f, 0xf0, 0x0f, 0x01, 0xa5, 0x36),
-      //   cipher_text: vec!(0x01, 0xe2, 0x37, 0x22, 0x0b, 0x61, 0x90, 0x54, 0xa1, 0xf3, 0x67, 0x09, 0x28, 0xfe, 0x67, 0xd4, 0x04, 0x84, 0xb5, 0xaf, 0x40, 0xfb, 0xd0, 0x4d, 0x03, 0x25, 0x00, 0xaa, 0xc5, 0xac, 0xaa, 0x3b, 0x45, 0x84, 0xdd, 0x99, 0xa5, 0x8c, 0x39, 0x06, 0x27, 0x63, 0x6a, 0x50, 0xde, 0x5d, 0x74, 0x4f, 0x76, 0xa5, 0x6a, 0x33, 0x20, 0x5f, 0x9e, 0x3b, 0x00, 0xe1, 0x61, 0x62, 0xeb, 0x47, 0xff, 0x33, 0x33, 0xe1, 0xe2, 0x08, 0xca, 0x20, 0x0f, 0x1a, 0x53, 0x38, 0xa8, 0x6e, 0x17, 0xbd, 0x92, 0xdd, 0x2d, 0x16, 0xaf, 0x8b, 0xb0, 0x22, 0xa7, 0xdc, 0x05, 0xb9, 0x23, 0xd0, 0x19, 0xe0, 0x52, 0x47, 0xf1, 0xa0, 0xd0, 0xb4, 0xbf, 0xcf, 0xce, 0x58, 0xdd, 0x6d, 0x83, 0x83, 0x07, 0x05, 0x70, 0x76, 0x76, 0xd5, 0x57, 0x39, 0xab, 0xee, 0x89, 0xfc, 0xd5, 0xcb, 0x94, 0xb8, 0xfd, 0xe0, 0x06, 0xa5, 0xda, 0x02, 0xdf, 0x64, 0xb0, 0x0a, 0x46, 0x7f, 0x45, 0x97, 0x0b, 0x5c, 0xa4, 0x40, 0xf2, 0x23, 0x19, 0xb9, 0x73, 0x5a, 0x55, 0xd4, 0x54, 0xb9, 0xfb, 0xa0, 0x58, 0x8f, 0xef, 0x0c, 0x59, 0xd3, 0xd8, 0x38, 0x23, 0xeb, 0xa6, 0xe0, 0x60, 0x1a, 0x96, 0xe1, 0x02, 0x33, 0x82, 0x6c, 0x5a, 0xde, 0xea, 0x6b, 0x2a, 0x51, 0xd3, 0x86, 0xa0, 0x7a, 0x9e, 0x04, 0x7a, 0xd4, 0x05, 0xb2, 0x3d, 0x4c, 0x3d, 0x89, 0xf3, 0x0c, 0x31, 0xe3, 0x19, 0x9f, 0x0c, 0x8f, 0x92, 0x7b, 0xfa, 0xc4, 0x3c, 0xee, 0xa1, 0xf9, 0x69, 0xde, 0x0a, 0x8c, 0x0f),
-      //   tag: vec!(0x09, 0x2f, 0x9f, 0x3c, 0x5d, 0x4f, 0x25, 0x70, 0xc9, 0x94, 0x6c, 0x87, 0x96, 0x7f, 0x45, 0x79)
-      // },
-      // TestVector{
-      //   key: [0xba, 0xe0, 0x6b, 0x9b, 0x54, 0x56, 0x70, 0x75, 0x51, 0xc7, 0xb0, 0xe2, 0x07, 0xaa, 0xe0, 0x2a, 0x19, 0xb4, 0x84, 0x8a, 0xd8, 0xca, 0x4c, 0xe4, 0x07, 0x05, 0xbf, 0x8c, 0x85, 0x6a, 0x6e, 0x52],
-      //   nonce: [0x9c, 0x27, 0x06, 0x5c, 0x3e, 0xf2, 0xd5, 0x22],
-      //   plain_text: vec!(0x50, 0xcd, 0xd8, 0x81, 0x37, 0xff, 0x42, 0x8a, 0x88, 0xe8, 0x7b, 0x58, 0x45, 0xbe, 0x49, 0x24, 0xf6, 0x38, 0x75, 0x37, 0xbb, 0x5c, 0x0b, 0x65, 0x4c, 0x80, 0x10, 0x7a, 0xb5, 0x69, 0x8d, 0xb7, 0x5b, 0x2e, 0x13, 0x18, 0x48, 0xe7, 0xae, 0xc1, 0x56, 0xd3, 0x1a, 0xed, 0x07, 0x66, 0xd3, 0x1c, 0x37, 0x9f, 0xec, 0xe4, 0x09, 0x5d, 0x38, 0x26, 0x4c, 0x6d, 0x59, 0x45, 0x97, 0x4d, 0x25, 0xf7, 0x29, 0xc3, 0xb0, 0xba, 0x11, 0xea, 0x85, 0x3e, 0x9c, 0xeb, 0xdb, 0x6f, 0x03, 0xbb, 0x67, 0x0f, 0xce, 0x08, 0xad, 0xff, 0x74, 0xd0, 0xa8, 0xf0, 0x2d, 0x63, 0x3f, 0xb3, 0x4e, 0x0f, 0xb7, 0x33, 0x7a, 0x8e, 0x66, 0xe1, 0xc1, 0x20, 0x84, 0xd9, 0x14, 0xfb, 0x61, 0x73, 0xb8, 0x10, 0x56, 0x84, 0xdb, 0x82, 0x27, 0x52, 0xc6, 0x75, 0x1a, 0x37, 0x2b, 0xb1, 0x66, 0x90, 0x28, 0x4d, 0x66, 0x1b, 0x8b, 0x8b, 0xc6, 0xa6, 0xdf, 0xbd, 0xdf, 0x45, 0xeb, 0xc2, 0x21, 0x95, 0x96, 0xf9, 0xf2, 0xf8, 0x78, 0xc1, 0x18, 0xdf, 0x69, 0x03, 0x0d, 0xe3, 0x8b, 0x4d, 0x99, 0xdd, 0xe4, 0x3b, 0x9b, 0x9e, 0x20, 0xa3, 0xda, 0xb6, 0x91, 0x64, 0x5d, 0xd5, 0x18, 0x34, 0x2f, 0x49, 0xb0, 0x6a, 0x0f, 0xe0, 0xa3, 0x97, 0xad, 0xf2, 0x61, 0xe9, 0x9f, 0x07, 0xaf, 0x5b, 0x0b, 0x37, 0x98, 0xb1, 0x02, 0x2b, 0xa0, 0x93, 0x9c, 0x42, 0xa5, 0x4d, 0x3b, 0x93, 0x64, 0x1c, 0xff, 0xa3, 0xc2, 0xe1, 0x74, 0xbc, 0xe9, 0xab, 0x7a, 0xd7, 0xe7, 0xc7, 0x92, 0x43, 0x08, 0xd1, 0xa7, 0x7a),
-      //   aad: vec!(0x5d, 0x55, 0x90, 0xdb, 0x1b, 0xd3, 0x16, 0xeb, 0x7a, 0x0e, 0x30, 0xe4, 0xc7, 0xa6, 0xdf, 0xdb, 0xef, 0x9d, 0x32, 0x87, 0xfd, 0xb8, 0xd8, 0x24, 0x38, 0x95, 0x99, 0xc3, 0xc2, 0xee, 0x26, 0x2b, 0x21, 0x92, 0xeb, 0x5b, 0x97, 0x08, 0xe6, 0x6e, 0x22, 0xdb, 0xc7, 0xec, 0xa8, 0x3f, 0xa1, 0xa9, 0x95, 0xda, 0x3c, 0xe6, 0x4c, 0x86, 0xfe, 0x5a, 0xa0, 0x8b, 0x82, 0x6d, 0x47, 0x6d, 0xc4, 0x39, 0x49, 0x7e, 0x2d, 0x12, 0xe2, 0x70, 0x2c, 0x63, 0xc8, 0xd2, 0x7a, 0xa7, 0xf0, 0x9f, 0xed, 0xee, 0x81, 0x6d, 0xc8, 0xbf, 0xfe, 0x13, 0x51, 0xd5, 0x32, 0x71, 0xa3, 0x4d, 0x42, 0x92, 0xb6, 0x13, 0xb7, 0xef, 0xce, 0xdb, 0x7e, 0x3c, 0xf3, 0xe6, 0xad, 0x38, 0x9e, 0xef, 0x12, 0x47, 0x1e, 0x9e, 0x20, 0xe3, 0x8e, 0x7a, 0xe2, 0x2a, 0x32, 0x3a, 0xbb, 0xad, 0xfe, 0x8f, 0x2e, 0x84, 0x27, 0x1b, 0xff, 0xb1, 0x81, 0x9f, 0xeb, 0x4f, 0x77, 0xb8, 0x28, 0x43, 0xcb, 0x87, 0x57, 0xcf, 0xae, 0x29, 0x36, 0x31, 0xbc, 0x6d, 0x39, 0x66, 0x91, 0x07, 0xe7, 0x01, 0x5c, 0x85, 0xd7, 0x34, 0x3f, 0xfa, 0x6f, 0xc1, 0xbb, 0xe6, 0xf5, 0xab, 0x4d, 0xe3, 0x0c, 0xd7, 0x52, 0xa2, 0x81, 0xe0, 0x30, 0x61, 0xea, 0x89, 0xde, 0x2a, 0x3f, 0x5e, 0x90, 0xe2, 0x0d, 0xa2, 0x2f, 0xd6, 0xe8, 0x52, 0x5c, 0x10, 0x07, 0x38, 0x66, 0x7f, 0x42, 0x21, 0x2b, 0x2c, 0xf4, 0x5f, 0xcb, 0x23, 0xbb, 0xb5, 0x4b, 0x21, 0xc1, 0x17, 0x48, 0x4b, 0x22, 0xc6, 0xe5, 0x14, 0x68, 0x53, 0x14, 0xdf),
-      //   cipher_text: vec!(0x66, 0xb7, 0xf6, 0x9a, 0xc4, 0x9f, 0xab, 0x4e, 0x59, 0x75, 0xae, 0xb6, 0xfa, 0x92, 0x87, 0xd8, 0xea, 0xc0, 0x2a, 0xc3, 0x12, 0xc4, 0xde, 0x78, 0xf7, 0x7f, 0x59, 0xda, 0x16, 0xcb, 0xcf, 0x87, 0x27, 0x4e, 0x66, 0x80, 0x1c, 0x4b, 0x86, 0x2c, 0x33, 0xea, 0x79, 0xcd, 0xc7, 0x65, 0x28, 0x86, 0x2b, 0xb2, 0x95, 0x6c, 0x06, 0xdb, 0x8b, 0x8a, 0xcf, 0xac, 0x47, 0x94, 0xeb, 0xf3, 0x9e, 0x35, 0xac, 0x03, 0xcc, 0x73, 0xa4, 0x35, 0x1a, 0x4f, 0xf7, 0x62, 0xf6, 0x81, 0xa4, 0x8d, 0x6f, 0x25, 0xca, 0xd3, 0x6e, 0x28, 0x14, 0xc9, 0xb5, 0xc4, 0x0b, 0x9a, 0xe9, 0x25, 0x09, 0xe5, 0x84, 0x29, 0x10, 0x68, 0x47, 0x78, 0x94, 0x54, 0xd3, 0x76, 0x83, 0x69, 0x36, 0xbe, 0xbc, 0x7a, 0x80, 0xe6, 0xc6, 0x6e, 0x7a, 0xa5, 0x29, 0x36, 0xd6, 0xb3, 0x61, 0x37, 0x8a, 0x41, 0xf8, 0x49, 0xad, 0x4e, 0x48, 0xf9, 0xee, 0x2d, 0x3e, 0x92, 0x21, 0x7a, 0x90, 0x8f, 0xa8, 0xeb, 0x35, 0x73, 0x6a, 0xc8, 0xad, 0xa7, 0xd3, 0x2a, 0xe0, 0x53, 0x91, 0xf2, 0xd8, 0x07, 0xbe, 0x35, 0x12, 0x54, 0x3c, 0x36, 0x13, 0x8a, 0x5f, 0xe6, 0x60, 0xdd, 0x4c, 0xd4, 0xcd, 0x18, 0x4b, 0xb4, 0x3b, 0x6b, 0xa6, 0xbc, 0x0b, 0xae, 0x63, 0x4e, 0x2f, 0xa9, 0x66, 0x93, 0x04, 0xcd, 0x51, 0x0e, 0xd5, 0x10, 0x3f, 0x63, 0x00, 0x68, 0xff, 0x76, 0xd3, 0x37, 0x57, 0x38, 0xde, 0x60, 0xa3, 0x81, 0x84, 0x2b, 0x42, 0x14, 0x77, 0xe2, 0x5a, 0x49, 0x0c, 0xdd, 0x68, 0x94, 0xb2, 0x70, 0x41, 0x25),
-      //   tag: vec!(0xc9, 0x99, 0x8a, 0x67, 0x7d, 0xfb, 0x0e, 0x91, 0x92, 0x4a, 0xec, 0x9d, 0xe0, 0xaf, 0xd5, 0x85)
-      // },
-      // TestVector{
-      //   key: [0x2c, 0xb3, 0x74, 0xcb, 0x04, 0x8c, 0x16, 0x8f, 0x2e, 0x43, 0x59, 0x7f, 0x02, 0x8d, 0x9e, 0x73, 0xca, 0xde, 0x1b, 0x45, 0x82, 0x84, 0xff, 0xc2, 0x60, 0xd4, 0xfc, 0x6b, 0x90, 0x11, 0xc4, 0x14],
-      //   nonce: [0x9f, 0xb9, 0x09, 0x16, 0x9b, 0xc9, 0xf4, 0xe9],
-      //   plain_text: vec!(0x39, 0xeb, 0x92, 0x94, 0x82, 0x78, 0x4b, 0x46, 0x35, 0x46, 0xf5, 0xd8, 0x4f, 0x80, 0x51, 0x0f, 0x20, 0x19, 0x92, 0x3d, 0x46, 0x5b, 0x99, 0xd1, 0x94, 0x24, 0x6d, 0x68, 0xc7, 0xae, 0x34, 0x3f, 0x91, 0x97, 0x1d, 0x8f, 0x70, 0x59, 0xce, 0xbb, 0x86, 0xaa, 0x5d, 0xd0, 0x99, 0x28, 0x9a, 0xa6, 0x48, 0x24, 0x8b, 0x8c, 0x5c, 0xa0, 0x4e, 0x66, 0xac, 0x5e, 0x9b, 0xf0, 0x67, 0x76, 0xe3, 0x88, 0x34, 0x95, 0x39, 0x76, 0x18, 0xa0, 0x22, 0x7f, 0x03, 0x56, 0x66, 0x80, 0x6e, 0x63, 0x68, 0x36, 0xb4, 0x7d, 0x3d, 0x2d, 0x25, 0x5a, 0x49, 0xdb, 0x79, 0x86, 0x6c, 0xf0, 0x0d, 0x9d, 0xda, 0xbd, 0xa2, 0x59, 0xc4, 0xf9, 0x68, 0xa1, 0xe0, 0x1e, 0x65, 0x1c, 0x78, 0x11, 0xce, 0xbb, 0xee, 0x2e, 0xe7, 0x18, 0x03, 0xea, 0x1d, 0x9d, 0x23, 0x48, 0x7e, 0xb2, 0x21, 0xf2, 0xd9, 0x55, 0x57, 0x56, 0x80, 0x0a, 0xba, 0x5e, 0x6a, 0xbb, 0xef, 0xd6, 0xfb, 0x72, 0xb3, 0x15, 0x1c, 0xc9, 0x9c, 0xed, 0x59, 0x9c, 0xd8, 0x6d, 0xf2, 0xa9, 0xb1, 0xce, 0x94, 0xf8, 0x9f, 0x34, 0x7e, 0xeb, 0x12, 0x4d, 0x9e, 0x7f, 0x0d, 0x9c, 0xc4, 0x8d, 0x3d, 0xed, 0xd8, 0x19, 0xe6, 0xd3, 0xdb, 0xac, 0x57, 0xec, 0xee, 0x19, 0x95, 0x47, 0xb2, 0x66, 0x11, 0x6a, 0x20, 0x35, 0xc9, 0xac, 0xc4, 0xc8, 0xca, 0x32, 0x71, 0xac, 0x74, 0x95, 0x23, 0x72, 0x89, 0x7c, 0x4a, 0x5f, 0x2c, 0xb8, 0x4e, 0x2d, 0x81, 0x81, 0x7f, 0xec, 0x9d, 0x67, 0x74, 0xf6, 0xd8, 0xa5, 0xb2, 0x02, 0x16, 0x84, 0x13, 0x2d, 0xb4, 0xfc, 0xa3),
-      //   aad: vec!(0x0c, 0x7b, 0xd4, 0xf3, 0xa3, 0x0e, 0xe9, 0x44, 0xcc, 0xf9, 0x48, 0x91, 0x81, 0xe6, 0x91, 0x16, 0x84, 0xdc, 0xff, 0xad, 0x45, 0x93, 0xa9, 0xb6, 0x5a, 0x67, 0xdf, 0xc8, 0x07, 0x18, 0xc6, 0x9b, 0x35, 0x89, 0x7d, 0x01, 0x28, 0x10, 0x16, 0xb7, 0x73, 0x1e, 0x12, 0xc1, 0x5c, 0xad, 0x84, 0x82, 0xe7, 0x94, 0x58, 0xe0, 0x8a, 0x75, 0x56, 0x22, 0xe3, 0xf3, 0xf2, 0x2a, 0x23, 0xef, 0x6c, 0x84, 0x87, 0xa3, 0x6a, 0xd1, 0x77, 0x1b, 0xa0, 0x6c, 0x64, 0x1f, 0x06, 0xf8, 0x5d, 0xe0, 0xdb, 0x37, 0x76, 0xcc, 0x6d, 0xf0, 0x6a, 0xd8, 0xfe, 0x3b, 0x4d, 0x60, 0xd5, 0x85, 0x08, 0xde, 0x94, 0x30, 0x83, 0xf1, 0x7c, 0xbb, 0x9d, 0xc0, 0xd3, 0x90, 0xac, 0x94, 0xd8, 0x42, 0x9e, 0x8c, 0x6f, 0xcf, 0xe0, 0x63, 0xf4, 0x24, 0xfb, 0xde, 0x0f, 0x62, 0xf6, 0xa7, 0xf9, 0x1a, 0x62, 0x6d, 0x19, 0x5d, 0xc4, 0x98, 0xa6, 0xe6, 0x9b, 0xd9, 0x31, 0x09, 0xc4, 0xe9, 0xba, 0x13, 0xe7, 0x33, 0x0a, 0xba, 0x45, 0x6d, 0x71, 0x0a, 0x4b, 0x0c, 0xc2, 0x79, 0xd4, 0x04, 0x56, 0x60, 0x40, 0x6e, 0x26, 0xd6, 0x1d, 0xff, 0x70, 0xd4, 0xa3, 0x3c, 0x4f, 0x10, 0x52, 0x86, 0x9f, 0x92, 0x48, 0x02, 0x4e, 0x7a, 0x0f, 0x85, 0xf1, 0xef, 0xfb, 0x32, 0xf6, 0xf7, 0xcc, 0xb1, 0xf8, 0x60, 0xf3, 0xef, 0x04, 0xe8, 0xf7, 0xb2, 0x90, 0x96, 0xe6, 0xbc, 0xf9, 0xd4, 0xb3, 0xe0, 0xce, 0x70, 0x3e, 0x9b, 0xf2, 0x28, 0xfd, 0xf5, 0x15, 0xc2, 0xff, 0x9c, 0xba, 0xbd, 0x16, 0x98, 0x7b, 0xe0, 0xf9, 0xba, 0xbd, 0x3d, 0x8a),
-      //   cipher_text: vec!(0x91, 0xdd, 0xad, 0xb8, 0x6b, 0x7e, 0xbe, 0xf7, 0x98, 0xdd, 0xaa, 0x59, 0xda, 0x51, 0xd7, 0x13, 0x16, 0xfc, 0xf6, 0xc9, 0x67, 0x81, 0x43, 0x17, 0x82, 0x27, 0xd7, 0x78, 0x75, 0x0d, 0xc9, 0x82, 0x7f, 0xc6, 0xcc, 0x21, 0xe6, 0x05, 0xc5, 0x05, 0x02, 0x3e, 0x6d, 0xb2, 0x58, 0x49, 0xdf, 0x7f, 0xb6, 0xfc, 0x1c, 0xa4, 0xd2, 0x23, 0xaa, 0x21, 0x5f, 0x8c, 0x85, 0xb7, 0x24, 0x64, 0x3c, 0x83, 0xbf, 0x82, 0x18, 0x81, 0x5a, 0x9f, 0x9e, 0x29, 0x52, 0x38, 0x4e, 0x0c, 0xa6, 0xa8, 0x0a, 0x37, 0x60, 0xb3, 0x9d, 0xaf, 0x91, 0xa3, 0xc6, 0x15, 0x4c, 0x47, 0x28, 0xc2, 0x37, 0x1f, 0xd1, 0x81, 0xfa, 0x37, 0x64, 0x75, 0x3d, 0x0b, 0x0c, 0x23, 0x80, 0x8a, 0x82, 0xcd, 0x8f, 0x04, 0x97, 0x24, 0x6e, 0x3a, 0x0f, 0x17, 0xf8, 0x90, 0x6a, 0x07, 0xc7, 0x25, 0xd2, 0x89, 0x1c, 0xe9, 0x68, 0xa9, 0xd4, 0x32, 0xc2, 0xb1, 0x02, 0xd8, 0x5c, 0x05, 0x51, 0x0b, 0x28, 0xe7, 0x15, 0xbb, 0x60, 0xd0, 0x40, 0x3a, 0x77, 0x49, 0x0e, 0x7f, 0x18, 0xbe, 0x81, 0x21, 0x8b, 0xc4, 0xf3, 0x92, 0x87, 0xb9, 0xbb, 0x09, 0xf5, 0x02, 0x27, 0xdd, 0x2f, 0x55, 0xe4, 0xfb, 0x70, 0xc4, 0x43, 0x8d, 0xa8, 0xba, 0x3c, 0x8f, 0xfb, 0xce, 0xd8, 0x7d, 0x90, 0x15, 0x59, 0x13, 0xfa, 0xa9, 0x97, 0x9f, 0xc5, 0x7e, 0x6c, 0xbe, 0xdd, 0xfa, 0xba, 0x3d, 0x3a, 0xb4, 0x16, 0x3c, 0x0e, 0xeb, 0xc7, 0xd9, 0x42, 0x79, 0xc2, 0x7d, 0x3e, 0xd5, 0x63, 0x38, 0x89, 0x3d, 0xba, 0x54, 0x2e, 0xae, 0xfb, 0xa3, 0x0f, 0x8c, 0x3b),
-      //   tag: vec!(0x72, 0x8e, 0x60, 0xf8, 0x12, 0x4e, 0xff, 0xba, 0xc2, 0x34, 0xf7, 0x0d, 0xa9, 0x25, 0x88, 0x1c)
-      // },
-      // TestVector{
-      //   key: [0xf0, 0xf1, 0x6b, 0x6f, 0x12, 0xb3, 0x84, 0x0b, 0xbd, 0x1c, 0x4a, 0x6a, 0x08, 0x11, 0xee, 0xf2, 0x37, 0xf1, 0x52, 0x1b, 0x45, 0xde, 0x99, 0x86, 0xda, 0xec, 0x9f, 0x28, 0xfc, 0xa6, 0x48, 0x5c],
-      //   nonce: [0x7a, 0xc9, 0x3e, 0x75, 0x4e, 0x29, 0x03, 0x23],
-      //   plain_text: vec!(0x05, 0x30, 0x55, 0x64, 0x24, 0xd8, 0x23, 0xf9, 0x0a, 0x7f, 0x1c, 0x52, 0x4c, 0x4b, 0xaa, 0x70, 0x6a, 0xad, 0x28, 0x07, 0xe2, 0x89, 0xe9, 0x47, 0x93, 0x01, 0xe3, 0xe7, 0xa7, 0x1f, 0x2a, 0x5e, 0x14, 0xe6, 0x23, 0x2e, 0xa7, 0x85, 0xf3, 0x39, 0xc6, 0x69, 0xaf, 0x2e, 0x6d, 0x25, 0xf1, 0xd5, 0xa2, 0x61, 0x09, 0x6a, 0x54, 0x8d, 0x23, 0x86, 0x49, 0x45, 0xc3, 0xa5, 0x89, 0xb6, 0x7b, 0x09, 0xb0, 0x30, 0x4a, 0x78, 0x4d, 0x61, 0xb4, 0x2b, 0x24, 0x19, 0x13, 0x94, 0x85, 0x24, 0x2e, 0x0d, 0x51, 0xfc, 0xbe, 0x9e, 0x8f, 0xed, 0x99, 0x6d, 0x21, 0x4d, 0xe8, 0x71, 0x7e, 0x6a, 0x71, 0xf8, 0x98, 0x7c, 0xca, 0xd6, 0x5e, 0xb9, 0x2e, 0x66, 0x70, 0x70, 0x34, 0xa5, 0xae, 0x38, 0xe6, 0x48, 0x6e, 0x26, 0xeb, 0x43, 0x74, 0xc5, 0x65, 0xaa, 0xd5, 0xdf, 0x94, 0x9d, 0xab, 0x20, 0x9f, 0x7f, 0x7b, 0xcd, 0x8e, 0xb6, 0xfc, 0x52, 0x76, 0x1a, 0x26, 0xcf, 0xe5, 0xd0, 0x1f, 0xd3, 0x49, 0xe5, 0x9f, 0x40, 0x42, 0xe6, 0xdb, 0xe6, 0xb2, 0x32, 0xf9, 0x30, 0x1b, 0x97, 0x1d, 0xee, 0x12, 0x1d, 0x8a, 0xa1, 0xe6, 0x2d, 0x40, 0xf0, 0x43, 0xa4, 0x2f, 0x3a, 0xa8, 0x59, 0xd8, 0x67, 0xeb, 0x80, 0x9b, 0x1c, 0xed, 0x5a, 0xe1, 0xec, 0x62, 0xca, 0xcf, 0x94, 0xa6, 0x9f, 0xaf, 0xd0, 0x63, 0x1a, 0x8b, 0x5d, 0xfd, 0x66, 0xd8, 0x55, 0x90, 0x0f, 0xb2, 0x95, 0xee, 0xc9, 0x0a, 0xe5, 0xfc, 0xbf, 0x77, 0xbe, 0xae, 0x26, 0x7a, 0x79, 0xd2, 0x40, 0x81, 0xbb, 0x32, 0x2d, 0x8c, 0x4e, 0x06, 0x30, 0xfe, 0xd2, 0x52, 0x54, 0x1b, 0x36),
-      //   aad: vec!(0x13, 0xbf, 0xcc, 0x17, 0xb8, 0x10, 0x09, 0x9c, 0xda, 0x31, 0xca, 0x53, 0xa1, 0x32, 0x3d, 0xb9, 0xb0, 0x76, 0x33, 0xce, 0xb2, 0x08, 0x8a, 0x42, 0x26, 0x3a, 0x4c, 0xbd, 0x6a, 0x4d, 0x47, 0x97, 0x87, 0x76, 0x00, 0x5c, 0x9a, 0x20, 0x20, 0x33, 0x19, 0xc3, 0xa3, 0xae, 0x43, 0x4e, 0x9a, 0x26, 0xfb, 0x54, 0x10, 0x47, 0xdc, 0x9d, 0xf3, 0x8d, 0xc3, 0x6c, 0x09, 0x52, 0x67, 0x27, 0x2e, 0x20, 0x3d, 0x0b, 0x24, 0xd1, 0x19, 0xa7, 0x0a, 0x7e, 0x96, 0x04, 0x1b, 0x6d, 0x82, 0xb7, 0xc4, 0xd5, 0x57, 0x0e, 0x1e, 0x4a, 0x1c, 0xf2, 0xf6, 0xe4, 0x4a, 0xe6, 0x3f, 0xe0, 0x05, 0xa1, 0xf5, 0xb9, 0x00, 0x77, 0x8c, 0x48, 0x2f, 0x7b, 0xd8, 0x9e, 0x2e, 0x02, 0x30, 0x5e, 0x35, 0xb8, 0xf6, 0x1b, 0x7b, 0xb2, 0xc7, 0x8a, 0x13, 0xae, 0xbf, 0xce, 0x01, 0x45, 0xd1, 0xc5, 0xaa, 0x0b, 0xf1, 0xd1, 0x0d, 0x23, 0x61, 0x6d, 0x5a, 0x3a, 0x44, 0x6d, 0xe5, 0x50, 0x30, 0x2f, 0x56, 0xf8, 0x1d, 0xc5, 0x6f, 0xe4, 0xf3, 0x70, 0x0f, 0x14, 0x24, 0x26, 0x88, 0xd9, 0xb9, 0x2d, 0x8a, 0x42, 0x79, 0x79, 0xb4, 0x03, 0xc8, 0xde, 0x8c, 0x49, 0x3a, 0x2c, 0xde, 0x51, 0x0e, 0xaf, 0x6b, 0x28, 0x5e, 0x66, 0x75, 0xb1, 0x73, 0xaa, 0x03, 0x14, 0xa3, 0x86, 0xb6, 0x35, 0xc7, 0x57, 0x7d, 0x5a, 0xff, 0x0d, 0x86, 0x8a, 0x0c, 0xb3, 0xf7, 0x3c, 0x8d, 0x20, 0x05, 0xf8, 0xc7, 0xc9, 0xda, 0xb5, 0xa0, 0x60, 0xef, 0x80, 0x10, 0x2c, 0x9d, 0x4a, 0x4a, 0xf9, 0x88, 0x83, 0x8a, 0xfe, 0x87, 0xaf, 0xf0, 0x4c, 0x06, 0x89, 0xe8, 0xc3, 0xc7, 0xf9),
-      //   cipher_text: vec!(0x2c, 0x14, 0xc3, 0x93, 0x1e, 0x98, 0xe8, 0x45, 0x07, 0xc4, 0xc1, 0x65, 0xc2, 0xed, 0x47, 0xad, 0x4a, 0x17, 0x8f, 0x0e, 0x21, 0x6c, 0xd7, 0xac, 0x24, 0x53, 0xbb, 0xbf, 0x9f, 0x85, 0xdd, 0x06, 0xbd, 0x8e, 0xf5, 0x4a, 0x9f, 0xf1, 0xfd, 0x3d, 0xd8, 0xe0, 0xca, 0xfb, 0x63, 0x5d, 0x8f, 0x2d, 0xe8, 0x61, 0xa0, 0xdb, 0x5b, 0x14, 0xd0, 0x3f, 0x17, 0xaa, 0xea, 0x8c, 0x89, 0xb3, 0x01, 0x07, 0x97, 0xc7, 0x1c, 0x13, 0xa0, 0xe6, 0x66, 0x89, 0x9d, 0x7f, 0xf6, 0xe5, 0x3c, 0x4f, 0x08, 0xbe, 0x8d, 0xdb, 0x3e, 0x37, 0x68, 0x8b, 0x5a, 0xfa, 0x08, 0x80, 0x79, 0xb6, 0xc7, 0x51, 0x9b, 0x83, 0x3e, 0x16, 0x56, 0x00, 0x73, 0xe6, 0x99, 0x53, 0x03, 0x02, 0x02, 0x8a, 0x34, 0x96, 0xe0, 0x5e, 0xdd, 0xde, 0xc0, 0x1a, 0x23, 0xa4, 0xc7, 0x98, 0x39, 0x56, 0x25, 0x0e, 0x8d, 0x9e, 0x61, 0x6f, 0x7b, 0x94, 0x08, 0x56, 0x95, 0x5c, 0xde, 0x81, 0xc1, 0xef, 0xab, 0xf6, 0xb7, 0xb9, 0x2f, 0x15, 0x3d, 0x03, 0xf4, 0xcd, 0x17, 0xe7, 0xf7, 0xd2, 0x90, 0x76, 0x70, 0xcf, 0xc8, 0x4d, 0x45, 0xc1, 0xd7, 0x93, 0x67, 0x75, 0xa3, 0xfc, 0xe4, 0x79, 0x68, 0x50, 0x42, 0x78, 0xff, 0xae, 0xca, 0xce, 0xa0, 0x87, 0x1b, 0x22, 0x7f, 0x25, 0x0e, 0x29, 0x79, 0x51, 0x6f, 0x6f, 0xa3, 0x10, 0xfe, 0xc0, 0xd8, 0xdf, 0x1a, 0xf7, 0x87, 0x2e, 0x5a, 0x53, 0x4e, 0x82, 0x87, 0x0a, 0xa0, 0x5f, 0x43, 0xef, 0x0a, 0x45, 0x58, 0x46, 0xb9, 0x3c, 0xe9, 0x38, 0x06, 0x4f, 0xa3, 0x3e, 0x92, 0xde, 0x26, 0x2e, 0x41, 0x56, 0xda, 0xe5, 0x67, 0x75),
-      //   tag: vec!(0xd9, 0x5d, 0x73, 0xbf, 0x9a, 0xeb, 0x71, 0xeb, 0xa9, 0x04, 0x23, 0x96, 0xf3, 0x72, 0x54, 0x24)
-      // },
-      // TestVector{
-      //   key: [0x37, 0x92, 0x94, 0x3c, 0x03, 0x96, 0xf1, 0x84, 0x04, 0x96, 0x91, 0x7c, 0xe8, 0xad, 0x89, 0x60, 0x83, 0x85, 0x00, 0x7e, 0x79, 0x6f, 0xeb, 0xee, 0xa3, 0x80, 0x5f, 0x3f, 0x4c, 0xbe, 0xcc, 0xf7],
-      //   nonce: [0x23, 0xb2, 0xf9, 0x06, 0x8b, 0x2c, 0x4c, 0x85],
-      //   plain_text: vec!(0xbe, 0x6b, 0x67, 0xeb, 0x94, 0x3e, 0xe7, 0xb5, 0xc7, 0x85, 0xcd, 0x88, 0x2f, 0x65, 0x3e, 0x73, 0xa8, 0xf7, 0x5b, 0x4a, 0x41, 0xa2, 0xa7, 0xc5, 0x6a, 0xe5, 0xa1, 0x0f, 0x72, 0x9c, 0xaf, 0x39, 0x94, 0x8f, 0xe4, 0x8a, 0xd0, 0xe5, 0x12, 0x40, 0xe2, 0xe7, 0xaa, 0x43, 0x19, 0x3c, 0x7e, 0xc6, 0xce, 0x7f, 0x49, 0x09, 0xfc, 0x94, 0xc9, 0xf9, 0x9e, 0x38, 0xe6, 0xa0, 0xad, 0x7e, 0x98, 0xeb, 0x29, 0xc5, 0xc2, 0xe6, 0x1c, 0x99, 0xe9, 0xcb, 0xe8, 0x90, 0xf1, 0x54, 0x18, 0x5c, 0xec, 0x21, 0x3a, 0x74, 0x72, 0x5d, 0x23, 0xc1, 0xa4, 0xe4, 0xd0, 0xcb, 0x9b, 0x1a, 0x36, 0xb7, 0x8c, 0x87, 0xe5, 0xee, 0xe2, 0x0d, 0x2a, 0xa2, 0x9a, 0xae, 0x80, 0xd4, 0x75, 0x9e, 0xb0, 0xc5, 0x1c, 0x5d, 0xc3, 0xa9, 0x5b, 0xdb, 0xbf, 0x7e, 0x14, 0xeb, 0x43, 0x44, 0x19, 0xa6, 0xc8, 0x8a, 0x95, 0x4a, 0xc0, 0x3d, 0x0c, 0x98, 0x73, 0x9f, 0x42, 0x11, 0xb8, 0x73, 0x2a, 0xcd, 0x71, 0xc2, 0x97, 0xf5, 0x78, 0xb8, 0xcb, 0x64, 0xcc, 0xac, 0x45, 0xf7, 0x23, 0x5d, 0xdc, 0x7f, 0x2a, 0x3f, 0x5f, 0x99, 0x75, 0x25, 0xc1, 0xed, 0x39, 0xdc, 0x55, 0x01, 0x26, 0xcd, 0xf9, 0xce, 0xda, 0xf5, 0x54, 0x25, 0x48, 0x90, 0x85, 0xe9, 0x1b, 0x17, 0x0b, 0xe6, 0x20, 0x5a, 0x5a, 0x39, 0x5f, 0x2d, 0xd4, 0x08, 0x4a, 0x3e, 0x8d, 0xbc, 0x4f, 0xd8, 0xb1, 0x32, 0x52, 0xf7, 0xef, 0xfa, 0xe0, 0x67, 0xb5, 0x71, 0xcb, 0x94, 0xa1, 0xe5, 0x4a, 0xba, 0x45, 0xb1, 0xb9, 0x84, 0x13, 0x08, 0xdb, 0x0c, 0xc7, 0x5b, 0x03, 0xcf, 0xce, 0x4d, 0xda, 0xfe, 0x89, 0xce, 0x20, 0xf2, 0xd1),
-      //   aad: vec!(0x7e, 0xb6, 0xd7, 0xb7, 0xbb, 0xaa, 0xa3, 0xc2, 0x02, 0xa4, 0xf0, 0xf1, 0xde, 0x22, 0x63, 0x76, 0x71, 0x69, 0xeb, 0x4a, 0x64, 0x85, 0x32, 0x40, 0xd4, 0x8c, 0x0f, 0x8d, 0x5d, 0x31, 0xb0, 0x8d, 0x5b, 0xaf, 0x42, 0x97, 0x76, 0x14, 0xa5, 0x7a, 0xad, 0x99, 0x42, 0x6c, 0xde, 0x76, 0xd2, 0x42, 0xcb, 0x37, 0xd2, 0x95, 0x6d, 0x8c, 0x77, 0xdc, 0x4f, 0xd6, 0x2a, 0x3a, 0xbf, 0x30, 0xe8, 0xac, 0x6c, 0xd5, 0x8c, 0x8e, 0xf3, 0x5e, 0x67, 0x49, 0x70, 0x22, 0x96, 0x01, 0x38, 0xc5, 0x77, 0x87, 0x81, 0x88, 0x92, 0x46, 0x0f, 0x3b, 0xfc, 0x16, 0xe3, 0x7f, 0xf3, 0x88, 0xb1, 0xed, 0xc6, 0xce, 0x2b, 0xc5, 0x3c, 0x22, 0x71, 0x7e, 0xdc, 0x7a, 0x03, 0xd4, 0xc7, 0x8b, 0x0d, 0xbb, 0xe9, 0x12, 0x1c, 0x7f, 0xd8, 0xa3, 0xe3, 0x99, 0x3b, 0x87, 0xa4, 0xfe, 0x38, 0x9b, 0xff, 0x13, 0xbd, 0xae, 0x3b, 0x34, 0x9d, 0xe0, 0xb6, 0xdb, 0x56, 0x16, 0x02, 0xc5, 0x3f, 0x74, 0x60, 0x22, 0xae, 0xb4, 0x48, 0x3c, 0x72, 0x3b, 0x67, 0x82, 0x50, 0x42, 0xf4, 0xaf, 0x20, 0xb7, 0xdd, 0x1e, 0x60, 0x31, 0xcf, 0x54, 0x21, 0x52, 0x66, 0x29, 0x5c, 0x52, 0x4a, 0xc8, 0xe1, 0x37, 0x04, 0x24, 0xc5, 0xc5, 0xe6, 0x07, 0xfb, 0x3e, 0x23, 0xe9, 0x7c, 0x8e, 0xeb, 0xe6, 0x46, 0x56, 0x77, 0x5e, 0xdf, 0x61, 0x64, 0x22, 0xa8, 0xb9, 0x74, 0xe1, 0xac, 0xf1, 0x3a, 0xb4, 0x5c, 0x9a, 0x36, 0x7a, 0x7d, 0xd9, 0xb2, 0xd6, 0x2f, 0x48, 0xbb, 0xc0, 0x58, 0x19, 0xb6, 0x5e, 0xcc, 0xb8, 0x13, 0xca, 0x81, 0x3f, 0x57, 0xb2, 0x2e, 0xe4, 0xc2, 0x80, 0xdb, 0xb5, 0xa9, 0xd8, 0xd5),
-      //   cipher_text: vec!(0x0b, 0x31, 0x6a, 0xb2, 0xbc, 0xf5, 0x35, 0x99, 0x00, 0xfa, 0x40, 0x82, 0xd5, 0xd2, 0x53, 0xb4, 0x9a, 0xd9, 0x4b, 0x70, 0xe3, 0xfa, 0xb5, 0x44, 0xf9, 0x8b, 0xd1, 0x11, 0xcb, 0xce, 0xf6, 0x76, 0x6c, 0xf9, 0x53, 0xde, 0xec, 0x08, 0xca, 0xe1, 0xf4, 0x89, 0xfe, 0x12, 0xf7, 0xac, 0xc0, 0x03, 0x2d, 0xb8, 0xa6, 0xb0, 0xc0, 0xee, 0xe0, 0xc2, 0x06, 0xea, 0x5f, 0xb9, 0x73, 0xfe, 0xae, 0xbf, 0x90, 0xf6, 0x90, 0xe8, 0x40, 0x09, 0x4d, 0xb5, 0xe1, 0x3f, 0xdd, 0x71, 0x57, 0xba, 0x12, 0x73, 0x68, 0xc9, 0x95, 0xb4, 0x26, 0x52, 0x94, 0x35, 0xa1, 0xbc, 0xdd, 0x1f, 0x14, 0xce, 0x91, 0x25, 0xb8, 0xa0, 0xe4, 0xc9, 0x6b, 0x6e, 0xc0, 0x9e, 0x3c, 0x36, 0xa1, 0x80, 0xad, 0xf8, 0x19, 0x41, 0xc0, 0x02, 0xd1, 0x9c, 0x19, 0xd5, 0x3c, 0x20, 0x09, 0xbe, 0x80, 0x3b, 0x98, 0x75, 0x04, 0x60, 0x6b, 0x7d, 0x43, 0xbd, 0xee, 0x5e, 0x0b, 0x32, 0xff, 0x23, 0xc4, 0x66, 0xb6, 0xcc, 0xcf, 0xcd, 0x0d, 0x4e, 0x88, 0xfd, 0x13, 0x32, 0xe7, 0x37, 0x12, 0xb5, 0xab, 0x72, 0x5c, 0x1a, 0x38, 0x3e, 0x58, 0x4f, 0x34, 0xf8, 0x0d, 0xaf, 0xf2, 0x9d, 0x28, 0x5a, 0xe5, 0xe4, 0x3c, 0xf1, 0xd0, 0xcc, 0x7a, 0x82, 0x8e, 0x75, 0xc2, 0x5d, 0xac, 0xed, 0x3a, 0x58, 0x1a, 0x93, 0xd7, 0xa5, 0x0f, 0x31, 0x3b, 0x33, 0xf3, 0x8d, 0xdd, 0xfa, 0xa2, 0x3c, 0xd5, 0xb9, 0x91, 0x47, 0x97, 0xdb, 0x82, 0x0e, 0xe2, 0x40, 0x0d, 0x52, 0xbf, 0x5f, 0xa9, 0x82, 0x27, 0x7f, 0xe9, 0xb5, 0x88, 0x1a, 0xc4, 0x29, 0x81, 0x63, 0x3b, 0x39, 0x57, 0xb0, 0xe9, 0x35, 0x05, 0x18, 0x28),
-      //   tag: vec!(0x01, 0x97, 0x3e, 0xe2, 0xe8, 0x1c, 0xef, 0x22, 0x75, 0x1a, 0x6a, 0x88, 0x31, 0xd7, 0x52, 0xef)
-      // },
-      // TestVector{
-      //   key: [0xfe, 0x4b, 0xe6, 0x05, 0x47, 0x73, 0xf6, 0x34, 0x35, 0x6a, 0xc3, 0x28, 0x59, 0x1f, 0xbc, 0x6f, 0x83, 0x3b, 0x0d, 0x1b, 0xee, 0xb3, 0x8d, 0xd5, 0xb6, 0xfe, 0xb7, 0x48, 0x1b, 0x44, 0x89, 0xd4],
-      //   nonce: [0x0b, 0x3f, 0x16, 0xf8, 0x98, 0xa5, 0xa7, 0xd5],
-      //   plain_text: vec!(0x76, 0xce, 0xd1, 0xad, 0xe6, 0xd1, 0xef, 0x40, 0x69, 0xaf, 0xdd, 0xb3, 0x2e, 0x74, 0x32, 0xd4, 0xff, 0x2f, 0xd0, 0x66, 0x85, 0x12, 0x1f, 0x7b, 0x16, 0x46, 0x4e, 0x7a, 0x72, 0xd3, 0x65, 0x74, 0x4f, 0x54, 0x7d, 0x2c, 0xcf, 0x53, 0x48, 0x63, 0x10, 0xe3, 0x8b, 0x42, 0xd8, 0xba, 0xca, 0xf7, 0x11, 0xe5, 0x4c, 0x54, 0x58, 0xd2, 0xd6, 0x8c, 0x4d, 0xbc, 0xc8, 0xde, 0x31, 0xab, 0x67, 0x32, 0xf4, 0x43, 0x0e, 0x88, 0xa6, 0x45, 0x65, 0xf5, 0xb2, 0x87, 0x64, 0x07, 0x75, 0xaa, 0xa2, 0xaf, 0x1c, 0xc4, 0x61, 0xd3, 0xe4, 0x15, 0xbb, 0x27, 0x5c, 0x62, 0x46, 0xb1, 0xb5, 0x85, 0x17, 0xaa, 0x72, 0x66, 0x7e, 0xae, 0x29, 0x1a, 0x29, 0x82, 0xed, 0xa1, 0x75, 0xd1, 0xb2, 0x2c, 0x5a, 0x58, 0xe6, 0xfe, 0xc2, 0xb3, 0x74, 0x3d, 0x55, 0x71, 0x2f, 0x20, 0x1c, 0xa2, 0x4b, 0xa5, 0xc0, 0xae, 0x8c, 0x25, 0x72, 0x48, 0x71, 0xb2, 0xec, 0x2f, 0xb9, 0x14, 0xa8, 0xda, 0x5a, 0x52, 0x67, 0x0a, 0xb9, 0xb4, 0x3a, 0x83, 0xb8, 0x56, 0x8c, 0xe7, 0x4d, 0xb5, 0xc6, 0x34, 0x06, 0x1c, 0xb8, 0x05, 0x30, 0xc8, 0x07, 0x0c, 0x38, 0xb8, 0xf4, 0x8c, 0x33, 0xba, 0x13, 0x6c, 0xb9, 0xf2, 0x15, 0x8e, 0xe7, 0xed, 0xa8, 0xb6, 0x5f, 0x21, 0x92, 0xfc, 0x94, 0xd1, 0x29, 0x1f, 0x18, 0x2f, 0x10, 0x17, 0x95, 0xb7, 0x19, 0x0c, 0x74, 0xb3, 0x19, 0xd2, 0xd3, 0xe0, 0x2a, 0x97, 0xc8, 0x24, 0xd9, 0xc9, 0x47, 0x1a, 0x83, 0x79, 0x7e, 0x49, 0x36, 0x31, 0x0b, 0x20, 0x7e, 0x3a, 0x1e, 0x0b, 0xcf, 0x75, 0xf7, 0xc3, 0xe3, 0xee, 0x48, 0xa7, 0x47, 0x64, 0x1c, 0xdc, 0x43, 0x77, 0xf2, 0xd5, 0x50, 0x82),
-      //   aad: vec!(0x83, 0x4c, 0xd7, 0x75, 0xcb, 0xef, 0xe4, 0xb3, 0x3a, 0x3c, 0xa5, 0x3a, 0x00, 0xc0, 0x6a, 0x3c, 0x4a, 0x66, 0x69, 0x83, 0xe4, 0x11, 0x5a, 0x02, 0x9f, 0x15, 0x72, 0x94, 0x60, 0xda, 0xa4, 0x5d, 0x15, 0x05, 0xe9, 0x51, 0x72, 0xd3, 0x69, 0x56, 0x25, 0xa1, 0x86, 0xb2, 0x8b, 0x8b, 0xe1, 0x73, 0xa9, 0x25, 0xaf, 0x04, 0x66, 0x5f, 0x20, 0x92, 0x67, 0xb3, 0xc5, 0x12, 0x3e, 0x8b, 0xe1, 0x3d, 0xa4, 0x47, 0xee, 0x1a, 0xe8, 0x56, 0xbb, 0x09, 0x25, 0xf3, 0x5a, 0xaa, 0x76, 0xe0, 0x4a, 0x7b, 0xca, 0x84, 0x60, 0xf7, 0x6c, 0x20, 0x24, 0xde, 0x21, 0x49, 0xf3, 0x8a, 0x8c, 0xfb, 0xa8, 0x16, 0x94, 0xb8, 0x54, 0x88, 0x5d, 0x72, 0x56, 0x81, 0x05, 0x57, 0x1b, 0x6b, 0x21, 0x3a, 0x0b, 0xc1, 0x88, 0xa4, 0x4c, 0xc7, 0xfe, 0x13, 0x15, 0x3c, 0xbf, 0x26, 0x14, 0x01, 0xb2, 0x38, 0xcf, 0x12, 0xa9, 0x5e, 0x23, 0xcb, 0x56, 0xf2, 0x40, 0x11, 0x4f, 0x16, 0xe2, 0xf1, 0xe3, 0xa5, 0x14, 0x61, 0x5a, 0xab, 0x44, 0x49, 0xc0, 0xc4, 0x9e, 0x4d, 0x90, 0x0b, 0x0e, 0x17, 0xd1, 0xa8, 0xda, 0xbb, 0x53, 0xd4, 0x3d, 0xca, 0x32, 0xfa, 0x05, 0x2d, 0x57, 0x6b, 0x73, 0xdd, 0x9b, 0x40, 0x85, 0x6b, 0x51, 0x5d, 0x6d, 0x7e, 0xfc, 0x2a, 0x5c, 0x17, 0xe0, 0xeb, 0xcb, 0x17, 0xbd, 0x59, 0xdc, 0x86, 0xf2, 0x2c, 0xe9, 0x09, 0x30, 0x1a, 0x26, 0x52, 0xf1, 0x34, 0xe8, 0x2e, 0xf0, 0xe4, 0x51, 0x94, 0x87, 0xed, 0x12, 0xd5, 0x15, 0x36, 0x02, 0x4f, 0x2a, 0xe8, 0xf7, 0x5d, 0x93, 0x7c, 0x42, 0xd0, 0x03, 0x07, 0x6e, 0x5d, 0xea, 0x8d, 0xe0, 0xc6, 0x84, 0xcd, 0xa1, 0xf3, 0x42, 0x53, 0xd8, 0xfc),
-      //   cipher_text: vec!(0xf8, 0xde, 0xfb, 0x6f, 0xe9, 0x5d, 0xfe, 0xc4, 0x99, 0xb9, 0x09, 0x99, 0x6a, 0x1f, 0x75, 0xa1, 0x98, 0xa9, 0x0e, 0x4d, 0x6c, 0x64, 0x64, 0xd0, 0x0a, 0x35, 0x7a, 0x55, 0x53, 0x11, 0xc4, 0x2f, 0xe9, 0x2d, 0xbb, 0xc4, 0xb7, 0x9c, 0x93, 0x5e, 0x4f, 0x0b, 0x1a, 0x95, 0xe4, 0x4f, 0xdb, 0xc1, 0x38, 0x0b, 0xeb, 0xab, 0xca, 0x28, 0xdb, 0x4d, 0xd0, 0xd2, 0x87, 0x0d, 0xaa, 0xaf, 0xc3, 0x8e, 0xf2, 0x79, 0x08, 0xc3, 0x50, 0x9e, 0x94, 0x57, 0x14, 0x80, 0x1c, 0xc5, 0x1f, 0x1a, 0x07, 0xb2, 0x43, 0x0c, 0x74, 0xfa, 0x64, 0xf2, 0xa7, 0xc2, 0xf7, 0xfd, 0x15, 0x51, 0xd2, 0x58, 0xc9, 0xc3, 0xbe, 0x02, 0x08, 0x73, 0xfc, 0x1b, 0xf1, 0x9f, 0x33, 0xab, 0x6c, 0x66, 0x09, 0x11, 0xdc, 0xf2, 0x31, 0x71, 0x95, 0xd0, 0xef, 0xee, 0x82, 0xd2, 0x0e, 0xc2, 0x6d, 0x22, 0x61, 0x1f, 0x9c, 0xf8, 0x6c, 0x51, 0xa6, 0x4e, 0x28, 0xb3, 0xa1, 0xf3, 0x44, 0x50, 0x00, 0x18, 0xe0, 0x85, 0x5c, 0x88, 0xda, 0xe3, 0xc0, 0x7a, 0xca, 0xea, 0xa1, 0x0b, 0x60, 0x38, 0x84, 0x84, 0xdc, 0xe9, 0x3e, 0x16, 0xe6, 0xe1, 0xa6, 0xe6, 0x9e, 0x89, 0x98, 0x06, 0x64, 0x8a, 0x92, 0x56, 0x8c, 0x87, 0x80, 0xe9, 0xf4, 0xba, 0xac, 0xd9, 0x8c, 0xbb, 0x35, 0x3a, 0xc2, 0xf9, 0x08, 0xe7, 0x75, 0xd9, 0x23, 0x03, 0xcf, 0xab, 0x84, 0x3f, 0x15, 0xbe, 0x0e, 0x0c, 0x32, 0x2a, 0x95, 0x88, 0x02, 0xfb, 0x1a, 0x60, 0xfc, 0xc7, 0x63, 0x1f, 0x15, 0x1f, 0x4c, 0x2b, 0x8c, 0xb9, 0x65, 0xd2, 0xd2, 0x96, 0xac, 0xef, 0x25, 0x02, 0x75, 0xa2, 0xfe, 0xcc, 0x0c, 0xea, 0x80, 0x3c, 0xe7, 0xc0, 0x58, 0xb1, 0x2d, 0xd2),
-      //   tag: vec!(0xad, 0xe5, 0x15, 0x09, 0x19, 0x30, 0xdd, 0x78, 0x61, 0xb2, 0x7f, 0x78, 0xa8, 0x7e, 0xf6, 0x0c)
-      // },
-      // TestVector{
-      //   key: [0xa2, 0x88, 0xb1, 0x1c, 0xe5, 0x38, 0x2e, 0xc7, 0x24, 0xce, 0x4a, 0xb2, 0xd7, 0xef, 0xa8, 0xe7, 0x77, 0xe9, 0x1e, 0xbd, 0x04, 0x36, 0x79, 0x35, 0xe1, 0x5f, 0x9d, 0xac, 0x48, 0x3e, 0x95, 0x96],
-      //   nonce: [0x87, 0x41, 0x44, 0xdb, 0xf6, 0x48, 0xb3, 0x25],
-      //   plain_text: vec!(0x4c, 0x91, 0x95, 0x28, 0x0a, 0x79, 0xa5, 0x09, 0x91, 0x9a, 0xf4, 0x94, 0x7e, 0x9e, 0x07, 0x23, 0x16, 0x95, 0xfd, 0x7c, 0x50, 0x88, 0x53, 0x9f, 0x23, 0x93, 0x6c, 0xe8, 0x87, 0x70, 0xce, 0x07, 0xd9, 0xad, 0x3a, 0xe4, 0xa4, 0x63, 0xb3, 0xa5, 0x7d, 0x06, 0x34, 0xd3, 0xa7, 0x7c, 0xea, 0xad, 0xf3, 0x47, 0xa3, 0x34, 0x68, 0x2b, 0x04, 0xbe, 0x8e, 0x58, 0xb8, 0xe8, 0x6f, 0xb9, 0x4a, 0x1f, 0x93, 0x25, 0x51, 0x32, 0xb8, 0xcd, 0xb0, 0xdf, 0x86, 0xf5, 0xbe, 0xa3, 0x54, 0xee, 0xa4, 0xe8, 0x31, 0x5f, 0xea, 0x83, 0xe3, 0xfd, 0xf6, 0xe5, 0x8a, 0xa9, 0xf2, 0x6e, 0x93, 0xca, 0xa0, 0x8e, 0x5e, 0x25, 0x51, 0xa9, 0x4b, 0xd9, 0x16, 0xa5, 0x1f, 0xed, 0x29, 0xec, 0x16, 0xf6, 0x68, 0x00, 0xcd, 0xa6, 0xa0, 0xaa, 0x24, 0xec, 0x30, 0x8b, 0xf5, 0xfb, 0x88, 0x5a, 0xfb, 0xa2, 0x72, 0x68, 0x5d, 0xe2, 0x7c, 0x1e, 0xdc, 0xdd, 0x36, 0x68, 0x04, 0x8e, 0xf0, 0x7b, 0x06, 0xe9, 0x0d, 0x46, 0x4a, 0x8a, 0xa2, 0x86, 0x64, 0x90, 0x3c, 0xac, 0x45, 0xe1, 0x54, 0xe8, 0xe1, 0xe3, 0x9c, 0x25, 0x7e, 0x1f, 0xf5, 0x06, 0xb9, 0xd9, 0x5c, 0xef, 0x4f, 0x30, 0x0b, 0xb7, 0x3b, 0x89, 0x9e, 0x78, 0x28, 0x60, 0x2c, 0x3c, 0x1d, 0x29, 0x0b, 0x8c, 0xf5, 0x5e, 0xe5, 0xfd, 0x72, 0xec, 0xce, 0x9e, 0x6e, 0xfc, 0x92, 0x93, 0xae, 0xbf, 0x67, 0x4a, 0x70, 0xe2, 0xa7, 0x67, 0x3e, 0x75, 0x62, 0x9c, 0x12, 0x95, 0x06, 0x22, 0xdf, 0xf7, 0x1d, 0x3e, 0xc0, 0x99, 0x2e, 0x57, 0x77, 0x6c, 0x78, 0x8c, 0x69, 0x27, 0xd3, 0x0b, 0x4e, 0x24, 0xb7, 0x49, 0x19, 0x1c, 0x3c, 0xe8, 0x01, 0x7f, 0x0a, 0xda, 0x62, 0x76, 0xe4, 0x37, 0x20),
-      //   aad: vec!(0x04, 0xab, 0xe8, 0x58, 0x8c, 0x8c, 0x8c, 0x39, 0xa1, 0x82, 0x09, 0x2e, 0x5e, 0x78, 0x40, 0x44, 0x2b, 0xd1, 0xc1, 0x14, 0x9d, 0xa1, 0x02, 0xc4, 0xee, 0x41, 0x2b, 0xd8, 0xb8, 0x2b, 0xaa, 0x50, 0x87, 0xef, 0x72, 0x91, 0xb5, 0xcd, 0x07, 0x7c, 0x17, 0x7c, 0x42, 0x77, 0x0b, 0x00, 0x23, 0xe0, 0xe4, 0x62, 0xb0, 0x6e, 0x75, 0x53, 0xf1, 0x91, 0xbc, 0xb0, 0x31, 0x5a, 0x34, 0x91, 0x8d, 0xcd, 0xbf, 0xfe, 0x2b, 0x99, 0xc3, 0xe0, 0x11, 0xb4, 0x22, 0x0c, 0xc1, 0x77, 0x5d, 0xeb, 0xcc, 0x0d, 0xb5, 0x5f, 0xa6, 0x0d, 0xf9, 0xb5, 0x22, 0x34, 0xf3, 0xd3, 0xfa, 0x96, 0x06, 0x50, 0x8b, 0xad, 0xc2, 0x6f, 0x30, 0xb4, 0x7c, 0xdb, 0x4f, 0x1c, 0x0f, 0x47, 0x08, 0xd4, 0x17, 0xb6, 0x85, 0x3e, 0x66, 0xc2, 0xf1, 0xf6, 0x7f, 0x62, 0x00, 0xda, 0xf7, 0x60, 0xce, 0xb6, 0x4f, 0xfc, 0x43, 0xdb, 0x27, 0xf0, 0x57, 0xad, 0x3e, 0xe9, 0x73, 0xe3, 0x1d, 0x7e, 0x5d, 0x5d, 0xeb, 0x05, 0x03, 0x15, 0xc1, 0xc6, 0x87, 0x98, 0x0c, 0x0c, 0x14, 0x8e, 0xe1, 0xa4, 0x92, 0xd4, 0x7a, 0xcf, 0xcd, 0x61, 0x32, 0x33, 0x41, 0x76, 0xc1, 0x12, 0x58, 0xc8, 0x9b, 0x19, 0xba, 0x02, 0xe6, 0xac, 0xc5, 0x5d, 0x85, 0x2f, 0x87, 0xb6, 0xa2, 0x16, 0x9e, 0xd3, 0x4a, 0x61, 0x47, 0xca, 0xa6, 0x09, 0x06, 0xac, 0x8c, 0x08, 0x13, 0xc0, 0xf0, 0x55, 0x22, 0xaf, 0x7b, 0x7f, 0x0f, 0xad, 0xdb, 0x4b, 0xc2, 0x97, 0x40, 0x5e, 0x28, 0xec, 0xf5, 0xa0, 0xf6, 0xaa, 0xc6, 0x25, 0x84, 0x22, 0xd2, 0x9c, 0xfe, 0x25, 0x0d, 0x61, 0x40, 0x28, 0x40, 0xf3, 0xc2, 0x7d, 0x0c, 0xe3, 0x9b, 0x3e, 0x2d, 0x5f, 0x1e, 0x52, 0x05, 0x41, 0xd2, 0x96, 0x5e),
-      //   cipher_text: vec!(0x0a, 0xfc, 0xe7, 0x70, 0xa1, 0x2f, 0x15, 0xd6, 0x7a, 0xc1, 0x04, 0xba, 0x06, 0x40, 0xaa, 0xb9, 0x59, 0x22, 0x39, 0x06, 0x07, 0x47, 0x3c, 0xbd, 0xa7, 0x13, 0x21, 0x15, 0x6a, 0x55, 0x59, 0x90, 0x6b, 0xe9, 0x33, 0xfb, 0x09, 0x80, 0xda, 0x56, 0xf2, 0x7e, 0x89, 0x79, 0x6e, 0xaa, 0x10, 0x54, 0xf5, 0xaa, 0xcf, 0x16, 0x68, 0xd9, 0xf2, 0x73, 0xcc, 0x69, 0x07, 0x1b, 0x9e, 0x8e, 0x22, 0xaf, 0x6a, 0x20, 0x5a, 0x6a, 0x88, 0xf7, 0xad, 0x91, 0x8e, 0x22, 0xf6, 0x16, 0xbd, 0xdb, 0xb0, 0x7c, 0x78, 0x91, 0x3c, 0x7e, 0x05, 0x6e, 0x76, 0x9e, 0x6f, 0xcf, 0x91, 0xc7, 0x60, 0x0c, 0x27, 0x40, 0x21, 0x2e, 0x3a, 0x17, 0x6e, 0x41, 0x10, 0xca, 0xc9, 0xe3, 0x61, 0xa5, 0x9a, 0x77, 0x34, 0x57, 0x06, 0x4d, 0x2d, 0xc6, 0x52, 0xdd, 0x11, 0x5d, 0x04, 0xf1, 0xc3, 0x75, 0x6c, 0x0e, 0x1d, 0x39, 0xf6, 0x73, 0x7a, 0x16, 0xb4, 0x50, 0x86, 0x63, 0xe3, 0x10, 0x93, 0x4c, 0x49, 0xc5, 0x80, 0x58, 0xb3, 0xc7, 0xb9, 0xaf, 0x7b, 0xb2, 0x33, 0x4c, 0x8a, 0x16, 0x36, 0x08, 0xc4, 0x24, 0x99, 0x65, 0x89, 0x86, 0x92, 0x7c, 0xda, 0x36, 0x5e, 0x2a, 0xea, 0xd3, 0xac, 0x29, 0xde, 0x16, 0xe4, 0x7e, 0x95, 0x43, 0x83, 0xea, 0x56, 0x6f, 0x8f, 0xb2, 0x45, 0xa4, 0xe5, 0xa9, 0x34, 0xc7, 0x67, 0xbb, 0x3b, 0xf7, 0xe0, 0xeb, 0x8a, 0x47, 0x7f, 0xd0, 0xe1, 0xf6, 0x1b, 0xcb, 0x23, 0x84, 0x62, 0xa0, 0xd1, 0x9c, 0x5c, 0xea, 0x92, 0x93, 0xca, 0x58, 0xad, 0xe7, 0x68, 0x29, 0x41, 0x32, 0x16, 0xa7, 0x88, 0x2c, 0xd2, 0x84, 0x63, 0x23, 0x04, 0x66, 0x94, 0xf7, 0x8c, 0xd8, 0xb0, 0x34, 0x77, 0x92, 0xeb, 0xb7, 0x5a, 0xbd, 0xc1),
-      //   tag: vec!(0x97, 0x3e, 0x58, 0xb1, 0xb8, 0xad, 0xb1, 0x76, 0xa6, 0xf1, 0xe5, 0xc9, 0x63, 0xbf, 0xdc, 0x5c)
-      // },
-      // TestVector{
-      //   key: [0x65, 0xb6, 0x3e, 0xd5, 0x37, 0x50, 0xc8, 0x8c, 0x50, 0x8c, 0x44, 0x88, 0x1a, 0xe5, 0x9e, 0x6f, 0xff, 0x69, 0xc6, 0x62, 0x88, 0xf3, 0xc1, 0x4c, 0xfe, 0xc5, 0x03, 0x39, 0x12, 0x62, 0xca, 0xfc],
-      //   nonce: [0x7f, 0x5e, 0x56, 0x0a, 0x1d, 0xe4, 0x34, 0xba],
-      //   plain_text: vec!(0x84, 0x5e, 0xf2, 0x7b, 0x66, 0x15, 0xfb, 0x69, 0x9d, 0x37, 0x97, 0x1d, 0xb6, 0xb5, 0x97, 0x93, 0x0a, 0x7e, 0xf1, 0xe6, 0xf9, 0x00, 0x54, 0x79, 0x1e, 0xb0, 0x4d, 0xdf, 0xe7, 0x25, 0x2b, 0x5f, 0x88, 0xfd, 0x60, 0xeb, 0xa5, 0xaf, 0x46, 0x9b, 0xc0, 0x96, 0x61, 0xc0, 0x98, 0x7a, 0x49, 0x6f, 0xa5, 0x40, 0x62, 0x1a, 0xfe, 0xec, 0x51, 0xbe, 0xbd, 0xa7, 0x86, 0x82, 0x68, 0x00, 0x94, 0x3d, 0x97, 0x70, 0x39, 0xde, 0xe7, 0x62, 0x35, 0x24, 0x81, 0x12, 0xff, 0x8b, 0x74, 0x3f, 0x25, 0xed, 0x5f, 0x3c, 0xb0, 0xd3, 0x30, 0x7f, 0x5e, 0x11, 0x8d, 0x84, 0xfd, 0xbb, 0x9c, 0x3f, 0x55, 0x31, 0xbc, 0x17, 0x7f, 0xb8, 0x45, 0x49, 0xc9, 0x94, 0xea, 0x44, 0x96, 0xc6, 0x5e, 0x52, 0x49, 0xda, 0x98, 0x7d, 0xd7, 0x55, 0xd4, 0x6d, 0xc1, 0x78, 0x8f, 0x58, 0x24, 0x10, 0x26, 0x6a, 0x10, 0xf2, 0x91, 0xc1, 0x47, 0x4f, 0x73, 0x21, 0x83, 0xa2, 0xa3, 0x9a, 0xfe, 0x60, 0x37, 0x71, 0xbb, 0x9c, 0x42, 0x3f, 0xe3, 0xe8, 0x90, 0x6f, 0x2b, 0xe4, 0x4a, 0x0c, 0x9a, 0x7c, 0x3f, 0x0c, 0xeb, 0x09, 0xd1, 0xd0, 0xf9, 0x2d, 0x94, 0x23, 0x83, 0xa8, 0x75, 0xc0, 0x56, 0x7c, 0x78, 0x69, 0xf0, 0x45, 0xe5, 0x6d, 0xd1, 0xa4, 0xd6, 0xe9, 0x0c, 0x58, 0xd4, 0x4f, 0xe0, 0xc5, 0x76, 0x0b, 0xb4, 0xfd, 0x01, 0xde, 0x55, 0x43, 0x9d, 0xb5, 0x2b, 0x56, 0x83, 0x1e, 0x5a, 0x26, 0xa4, 0x7d, 0xe1, 0x42, 0x49, 0x45, 0x3a, 0x4f, 0x8e, 0x7d, 0xa3, 0xcb, 0x32, 0x82, 0xc6, 0x62, 0x29, 0x16, 0x19, 0x7e, 0xbf, 0xaa, 0xd8, 0x5d, 0xd6, 0x5c, 0x61, 0xe7, 0xd2, 0xd3, 0xba, 0x62, 0x62, 0x76, 0x36, 0x67, 0x46, 0xf3, 0x96, 0x39, 0x4c, 0x1b, 0xf7, 0x5f, 0x51, 0xce),
-      //   aad: vec!(0x51, 0xa3, 0x58, 0x83, 0x98, 0x80, 0x8e, 0x1d, 0x6a, 0x98, 0x50, 0x5c, 0x6e, 0x56, 0x01, 0xae, 0x2a, 0x27, 0x66, 0xf1, 0xf2, 0x8f, 0x8f, 0x69, 0xd1, 0xcc, 0xbc, 0xad, 0x18, 0x03, 0x8c, 0x15, 0x7b, 0x41, 0x52, 0x5b, 0xe5, 0x8a, 0xe4, 0x52, 0x7a, 0x07, 0x37, 0x48, 0xb7, 0xa0, 0x48, 0x09, 0xe5, 0x2a, 0x5d, 0xf0, 0xc7, 0x98, 0x84, 0x17, 0x60, 0x77, 0x38, 0xe6, 0x3d, 0x7e, 0xad, 0x47, 0xdb, 0x79, 0x5a, 0x34, 0x6b, 0x04, 0xe7, 0x40, 0x18, 0x6e, 0x73, 0xcc, 0xad, 0x79, 0xf7, 0x25, 0xb5, 0x8e, 0xe2, 0x2d, 0xc6, 0xe3, 0x0d, 0x1f, 0x0a, 0x21, 0x8e, 0xda, 0x17, 0x91, 0xe2, 0x22, 0x9b, 0x25, 0x3d, 0x4a, 0xb2, 0xb9, 0x63, 0xa4, 0x3e, 0x12, 0x31, 0x8c, 0x8b, 0x07, 0x85, 0xc2, 0x0f, 0xca, 0x3a, 0xbc, 0xf2, 0x20, 0xc0, 0x87, 0x45, 0xd9, 0xf9, 0x60, 0x2f, 0x0e, 0xce, 0x54, 0x4a, 0x05, 0x73, 0x6d, 0x76, 0xb1, 0x2d, 0x24, 0x96, 0x99, 0xc9, 0xe3, 0xe9, 0x9f, 0x3f, 0x13, 0xcf, 0x4e, 0x5d, 0xc1, 0x3a, 0x04, 0x12, 0x5c, 0x94, 0x9a, 0x5b, 0x30, 0xd0, 0x34, 0xb2, 0x3c, 0xb3, 0x64, 0xc8, 0x78, 0x19, 0x64, 0xbc, 0x6c, 0x30, 0xe5, 0xe5, 0xca, 0x96, 0x73, 0xd5, 0x17, 0xef, 0x5f, 0x35, 0x96, 0x5d, 0x8a, 0x8c, 0xf1, 0xbe, 0x01, 0x7e, 0x34, 0x3d, 0xf9, 0x7b, 0x6b, 0xee, 0x37, 0xb3, 0x06, 0x38, 0xb1, 0x54, 0x28, 0x6d, 0x1f, 0x36, 0xd2, 0xf9, 0xa0, 0xea, 0xa2, 0x3c, 0xc4, 0x84, 0xea, 0xc5, 0xa0, 0x5b, 0x15, 0xd9, 0xef, 0xc5, 0x37, 0xd9, 0x89, 0xdb, 0xc8, 0xb3, 0x10, 0x6c, 0x0d, 0xc1, 0xa5, 0x6e, 0x97, 0xe6, 0xae, 0xc2, 0xef, 0xf5, 0x4a, 0x82, 0xcf, 0x7a, 0xe9, 0xdf, 0x2a, 0xf4, 0x6b, 0x4c, 0x86, 0x0f, 0x83),
-      //   cipher_text: vec!(0x02, 0x7b, 0x14, 0x19, 0x7b, 0x40, 0x12, 0x25, 0x6b, 0x13, 0x3b, 0x78, 0xdd, 0xc9, 0x4e, 0x72, 0xfb, 0x4d, 0x72, 0x4f, 0xef, 0xa4, 0xae, 0x32, 0x9f, 0x5a, 0x5f, 0xa3, 0xfa, 0x78, 0x4f, 0xe6, 0xd7, 0xe1, 0xe8, 0x05, 0xe3, 0xf7, 0xa7, 0x55, 0x57, 0xde, 0x64, 0xde, 0x50, 0x6d, 0x38, 0x23, 0x7b, 0x46, 0x7f, 0xa5, 0x77, 0xef, 0xb5, 0x9e, 0x7c, 0xfe, 0x23, 0x56, 0xbe, 0xd6, 0x65, 0x5c, 0x5a, 0xa4, 0xe2, 0x38, 0xdc, 0xfe, 0xb7, 0x5c, 0x16, 0x54, 0x9a, 0x09, 0x17, 0x26, 0x87, 0x68, 0xa9, 0x6a, 0xcb, 0x5e, 0x20, 0x54, 0x6a, 0x1f, 0xb7, 0xe3, 0xa7, 0xcf, 0xf8, 0x87, 0xf4, 0x9f, 0x2c, 0xd7, 0xa1, 0x35, 0xf7, 0x2a, 0x98, 0xa7, 0x79, 0x15, 0x0f, 0x32, 0x07, 0xbf, 0x73, 0x3e, 0x88, 0x86, 0x1f, 0xd7, 0x9e, 0xad, 0xbf, 0x77, 0xfa, 0x3b, 0xfe, 0x97, 0xbf, 0xe8, 0xb6, 0xa9, 0x91, 0xcb, 0x3b, 0xcc, 0x2c, 0xde, 0x82, 0x87, 0xf7, 0xe8, 0x93, 0x84, 0x84, 0x65, 0x61, 0x93, 0x4b, 0x0f, 0x3e, 0x05, 0xe0, 0x64, 0x6e, 0x0e, 0x19, 0x07, 0x77, 0x0d, 0xf6, 0x7a, 0x75, 0x94, 0x16, 0x1a, 0x4d, 0x07, 0x63, 0xfa, 0xa6, 0xfa, 0x84, 0x40, 0x80, 0x93, 0x21, 0x59, 0x99, 0x9d, 0x52, 0x8e, 0xe0, 0x55, 0x87, 0x10, 0x05, 0x8c, 0xe1, 0x6f, 0x97, 0xd1, 0x3a, 0xc9, 0xfd, 0x9b, 0xf5, 0x04, 0x41, 0x91, 0x18, 0x8b, 0xbf, 0xb5, 0x98, 0xd0, 0xfa, 0xfb, 0xdf, 0x79, 0x0b, 0x61, 0xce, 0x07, 0x81, 0xec, 0xc0, 0x42, 0x18, 0xa3, 0x0d, 0xed, 0x45, 0xef, 0xd4, 0x98, 0xcc, 0x9b, 0xa0, 0x35, 0x62, 0xed, 0x2b, 0x4a, 0x99, 0x3e, 0xe9, 0x88, 0x76, 0xb3, 0xab, 0x7a, 0x9b, 0xc0, 0x78, 0x29, 0xf1, 0xc4, 0xca, 0x6e, 0xad, 0x98, 0xc0, 0x6b),
-      //   tag: vec!(0xe4, 0xd1, 0x8a, 0x70, 0x1b, 0x83, 0x08, 0x69, 0x7b, 0x5e, 0x79, 0x14, 0x1e, 0xd7, 0x83, 0xc1)
-      // },
-      // TestVector{
-      //   key: [0x49, 0x86, 0xfd, 0x62, 0xd6, 0xcb, 0x86, 0xb2, 0xea, 0xf2, 0x19, 0x17, 0x4b, 0xec, 0x68, 0x1b, 0xeb, 0xcd, 0xef, 0x86, 0xc8, 0xbe, 0x29, 0x1f, 0x27, 0xd3, 0xe5, 0xdc, 0x69, 0xe2, 0xfe, 0xba],
-      //   nonce: [0xd0, 0x8d, 0x48, 0x66, 0x20, 0xed, 0x2e, 0x84],
-      //   plain_text: vec!(0x3a, 0x22, 0xad, 0x5d, 0xe3, 0x87, 0xdb, 0x4f, 0xdd, 0x5d, 0x62, 0xa1, 0xb7, 0x28, 0xc2, 0x3a, 0x8d, 0xdd, 0xc5, 0x0b, 0x1e, 0x89, 0xf5, 0x4f, 0x61, 0x98, 0xb9, 0x04, 0x99, 0xf9, 0xda, 0x31, 0x22, 0xeb, 0xeb, 0x38, 0xeb, 0xf5, 0xfd, 0xfe, 0x30, 0x30, 0x97, 0x34, 0xf7, 0x9a, 0xff, 0x01, 0xe3, 0xde, 0x1e, 0x19, 0x6b, 0x35, 0xbf, 0xfa, 0x33, 0xba, 0xe4, 0x51, 0xf3, 0x1f, 0x74, 0xb8, 0xae, 0xc0, 0x37, 0x63, 0xf9, 0xe0, 0x86, 0x1a, 0x34, 0xfe, 0x5d, 0xb0, 0xb4, 0x0c, 0x76, 0xe5, 0x7c, 0x7f, 0xc5, 0x82, 0xbf, 0xa1, 0x9c, 0x94, 0xee, 0x25, 0xb5, 0xe1, 0x68, 0x27, 0x0f, 0x37, 0x9b, 0xf9, 0xf8, 0xa0, 0xa1, 0x8b, 0xed, 0x05, 0xde, 0x25, 0x6f, 0x8f, 0x0d, 0xd7, 0xc2, 0x3b, 0xa2, 0xff, 0x1c, 0x7f, 0x72, 0x14, 0x09, 0x46, 0x2f, 0x04, 0xcc, 0x61, 0x1a, 0xd9, 0xbd, 0x4c, 0x3c, 0x9a, 0xcf, 0x30, 0x74, 0x2a, 0xcf, 0xb9, 0x51, 0x8a, 0x63, 0x75, 0xcb, 0xb1, 0x5d, 0x65, 0xa1, 0xbc, 0x69, 0x93, 0xea, 0x43, 0x48, 0x94, 0xf9, 0x3d, 0x4f, 0x6e, 0x05, 0x99, 0x6e, 0xbc, 0x1b, 0xd5, 0x65, 0x79, 0x29, 0x63, 0x09, 0xa2, 0xc6, 0xb8, 0xfd, 0xe9, 0x50, 0x72, 0x16, 0x8b, 0x5f, 0xd3, 0x19, 0x27, 0xc4, 0xc0, 0xab, 0xaa, 0x05, 0x6b, 0xcd, 0x16, 0x22, 0x1d, 0x5f, 0x22, 0x0b, 0xe4, 0x75, 0x91, 0xf4, 0x32, 0x55, 0x01, 0x3a, 0x26, 0x2d, 0xce, 0x43, 0x98, 0x17, 0xf5, 0x34, 0x83, 0x0b, 0xa8, 0x21, 0x55, 0x34, 0x7e, 0x5f, 0xe3, 0x10, 0x1f, 0x80, 0x11, 0xb8, 0x93, 0x65, 0xa6, 0x56, 0x82, 0x14, 0xed, 0x06, 0x61, 0x91, 0x4e, 0x8c, 0xb3, 0x43, 0x1d, 0x6c, 0x8f, 0x23, 0x47, 0xdf, 0xc1, 0x20, 0x9a, 0x3e, 0xca, 0x4a, 0xaf, 0x0a, 0x11, 0x1f, 0x47, 0xfe),
-      //   aad: vec!(0x7d, 0xd3, 0xf6, 0x56, 0xa0, 0x3c, 0x00, 0x1b, 0x45, 0xca, 0x06, 0x80, 0xbc, 0x3a, 0xc9, 0xd6, 0x8c, 0x6e, 0x96, 0xb5, 0x91, 0xd3, 0xc6, 0x9e, 0xb8, 0xc6, 0x5e, 0x48, 0x90, 0x09, 0xd8, 0x45, 0xcb, 0x33, 0x1c, 0x98, 0xb8, 0x2e, 0x62, 0x7e, 0x06, 0xd5, 0xbf, 0x01, 0xe7, 0x4c, 0x57, 0x3d, 0xf2, 0x68, 0xc2, 0x38, 0x6f, 0x12, 0x62, 0x8c, 0x01, 0x99, 0x51, 0xd4, 0x2f, 0x55, 0x99, 0x1f, 0xf2, 0x0d, 0x72, 0xa7, 0xb2, 0xc4, 0x5f, 0x41, 0xd0, 0xbe, 0x7a, 0xf4, 0x28, 0xc9, 0x2f, 0x32, 0x4a, 0xaa, 0xb8, 0xdf, 0x70, 0xd9, 0x00, 0x30, 0x1c, 0xdf, 0x09, 0xa3, 0xd9, 0x3e, 0xb7, 0x11, 0xc9, 0x19, 0xd3, 0x4a, 0x86, 0xff, 0xf9, 0xcb, 0x07, 0x83, 0x22, 0xee, 0x2e, 0x0a, 0xd4, 0x8d, 0xbd, 0xf3, 0xb7, 0x88, 0x4f, 0x0f, 0x2d, 0xc5, 0xc3, 0x62, 0x62, 0xc5, 0x9b, 0xcf, 0xd7, 0x5a, 0xc6, 0x20, 0x0f, 0x59, 0xc6, 0xfc, 0xd0, 0xce, 0x10, 0xff, 0x50, 0x05, 0xfe, 0xf5, 0xdf, 0x8f, 0x04, 0x32, 0x37, 0x7d, 0xfb, 0xfc, 0x1d, 0xb8, 0xf5, 0x59, 0xe2, 0x7e, 0x1a, 0xee, 0xf3, 0x38, 0x0e, 0xa3, 0x86, 0x48, 0x67, 0xd3, 0x6a, 0x25, 0xa1, 0x86, 0x54, 0x77, 0x9a, 0x75, 0x15, 0x86, 0xca, 0xd3, 0xb8, 0xa4, 0x6b, 0x90, 0x86, 0x4e, 0xe6, 0x97, 0xb0, 0x86, 0x05, 0x67, 0x3b, 0x8d, 0x21, 0x23, 0x43, 0x3c, 0x02, 0x0a, 0x21, 0xc4, 0xdb, 0x24, 0x3d, 0xde, 0x24, 0x20, 0xc1, 0x2f, 0xd4, 0xd5, 0x4a, 0x27, 0x04, 0xa0, 0xc8, 0xc3, 0x76, 0x45, 0x4a, 0x1b, 0x5e, 0x80, 0xfd, 0x6d, 0xb8, 0x9a, 0xab, 0xd5, 0x6d, 0x9b, 0x42, 0x1f, 0x29, 0x64, 0x9e, 0x47, 0x48, 0x24, 0xdf, 0xa5, 0x6c, 0xb5, 0xc6, 0x73, 0xc5, 0x04, 0xd1, 0x0b, 0xe5, 0x2b, 0x53, 0x75, 0x17, 0x09, 0xfe),
-      //   cipher_text: vec!(0xc4, 0x01, 0x80, 0xaf, 0xd5, 0x30, 0x01, 0x66, 0x3f, 0xf4, 0x83, 0x41, 0x10, 0xf5, 0x6e, 0x6b, 0x0f, 0x17, 0x8c, 0xd3, 0xc0, 0xe7, 0xf7, 0xde, 0x5d, 0x00, 0x89, 0xee, 0x41, 0xd8, 0x40, 0x3f, 0xfb, 0x98, 0xe8, 0x49, 0x22, 0x70, 0x65, 0x44, 0xa3, 0x44, 0xd7, 0xe2, 0x62, 0x5b, 0x12, 0xcf, 0x66, 0xb9, 0xc9, 0x66, 0xf9, 0xf5, 0x7d, 0x7b, 0x94, 0xe3, 0xe4, 0xb3, 0x4e, 0x6f, 0x0a, 0xae, 0xd1, 0x76, 0x3c, 0xe0, 0x12, 0x78, 0x2e, 0x2f, 0x5e, 0x16, 0x82, 0xe6, 0xc3, 0x43, 0xfc, 0x79, 0x61, 0xfe, 0xdd, 0xdd, 0x09, 0x19, 0xd0, 0xb9, 0x10, 0xe9, 0x92, 0x3c, 0x17, 0xe3, 0x64, 0x06, 0x97, 0x9b, 0x25, 0x6b, 0x85, 0xae, 0xc2, 0x4e, 0xe3, 0x52, 0xf0, 0x3b, 0x48, 0xc1, 0x30, 0x2e, 0xab, 0x41, 0x9c, 0x83, 0xdc, 0xcc, 0x53, 0x72, 0xcc, 0x05, 0x9e, 0x9d, 0xe5, 0x96, 0x22, 0x4f, 0xa7, 0x00, 0x98, 0xeb, 0x32, 0xfc, 0x95, 0x79, 0xe9, 0x79, 0x17, 0xb9, 0x23, 0x91, 0x4f, 0xa2, 0xef, 0xc3, 0x0a, 0xb2, 0x9b, 0x45, 0x7b, 0xf1, 0x4e, 0x45, 0x58, 0x3b, 0x37, 0x71, 0x48, 0x6b, 0xdc, 0x08, 0x76, 0xf3, 0xea, 0x6e, 0x1a, 0x64, 0x67, 0x46, 0xc4, 0xf8, 0xc5, 0xcb, 0x26, 0x41, 0xa1, 0x55, 0x7c, 0x84, 0x73, 0xe6, 0xea, 0x67, 0xd4, 0x81, 0x1a, 0x67, 0x48, 0x5a, 0xe9, 0xa6, 0x78, 0xff, 0x3a, 0x24, 0x08, 0xca, 0x84, 0x5c, 0x3b, 0x51, 0x95, 0x7e, 0x18, 0x9e, 0xef, 0x47, 0xdf, 0xc1, 0xd4, 0x6b, 0xde, 0x4b, 0x9d, 0x75, 0x4d, 0x7d, 0xf1, 0x3f, 0x82, 0x8d, 0xda, 0xdb, 0x06, 0xe4, 0xeb, 0xdd, 0xb5, 0xf0, 0xda, 0xfb, 0xdb, 0x28, 0xde, 0x4c, 0x5e, 0x60, 0x78, 0x92, 0x6f, 0x20, 0xcd, 0xf9, 0xe9, 0x7e, 0xcd, 0x58, 0xe3, 0x09, 0xe6, 0x40, 0xf7, 0x4f, 0x06),
-      //   tag: vec!(0xfd, 0x5e, 0x29, 0x33, 0x28, 0x32, 0xa1, 0x4a, 0x31, 0xa9, 0xce, 0x2c, 0xa8, 0x56, 0x84, 0x98)
-      // },
-      // TestVector{
-      //   key: [0x7d, 0x28, 0xa6, 0x08, 0x10, 0xe4, 0x3d, 0x3d, 0xfa, 0x32, 0xe9, 0x7c, 0x07, 0x95, 0x7e, 0xc0, 0x69, 0xfc, 0x80, 0xcc, 0x6a, 0x50, 0x06, 0x18, 0x30, 0xaa, 0x29, 0xb3, 0xaa, 0x77, 0x7d, 0xfc],
-      //   nonce: [0x47, 0x73, 0x8a, 0xc8, 0xf1, 0x0f, 0x2c, 0x3a],
-      //   plain_text: vec!(0xb5, 0x02, 0x78, 0xae, 0x0f, 0x0f, 0xa2, 0xf9, 0x18, 0xbb, 0x9a, 0x5e, 0xd3, 0xa0, 0x79, 0x7c, 0x32, 0x8e, 0x45, 0x29, 0x74, 0xd3, 0x3c, 0xbf, 0x26, 0xa1, 0xe2, 0x13, 0xaa, 0x20, 0xc0, 0x3d, 0x0d, 0x89, 0x49, 0x08, 0x69, 0x75, 0x4a, 0xbf, 0x84, 0xdb, 0xbe, 0x23, 0x1d, 0x7b, 0xcc, 0xdc, 0xed, 0x77, 0xd5, 0x3f, 0xd4, 0x52, 0x73, 0x56, 0xd8, 0xe0, 0x2b, 0x68, 0x1f, 0xc8, 0x9a, 0x53, 0x5a, 0xe8, 0x73, 0x08, 0xbf, 0x7f, 0xbc, 0x26, 0x19, 0x7a, 0x5e, 0xa8, 0x5b, 0xdb, 0x3a, 0xa0, 0x33, 0xb8, 0xda, 0x5c, 0xd1, 0x97, 0xea, 0x6d, 0x72, 0xf9, 0x6f, 0x63, 0xb0, 0x3f, 0x4e, 0xcc, 0x7a, 0xde, 0xdf, 0x39, 0x9a, 0x50, 0x43, 0x77, 0x6c, 0xdb, 0x32, 0xc0, 0x8f, 0x30, 0xb7, 0x7f, 0x34, 0xdf, 0x85, 0xf8, 0xad, 0xb8, 0xe0, 0x26, 0x49, 0xa0, 0x4b, 0x02, 0x0b, 0x03, 0xe1, 0x7d, 0x44, 0x5c, 0xa6, 0x3e, 0x4e, 0xd7, 0x3a, 0xe4, 0x32, 0xc4, 0x81, 0x39, 0x2e, 0x03, 0x1e, 0xba, 0x2f, 0x9d, 0x2f, 0x7f, 0x98, 0x1d, 0x1e, 0x50, 0x91, 0x78, 0x22, 0xbd, 0x6f, 0xf7, 0x1c, 0x23, 0x9d, 0x33, 0x44, 0x4a, 0xda, 0x35, 0x23, 0xa5, 0x9d, 0xfb, 0xce, 0x54, 0x57, 0xea, 0xde, 0xc1, 0xab, 0x92, 0x6c, 0x9e, 0x6c, 0x52, 0x99, 0xc7, 0x52, 0x1e, 0x3f, 0x20, 0x4b, 0x96, 0x90, 0x1a, 0x71, 0x25, 0x04, 0xfc, 0xc7, 0x82, 0xe8, 0xce, 0xa8, 0x0b, 0xa1, 0x2a, 0x7f, 0x7e, 0x71, 0xce, 0xc3, 0xd0, 0x87, 0x18, 0x99, 0xb6, 0xca, 0x05, 0x90, 0x61, 0xda, 0x03, 0x77, 0x15, 0xf7, 0xd1, 0x3f, 0xed, 0x01, 0xc9, 0xca, 0xde, 0x1e, 0x68, 0x7b, 0x4f, 0xbb, 0x1f, 0x4a, 0xc4, 0xb0, 0x40, 0xdb, 0x3b, 0x43, 0x80, 0x0f, 0x11, 0x2f, 0xb9, 0x00, 0xe4, 0xf7, 0x72, 0xd6, 0x1b, 0x92, 0x1c, 0xbc, 0xe4, 0xda, 0x6f),
-      //   aad: vec!(0x32, 0x42, 0x92, 0x81, 0x3b, 0x7d, 0xf1, 0x5b, 0xc0, 0x70, 0xcc, 0x5d, 0x8a, 0x4b, 0xf7, 0x4e, 0xad, 0x03, 0x64, 0x30, 0xbe, 0x63, 0xab, 0xc4, 0x33, 0x04, 0xcf, 0x65, 0x39, 0x59, 0xa2, 0x4a, 0x91, 0xc7, 0xde, 0x5a, 0x67, 0x1c, 0x50, 0xfa, 0x8a, 0x87, 0xe2, 0x1b, 0xb8, 0x2b, 0x06, 0x99, 0x99, 0xaa, 0xdf, 0xb6, 0x89, 0x5d, 0x8b, 0xda, 0x4c, 0x30, 0x83, 0xd1, 0x7b, 0x8c, 0xa5, 0x5b, 0x9a, 0xb1, 0x51, 0x1e, 0xd8, 0xc4, 0xb3, 0x9d, 0x8c, 0x28, 0xc1, 0x1a, 0x22, 0xef, 0x90, 0xc0, 0x8a, 0x98, 0x3e, 0x3f, 0xe2, 0xd9, 0x88, 0xdf, 0x9e, 0x02, 0xb1, 0x6a, 0x20, 0xb2, 0x4f, 0x39, 0xdd, 0xb2, 0x84, 0x29, 0x62, 0x5f, 0x51, 0x1d, 0xb0, 0x82, 0x98, 0xc4, 0xdc, 0x32, 0x1f, 0x6c, 0x26, 0x8f, 0xc8, 0x36, 0xa6, 0x19, 0x1d, 0xf6, 0x23, 0x2f, 0x51, 0xc4, 0x63, 0xa3, 0x97, 0xa8, 0xd8, 0xb3, 0x33, 0x74, 0xab, 0xe9, 0x4e, 0x62, 0xc0, 0xf5, 0xc3, 0x22, 0x38, 0x7e, 0x1f, 0xc4, 0xa1, 0xc1, 0x98, 0x0a, 0x04, 0xa1, 0xa3, 0xc2, 0xc3, 0x1b, 0x32, 0xf1, 0x83, 0xa1, 0x1c, 0x32, 0x68, 0xc6, 0xdc, 0xa5, 0x21, 0x14, 0x9d, 0xc1, 0x6a, 0xf1, 0x20, 0xa7, 0x8b, 0xe6, 0x62, 0x72, 0x10, 0xe8, 0xdd, 0xbc, 0x44, 0x47, 0x2b, 0xc2, 0x4d, 0x66, 0xce, 0x36, 0x81, 0xc7, 0x57, 0x9b, 0x3d, 0x9a, 0x42, 0x52, 0x12, 0xa7, 0x04, 0xa4, 0xf5, 0x10, 0x5c, 0xb8, 0x0f, 0x0d, 0x18, 0xee, 0x86, 0x09, 0x53, 0xd1, 0x0b, 0x59, 0xc1, 0x14, 0x82, 0x67, 0x79, 0xbb, 0xc3, 0x68, 0xd7, 0xa0, 0xee, 0xce, 0x9f, 0x22, 0x3e, 0x47, 0xcd, 0x8e, 0x5f, 0xd4, 0x53, 0x60, 0x7d, 0x10, 0x1d, 0x9d, 0x9c, 0x2b, 0xd9, 0xa6, 0x58, 0xd6, 0x52, 0x0b, 0x87, 0xd7, 0xb4, 0x26, 0x3f, 0x6d, 0x84, 0x5a, 0x52, 0x4a, 0x36, 0xe4),
-      //   cipher_text: vec!(0x2c, 0x21, 0x7e, 0x96, 0x9c, 0x04, 0x74, 0x0a, 0x1a, 0xcf, 0xa3, 0x01, 0x17, 0xeb, 0x5b, 0x32, 0xdc, 0x57, 0x3d, 0xf3, 0x35, 0x4f, 0x4c, 0xc3, 0xbf, 0x8f, 0x69, 0x6f, 0xf9, 0x05, 0xf1, 0xe6, 0x40, 0xf3, 0xb2, 0xc2, 0x50, 0x47, 0x3b, 0x37, 0x66, 0x22, 0xe0, 0xc9, 0xbd, 0xa1, 0x3b, 0x94, 0x64, 0x05, 0x21, 0xbe, 0x1e, 0xf0, 0xfc, 0x66, 0x0b, 0x4c, 0x10, 0xdb, 0xe2, 0xbf, 0xc0, 0x93, 0x03, 0x07, 0x53, 0xe0, 0x4f, 0x6a, 0xae, 0xcf, 0x81, 0x3b, 0x43, 0xb6, 0x1f, 0x96, 0x04, 0x55, 0x97, 0x4b, 0x8b, 0xb8, 0xa9, 0xb4, 0x61, 0xd1, 0xe8, 0xfd, 0x38, 0x02, 0x31, 0x5e, 0x86, 0x3c, 0x00, 0x44, 0x8f, 0x24, 0xdd, 0x38, 0xde, 0xb9, 0x0e, 0x13, 0x54, 0x93, 0x27, 0x4e, 0xb1, 0x4c, 0xcb, 0xde, 0x15, 0xc5, 0x0d, 0xca, 0xd7, 0x34, 0xed, 0x81, 0x5a, 0x80, 0x6b, 0xe6, 0x62, 0x24, 0x92, 0xa8, 0x4c, 0xd0, 0x62, 0xe3, 0xba, 0x56, 0x7b, 0x90, 0x9a, 0x20, 0x5a, 0x1d, 0x0d, 0x2b, 0xed, 0xd4, 0x01, 0x69, 0x69, 0x7d, 0x26, 0x1c, 0x7b, 0x6c, 0x2e, 0x0b, 0x1f, 0x06, 0x98, 0x53, 0xfd, 0x47, 0x0e, 0x8f, 0x36, 0x4a, 0x14, 0x2c, 0x38, 0x6c, 0x43, 0x9a, 0x6d, 0xbe, 0x19, 0x2d, 0xed, 0x5a, 0x3d, 0x0f, 0xbf, 0x73, 0x79, 0x9f, 0x58, 0x8c, 0x59, 0xe5, 0x8c, 0x60, 0x24, 0x9d, 0x98, 0x0d, 0xdc, 0xf0, 0xd9, 0x69, 0x36, 0x31, 0xcd, 0x9b, 0x3f, 0x97, 0x25, 0x09, 0xc3, 0xa7, 0x71, 0x23, 0xd3, 0x8d, 0x9e, 0x26, 0x7e, 0xca, 0xd0, 0x6e, 0x12, 0x08, 0xe3, 0xf1, 0xc0, 0xa6, 0x9f, 0xbc, 0xa7, 0xc3, 0xbb, 0x1a, 0x48, 0xfd, 0xa1, 0x94, 0x93, 0xd0, 0xf8, 0xf4, 0x83, 0x98, 0x82, 0x00, 0x57, 0xb9, 0x41, 0x20, 0xf3, 0xef, 0x97, 0xd8, 0x7e, 0x9e, 0x8a, 0x1b, 0x30, 0x1a, 0x25, 0x34, 0xc6, 0x8f),
-      //   tag: vec!(0x1f, 0xdd, 0x2d, 0xcd, 0x93, 0x5f, 0x55, 0x82, 0x2b, 0xf7, 0x23, 0x1a, 0x51, 0x6c, 0xa8, 0x41)
-      // },
-      // TestVector{
-      //   key: [0xa7, 0x6e, 0x9b, 0x91, 0x6f, 0x5a, 0x67, 0xb7, 0x8a, 0x59, 0x49, 0x65, 0x1c, 0x8c, 0x3a, 0x97, 0x41, 0xa1, 0xbc, 0x3c, 0x41, 0xcd, 0xf8, 0x5f, 0xd2, 0xc8, 0xf3, 0xe9, 0xa0, 0x61, 0x60, 0x98],
-      //   nonce: [0x08, 0x08, 0xda, 0x82, 0x92, 0xdc, 0x14, 0xe0],
-      //   plain_text: vec!(0x9c, 0x14, 0x9e, 0xeb, 0x09, 0x34, 0x5c, 0x3c, 0x22, 0x46, 0x2b, 0x03, 0xe4, 0x9e, 0xb4, 0xdb, 0xa6, 0xbc, 0x98, 0xb2, 0x69, 0xb1, 0x08, 0x6d, 0x75, 0x2b, 0xcd, 0x8e, 0xea, 0x53, 0xb8, 0x97, 0x7b, 0x23, 0x8a, 0x04, 0xa9, 0x94, 0xba, 0xf9, 0x15, 0x59, 0x16, 0x86, 0xba, 0xab, 0x90, 0xb7, 0x9a, 0x3b, 0xf7, 0xd9, 0xad, 0xb2, 0xc6, 0xc2, 0xe3, 0x1a, 0xcd, 0x3e, 0x72, 0xf0, 0x81, 0x3f, 0xb7, 0x45, 0xaa, 0x5f, 0xb2, 0xe3, 0xda, 0x40, 0x8f, 0x78, 0x00, 0x1c, 0x9c, 0x09, 0xbd, 0x26, 0xa1, 0xa2, 0x64, 0x60, 0x11, 0xb6, 0x12, 0x0a, 0xaa, 0x2b, 0xba, 0xcc, 0x4a, 0x16, 0xc3, 0x9f, 0xb5, 0x25, 0x7b, 0x9b, 0x2e, 0xa2, 0xad, 0x8b, 0xf7, 0x0b, 0xcc, 0x98, 0x55, 0xcf, 0x11, 0x84, 0x11, 0x16, 0xc2, 0x76, 0x73, 0x10, 0xcf, 0x3c, 0xd4, 0x9d, 0x1a, 0xa4, 0x4c, 0xd5, 0x05, 0xf0, 0x79, 0x76, 0x1e, 0x06, 0x4d, 0x5b, 0xc7, 0xce, 0xa4, 0xa7, 0x17, 0x3b, 0x08, 0x68, 0x82, 0xa7, 0x7d, 0x3f, 0xc1, 0x79, 0xef, 0xc8, 0x6f, 0xc4, 0xdb, 0x8a, 0x37, 0x34, 0x91, 0xd2, 0xed, 0x81, 0xea, 0xbc, 0x63, 0xc9, 0x50, 0xe8, 0x32, 0xdb, 0x17, 0xd0, 0x9f, 0x47, 0x4d, 0x4e, 0xc4, 0x6b, 0xde, 0x47, 0x83, 0x0c, 0xaf, 0x26, 0xfa, 0xba, 0xa0, 0x37, 0x2b, 0x81, 0xfc, 0xcc, 0x44, 0x9c, 0x0e, 0x19, 0xcc, 0xd6, 0x30, 0xca, 0xf6, 0x93, 0xa7, 0xb4, 0x3b, 0xb1, 0xc4, 0x08, 0xa5, 0x4e, 0x03, 0xf5, 0x0c, 0x44, 0x28, 0x0a, 0x05, 0xad, 0x89, 0xfb, 0x6e, 0x8f, 0x01, 0xd8, 0xac, 0x27, 0x8e, 0xdf, 0x55, 0x6e, 0x5d, 0x86, 0xce, 0xb4, 0xb6, 0x14, 0xfb, 0x2e, 0xf1, 0x33, 0x81, 0x9c, 0x6e, 0x1f, 0xf6, 0xab, 0xb8, 0x6c, 0x54, 0xa1, 0x35, 0x25, 0x62, 0x04, 0xb5, 0xcd, 0x40, 0x0b, 0x93, 0x62, 0x4d, 0x39, 0x32, 0xe7, 0xc2, 0xb0, 0x46),
-      //   aad: vec!(0x6a, 0xeb, 0x70, 0x31, 0xe4, 0xa2, 0xe2, 0x3e, 0xea, 0x93, 0xf0, 0x5f, 0xdc, 0x56, 0x2a, 0xa2, 0xbf, 0x43, 0xb8, 0x99, 0x8b, 0xea, 0x73, 0x44, 0x37, 0x7a, 0xad, 0xdc, 0x60, 0xfb, 0xdb, 0x7b, 0xcb, 0x14, 0x91, 0xd3, 0x79, 0xed, 0x0c, 0xb6, 0x13, 0xee, 0x75, 0x7c, 0xfb, 0x66, 0x49, 0x0d, 0xb6, 0x1b, 0xb4, 0x31, 0xd2, 0xfa, 0xd3, 0x4b, 0x38, 0xdd, 0xd5, 0x5b, 0xc5, 0xb2, 0x2a, 0xa6, 0xc4, 0x77, 0x3b, 0x99, 0x92, 0xf3, 0x4b, 0x87, 0x8c, 0x56, 0x63, 0xf6, 0xe8, 0xcd, 0xb5, 0xf8, 0x0a, 0x17, 0xf4, 0xd3, 0x12, 0xbf, 0x34, 0x24, 0x92, 0xe4, 0x8d, 0x1c, 0xe4, 0xc6, 0xd7, 0x54, 0x07, 0x6a, 0x63, 0x4f, 0xec, 0xe6, 0x15, 0x00, 0xac, 0xf8, 0x16, 0x8d, 0x47, 0x38, 0x1a, 0xf4, 0xfa, 0xf9, 0x80, 0xc6, 0xca, 0xc2, 0xbf, 0xd5, 0xda, 0x8c, 0x09, 0xb6, 0xed, 0xb0, 0xf5, 0x43, 0xbf, 0x0f, 0xe0, 0x26, 0x43, 0xe3, 0x8d, 0x73, 0xfa, 0x37, 0xd8, 0xae, 0x87, 0xfb, 0x66, 0x19, 0x3f, 0x22, 0xe5, 0x7f, 0xaf, 0x43, 0x93, 0xc0, 0x07, 0xd4, 0x8c, 0x86, 0x31, 0xa6, 0x85, 0xd5, 0x20, 0x57, 0x8f, 0x8f, 0x89, 0xdb, 0x68, 0x4f, 0xb3, 0x71, 0xea, 0x02, 0xf3, 0xa5, 0x8b, 0x1e, 0x21, 0x68, 0xf0, 0x21, 0x63, 0x21, 0x13, 0x94, 0x72, 0xe0, 0xd0, 0x3b, 0x6d, 0x90, 0xba, 0x8a, 0xab, 0x65, 0x40, 0x2e, 0x1c, 0x1a, 0xc4, 0xf9, 0x17, 0x2a, 0x60, 0xe2, 0x7e, 0x3d, 0x99, 0x7b, 0x9b, 0x05, 0xe2, 0xf6, 0x72, 0x12, 0x0d, 0x6c, 0x87, 0xbc, 0xaf, 0xa6, 0xd4, 0xc9, 0xb4, 0xcf, 0x8b, 0xa8, 0xa8, 0x29, 0x32, 0xd9, 0x28, 0x40, 0x36, 0x8f, 0xc5, 0x3d, 0xc5, 0xb4, 0x85, 0x26, 0x10, 0x3d, 0xca, 0xb5, 0xf1, 0x53, 0x10, 0x38, 0xaa, 0xbe, 0x89, 0x17, 0x13, 0x27, 0xac, 0x55, 0x9b, 0x98, 0xa3, 0xcf, 0x4e, 0xa7, 0x0b, 0xf0, 0x51),
-      //   cipher_text: vec!(0x9c, 0x3f, 0xaa, 0xb9, 0x26, 0x1a, 0x63, 0xce, 0xa9, 0x47, 0x7b, 0x32, 0x69, 0x00, 0x72, 0x83, 0x99, 0x5b, 0x06, 0xba, 0x77, 0xef, 0x83, 0xd9, 0xe6, 0x93, 0xf7, 0xe4, 0xee, 0x98, 0x55, 0x55, 0x0e, 0xef, 0x94, 0x85, 0x5b, 0xe3, 0x9a, 0x7a, 0x43, 0x5b, 0x6a, 0x35, 0x84, 0xb2, 0x02, 0x97, 0x37, 0x77, 0xc7, 0xb2, 0x48, 0x23, 0x76, 0xba, 0x47, 0xb4, 0x93, 0x11, 0x94, 0x7a, 0x64, 0x98, 0x3b, 0x60, 0x23, 0x67, 0x56, 0xee, 0x44, 0x55, 0xd4, 0xcf, 0xad, 0xa8, 0xc3, 0x6a, 0xf8, 0xeb, 0x06, 0xb0, 0x6b, 0xa2, 0xf6, 0xb7, 0x9f, 0xfb, 0x11, 0x85, 0xc8, 0x9f, 0x2b, 0x2a, 0x83, 0x1c, 0xfa, 0xa3, 0x85, 0x5f, 0xc1, 0x84, 0x1d, 0x89, 0x10, 0x90, 0x8b, 0xe5, 0x07, 0x83, 0x52, 0x01, 0x11, 0x68, 0xa6, 0x7d, 0x36, 0x37, 0x2d, 0x85, 0x1a, 0x32, 0x17, 0xca, 0xbf, 0x59, 0x3e, 0xa4, 0x62, 0xdc, 0xd3, 0x25, 0xcf, 0x9a, 0x4f, 0x67, 0xe8, 0x54, 0x18, 0xfd, 0x5c, 0x92, 0x4e, 0x9b, 0x92, 0xab, 0x02, 0x6c, 0xbe, 0xe4, 0xe7, 0xab, 0x10, 0x67, 0x06, 0x6c, 0xb5, 0x94, 0x9d, 0xfc, 0x69, 0x9a, 0x68, 0xfe, 0x53, 0x9e, 0x1a, 0xbb, 0x13, 0xce, 0xc3, 0x39, 0x04, 0xe5, 0x20, 0x7e, 0x69, 0x63, 0xd2, 0x4f, 0x5a, 0x0b, 0x77, 0x06, 0x13, 0xb8, 0xb0, 0x00, 0x14, 0xe7, 0x91, 0xbf, 0xff, 0x88, 0xf9, 0xc2, 0x5c, 0xa1, 0x26, 0x12, 0x7a, 0x2f, 0x8d, 0x1d, 0x1e, 0x97, 0x94, 0xef, 0xd2, 0x8d, 0xce, 0x98, 0xb5, 0x3e, 0x22, 0x80, 0x73, 0xfa, 0xae, 0x8d, 0x50, 0x47, 0x53, 0x0d, 0x50, 0x21, 0x84, 0xfc, 0x34, 0x13, 0x21, 0xc3, 0xf5, 0x5f, 0xcb, 0xf4, 0x11, 0x87, 0xfc, 0x31, 0x26, 0x2c, 0x32, 0x5b, 0x97, 0xf5, 0x19, 0x95, 0x9b, 0x6a, 0x29, 0xb3, 0x6c, 0x71, 0xf7, 0x6f, 0x60, 0x19, 0x6b, 0xb1, 0x45, 0x7b, 0x77, 0xc8, 0xbb),
-      //   tag: vec!(0xb4, 0x5d, 0xf1, 0x19, 0x04, 0x3d, 0x29, 0x00, 0x8f, 0xce, 0xf3, 0x6a, 0x16, 0x9e, 0xf8, 0x86)
-      // },
-      // TestVector{
-      //   key: [0x98, 0xcd, 0x24, 0x77, 0xa7, 0xa0, 0x72, 0xc6, 0x9f, 0x37, 0x5b, 0x88, 0xd0, 0x9e, 0xd9, 0xd7, 0xb9, 0xc3, 0xdf, 0x3f, 0x87, 0xe3, 0x6c, 0xe6, 0x21, 0x72, 0x6f, 0x76, 0xe3, 0xb4, 0x1a, 0x1d],
-      //   nonce: [0x77, 0xd1, 0x85, 0xaa, 0xf7, 0x15, 0xaa, 0x48],
-      //   plain_text: vec!(0x42, 0xb3, 0x1e, 0xef, 0xda, 0xca, 0xb0, 0xf0, 0x3e, 0xf6, 0x06, 0x01, 0x56, 0x00, 0x0c, 0x81, 0x95, 0xad, 0xb0, 0x97, 0x6c, 0xab, 0xbe, 0x1a, 0x42, 0xbf, 0xcc, 0x09, 0xf8, 0x56, 0x59, 0xc6, 0x0b, 0x98, 0x63, 0x84, 0x01, 0xf2, 0xd2, 0xe2, 0xfa, 0xcf, 0xb9, 0xa9, 0x7a, 0x62, 0x92, 0x6b, 0xb0, 0xce, 0xca, 0xf3, 0xaf, 0x01, 0x80, 0xa0, 0x1b, 0xfb, 0x6e, 0x57, 0x6b, 0xab, 0xf7, 0xfc, 0x43, 0x33, 0x19, 0x37, 0xa9, 0x2a, 0xbd, 0x30, 0xcd, 0xdf, 0xa3, 0xe4, 0x50, 0xf8, 0x95, 0xe9, 0xdd, 0x91, 0x4d, 0xea, 0x3f, 0xaf, 0xd7, 0x59, 0xc1, 0x36, 0xd6, 0x85, 0x31, 0x0e, 0xbc, 0xe2, 0x8a, 0xc0, 0x61, 0x3c, 0xcd, 0xbf, 0x30, 0x11, 0x59, 0x46, 0xc9, 0x63, 0x4b, 0x67, 0x51, 0x0b, 0x77, 0xd0, 0xe3, 0x7f, 0x07, 0x71, 0x4b, 0x2d, 0xda, 0xc9, 0xd7, 0x09, 0x5b, 0x8d, 0x4b, 0xd8, 0x87, 0xc1, 0x32, 0xc4, 0xa9, 0x12, 0x7e, 0xb0, 0x1c, 0x8d, 0xed, 0xb4, 0xc3, 0x9c, 0x87, 0xb9, 0x8a, 0x74, 0x13, 0x16, 0x65, 0x6f, 0x9a, 0x8d, 0x5a, 0x5b, 0x0c, 0x0a, 0xc8, 0x47, 0x89, 0xaa, 0x23, 0x47, 0xa5, 0xf9, 0x9c, 0xa5, 0xad, 0x55, 0xcd, 0x1b, 0xcf, 0x98, 0xf7, 0x03, 0xeb, 0x4b, 0x00, 0xba, 0xdb, 0x8a, 0x85, 0x55, 0xf3, 0x8b, 0x3b, 0x36, 0x8d, 0xb8, 0xba, 0x7c, 0xee, 0xa9, 0x4e, 0x8b, 0x21, 0x9f, 0x51, 0xed, 0xce, 0x75, 0xd8, 0x41, 0x66, 0xb5, 0x60, 0x21, 0x56, 0xed, 0x59, 0x62, 0xa9, 0x3a, 0x51, 0xdb, 0x73, 0xc5, 0x9d, 0x87, 0xe9, 0x06, 0x17, 0x9d, 0x7a, 0x74, 0xa2, 0xa2, 0xa6, 0x9d, 0x8a, 0xd9, 0x9f, 0x32, 0x32, 0x25, 0xc8, 0x7e, 0x47, 0x5d, 0x3f, 0x77, 0x1b, 0x4a, 0x20, 0x3a, 0x2e, 0x2b, 0x03, 0xb4, 0x58, 0x40, 0x10, 0x44, 0x64, 0x9f, 0xa6, 0x53, 0x6d, 0xfa, 0xb2, 0x4d, 0x70, 0x37, 0x80, 0x7d, 0xcb, 0xf6, 0x51, 0x8e, 0x65, 0x78),
-      //   aad: vec!(0xf5, 0xbb, 0x14, 0x96, 0x05, 0x2a, 0x43, 0x61, 0xdd, 0xdf, 0x72, 0xa2, 0x88, 0xe3, 0x69, 0x53, 0xa3, 0xd8, 0x15, 0xd6, 0x87, 0x6c, 0x01, 0x3f, 0x1d, 0x6b, 0xa8, 0x39, 0xe1, 0x27, 0xf7, 0x21, 0xb0, 0x52, 0xb1, 0xf7, 0xd8, 0xca, 0x20, 0xc7, 0xdc, 0x03, 0x86, 0xa7, 0xd4, 0x59, 0xeb, 0xd7, 0xeb, 0x9f, 0xc8, 0xcb, 0x08, 0x94, 0x1e, 0x6c, 0xa9, 0xdd, 0xb9, 0x80, 0xf3, 0x11, 0x5f, 0x65, 0xbc, 0x19, 0x28, 0xa4, 0x14, 0xd4, 0x41, 0xae, 0x71, 0xdc, 0xb8, 0x79, 0xd5, 0xbf, 0xe0, 0xcd, 0xe0, 0x56, 0x2b, 0xc3, 0x7f, 0x8f, 0xde, 0x0d, 0x52, 0x91, 0xad, 0x40, 0x5c, 0x92, 0xfc, 0xbb, 0x86, 0x0c, 0x43, 0xb5, 0x5a, 0xc0, 0xfe, 0x66, 0x3b, 0x54, 0xb3, 0xd0, 0x61, 0x6a, 0xca, 0x13, 0xa5, 0xc8, 0x2b, 0x7b, 0x5d, 0x34, 0x12, 0x5a, 0x05, 0xc2, 0xac, 0xb5, 0x53, 0x01, 0x41, 0x03, 0x0e, 0x6f, 0x2a, 0xa0, 0xc8, 0x32, 0x2b, 0x2c, 0x8f, 0xa3, 0x07, 0xe7, 0x51, 0x89, 0x18, 0xe5, 0x50, 0xe9, 0xf4, 0x89, 0x21, 0xc6, 0x16, 0x8f, 0x09, 0x4d, 0x87, 0x58, 0xe1, 0x6b, 0x9f, 0x81, 0x5f, 0xd0, 0x45, 0x80, 0x95, 0xc4, 0x14, 0x3f, 0x09, 0x22, 0xad, 0xb1, 0x84, 0x0d, 0x0e, 0x68, 0x56, 0x36, 0x82, 0x5a, 0x9c, 0x90, 0xee, 0x90, 0xee, 0x53, 0x7f, 0x4b, 0x8d, 0xce, 0xec, 0xbc, 0x42, 0x87, 0xc8, 0x2d, 0xc9, 0xa0, 0x0d, 0x7e, 0x51, 0x67, 0x1e, 0x37, 0xea, 0x28, 0x4e, 0xe3, 0xca, 0x50, 0x1b, 0x1b, 0x25, 0x96, 0x45, 0x9d, 0x3f, 0x59, 0x2f, 0x70, 0x18, 0x6f, 0x41, 0x12, 0x57, 0x39, 0xe3, 0x42, 0xc9, 0xf6, 0xbe, 0x92, 0x41, 0x97, 0x3b, 0x14, 0x14, 0xdf, 0xe5, 0xfb, 0x8c, 0xba, 0x1a, 0xf8, 0x2e, 0x67, 0x92, 0x78, 0xcf, 0xcf, 0x95, 0x42, 0x0d, 0xf0, 0xc5, 0x36, 0x4a, 0xf4, 0xd7, 0xe7, 0x2a, 0xd5, 0x7d, 0x5c, 0x87, 0x1f, 0xcb, 0xc3, 0x54, 0x62),
-      //   cipher_text: vec!(0x7a, 0x3b, 0xf3, 0xe3, 0xad, 0x5a, 0xe3, 0xab, 0x71, 0xfb, 0x1f, 0x71, 0x21, 0xc3, 0xd8, 0xfb, 0x51, 0x10, 0x99, 0x48, 0x4b, 0x50, 0xaf, 0x7c, 0xa1, 0x28, 0xee, 0x03, 0x37, 0xed, 0x4b, 0x82, 0x8d, 0xc4, 0xcd, 0xe0, 0xb8, 0x8d, 0xc1, 0xe8, 0x08, 0x91, 0x01, 0xfa, 0x82, 0xc9, 0xbe, 0xb3, 0xeb, 0x48, 0xfd, 0xcf, 0x0f, 0x5b, 0x16, 0xda, 0x44, 0x1f, 0x5a, 0x3f, 0xce, 0x9a, 0x59, 0x00, 0x22, 0xaf, 0x95, 0xa9, 0x4a, 0xed, 0x6a, 0x3e, 0x71, 0xe5, 0x05, 0xf6, 0x0f, 0x30, 0x3c, 0x78, 0xc3, 0x56, 0xf2, 0x74, 0xea, 0x85, 0xa5, 0x53, 0x54, 0x07, 0x85, 0x30, 0x66, 0x4e, 0xcd, 0xa3, 0x2c, 0x80, 0xe7, 0x7d, 0xc2, 0x09, 0x74, 0xb3, 0xb3, 0x8f, 0x48, 0x25, 0xb8, 0xfb, 0xee, 0x8c, 0x39, 0x70, 0x76, 0x9a, 0x2f, 0x42, 0xc5, 0x18, 0x16, 0x08, 0xa8, 0xd7, 0xd7, 0x6e, 0xf4, 0xd0, 0x93, 0x96, 0x1b, 0x66, 0x5e, 0xe4, 0x2b, 0x97, 0x08, 0xfc, 0xaf, 0xe2, 0xc8, 0x2d, 0x3a, 0x30, 0x71, 0x73, 0xe2, 0xa2, 0x5a, 0xd2, 0x52, 0x8c, 0x3b, 0xf8, 0x33, 0x52, 0xb9, 0x26, 0x5e, 0x45, 0xb7, 0x07, 0x22, 0xd7, 0xcf, 0x8c, 0x9b, 0x80, 0x82, 0x6d, 0x21, 0x33, 0x52, 0x34, 0xee, 0x3d, 0xb6, 0x9d, 0x0d, 0x37, 0x87, 0x1c, 0x83, 0x22, 0x23, 0x65, 0x90, 0x0c, 0x96, 0xc1, 0x7a, 0x7e, 0x9f, 0x57, 0x42, 0xd0, 0xbf, 0xe3, 0x83, 0xbe, 0x24, 0xd0, 0xd4, 0x45, 0x90, 0xd4, 0xb0, 0xf2, 0x9f, 0x7a, 0xbe, 0x0c, 0x65, 0xda, 0xaf, 0xfb, 0x96, 0x8b, 0x3f, 0x26, 0x57, 0xb1, 0xeb, 0x30, 0x05, 0x34, 0xea, 0xcb, 0x52, 0xec, 0x7a, 0x6b, 0x6f, 0x9f, 0x57, 0xa5, 0x0a, 0x91, 0xb1, 0x79, 0x9f, 0x49, 0x13, 0x61, 0xcf, 0x61, 0x3c, 0x93, 0x4b, 0x7f, 0x52, 0x0d, 0xc4, 0xee, 0xeb, 0x40, 0xff, 0xc4, 0x5e, 0x10, 0xbe, 0x0a, 0x95, 0xe7, 0x6f, 0x36, 0x6d, 0x4e, 0xac, 0x14),
-      //   tag: vec!(0xf6, 0x13, 0xb6, 0x52, 0x26, 0xaf, 0xb6, 0x4c, 0x61, 0x4f, 0xe6, 0x0d, 0x9c, 0x71, 0xed, 0x74)
-      // },
-      // TestVector{
-      //   key: [0x2f, 0x0f, 0x46, 0x31, 0xab, 0x1c, 0x1b, 0xcf, 0x8f, 0x3a, 0xd0, 0x55, 0x9c, 0x81, 0x8d, 0x50, 0xe0, 0xaf, 0x7d, 0x8c, 0xd6, 0x3f, 0xaa, 0x35, 0x7f, 0x20, 0x69, 0xf3, 0x08, 0x81, 0xd9, 0xcb],
-      //   nonce: [0x7d, 0x0c, 0xed, 0x2f, 0xdb, 0x1c, 0x91, 0x73],
-      //   plain_text: vec!(0x65, 0x16, 0xba, 0x1d, 0x29, 0x35, 0x71, 0x44, 0xee, 0xbf, 0xa4, 0x86, 0xd2, 0x1d, 0xec, 0xf2, 0x23, 0xda, 0x3a, 0xa7, 0x6e, 0xc2, 0x9b, 0xbf, 0xcb, 0xe7, 0xf1, 0xee, 0xaf, 0x4a, 0x84, 0x77, 0x10, 0xe5, 0x08, 0x01, 0x77, 0xf7, 0xe5, 0xa7, 0xc8, 0xb4, 0x75, 0x2c, 0x21, 0x9b, 0x1c, 0xc7, 0x0a, 0xef, 0x4d, 0xb8, 0x61, 0xba, 0x67, 0xd0, 0xfa, 0x62, 0x22, 0xd9, 0xf4, 0xa1, 0xdc, 0x75, 0x6a, 0x0b, 0xa4, 0x4e, 0x62, 0x90, 0x6f, 0x93, 0x74, 0xa9, 0x60, 0xc1, 0x61, 0x98, 0x86, 0x6d, 0x86, 0x78, 0x54, 0xd8, 0x8f, 0x52, 0x8a, 0x60, 0xe2, 0x12, 0xeb, 0x91, 0x64, 0x57, 0x87, 0xe7, 0x56, 0x85, 0xb2, 0xe2, 0x15, 0xc0, 0xa4, 0x19, 0x90, 0xab, 0xc3, 0x44, 0xa7, 0x72, 0x36, 0xec, 0x01, 0x86, 0xba, 0x63, 0xa6, 0x64, 0x59, 0x29, 0x38, 0xcc, 0x5a, 0x8a, 0xc1, 0xd3, 0xeb, 0x99, 0xc9, 0x5c, 0xe0, 0x0e, 0x19, 0xfb, 0xe2, 0x49, 0x26, 0x30, 0x83, 0xd8, 0x5b, 0x05, 0x2d, 0x48, 0xbf, 0xdf, 0xfc, 0x01, 0x58, 0x5d, 0xc5, 0x7b, 0xb2, 0xa2, 0xc6, 0xc4, 0xa8, 0x19, 0x60, 0x4c, 0x1e, 0xc0, 0x54, 0x8c, 0x6f, 0x0f, 0x78, 0xdc, 0x05, 0xe4, 0x41, 0x8b, 0x36, 0x27, 0x7d, 0xc0, 0x72, 0x33, 0xc7, 0x53, 0x2f, 0x9c, 0x28, 0x9d, 0x6a, 0xed, 0x0c, 0xc6, 0xbc, 0x7d, 0xf4, 0xfd, 0x0a, 0x53, 0x6c, 0x49, 0x7b, 0x98, 0x2e, 0x2d, 0xad, 0x2c, 0x30, 0xd2, 0xdb, 0x1c, 0x65, 0x45, 0xa8, 0x45, 0xc5, 0xdf, 0xa8, 0x3a, 0x4a, 0xc4, 0x9e, 0xf0, 0x6f, 0xc9, 0xc9, 0x19, 0x07, 0x9d, 0x3e, 0x29, 0x9e, 0x31, 0xb5, 0xc3, 0xbe, 0x37, 0x08, 0x14, 0xae, 0x50, 0x22, 0xae, 0x46, 0x9d, 0x3e, 0xe5, 0x52, 0x46, 0xa4, 0x1b, 0xd0, 0xdc, 0x4e, 0x64, 0x35, 0x1c, 0xc3, 0x8c, 0x3c, 0x09, 0xaf, 0x0a, 0x1a, 0xee, 0x3b, 0x38, 0x8a, 0x68, 0x92, 0xde, 0xff, 0x0d, 0xf3, 0xf9, 0x3c, 0xd9, 0x2d, 0x72, 0x2b),
-      //   aad: vec!(0x1c, 0xcf, 0xa1, 0xec, 0xec, 0xc8, 0xde, 0x1e, 0x20, 0x0d, 0x0e, 0xcc, 0x19, 0xdc, 0xf6, 0x7b, 0x7c, 0x96, 0xbe, 0xa3, 0xa2, 0x82, 0xc2, 0xbc, 0xcb, 0xa6, 0x10, 0x35, 0xdb, 0x5c, 0x14, 0x77, 0x63, 0x87, 0xb8, 0xb8, 0xf5, 0x8e, 0x57, 0x57, 0xde, 0xb0, 0x12, 0x9d, 0x4e, 0x5e, 0x31, 0x5f, 0x64, 0xdf, 0x35, 0x4a, 0x59, 0x85, 0xd2, 0xe4, 0x7e, 0xbb, 0xbe, 0xaf, 0xe0, 0xc9, 0x14, 0xf7, 0xcf, 0x1d, 0x63, 0xdd, 0x03, 0x11, 0xac, 0xe1, 0x9e, 0x69, 0xa8, 0xb6, 0xff, 0x0a, 0xb2, 0x5c, 0xc8, 0xdf, 0x04, 0x08, 0xd2, 0x21, 0x32, 0x20, 0x5e, 0x89, 0xe5, 0xeb, 0x67, 0x92, 0x68, 0xd8, 0x2b, 0x29, 0x13, 0xe6, 0x4e, 0x3f, 0x88, 0x5b, 0xbf, 0x4a, 0x6d, 0x37, 0x9b, 0x76, 0x0b, 0x94, 0x59, 0x0e, 0x31, 0x40, 0xdd, 0x72, 0x75, 0xab, 0x47, 0x13, 0xcb, 0x56, 0xd0, 0xb7, 0x16, 0xe2, 0x71, 0x8f, 0x11, 0x31, 0x66, 0x40, 0xcb, 0x39, 0x48, 0x02, 0x86, 0x2d, 0x39, 0xe7, 0x7a, 0x46, 0xd0, 0xc0, 0x65, 0xaf, 0x3c, 0xaf, 0x7d, 0xec, 0x14, 0xe8, 0x87, 0x03, 0x9d, 0x8a, 0xa8, 0xc3, 0xd3, 0xa8, 0xac, 0x1e, 0xe0, 0x60, 0x26, 0xf4, 0x9d, 0x00, 0xb2, 0xf5, 0x9d, 0x97, 0x1b, 0x54, 0x73, 0x5e, 0x95, 0xa5, 0x1f, 0x19, 0x93, 0x89, 0xa9, 0x3a, 0x4f, 0xc2, 0x4e, 0xba, 0xba, 0x1f, 0x7a, 0x2e, 0xef, 0x74, 0x12, 0xf6, 0x1f, 0xeb, 0xf7, 0x90, 0x84, 0xfb, 0xf4, 0x81, 0xaf, 0xc6, 0xfb, 0x6b, 0x20, 0x40, 0x84, 0xe5, 0xef, 0x5d, 0xf7, 0x1f, 0x30, 0x50, 0x64, 0x59, 0xde, 0xa0, 0x74, 0xf1, 0x1f, 0xc0, 0x55, 0xcd, 0x2a, 0x8c, 0x0f, 0xc9, 0x22, 0xc4, 0x81, 0x1a, 0x84, 0x99, 0x84, 0x35, 0x2a, 0x56, 0xa1, 0x56, 0x59, 0xb7, 0xd0, 0x7a, 0x4c, 0xc9, 0x0b, 0x88, 0x62, 0x36, 0x38, 0xea, 0x00, 0xc4, 0xc8, 0xbc, 0x13, 0x88, 0x4d, 0xf2, 0x23, 0x7b, 0x35, 0x9f, 0x28, 0x77, 0xaa, 0x41, 0xd6),
-      //   cipher_text: vec!(0xe5, 0x80, 0x09, 0x37, 0x89, 0xba, 0x17, 0xff, 0xb4, 0x66, 0x72, 0xdc, 0x32, 0x6f, 0x09, 0x27, 0x8a, 0xca, 0x08, 0x59, 0x8d, 0x3e, 0x54, 0x58, 0xea, 0xa5, 0x3e, 0x6e, 0xd4, 0x5d, 0x5c, 0x71, 0xa3, 0x96, 0xe3, 0x5b, 0x5e, 0xa3, 0xfe, 0x7b, 0x7c, 0x04, 0x96, 0xa7, 0x34, 0xd2, 0x4f, 0x1c, 0x75, 0x42, 0x06, 0x94, 0xbe, 0x2f, 0xf0, 0x95, 0xd5, 0x17, 0x2f, 0xd3, 0x40, 0x77, 0x94, 0xe4, 0xb9, 0x9f, 0xd7, 0xc3, 0x74, 0xfb, 0xe8, 0xd1, 0x56, 0x4a, 0x04, 0x86, 0x14, 0xd3, 0xf3, 0x55, 0xbf, 0xb5, 0x86, 0x6d, 0xe1, 0xa5, 0x3e, 0x1a, 0x51, 0xf9, 0xf5, 0xe8, 0x31, 0x22, 0x53, 0xcf, 0xd8, 0x2f, 0x36, 0xef, 0xaa, 0x18, 0x98, 0xc8, 0x50, 0xca, 0x0d, 0x97, 0x5a, 0xd1, 0xe8, 0xb0, 0xd9, 0x59, 0x7a, 0x5a, 0x9e, 0x65, 0x16, 0xfe, 0x2a, 0x3c, 0x92, 0xef, 0xb7, 0x49, 0x55, 0x57, 0xa8, 0xaf, 0xc3, 0xda, 0x15, 0xb0, 0xd3, 0xe2, 0xba, 0x58, 0xf6, 0x12, 0x51, 0x98, 0x36, 0x94, 0x6c, 0xf2, 0xd1, 0x5b, 0x89, 0x83, 0x20, 0xd1, 0x6a, 0x02, 0x6c, 0x8c, 0x00, 0xa1, 0xbe, 0x2e, 0x35, 0xf0, 0xeb, 0xe6, 0x8f, 0x28, 0xd9, 0x1c, 0x6c, 0x45, 0xd2, 0x4c, 0x3f, 0x3c, 0x15, 0x7c, 0xb1, 0x32, 0xfa, 0x65, 0x9b, 0x77, 0x94, 0xdf, 0x88, 0x3d, 0x90, 0x74, 0x1f, 0xa2, 0xd2, 0xaf, 0xcc, 0x4f, 0x27, 0x85, 0x8e, 0x13, 0xec, 0xd4, 0x1b, 0x15, 0x4a, 0x35, 0xd2, 0x49, 0x47, 0xae, 0x73, 0x61, 0x17, 0x00, 0x60, 0xc1, 0x07, 0xd8, 0xec, 0xac, 0xb3, 0x93, 0xea, 0x67, 0x10, 0x4b, 0x60, 0x45, 0x72, 0x78, 0xa3, 0x92, 0xfd, 0xf1, 0x79, 0x4b, 0xab, 0x97, 0xd3, 0xb0, 0x2b, 0x71, 0xa4, 0xeb, 0x01, 0x5e, 0xaa, 0x38, 0xa4, 0xb4, 0xc9, 0x44, 0xc2, 0xbc, 0x7c, 0xd5, 0xe3, 0x29, 0xda, 0x4a, 0x1a, 0xb2, 0x93, 0x7a, 0x6a, 0xf8, 0x1a, 0x6c, 0xaa, 0x5f, 0xce, 0x75, 0x23, 0x31, 0xfd, 0xef, 0xd4),
-      //   tag: vec!(0x0f, 0xd7, 0x41, 0x9c, 0x54, 0xbc, 0x84, 0x26, 0x5e, 0xd3, 0x10, 0xa3, 0x41, 0x1a, 0x3f, 0x2e)
-      // },
-      // TestVector{
-      //   key: [0xa4, 0x8b, 0x9b, 0x6d, 0xf4, 0x75, 0xe5, 0x66, 0xab, 0xa7, 0x67, 0x1f, 0xbd, 0x76, 0x77, 0x2c, 0xb0, 0xef, 0xf0, 0xb1, 0x24, 0x99, 0x96, 0x79, 0x78, 0xce, 0x3e, 0x25, 0xfa, 0xc9, 0x2f, 0xeb],
-      //   nonce: [0x2c, 0xcb, 0xf0, 0xd6, 0xc4, 0x0c, 0xb3, 0x02],
-      //   plain_text: vec!(0x09, 0xda, 0x1c, 0xac, 0xd0, 0x01, 0xdc, 0xe4, 0xf7, 0x57, 0x3a, 0x06, 0x5a, 0x44, 0x06, 0xfe, 0x0d, 0xa0, 0x4a, 0xb3, 0x67, 0xa2, 0xd8, 0x77, 0x80, 0xa2, 0x76, 0x2e, 0x16, 0x89, 0x57, 0xa8, 0x8d, 0x3f, 0xa7, 0x8f, 0x0a, 0x4b, 0x69, 0x78, 0xd4, 0x49, 0x02, 0x6e, 0x5a, 0x80, 0x1d, 0x32, 0x88, 0x4b, 0x6e, 0x14, 0xfd, 0xaa, 0xaf, 0x86, 0x42, 0x14, 0xf9, 0x28, 0xeb, 0xc0, 0x3d, 0xea, 0xd0, 0x81, 0xfe, 0xe9, 0x66, 0x83, 0xeb, 0xb0, 0x32, 0x36, 0x2d, 0x50, 0x88, 0xc4, 0xc2, 0xa3, 0xb1, 0xe2, 0x42, 0xf0, 0x55, 0xf2, 0x60, 0x49, 0x19, 0xf4, 0xdd, 0x55, 0x1d, 0xb7, 0x77, 0xa2, 0x58, 0xcf, 0x9d, 0xa6, 0xd9, 0x5a, 0x2b, 0xde, 0x24, 0x92, 0x47, 0x81, 0x2b, 0x9e, 0xfc, 0x79, 0x85, 0xcf, 0x08, 0x70, 0x76, 0x20, 0x80, 0x85, 0x24, 0xd6, 0xdd, 0x30, 0x79, 0xb0, 0xb6, 0x3b, 0xf0, 0xf7, 0x1e, 0xa5, 0xde, 0x83, 0x4c, 0xcb, 0x8b, 0x7c, 0x6a, 0x97, 0x12, 0x5f, 0xd6, 0xca, 0x49, 0x14, 0x8e, 0x86, 0x6d, 0x31, 0x34, 0xbb, 0xf1, 0xd8, 0xa6, 0xb7, 0x14, 0xe9, 0xa8, 0x0f, 0xe5, 0x49, 0xc8, 0xbf, 0xef, 0xe3, 0x42, 0xf4, 0x1b, 0xe2, 0xba, 0x23, 0x00, 0xe0, 0x02, 0x8f, 0x78, 0xce, 0xfa, 0xb6, 0x52, 0x74, 0x63, 0x2d, 0xfd, 0xbe, 0x70, 0xbf, 0x7d, 0x65, 0x5e, 0xc4, 0x03, 0x6d, 0xf5, 0x61, 0xf2, 0xd4, 0xfc, 0x4d, 0x56, 0xa4, 0x82, 0xbb, 0xe2, 0xf9, 0xf2, 0xae, 0x27, 0x9b, 0x3a, 0xa2, 0x16, 0xb3, 0x9a, 0xfe, 0xe7, 0x5e, 0x53, 0x60, 0x2d, 0xe3, 0x19, 0x48, 0x4d, 0xb8, 0x9a, 0x51, 0xe8, 0x44, 0xf3, 0x8c, 0x36, 0x16, 0x34, 0xe4, 0x74, 0xf8, 0xf1, 0xf0, 0x1c, 0x34, 0x0f, 0x3f, 0x35, 0x94, 0x86, 0x0d, 0x67, 0x13, 0x46, 0x44, 0x9c, 0x6d, 0x08, 0xee, 0x38, 0xde, 0x22, 0xd2, 0x46, 0x30, 0x9b, 0xc7, 0xe4, 0xa2, 0x52, 0xa2, 0x9c, 0x86, 0xaa, 0x6d, 0x94, 0xb5, 0xb4, 0xfa, 0x58, 0x90, 0x4c, 0x70),
-      //   aad: vec!(0x1c, 0x25, 0x03, 0xd5, 0xaa, 0x1a, 0xad, 0x19, 0x3f, 0x0d, 0xa1, 0x28, 0x74, 0x07, 0x4e, 0xa0, 0x43, 0x2b, 0xb7, 0x6a, 0x61, 0xcd, 0x43, 0xa3, 0x01, 0x70, 0x61, 0x51, 0x4d, 0xa0, 0x75, 0x98, 0x46, 0xa0, 0xf3, 0xae, 0x3a, 0x49, 0xfd, 0xb0, 0xb6, 0xd2, 0x9f, 0x71, 0x3d, 0xe6, 0x65, 0xbe, 0xac, 0xb6, 0x56, 0x8f, 0x26, 0x94, 0x11, 0x2c, 0xa3, 0x80, 0xd1, 0x3f, 0x3c, 0x16, 0x98, 0x31, 0x68, 0x66, 0xa7, 0xa7, 0xf8, 0x7f, 0x1d, 0x75, 0x03, 0xa9, 0x21, 0x76, 0xab, 0x84, 0xfc, 0x08, 0x97, 0x7b, 0x46, 0xba, 0x66, 0x45, 0x08, 0xa8, 0x58, 0xe7, 0x52, 0x57, 0x53, 0xc4, 0x55, 0x11, 0xb3, 0xd2, 0xf4, 0x07, 0xd5, 0xe9, 0x93, 0xc6, 0xed, 0xe7, 0x7f, 0x13, 0xd1, 0x29, 0x75, 0x70, 0x7e, 0x51, 0x95, 0x70, 0x49, 0x70, 0xa8, 0x9f, 0x71, 0xfc, 0x30, 0x82, 0x80, 0x49, 0xf9, 0x2f, 0x94, 0x4f, 0x3a, 0xa9, 0x3d, 0x6a, 0x52, 0x97, 0xe6, 0x78, 0xe0, 0x89, 0x52, 0x91, 0x9b, 0xeb, 0x7e, 0xac, 0x59, 0x19, 0xdf, 0x19, 0x19, 0xca, 0xb3, 0xc3, 0xda, 0x6a, 0xa6, 0x96, 0xa1, 0xee, 0xab, 0x63, 0x71, 0xf3, 0x10, 0xf7, 0xe8, 0x11, 0x43, 0xe7, 0xd2, 0x40, 0xb0, 0x21, 0x3a, 0xe5, 0x54, 0x52, 0x4b, 0x52, 0x00, 0x03, 0x06, 0x16, 0x0d, 0xd4, 0x87, 0x7b, 0xf1, 0x3b, 0xa0, 0xf1, 0x3b, 0xbe, 0x86, 0x7d, 0xa7, 0xc7, 0xd7, 0x07, 0xf3, 0x13, 0x35, 0xee, 0xf4, 0xcd, 0x94, 0x29, 0x38, 0xac, 0x89, 0x0a, 0x08, 0x29, 0xec, 0x66, 0xbd, 0x30, 0xae, 0x01, 0xa2, 0x18, 0x8a, 0x6e, 0x5e, 0xa0, 0xf1, 0x7c, 0xd7, 0xdc, 0x87, 0x5e, 0x17, 0xf0, 0x3c, 0x0a, 0xb5, 0xdd, 0x18, 0xe3, 0x6d, 0xb8, 0xa1, 0xfc, 0x1f, 0x72, 0x85, 0x9e, 0xe0, 0x46, 0xb6, 0x23, 0x68, 0xf1, 0x68, 0xb3, 0xbe, 0xa2, 0x23, 0x4e, 0x04, 0x32, 0xc0, 0x7b, 0x7d, 0x8e, 0x1b, 0x92, 0x77, 0xf2, 0x1e, 0x69, 0x2c, 0x51, 0x3b, 0x9e, 0x81, 0x6e, 0x68, 0x60),
-      //   cipher_text: vec!(0x7d, 0x35, 0xcf, 0xe4, 0xbe, 0x56, 0xbd, 0x6e, 0x0e, 0x09, 0xde, 0xdc, 0xd0, 0x17, 0x35, 0xb9, 0x15, 0xbc, 0x18, 0x91, 0xa4, 0xd1, 0xf6, 0xa5, 0x41, 0xab, 0xc4, 0xbc, 0xd0, 0xeb, 0xe8, 0x9d, 0xcb, 0x8e, 0x36, 0x5e, 0x58, 0x13, 0x74, 0x2e, 0x8e, 0xc6, 0x57, 0x77, 0xb6, 0x15, 0x94, 0x22, 0xfa, 0xda, 0x74, 0x7d, 0xa9, 0x93, 0x94, 0x25, 0x2b, 0xaf, 0x8a, 0x04, 0x6f, 0xc1, 0xb6, 0x0a, 0xd7, 0x97, 0x55, 0xf5, 0x45, 0xf4, 0x44, 0x86, 0x27, 0xb7, 0xac, 0xaf, 0x40, 0x30, 0x00, 0x89, 0x4f, 0x56, 0x41, 0xe7, 0x8d, 0x3f, 0x94, 0x6d, 0xfc, 0xa2, 0x9e, 0xc6, 0x17, 0xf0, 0x66, 0x0d, 0xcd, 0x6e, 0x8d, 0x88, 0x27, 0xe6, 0x7e, 0x10, 0x22, 0xa2, 0x45, 0xc5, 0x95, 0xd8, 0x6e, 0x60, 0xfb, 0xd1, 0x76, 0xbf, 0x72, 0x1b, 0x17, 0x1b, 0xbe, 0x5e, 0xca, 0xf4, 0xae, 0x67, 0x1b, 0x9f, 0x3d, 0xd3, 0x92, 0x01, 0x46, 0xe6, 0xad, 0x43, 0x1b, 0xd8, 0xfc, 0x43, 0x18, 0x20, 0xe1, 0x94, 0x54, 0xb6, 0xca, 0x20, 0x97, 0x23, 0xd8, 0x0f, 0xdb, 0xee, 0x18, 0x7f, 0xca, 0x9c, 0x93, 0x7c, 0x97, 0x92, 0x06, 0xae, 0x97, 0xbe, 0x55, 0xf6, 0xba, 0x73, 0x66, 0xa5, 0x60, 0x87, 0x70, 0xa1, 0x1d, 0x53, 0x73, 0x96, 0x48, 0x5e, 0xb0, 0xa6, 0x65, 0x86, 0x38, 0x5f, 0x4d, 0x4c, 0xf3, 0x90, 0x5d, 0x1f, 0xc9, 0x08, 0x31, 0xc3, 0xe1, 0x36, 0xd5, 0xd5, 0x13, 0xfa, 0x22, 0xbe, 0x28, 0x51, 0x93, 0x14, 0x29, 0x94, 0xa3, 0xed, 0x47, 0x71, 0x45, 0xba, 0xcd, 0xcb, 0xdd, 0x79, 0x1e, 0x8b, 0x3b, 0x88, 0xb0, 0xd4, 0xf1, 0xd1, 0x8b, 0x27, 0x38, 0x25, 0x50, 0xa8, 0x18, 0xc4, 0xfd, 0x88, 0x84, 0xbf, 0x36, 0xf6, 0x77, 0xc6, 0xc3, 0xff, 0x56, 0x77, 0x40, 0x6e, 0x51, 0x09, 0x11, 0xe6, 0x96, 0xaf, 0x75, 0xe5, 0xb3, 0xf8, 0x59, 0xbe, 0xf6, 0x99, 0xbd, 0xd1, 0x6e, 0x62, 0x15, 0xfd, 0xb9, 0x8d, 0x87, 0x40, 0x25, 0xea, 0xda, 0x50),
-      //   tag: vec!(0x2a, 0xab, 0xff, 0x35, 0x61, 0x1b, 0x3e, 0x00, 0x13, 0xf6, 0xae, 0x0d, 0xf1, 0x30, 0x79, 0x9b)
-      // },
-      // TestVector{
-      //   key: [0x92, 0x3d, 0x4b, 0x08, 0x6b, 0x9e, 0x43, 0xb9, 0x86, 0xf7, 0xb6, 0x5e, 0x4c, 0xea, 0x61, 0x13, 0xa3, 0xd8, 0xaa, 0xbe, 0xfa, 0x89, 0x32, 0x3c, 0x5e, 0x4d, 0x5b, 0x6f, 0x15, 0x8b, 0xb7, 0xe0],
-      //   nonce: [0xa0, 0xf7, 0x32, 0x97, 0xb8, 0x7f, 0x5d, 0xeb],
-      //   plain_text: vec!(0x21, 0x43, 0x5e, 0x8d, 0x5c, 0x8e, 0xdf, 0x06, 0x84, 0xf5, 0x8c, 0x2c, 0xba, 0x40, 0x70, 0xc1, 0x0b, 0x48, 0x01, 0xad, 0xf4, 0x6b, 0x6c, 0x4d, 0x32, 0x2e, 0xb3, 0x99, 0x0a, 0x38, 0xa9, 0xad, 0x33, 0x8a, 0xd7, 0x04, 0xb9, 0xdf, 0x65, 0x97, 0xf3, 0xe6, 0x8d, 0x66, 0xcd, 0x5b, 0x56, 0x29, 0x0c, 0x84, 0x66, 0xdb, 0x22, 0x31, 0xe5, 0x6d, 0x6b, 0xcb, 0x9c, 0x44, 0xe1, 0xbd, 0x08, 0x1f, 0x42, 0xca, 0x2a, 0x89, 0x4d, 0xad, 0x36, 0x9d, 0xf2, 0xbd, 0x0d, 0x2c, 0x63, 0xd6, 0xc8, 0x81, 0x73, 0x2d, 0x6e, 0xa2, 0x2b, 0xb2, 0x2b, 0x5b, 0xc9, 0xa6, 0x2e, 0xaf, 0xfa, 0x1b, 0x09, 0x4d, 0x08, 0x45, 0xf6, 0xb9, 0x66, 0xd2, 0xcb, 0x09, 0x5e, 0x7b, 0x3b, 0x8b, 0xcb, 0xc1, 0x5e, 0x70, 0x74, 0x49, 0xd3, 0x5c, 0x8d, 0xf4, 0xae, 0xa3, 0x0c, 0x3b, 0x72, 0x43, 0xe9, 0x77, 0xff, 0xfd, 0x59, 0xc8, 0x0f, 0x1c, 0x5c, 0x9a, 0xf4, 0xbb, 0x5a, 0x54, 0xb9, 0xc7, 0x86, 0xfb, 0xbe, 0x8d, 0x21, 0xb2, 0xb9, 0x06, 0xa8, 0x7a, 0x78, 0x6c, 0xae, 0xd8, 0x41, 0xa3, 0x4a, 0x3e, 0x0c, 0xc0, 0xac, 0x32, 0x09, 0xd8, 0x3c, 0x58, 0xaf, 0xba, 0x19, 0xed, 0xd6, 0x36, 0x22, 0xdd, 0x26, 0x15, 0x32, 0xd2, 0xcf, 0xb0, 0xb4, 0x9d, 0x52, 0x7d, 0x8e, 0xaa, 0x08, 0x87, 0xa0, 0x87, 0xf5, 0x12, 0x9d, 0x89, 0x7f, 0x66, 0x52, 0x64, 0xb2, 0x29, 0xf8, 0x60, 0x36, 0x3d, 0x71, 0xa8, 0x8b, 0x7d, 0x49, 0xc8, 0xdc, 0x63, 0x60, 0x18, 0x2b, 0x35, 0x7b, 0x06, 0x62, 0x39, 0x1b, 0xb4, 0x13, 0x37, 0xf4, 0x60, 0x10, 0xac, 0x32, 0xb9, 0xfa, 0xda, 0x2d, 0x60, 0xa2, 0xef, 0xcb, 0x99, 0x36, 0x5d, 0x3b, 0x27, 0xb7, 0xac, 0x39, 0x69, 0x00, 0xd1, 0xc8, 0x21, 0xd0, 0xdf, 0x8b, 0x86, 0xcc, 0x9c, 0xc1, 0xf2, 0x67, 0x32, 0x59, 0xa3, 0x3e, 0xfe, 0xa6, 0x10, 0xbf, 0x8e, 0x1d, 0x00, 0xd7, 0xe9, 0xdb, 0x2a, 0xfe, 0xa2, 0x1d, 0xa8, 0xf5, 0x8c, 0x55, 0xf7, 0x99, 0x99, 0x9d),
-      //   aad: vec!(0xc8, 0x53, 0xa8, 0xb3, 0x9c, 0x0d, 0xc5, 0x97, 0xd5, 0x62, 0xf1, 0x23, 0xcd, 0x22, 0x1e, 0x41, 0x04, 0xb6, 0x54, 0x23, 0xa0, 0x62, 0xa4, 0xf4, 0xba, 0x89, 0x0b, 0xa3, 0x44, 0xfe, 0xb8, 0x42, 0x90, 0xf6, 0x18, 0x17, 0xe2, 0x33, 0x30, 0xc3, 0x65, 0xf5, 0x8c, 0x35, 0x83, 0xce, 0x08, 0x36, 0x0d, 0x3c, 0x11, 0x71, 0x98, 0x2e, 0xad, 0x54, 0x96, 0xd5, 0x25, 0xac, 0x87, 0x8f, 0x23, 0xa5, 0x74, 0x80, 0xa6, 0xee, 0x39, 0xd4, 0xe6, 0x5a, 0xfd, 0x62, 0x68, 0x24, 0x5b, 0xb9, 0x82, 0xa2, 0x54, 0x5f, 0xa1, 0x19, 0x54, 0x27, 0xcd, 0xbb, 0xcd, 0x40, 0x4c, 0xda, 0xd5, 0x19, 0x8f, 0x55, 0xcc, 0xe2, 0xa5, 0xa0, 0x28, 0xfa, 0xe4, 0x35, 0xf7, 0x1b, 0x15, 0x92, 0x1d, 0x06, 0x6e, 0x8d, 0x43, 0x76, 0x6c, 0x32, 0xb2, 0xf2, 0xc3, 0xf5, 0x7c, 0x06, 0x74, 0xe1, 0x29, 0x60, 0x7d, 0xcd, 0x37, 0x03, 0xec, 0xa5, 0x29, 0x41, 0x4a, 0xda, 0xee, 0x79, 0xd8, 0x1f, 0xed, 0x43, 0x21, 0x53, 0xcc, 0xeb, 0x6f, 0x3f, 0xc5, 0x34, 0x04, 0x81, 0x0d, 0x8e, 0xc8, 0x78, 0xf7, 0xd9, 0x4b, 0xe5, 0xd3, 0x79, 0xd0, 0xe0, 0xe1, 0xaa, 0x9b, 0xc4, 0x04, 0xb4, 0xb5, 0xd3, 0x96, 0x03, 0x8a, 0x9d, 0x76, 0xa5, 0xce, 0x53, 0xc9, 0xf3, 0x75, 0x9b, 0x8e, 0x50, 0xfb, 0x33, 0x18, 0x58, 0xca, 0x58, 0xce, 0xe8, 0x1b, 0xfc, 0x3e, 0xe5, 0x8b, 0xae, 0xf5, 0xd1, 0x9c, 0x40, 0x2a, 0x3d, 0xc8, 0xb3, 0x63, 0x70, 0xec, 0x1a, 0xce, 0x5a, 0x4a, 0xa2, 0x52, 0x7f, 0xb9, 0x4b, 0x4f, 0x93, 0x3a, 0x4a, 0xb8, 0xcc, 0xaa, 0xf6, 0xa5, 0xaf, 0x5a, 0x77, 0x9e, 0xae, 0x56, 0x67, 0xc2, 0xa2, 0x4a, 0xb0, 0x27, 0xe7, 0x81, 0xc8, 0xd4, 0xf3, 0x0c, 0x37, 0x7a, 0xa5, 0x88, 0x5a, 0x2f, 0xda, 0xf6, 0x50, 0x7d, 0x18, 0xcd, 0x82, 0x4a, 0x84, 0x7c, 0x35, 0x36, 0x8b, 0x4e, 0xa9, 0x84, 0xd2, 0xc3, 0xc3, 0x82, 0x4a, 0x5b, 0x8b, 0xa3, 0x04, 0x2e, 0x18, 0x52, 0x50, 0x4a, 0x21, 0xa3),
-      //   cipher_text: vec!(0xf2, 0xe2, 0x10, 0x52, 0xee, 0xbb, 0xb8, 0x6a, 0x4f, 0x5e, 0x80, 0x33, 0x60, 0x85, 0x5d, 0x86, 0x32, 0xaa, 0x72, 0x7d, 0xca, 0x6f, 0x5e, 0x79, 0xdd, 0x74, 0xd7, 0xaf, 0xf1, 0x06, 0xe4, 0x42, 0x00, 0x19, 0x28, 0xd1, 0x13, 0x00, 0x5b, 0x03, 0x0f, 0x84, 0x46, 0xf8, 0xef, 0xf2, 0xee, 0x95, 0x1d, 0xb6, 0x63, 0x97, 0x8a, 0xbe, 0x43, 0x09, 0x0d, 0xd5, 0xad, 0x2c, 0x51, 0xba, 0x97, 0xa0, 0xec, 0xf9, 0x88, 0xc6, 0x07, 0xd9, 0x5e, 0x48, 0x6d, 0x02, 0x52, 0x4f, 0x69, 0x0f, 0xa3, 0xc2, 0x8d, 0x5c, 0x48, 0xc1, 0xf7, 0x5c, 0x1f, 0x55, 0x5e, 0x7b, 0x43, 0xfe, 0x7e, 0x46, 0xf2, 0xca, 0x2b, 0x9f, 0xdb, 0x40, 0x8e, 0xc4, 0xba, 0x18, 0xb6, 0xcd, 0xde, 0x2a, 0xf6, 0x73, 0x18, 0x3c, 0xb7, 0xb1, 0xa3, 0xc2, 0x3a, 0xe7, 0x7e, 0xdd, 0xd4, 0xca, 0xc7, 0x5e, 0x1e, 0xa1, 0x47, 0x43, 0xfc, 0x57, 0x1f, 0x8d, 0x31, 0xce, 0x2e, 0x96, 0x78, 0x75, 0x24, 0xcd, 0x48, 0xaa, 0xda, 0xa4, 0x74, 0x18, 0x1c, 0x09, 0x6a, 0x03, 0x21, 0x84, 0x57, 0x4d, 0xdc, 0x25, 0xa6, 0xe0, 0xac, 0x84, 0x41, 0xc2, 0x12, 0xbc, 0x36, 0x29, 0x87, 0x08, 0xe3, 0x3c, 0x96, 0x3a, 0xe9, 0x31, 0xe6, 0xc6, 0x24, 0x1d, 0x1a, 0xff, 0xee, 0xf7, 0xb6, 0xef, 0x75, 0x94, 0x95, 0xdf, 0x44, 0xb6, 0xab, 0x64, 0x74, 0x47, 0x69, 0x3c, 0xf7, 0x03, 0x56, 0x9e, 0x69, 0xaa, 0x72, 0xf1, 0xde, 0xf9, 0xa3, 0x42, 0xb8, 0x97, 0x8c, 0x1e, 0xde, 0xa9, 0x70, 0x3a, 0x42, 0x1c, 0xa7, 0x5b, 0x92, 0xca, 0xc4, 0xde, 0x14, 0xb8, 0x8c, 0x69, 0x32, 0x00, 0x02, 0x2b, 0x8a, 0x2e, 0xd2, 0x2b, 0x1c, 0x46, 0x78, 0xb9, 0x9f, 0x4d, 0x69, 0x5e, 0x08, 0x0d, 0xd1, 0x19, 0x6d, 0x71, 0x68, 0xe1, 0x4f, 0x0d, 0x0f, 0x8f, 0xf8, 0x80, 0xd7, 0x42, 0xe9, 0x7b, 0x9f, 0x6d, 0x00, 0xaf, 0x1f, 0x71, 0x18, 0xe1, 0x0b, 0x77, 0xc5, 0xef, 0x3e, 0xa6, 0xc5, 0x2f, 0x84, 0xa2, 0x0f, 0xd6, 0xea, 0x46, 0xdc),
-      //   tag: vec!(0xfa, 0x8e, 0xe1, 0x34, 0x00, 0xfb, 0x3f, 0x63, 0xb8, 0x99, 0xdf, 0x58, 0x2f, 0x2f, 0xec, 0x45)
-      // },
-      // TestVector{
-      //   key: [0xdf, 0x73, 0xad, 0xab, 0x27, 0x68, 0x55, 0x9e, 0xa9, 0x83, 0xcc, 0xe8, 0x54, 0x53, 0xfe, 0x81, 0xd7, 0x9b, 0xe3, 0xb3, 0xc5, 0x7f, 0x20, 0x2b, 0x31, 0xb9, 0x4d, 0x66, 0x35, 0xcf, 0x2e, 0x4b],
-      //   nonce: [0xe7, 0xa8, 0x7e, 0x6b, 0xf6, 0xb5, 0xa3, 0x54],
-      //   plain_text: vec!(0x00, 0x32, 0xa3, 0x7a, 0xbf, 0x66, 0x1f, 0xaa, 0x18, 0xc5, 0x87, 0xfd, 0x2a, 0xa8, 0x88, 0x85, 0xc0, 0x61, 0xde, 0xeb, 0xa8, 0x11, 0x05, 0xdd, 0x22, 0x19, 0x69, 0xbe, 0xd5, 0xd5, 0x9c, 0x72, 0x04, 0xb0, 0x9b, 0x1a, 0x8c, 0x4c, 0x8d, 0xe3, 0xb9, 0xf7, 0x48, 0xc7, 0xfc, 0x70, 0x62, 0x6e, 0xbe, 0xac, 0xa0, 0x60, 0x23, 0x3a, 0x57, 0xb1, 0x02, 0x22, 0x1b, 0x1b, 0xf0, 0xf3, 0xd9, 0xfd, 0xaa, 0xad, 0x3d, 0x2b, 0x14, 0x39, 0xc2, 0x4d, 0x08, 0xf9, 0xc6, 0x7f, 0x49, 0xf3, 0xc4, 0x71, 0x28, 0xf9, 0x2e, 0xe5, 0x30, 0xab, 0xf4, 0xc4, 0xf4, 0x57, 0x3b, 0xc6, 0x0a, 0xe4, 0xb3, 0x81, 0x09, 0xf5, 0x5b, 0xca, 0x3c, 0xa9, 0xe1, 0xba, 0x9f, 0x9f, 0xd6, 0xe3, 0x4b, 0xa0, 0xd1, 0x74, 0x89, 0x29, 0x77, 0xa5, 0x33, 0x56, 0xe1, 0xf5, 0xc8, 0x8c, 0x61, 0x4f, 0xe3, 0xff, 0x3b, 0x3d, 0xd0, 0x81, 0x8e, 0x7a, 0x22, 0x85, 0x41, 0x2e, 0x3b, 0x37, 0x44, 0x4b, 0xbe, 0x8a, 0x80, 0x94, 0x2e, 0xfc, 0xfd, 0x03, 0x95, 0x88, 0x09, 0xa6, 0x96, 0x6c, 0xda, 0x94, 0x30, 0xb2, 0xf0, 0xc9, 0xe5, 0x52, 0xf4, 0xbc, 0xed, 0x6e, 0x19, 0xeb, 0x3e, 0x85, 0xfc, 0x57, 0x58, 0xbd, 0x7b, 0x58, 0x82, 0x97, 0xcc, 0xbe, 0xd3, 0x7e, 0xd9, 0x4c, 0x3a, 0xdc, 0x8c, 0x08, 0xea, 0x8b, 0x05, 0x84, 0x62, 0xaa, 0xc9, 0xd5, 0x7a, 0x93, 0x9e, 0xc7, 0x11, 0xbc, 0x4e, 0xcf, 0xec, 0x94, 0x4d, 0x2b, 0x65, 0x3b, 0x7c, 0xfc, 0x7b, 0x02, 0xa6, 0x5d, 0x70, 0x57, 0xc9, 0xfd, 0xad, 0xd5, 0x1b, 0x9d, 0xa8, 0xcc, 0x4a, 0x3c, 0x68, 0xda, 0xe9, 0xda, 0x8b, 0x9c, 0x53, 0x19, 0xc1, 0xa2, 0xba, 0xa3, 0xd6, 0xc8, 0x91, 0xc5, 0xac, 0x4a, 0x39, 0x46, 0x14, 0x84, 0xb5, 0xa0, 0x1a, 0xbc, 0x64, 0xdf, 0x44, 0x7a, 0xda, 0x24, 0xc0, 0x4a, 0x43, 0x63, 0xe6, 0x05, 0xea, 0xcc, 0xf3, 0x39, 0xa9, 0xaa, 0x51, 0x5e, 0x72, 0x42, 0x06, 0x20, 0x6d, 0xa6, 0xd2, 0x2b, 0xbd, 0x2f, 0x52, 0xe6, 0x4c, 0xd7, 0xc8, 0x95),
-      //   aad: vec!(0xf8, 0x33, 0xe5, 0xab, 0x4f, 0x8b, 0xc8, 0x91, 0x67, 0xf8, 0x0f, 0x57, 0x6b, 0x1d, 0x6b, 0x22, 0xcd, 0xd0, 0xe3, 0x07, 0x21, 0xf5, 0xf7, 0x35, 0x79, 0x97, 0x46, 0xcf, 0x64, 0x5b, 0x6e, 0xff, 0x53, 0x1d, 0x4c, 0x7b, 0x03, 0x58, 0x4f, 0x3d, 0xfc, 0xb7, 0x3c, 0xbd, 0x35, 0xac, 0x42, 0x73, 0x62, 0x16, 0xdc, 0x7f, 0x0d, 0xe0, 0x98, 0xa4, 0xf4, 0x2c, 0x61, 0xce, 0xb4, 0xb2, 0x27, 0xee, 0x28, 0x8e, 0x47, 0xd6, 0x97, 0xa0, 0xa7, 0x6a, 0xfc, 0x76, 0x2f, 0x08, 0x4e, 0x8f, 0xdb, 0xf9, 0x35, 0x1c, 0x28, 0x34, 0x0c, 0x32, 0x47, 0x71, 0xc1, 0x09, 0xa4, 0x69, 0x34, 0x1a, 0xb1, 0x0c, 0xa1, 0x04, 0x83, 0xed, 0x2a, 0xf5, 0xe8, 0x78, 0xd7, 0xd3, 0xdc, 0x2b, 0xce, 0xd2, 0xf7, 0x2d, 0xa3, 0xd1, 0xa2, 0x58, 0x52, 0xb1, 0x03, 0xee, 0x98, 0x78, 0xe8, 0x15, 0x8e, 0xb4, 0x30, 0x9c, 0x1c, 0xe5, 0x28, 0xf3, 0xa1, 0x78, 0xac, 0xe1, 0x53, 0xb6, 0xd3, 0xae, 0x0a, 0xf0, 0xd5, 0x77, 0xcb, 0x3c, 0xb1, 0x54, 0x04, 0x89, 0xe8, 0x04, 0x27, 0xf7, 0x92, 0x21, 0x7a, 0xd8, 0xa0, 0x9b, 0x84, 0xf0, 0x27, 0xfc, 0xa7, 0xce, 0xb6, 0x51, 0xb4, 0x26, 0x4e, 0x98, 0xe9, 0x4b, 0x4c, 0xb8, 0xa3, 0x7b, 0x13, 0x33, 0x90, 0x89, 0x72, 0x33, 0xe8, 0xba, 0x91, 0x03, 0x62, 0x8d, 0x05, 0xb9, 0x60, 0x9e, 0x85, 0x52, 0xc4, 0xa4, 0xb1, 0x1e, 0x3f, 0x2f, 0xa8, 0xd5, 0x6a, 0xf3, 0x69, 0x57, 0x39, 0x0e, 0x88, 0xcb, 0xa4, 0x46, 0x56, 0xbe, 0x3e, 0xda, 0xce, 0x79, 0x8c, 0xf8, 0xcd, 0xf7, 0x77, 0x1b, 0xac, 0x33, 0x8a, 0x25, 0x6b, 0xc3, 0xcb, 0xa6, 0xdf, 0x97, 0x72, 0x8f, 0x22, 0x2f, 0x42, 0x3c, 0xa7, 0xc6, 0xd1, 0x49, 0xc9, 0x37, 0x2d, 0x66, 0x16, 0x3a, 0x98, 0xf7, 0x9a, 0x23, 0x4b, 0x00, 0xd4, 0xb7, 0x5f, 0xb2, 0xec, 0x86, 0x0d, 0xcc, 0x2d, 0x19, 0x98, 0x10, 0x5e, 0x4b, 0x9c, 0x01, 0xd6, 0x8f, 0x07, 0x9f, 0x3e, 0x0a, 0xa2, 0x1c, 0xc5, 0x34, 0x04, 0x7f, 0xc7, 0xb8, 0x58, 0xf8),
-      //   cipher_text: vec!(0xb8, 0x42, 0xea, 0xdf, 0xdf, 0x43, 0x1c, 0x13, 0x5b, 0xd6, 0x58, 0x1d, 0x3e, 0xcc, 0xae, 0x54, 0xe2, 0x26, 0x7d, 0x88, 0x90, 0x03, 0x6a, 0xa3, 0x3d, 0xfe, 0x2d, 0x2d, 0x97, 0x15, 0xc4, 0x46, 0x25, 0x44, 0x12, 0x10, 0xa3, 0xa0, 0xd6, 0x66, 0xd7, 0x08, 0xd3, 0x05, 0x88, 0xfe, 0x85, 0x1e, 0xc3, 0x6e, 0x10, 0xd8, 0xfa, 0x35, 0x84, 0xed, 0x77, 0xb0, 0x95, 0x14, 0x94, 0x94, 0xb7, 0xc5, 0x43, 0x79, 0xd6, 0x2c, 0x89, 0x35, 0xe1, 0xd2, 0xb9, 0xa8, 0xf4, 0x7e, 0x47, 0x59, 0xad, 0x0b, 0x34, 0x37, 0xfd, 0xf2, 0xcc, 0x2f, 0xb6, 0xc5, 0xea, 0x25, 0xad, 0x10, 0xe0, 0xbd, 0xc9, 0xdc, 0x5b, 0x05, 0x17, 0xfc, 0x23, 0x7e, 0xb7, 0x83, 0xcc, 0x46, 0x1c, 0x46, 0x66, 0x5e, 0x2b, 0x1d, 0x1a, 0x5b, 0x80, 0x08, 0xdb, 0xf4, 0x09, 0xea, 0x2a, 0x63, 0xfe, 0xa0, 0x27, 0x6d, 0xe2, 0x3a, 0x32, 0xc9, 0x9d, 0x92, 0xa4, 0x98, 0x80, 0x7a, 0x0f, 0x95, 0xe2, 0x08, 0xfc, 0x62, 0x62, 0x32, 0x1a, 0x78, 0xaa, 0xfa, 0xf0, 0xcc, 0x3f, 0x83, 0x3f, 0xff, 0x37, 0xbd, 0x4e, 0xfa, 0x66, 0xf6, 0x02, 0x3a, 0x25, 0xcd, 0xc6, 0x70, 0x2c, 0xee, 0x39, 0x12, 0x79, 0x95, 0x63, 0xd9, 0x08, 0xa5, 0x18, 0x3c, 0x99, 0x56, 0xa0, 0x6a, 0xa7, 0x10, 0x85, 0xd8, 0x55, 0xdc, 0x7c, 0x80, 0x9e, 0xd6, 0xe2, 0x88, 0x95, 0x92, 0xb3, 0x61, 0xab, 0x3a, 0xb3, 0x90, 0x60, 0xf8, 0xe4, 0x19, 0x15, 0x21, 0x87, 0xa7, 0x94, 0xa1, 0x9c, 0x2a, 0x11, 0x28, 0x88, 0x22, 0x01, 0x90, 0x0e, 0xa2, 0xcd, 0x59, 0x78, 0x60, 0x67, 0x4b, 0xf7, 0x8d, 0x97, 0x20, 0x64, 0x3d, 0xf8, 0x70, 0x16, 0x76, 0x71, 0x8f, 0xd2, 0x01, 0xba, 0xed, 0x49, 0x35, 0xa8, 0x8e, 0x50, 0x55, 0x8d, 0xaf, 0x86, 0xed, 0xd0, 0x8a, 0x9a, 0xb2, 0x27, 0xac, 0x7a, 0xfa, 0xe5, 0x5c, 0x97, 0x4b, 0x68, 0xde, 0x8d, 0xac, 0xad, 0x4a, 0x4d, 0x79, 0xb1, 0x3e, 0xd6, 0xdf, 0xe7, 0x40, 0x17, 0xa4, 0xcb, 0x91, 0x48, 0xe0, 0x33, 0x43, 0x6f, 0xb6),
-      //   tag: vec!(0x18, 0x40, 0x95, 0xb7, 0xa8, 0x19, 0x0a, 0xbe, 0xc0, 0x8b, 0xb7, 0x2d, 0x19, 0xee, 0xb1, 0x03)
-      // },
-      // TestVector{
-      //   key: [0x55, 0xa4, 0xbe, 0x24, 0x48, 0xb4, 0x64, 0xc2, 0xea, 0x52, 0xa2, 0xf2, 0x66, 0x4e, 0xd6, 0xab, 0xa8, 0x65, 0xc1, 0x4e, 0xa1, 0xfe, 0xa7, 0x7f, 0x46, 0x89, 0x33, 0x1f, 0xd1, 0x05, 0xc8, 0xd4],
-      //   nonce: [0xdb, 0x37, 0xc0, 0xa4, 0x05, 0xb4, 0x62, 0x6d],
-      //   plain_text: vec!(0xd2, 0x66, 0xe6, 0x62, 0x72, 0xe5, 0xd3, 0x46, 0x20, 0x81, 0xb0, 0x04, 0xcb, 0x42, 0x42, 0x9c, 0x8b, 0x97, 0x41, 0xe9, 0xf6, 0x78, 0x15, 0x37, 0x54, 0xd7, 0x26, 0xf6, 0xf9, 0xaa, 0x51, 0x34, 0x64, 0x76, 0x3c, 0x5e, 0x79, 0x3b, 0x48, 0x2f, 0xe5, 0x12, 0xfe, 0xce, 0x97, 0x58, 0x5f, 0x14, 0x26, 0x12, 0x0d, 0x4c, 0xef, 0xb3, 0xd0, 0xa8, 0xcc, 0x0a, 0x8d, 0xb4, 0xbd, 0xe9, 0x3f, 0xc7, 0x2c, 0x78, 0xf4, 0x4d, 0x4f, 0xec, 0xca, 0x14, 0x65, 0x0c, 0x66, 0x0d, 0x3e, 0x28, 0x5b, 0x32, 0x7e, 0x7c, 0xdd, 0x81, 0x30, 0x63, 0xe7, 0xe8, 0x67, 0xb8, 0xa2, 0xd0, 0x59, 0xa4, 0x1b, 0xab, 0x70, 0x43, 0x2b, 0x7f, 0x85, 0x71, 0x99, 0x89, 0x4d, 0xa9, 0x0d, 0xca, 0x3f, 0xe5, 0x27, 0x2b, 0xae, 0x1e, 0xc6, 0x94, 0xa1, 0xa0, 0x7b, 0x60, 0xb0, 0x5d, 0xf2, 0x75, 0x78, 0x4d, 0x49, 0x75, 0x63, 0x7e, 0x46, 0x73, 0x10, 0x9f, 0x3b, 0xa8, 0x46, 0xdf, 0xd1, 0xa0, 0x48, 0xb2, 0x02, 0xed, 0x8e, 0x89, 0x97, 0x3b, 0xe6, 0x08, 0xb9, 0x1e, 0xe4, 0x74, 0x3b, 0x1e, 0x75, 0x99, 0x00, 0xf1, 0x44, 0x30, 0x38, 0x95, 0x1f, 0xe6, 0x18, 0x9e, 0x80, 0x66, 0x38, 0x98, 0x5f, 0x3c, 0x16, 0x33, 0x8c, 0x3c, 0x60, 0x69, 0x5d, 0xf5, 0x8e, 0x62, 0x11, 0x54, 0xd7, 0x9b, 0xb9, 0x73, 0x85, 0x9c, 0x45, 0x58, 0xe9, 0xdc, 0xa9, 0x04, 0x70, 0xf7, 0x7c, 0x73, 0xf0, 0x04, 0x44, 0x3a, 0xd5, 0xdb, 0x07, 0x17, 0xab, 0xbe, 0x43, 0x26, 0x6f, 0x90, 0xe5, 0x73, 0x97, 0xb8, 0x3a, 0xc3, 0x4d, 0x1f, 0xef, 0x2e, 0x89, 0x7e, 0x24, 0x83, 0xd5, 0xbc, 0xdc, 0xb6, 0x27, 0xab, 0xd6, 0x4b, 0x0d, 0x1a, 0xef, 0x52, 0x58, 0x35, 0xf2, 0x5e, 0x76, 0xd6, 0xe9, 0x15, 0x82, 0x32, 0xcd, 0xde, 0x6d, 0xce, 0x97, 0x0b, 0x59, 0xf5, 0x8d, 0xe8, 0xa9, 0x8e, 0x65, 0x3b, 0xe3, 0x2f, 0xb5, 0x8e, 0xda, 0xbb, 0xce, 0xfa, 0x50, 0x65, 0xd7, 0x3a, 0xfd, 0xf1, 0xc9, 0xc4, 0xfb, 0xf5, 0x0c, 0x10, 0x22, 0xbd, 0x22, 0xbf, 0xcb, 0x98, 0xe4, 0xb4, 0x22),
-      //   aad: vec!(0xfd, 0x6a, 0x3f, 0xdd, 0x87, 0x9f, 0x88, 0x80, 0x84, 0x3e, 0xac, 0x20, 0xae, 0x01, 0xc1, 0xb9, 0xdc, 0x34, 0x87, 0xd2, 0x70, 0xa8, 0x06, 0x57, 0x20, 0x88, 0xef, 0x2d, 0xdc, 0x1f, 0x1e, 0x0d, 0xe4, 0x95, 0xe7, 0x1d, 0x48, 0x13, 0xbf, 0x5c, 0x50, 0x1a, 0xd3, 0x1e, 0x5d, 0x79, 0x1c, 0x4b, 0x5b, 0x3a, 0x0a, 0x71, 0xb6, 0x3f, 0xdd, 0xdc, 0xc8, 0xde, 0x4b, 0x05, 0x60, 0x64, 0xef, 0x46, 0x79, 0x89, 0xec, 0xcc, 0xc5, 0xd0, 0x16, 0x0d, 0x40, 0x3b, 0xf3, 0xa0, 0x25, 0xd4, 0x89, 0x2b, 0x3b, 0x1d, 0xe3, 0xe0, 0x62, 0xbc, 0x35, 0x81, 0xd4, 0x41, 0x0f, 0x27, 0x33, 0x38, 0x31, 0x1e, 0xb4, 0x63, 0x75, 0x29, 0xe4, 0xa6, 0x80, 0xa6, 0xe4, 0xa5, 0xe2, 0x6e, 0x30, 0x86, 0x30, 0xa5, 0xb6, 0xd4, 0x9e, 0xad, 0x6d, 0x54, 0x3f, 0x8f, 0x2b, 0xf9, 0x05, 0x0a, 0xa9, 0x4c, 0xe0, 0x91, 0x31, 0x87, 0x21, 0xe1, 0xd8, 0xb9, 0x6e, 0x27, 0x9f, 0x34, 0xb9, 0x75, 0x9b, 0x65, 0x03, 0x7b, 0xec, 0x4b, 0xf6, 0xcc, 0xda, 0x69, 0x29, 0x70, 0x5a, 0xee, 0xee, 0xbe, 0x49, 0xe3, 0x27, 0xe4, 0xd7, 0xa9, 0x16, 0x62, 0x0c, 0x9f, 0xaf, 0x37, 0x65, 0x12, 0x06, 0x58, 0xaf, 0x34, 0xc5, 0x3f, 0xbb, 0x97, 0xec, 0x07, 0x65, 0x7b, 0x3f, 0x08, 0x8f, 0xcb, 0xdc, 0x40, 0x1a, 0xa7, 0x94, 0x9d, 0xde, 0xda, 0x34, 0xd8, 0x85, 0x01, 0x8c, 0x2c, 0x23, 0xf4, 0xf0, 0xbb, 0x82, 0x18, 0xbf, 0x0d, 0x4f, 0xc9, 0x06, 0x43, 0x65, 0x8b, 0x4d, 0x88, 0x34, 0xf4, 0xa8, 0xc0, 0x8e, 0x59, 0x0c, 0x2a, 0x79, 0x09, 0x95, 0xba, 0xa9, 0xe7, 0x76, 0x27, 0xc3, 0x42, 0xd2, 0x83, 0xe4, 0x54, 0xf8, 0x4f, 0xcc, 0x05, 0xbe, 0x15, 0xe9, 0x62, 0x7a, 0x2d, 0x9b, 0xe3, 0x40, 0xc9, 0xd7, 0x2f, 0x22, 0x2b, 0xbd, 0xfc, 0x47, 0x90, 0x5f, 0x56, 0x61, 0x6c, 0xd9, 0xf9, 0x36, 0xd4, 0x9e, 0x47, 0x32, 0xf3, 0x19, 0xf0, 0x20, 0x51, 0x33, 0x40, 0xfb, 0x8b, 0x22, 0x82, 0x8d, 0xb2, 0x51, 0xb1, 0x02, 0xb6, 0xb1, 0x37, 0xc9, 0x53, 0x39, 0x36, 0xd6),
-      //   cipher_text: vec!(0xbd, 0x11, 0xed, 0x07, 0xb7, 0xb4, 0xb3, 0x0e, 0xea, 0xf2, 0x5d, 0x6a, 0x41, 0xa5, 0x49, 0xcc, 0xa0, 0xa5, 0xae, 0xe7, 0x1f, 0x99, 0x0a, 0xc5, 0x66, 0xa3, 0x72, 0x65, 0xd7, 0xaf, 0x2c, 0xe3, 0xc0, 0x37, 0x03, 0x42, 0x7e, 0xe0, 0xb2, 0x75, 0x5c, 0x2b, 0xdf, 0xc2, 0x9f, 0x9d, 0x82, 0x6a, 0xec, 0x6e, 0xe4, 0xad, 0x28, 0xaf, 0x48, 0x07, 0x9a, 0xc2, 0x3d, 0xb1, 0x65, 0x80, 0xb9, 0x74, 0x24, 0xf3, 0xa4, 0xe3, 0x5c, 0xc2, 0x36, 0x25, 0xd3, 0x9f, 0x95, 0x69, 0x9d, 0x9f, 0xf5, 0x14, 0x3e, 0x9a, 0x2b, 0xc2, 0x6f, 0xcf, 0xee, 0x4f, 0x12, 0x5f, 0x5a, 0xa2, 0xd9, 0x68, 0xcc, 0xfc, 0x2f, 0xaa, 0xf9, 0xdb, 0x3c, 0x28, 0x85, 0x0f, 0x67, 0x57, 0xf7, 0x35, 0xcb, 0xc5, 0x0c, 0x94, 0xc4, 0x98, 0xbc, 0xde, 0x4f, 0x23, 0xbf, 0xfa, 0xfa, 0x8d, 0xd5, 0xf7, 0x0d, 0x1a, 0x01, 0x1e, 0x35, 0xeb, 0x26, 0xe9, 0x05, 0xd4, 0xe6, 0x88, 0x48, 0xfe, 0xde, 0xbe, 0xb1, 0x97, 0xbe, 0x59, 0x5c, 0x08, 0x5b, 0xa3, 0x3f, 0x11, 0xba, 0x83, 0x98, 0x25, 0x84, 0x45, 0x05, 0x17, 0x51, 0x88, 0x8e, 0x9b, 0xba, 0x11, 0x1f, 0x80, 0x0f, 0x31, 0xb3, 0x7c, 0x44, 0x70, 0x74, 0xca, 0x6d, 0xce, 0x6d, 0x54, 0xb4, 0xdf, 0xad, 0x6c, 0xee, 0x51, 0x38, 0x64, 0x3d, 0x4f, 0x6a, 0xc0, 0x45, 0xe8, 0x04, 0x72, 0x48, 0x92, 0x4e, 0x88, 0xea, 0x42, 0x94, 0xc7, 0x87, 0x8b, 0xc2, 0x2c, 0x9b, 0x41, 0x92, 0x4c, 0xe3, 0x01, 0xf2, 0x26, 0x93, 0xc3, 0x37, 0x33, 0x10, 0x7b, 0xf1, 0xba, 0x85, 0xe3, 0x48, 0x06, 0xc5, 0xe4, 0x36, 0x6e, 0xa6, 0x6f, 0xc5, 0x2a, 0x5f, 0x89, 0xdd, 0x9b, 0xf2, 0x13, 0x23, 0x91, 0x58, 0xb3, 0xd4, 0xd2, 0x60, 0x0d, 0xde, 0x69, 0x6c, 0x61, 0xd7, 0x6c, 0x39, 0x8b, 0x9b, 0xf1, 0x0d, 0xe9, 0x11, 0x8e, 0x81, 0x2e, 0x89, 0x1c, 0x8f, 0x33, 0x55, 0xc0, 0xec, 0xc6, 0x40, 0x5f, 0x79, 0xbc, 0x32, 0xa5, 0x89, 0x05, 0xe3, 0x78, 0x88, 0xa1, 0xd8, 0x39, 0x5f, 0xbe, 0xdc, 0x3a, 0xc5, 0x4e, 0xca, 0x56, 0x9f),
-      //   tag: vec!(0xf7, 0xd3, 0xb5, 0x8a, 0x34, 0xa8, 0x6e, 0x99, 0x26, 0x7e, 0x5d, 0xb2, 0x06, 0xf1, 0x7b, 0xbe)
-      // },
-      // TestVector{
-      //   key: [0x33, 0x04, 0xe4, 0x91, 0x7a, 0xd7, 0x77, 0x7b, 0x86, 0xc2, 0x6a, 0x63, 0x62, 0x92, 0xc9, 0xcc, 0x4c, 0x10, 0xd3, 0x20, 0x03, 0xc4, 0x9e, 0x07, 0x20, 0x9e, 0xb0, 0xef, 0x85, 0x05, 0x03, 0x1a],
-      //   nonce: [0x4d, 0x57, 0x2d, 0x11, 0x6f, 0xbd, 0x8c, 0x4d],
-      //   plain_text: vec!(0x2f, 0x24, 0x2c, 0x2b, 0xa3, 0x37, 0x90, 0xec, 0xef, 0x86, 0x2b, 0x0e, 0x07, 0x7f, 0xf8, 0xb1, 0x5e, 0xb9, 0xd1, 0x0c, 0xf2, 0xff, 0x62, 0x1e, 0xd6, 0x59, 0x02, 0x49, 0x44, 0x31, 0xdc, 0xbd),
-      //   aad: vec!(0xe6, 0x99, 0xbb, 0xf2, 0x50, 0xcd, 0xd9, 0x3d, 0x22, 0x9d, 0x07, 0x40, 0xe4, 0x33, 0x89, 0x7e, 0x2d, 0x19, 0x13, 0x2e, 0x2b, 0x72, 0x2d, 0xf8, 0xb6, 0x9b, 0xb6, 0xa7, 0xc2, 0xcf, 0x3b, 0x93),
-      //   cipher_text: vec!(0xfb, 0x81, 0xe3, 0x04, 0x36, 0xe4, 0x37, 0xc7, 0xf6, 0x86, 0xf8, 0x6b, 0x1b, 0x65, 0xc7, 0x35, 0x49, 0xa9, 0xd0, 0x9d, 0xb8, 0x10, 0xd3, 0x20, 0x78, 0x5c, 0x36, 0x34, 0x93, 0x41, 0x50, 0xb3),
-      //   tag: vec!(0x8b)
-      // },
-      // TestVector{
-      //   key: [0xed, 0x60, 0x57, 0xbb, 0x16, 0x3f, 0x16, 0x09, 0xff, 0x28, 0xb9, 0x38, 0x12, 0x2f, 0x49, 0x5e, 0x3d, 0x5a, 0xe4, 0xec, 0x3d, 0xbd, 0x74, 0x56, 0xc9, 0xb5, 0xc8, 0x2e, 0x28, 0xe9, 0x52, 0xdc],
-      //   nonce: [0xe6, 0xff, 0x68, 0x52, 0xf3, 0xa3, 0xaf, 0xde],
-      //   plain_text: vec!(0x3c, 0x50, 0xed, 0xc9, 0x67, 0xeb, 0x0b, 0x3b, 0x23, 0x55, 0xf6, 0x40, 0x0e, 0x0a, 0x03, 0x6e, 0x79, 0x6c, 0x8b, 0x7d, 0x72, 0xc5, 0xe5, 0x83, 0xa8, 0x6e, 0x82, 0x0d, 0x53, 0xe7, 0x6c, 0x43),
-      //   aad: vec!(0x24, 0x41, 0xdb, 0x55, 0x14, 0x8e, 0x14, 0xe9, 0xe2, 0x41, 0xd6, 0x82, 0x96, 0xeb, 0x60, 0xd5, 0x29, 0x40, 0x8f, 0x05, 0x34, 0x14, 0x30, 0x89, 0x67, 0x1b, 0xce, 0x54, 0x6d, 0xb9, 0x6d, 0x88),
-      //   cipher_text: vec!(0x6e, 0xca, 0xbc, 0xce, 0xe3, 0x15, 0x19, 0x37, 0x4d, 0x4b, 0xed, 0x11, 0x29, 0x6e, 0x74, 0x83, 0xd1, 0xcb, 0x75, 0x9b, 0xea, 0x3f, 0x44, 0x46, 0xa9, 0x6b, 0xda, 0x8b, 0x4c, 0xa6, 0xd7, 0xac),
-      //   tag: vec!(0x35, 0x5f)
-      // },
-      // TestVector{
-      //   key: [0x73, 0x56, 0x81, 0x83, 0xc1, 0xf9, 0x72, 0x5a, 0xf3, 0x0e, 0x0f, 0x20, 0x67, 0x60, 0x6c, 0xe8, 0x02, 0xc3, 0xfe, 0x3a, 0xb5, 0xcf, 0xf8, 0xd0, 0x2b, 0x3d, 0xb8, 0xc3, 0x51, 0x76, 0xee, 0x0d],
-      //   nonce: [0x0b, 0xc9, 0xe1, 0x93, 0x21, 0xb3, 0xd0, 0x0a],
-      //   plain_text: vec!(0xec, 0x25, 0x90, 0xaf, 0x5c, 0xcd, 0x22, 0x6a, 0x32, 0xff, 0x75, 0x0c, 0x1b, 0x02, 0x9c, 0x11, 0xe3, 0xdd, 0x76, 0xc4, 0x69, 0xa5, 0x57, 0x9d, 0xa9, 0x41, 0x8e, 0x4c, 0x3f, 0xdc, 0x0d, 0x41),
-      //   aad: vec!(0xdf, 0x30, 0x16, 0x0a, 0xe0, 0xcb, 0xf2, 0xcf, 0x89, 0x92, 0x22, 0x1b, 0xd6, 0x2d, 0xff, 0xe6, 0x91, 0xdd, 0x60, 0x2a, 0xfa, 0x78, 0x4c, 0xa6, 0x91, 0x47, 0x9e, 0x95, 0x7a, 0xf3, 0xac, 0xf1),
-      //   cipher_text: vec!(0x9e, 0x8d, 0x8a, 0xc3, 0x06, 0x26, 0xf8, 0xb8, 0x31, 0x44, 0x8d, 0x69, 0x76, 0x93, 0x3a, 0xa5, 0xbb, 0x8c, 0x6d, 0xbc, 0x79, 0x4e, 0x1f, 0x4b, 0x7e, 0xeb, 0x0e, 0x4a, 0x59, 0x34, 0x2c, 0x07),
-      //   tag: vec!(0x9f, 0xd3, 0x6a)
-      // },
-      // TestVector{
-      //   key: [0x27, 0x3b, 0xcb, 0x3f, 0x8c, 0x06, 0x7d, 0xa4, 0xec, 0x34, 0x18, 0x79, 0x9a, 0xd4, 0x0e, 0x7e, 0x4a, 0xee, 0x74, 0xad, 0x7e, 0x62, 0x94, 0x99, 0xd6, 0x46, 0xdf, 0x4a, 0x7e, 0x58, 0x50, 0x25],
-      //   nonce: [0xf6, 0x0b, 0xe3, 0xeb, 0x89, 0x4b, 0x40, 0x30],
-      //   plain_text: vec!(0x69, 0x74, 0x98, 0xba, 0x96, 0x4d, 0x5e, 0xf4, 0x01, 0xda, 0x4d, 0x94, 0x84, 0x4f, 0xab, 0x1e, 0xfc, 0x63, 0x5e, 0x71, 0x57, 0xd0, 0x83, 0x1a, 0x32, 0x5b, 0xb5, 0xa4, 0xcf, 0x1f, 0xbd, 0x34),
-      //   aad: vec!(0x91, 0x29, 0x71, 0x5d, 0xea, 0xb1, 0x4f, 0x02, 0xc7, 0x6b, 0xa8, 0x17, 0x25, 0x71, 0xb1, 0xfa, 0x9d, 0x50, 0x36, 0x5c, 0xd7, 0x95, 0xbf, 0xcc, 0xdf, 0xc2, 0x8e, 0x7e, 0x7b, 0x4f, 0x66, 0xfc),
-      //   cipher_text: vec!(0xbd, 0x4c, 0xd5, 0xaf, 0x83, 0xbe, 0x1c, 0x13, 0x93, 0x33, 0x02, 0x67, 0x5d, 0x9f, 0xca, 0xf1, 0xc4, 0xca, 0xcd, 0xf2, 0x69, 0xf6, 0xff, 0x44, 0x1d, 0x1e, 0xa2, 0x21, 0x1c, 0x54, 0xe7, 0xed),
-      //   tag: vec!(0x7a, 0xb1, 0x2a, 0x37)
-      // },
-      // TestVector{
-      //   key: [0xad, 0x39, 0x61, 0x0c, 0x2e, 0x6a, 0x6d, 0x09, 0x61, 0x20, 0x73, 0x90, 0xe0, 0x76, 0xe9, 0x72, 0xc2, 0xed, 0xad, 0xca, 0x88, 0x5c, 0x92, 0x96, 0x5f, 0xa6, 0x48, 0xb2, 0xce, 0x34, 0xfd, 0xbf],
-      //   nonce: [0xa9, 0x0d, 0xb6, 0x90, 0xbb, 0xa8, 0x3b, 0x78],
-      //   plain_text: vec!(0x31, 0xc4, 0x9e, 0x3c, 0xd3, 0xd8, 0x0a, 0x82, 0xe6, 0xb9, 0x03, 0x16, 0xdf, 0xb9, 0x4b, 0x38, 0xb8, 0xa2, 0x30, 0x42, 0x51, 0x9b, 0xf4, 0x0c, 0x81, 0x81, 0xfe, 0xc8, 0x73, 0xc9, 0x90, 0x02),
-      //   aad: vec!(0xdd, 0xbd, 0x7d, 0x82, 0x1d, 0x18, 0xd4, 0x4c, 0x66, 0x29, 0x5a, 0xbf, 0x24, 0x5b, 0x22, 0x7b, 0x5c, 0xf4, 0x36, 0x68, 0x11, 0xb7, 0xb3, 0x4c, 0x07, 0x67, 0x96, 0x00, 0xab, 0xdb, 0xfc, 0x29),
-      //   cipher_text: vec!(0x94, 0x62, 0x8f, 0xc3, 0x03, 0xa0, 0x54, 0x6e, 0xdd, 0x51, 0xe9, 0x66, 0xf2, 0xbd, 0x87, 0x96, 0x8f, 0x37, 0x80, 0x0c, 0x60, 0x7d, 0x5e, 0x5a, 0x91, 0xf7, 0x27, 0xfc, 0x1f, 0xec, 0x40, 0x6f),
-      //   tag: vec!(0xc2, 0x2e, 0xc4, 0xe4, 0xc8)
-      // },
-      // TestVector{
-      //   key: [0x29, 0x98, 0x49, 0x54, 0x06, 0x0b, 0xa0, 0x6e, 0xce, 0x1b, 0xcf, 0xc0, 0xe5, 0x01, 0x95, 0xf4, 0x63, 0x2c, 0x6d, 0xf4, 0x8d, 0xa1, 0xe0, 0x2a, 0xe6, 0xc1, 0x4f, 0x70, 0x65, 0x66, 0x89, 0x71],
-      //   nonce: [0xcc, 0xe5, 0x3a, 0x25, 0xae, 0xea, 0xf7, 0x47],
-      //   plain_text: vec!(0xb9, 0xb8, 0x74, 0x33, 0xa9, 0x89, 0x4f, 0x3c, 0x9c, 0xa8, 0x21, 0x26, 0x23, 0xd6, 0x23, 0x69, 0xa5, 0x65, 0xa2, 0xed, 0xcd, 0xdd, 0x27, 0x6e, 0x07, 0xd6, 0x11, 0xed, 0xa3, 0x59, 0x74, 0x26),
-      //   aad: vec!(0x19, 0xfa, 0x9a, 0xa5, 0x96, 0x97, 0x55, 0x9d, 0x8b, 0x46, 0xd9, 0xcd, 0x49, 0xc3, 0xb7, 0x63, 0xc0, 0xb7, 0x3b, 0x26, 0xb9, 0xe3, 0x34, 0xa3, 0xee, 0xac, 0x2c, 0x86, 0xfd, 0xba, 0xca, 0x8d),
-      //   cipher_text: vec!(0xb6, 0x8c, 0x83, 0x39, 0x77, 0x70, 0xc3, 0x6f, 0x07, 0x37, 0x10, 0x88, 0x2f, 0xa8, 0x6d, 0x43, 0xb0, 0xe5, 0x4e, 0x8e, 0xfe, 0xf0, 0xff, 0x75, 0x07, 0x56, 0x04, 0xd0, 0xd7, 0xec, 0x4e, 0x1b),
-      //   tag: vec!(0x40, 0xd4, 0xab, 0x75, 0x2f, 0x3d)
-      // },
-      // TestVector{
-      //   key: [0x5c, 0x3b, 0x83, 0x8b, 0x84, 0x10, 0x0b, 0x2a, 0x81, 0x8c, 0x08, 0x42, 0xe9, 0xfe, 0x19, 0xa7, 0xc5, 0x0c, 0xf5, 0xf3, 0xea, 0x73, 0x36, 0x4c, 0x81, 0x6e, 0xf5, 0x88, 0xe5, 0x00, 0xff, 0x3f],
-      //   nonce: [0xfd, 0xf6, 0xb0, 0x22, 0x9e, 0x4b, 0xcc, 0x2a],
-      //   plain_text: vec!(0x2b, 0xa9, 0x19, 0x04, 0xc1, 0x43, 0xbe, 0x99, 0x29, 0x7b, 0x39, 0xf5, 0x28, 0x56, 0x90, 0x4a, 0xf4, 0x17, 0x05, 0xc1, 0x76, 0xc8, 0xc6, 0x55, 0x4b, 0x6b, 0xc8, 0x9b, 0xdd, 0xff, 0xbc, 0xc1),
-      //   aad: vec!(0x35, 0x39, 0xd9, 0xdd, 0x82, 0x1f, 0x00, 0x4f, 0x4c, 0xed, 0x16, 0x37, 0x07, 0x1f, 0x4b, 0xe6, 0xab, 0xd7, 0xfe, 0x98, 0xf0, 0x17, 0xf0, 0xa8, 0xce, 0x3f, 0x49, 0xdc, 0x8d, 0x49, 0x6f, 0x46),
-      //   cipher_text: vec!(0xff, 0x9d, 0x6d, 0x92, 0x4e, 0x73, 0x7a, 0x1d, 0xf8, 0xc2, 0xbd, 0x30, 0x47, 0xe4, 0x0a, 0xb4, 0x01, 0xf9, 0x03, 0xaa, 0x0e, 0x5b, 0x51, 0xac, 0xb9, 0x91, 0xba, 0xc3, 0x8a, 0xc2, 0xcc, 0x4d),
-      //   tag: vec!(0x1b, 0xca, 0xa4, 0x15, 0xa6, 0xa3, 0xc7)
-      // },
-      TestVector{
-        key: [0x6d, 0x65, 0xe6, 0x27, 0xca, 0xb6, 0xd5, 0xeb, 0x1a, 0x08, 0x8b, 0x25, 0xbd, 0x6c, 0x3a, 0x8a, 0x00, 0x4a, 0x7a, 0x19, 0xcc, 0xca, 0xe9, 0x09, 0xd6, 0x2f, 0xed, 0x35, 0x59, 0xc8, 0x12, 0xf7],
-        nonce: [0x7f, 0xf0, 0x0a, 0x87, 0x98, 0xb7, 0x92, 0xde],
-        plain_text: vec!(0x68, 0x48, 0xee, 0x4a, 0xc8, 0x20, 0x29, 0x1a, 0x2e, 0x1d, 0xc3, 0xba, 0xad, 0x97, 0xf1, 0xad, 0x8b, 0x71, 0x60, 0xdf, 0xea, 0xa1, 0xbc, 0x83, 0xb2, 0x70, 0x0a, 0xe4, 0x2b, 0x5a, 0x36, 0x6b),
-        aad: vec!(0xd2, 0x43, 0x7b, 0x13, 0x06, 0xbf, 0x0e, 0xa2, 0x11, 0x44, 0x9f, 0xac, 0x86, 0x3c, 0xa0, 0xd1, 0x07, 0x4d, 0x84, 0xca, 0xee, 0x90, 0x09, 0xc5, 0xd5, 0x4b, 0x9e, 0x9b, 0xdc, 0x8d, 0xe6, 0xb1),
-        cipher_text: vec!(0x2d, 0xa0, 0xab, 0xe2, 0xa7, 0x1e, 0x1c, 0x0b, 0x1a, 0xb3, 0x09, 0xc1, 0x60, 0xa8, 0xce, 0xbe, 0x45, 0xc6, 0xe1, 0x61, 0x70, 0xaa, 0x55, 0x61, 0x80, 0x64, 0x84, 0xba, 0x2b, 0x5b, 0x9a, 0x9a),
-        tag: vec!(0x56, 0x60, 0x03, 0xe1, 0xf7, 0x8d, 0x2a, 0x90)
-      },
-      TestVector{
-        key: [0x63, 0x40, 0x10, 0x46, 0xa9, 0x6e, 0xfb, 0xc8, 0xc6, 0x48, 0x3a, 0x2c, 0x39, 0x6b, 0x2a, 0x59, 0x3d, 0x3f, 0xae, 0x0d, 0xb5, 0x65, 0x52, 0x5b, 0x85, 0x99, 0x9f, 0xae, 0x13, 0xa4, 0x6b, 0x6a],
-        nonce: [0x05, 0x13, 0x93, 0xd7, 0x75, 0xe6, 0x35, 0xee],
-        plain_text: vec!(0x2b, 0x4b, 0x64, 0x77, 0x58, 0x03, 0x82, 0xaa, 0xe7, 0x82, 0xf8, 0xb5, 0x77, 0x2c, 0x09, 0x48, 0xa4, 0x44, 0xd8, 0xd9, 0x5c, 0xaa, 0xcd, 0x85, 0xc0, 0x85, 0x6c, 0x7e, 0x43, 0x93, 0xfe, 0x09),
-        aad: vec!(0x3d, 0x84, 0xd2, 0xe7, 0x0e, 0x9c, 0x06, 0x2d, 0x1f, 0x51, 0x1e, 0xb6, 0x85, 0xa9, 0xa9, 0x0c, 0x8d, 0x5f, 0xa5, 0x0e, 0xad, 0xf8, 0x45, 0x5c, 0x71, 0x48, 0x66, 0x6b, 0x3e, 0x71, 0x55, 0xe0),
-        cipher_text: vec!(0x88, 0x0c, 0x11, 0x23, 0xe5, 0x4f, 0xd8, 0xff, 0xb3, 0xc2, 0x93, 0x72, 0x0d, 0xd1, 0x74, 0x91, 0x35, 0x72, 0xe6, 0x19, 0xef, 0x46, 0x50, 0x4c, 0xda, 0xa6, 0x4f, 0xc4, 0x51, 0xb0, 0xec, 0x1c),
-        tag: vec!(0x33, 0x92, 0x74, 0x33, 0x9c, 0x88, 0xd5, 0x0a, 0xc0)
-      },
-      TestVector{
-        key: [0x29, 0x1f, 0xcc, 0xfc, 0xe0, 0x78, 0x2f, 0x17, 0x87, 0xd6, 0x2d, 0x4b, 0x92, 0x93, 0xd2, 0xad, 0xa4, 0xc0, 0x4d, 0x37, 0xa8, 0x28, 0x8b, 0xa9, 0xba, 0x9a, 0xae, 0x0d, 0x31, 0xaa, 0xd2, 0x04],
-        nonce: [0x74, 0x50, 0xbb, 0xd6, 0x2e, 0x4a, 0xba, 0x7b],
-        plain_text: vec!(0xad, 0xc2, 0x51, 0xe7, 0x93, 0x18, 0x1e, 0x5d, 0x4c, 0x4b, 0xd9, 0x83, 0xb8, 0x53, 0xeb, 0x13, 0xf2, 0x09, 0x6c, 0xcb, 0x34, 0x09, 0x96, 0xb6, 0xec, 0xa4, 0xcd, 0x21, 0x57, 0xef, 0xce, 0xc7),
-        aad: vec!(0x4c, 0x59, 0x8f, 0x6d, 0xee, 0xdc, 0x8c, 0x1d, 0x97, 0xda, 0x33, 0x65, 0x47, 0x63, 0x49, 0x5c, 0xca, 0x35, 0x17, 0x43, 0x0e, 0xec, 0x4e, 0xdb, 0x00, 0x6b, 0x10, 0xc9, 0x5e, 0x03, 0x1a, 0xe6),
-        cipher_text: vec!(0x28, 0xbd, 0xa2, 0x2e, 0x49, 0x22, 0xcd, 0x8f, 0xf6, 0x73, 0x9c, 0xd8, 0xa6, 0xbd, 0xaf, 0xce, 0x03, 0x6d, 0x9c, 0x61, 0xa1, 0x45, 0xa6, 0x5c, 0xa1, 0xb8, 0x6f, 0x6d, 0x4d, 0x32, 0x06, 0xa1),
-        tag: vec!(0xd9, 0x8f, 0xd4, 0x3f, 0xe7, 0xac, 0x74, 0xd4, 0xb0, 0x16)
-      },
-      TestVector{
-        key: [0xfa, 0x3a, 0x96, 0x74, 0xd4, 0xa0, 0xeb, 0x36, 0xb2, 0xf7, 0x54, 0x7c, 0x95, 0x64, 0x43, 0xd0, 0x9e, 0x6b, 0x4e, 0x4a, 0xcf, 0xc9, 0xde, 0xda, 0x83, 0x8e, 0xb7, 0xeb, 0xdb, 0x99, 0x9a, 0x8d],
-        nonce: [0x0a, 0x25, 0x72, 0x59, 0x2c, 0x3b, 0xbb, 0xf6],
-        plain_text: vec!(0xae, 0x27, 0xf7, 0x0f, 0xda, 0x9f, 0x5a, 0x5b, 0xe0, 0xf7, 0x04, 0xa2, 0x7f, 0x0b, 0x8a, 0x9c, 0x04, 0xce, 0x83, 0xd3, 0xc2, 0xe0, 0xd7, 0xec, 0x15, 0x2d, 0xa2, 0x5f, 0x47, 0x3b, 0x0c, 0x8a),
-        aad: vec!(0x6e, 0xe8, 0x70, 0x5a, 0x9a, 0x36, 0x55, 0xd1, 0x98, 0x49, 0x7a, 0xd4, 0x10, 0xda, 0x02, 0x00, 0x58, 0x72, 0xec, 0xbe, 0x39, 0x78, 0x24, 0x85, 0x1b, 0x80, 0xf4, 0x05, 0x0b, 0xfd, 0xd3, 0x11),
-        cipher_text: vec!(0xf3, 0x56, 0xcb, 0xd8, 0x8e, 0x4e, 0x2a, 0xff, 0x62, 0xd9, 0x1e, 0x3f, 0x91, 0x40, 0x32, 0x08, 0x53, 0x88, 0x95, 0x5b, 0xbb, 0xa9, 0x95, 0xfd, 0xe0, 0x13, 0x75, 0x8b, 0x87, 0x02, 0xe3, 0x8f),
-        tag: vec!(0x00, 0x32, 0x4c, 0x76, 0xfe, 0xcd, 0x3f, 0x50, 0xe1, 0xe3, 0xb8)
-      },
-      TestVector{
-        key: [0x47, 0x1e, 0xc8, 0x7b, 0x99, 0x2b, 0x10, 0x4d, 0x36, 0x97, 0x48, 0xd9, 0x68, 0x56, 0xb5, 0xf6, 0x61, 0x49, 0xcb, 0x45, 0xca, 0x05, 0xc1, 0x7f, 0x29, 0xd2, 0x4e, 0xb9, 0x52, 0x6f, 0xe6, 0xdb],
-        nonce: [0x23, 0xa2, 0xdf, 0x9e, 0xd0, 0xb4, 0x74, 0x39],
-        plain_text: vec!(0x2b, 0x94, 0x52, 0xbc, 0xa0, 0xf4, 0x8e, 0x55, 0x19, 0xec, 0x3d, 0x07, 0x36, 0x59, 0x76, 0x08, 0xdf, 0x6a, 0xd9, 0xce, 0x79, 0x9e, 0xba, 0x91, 0x3c, 0xff, 0x71, 0x57, 0x3d, 0x79, 0xc0, 0x92),
-        aad: vec!(0xa5, 0x67, 0x22, 0xdd, 0xfa, 0xee, 0x5f, 0x1b, 0x64, 0x39, 0x8c, 0x22, 0x5e, 0xe8, 0xbc, 0xdc, 0xfd, 0xe5, 0xc2, 0x12, 0x71, 0x01, 0xc3, 0x63, 0xbf, 0xac, 0x52, 0xbc, 0x40, 0x9c, 0x10, 0x82),
-        cipher_text: vec!(0x7b, 0xbc, 0x46, 0x4a, 0xac, 0x5d, 0xd2, 0x9c, 0x25, 0x26, 0x2f, 0xe0, 0xb1, 0x16, 0xc1, 0x76, 0xd8, 0x27, 0xc2, 0xcc, 0x8d, 0xd6, 0x34, 0x28, 0x39, 0x3b, 0x0a, 0x91, 0x10, 0xf3, 0xc1, 0x94),
-        tag: vec!(0x2e, 0x87, 0xf4, 0xa6, 0x66, 0x3a, 0x62, 0xe4, 0x7c, 0x7e, 0x19, 0x7f)
-      },
-      TestVector{
-        key: [0xa2, 0x9d, 0x1c, 0xfd, 0x4c, 0xcd, 0xc1, 0x88, 0x03, 0xfb, 0xca, 0x95, 0x00, 0xf4, 0xbb, 0x29, 0xce, 0x99, 0xcf, 0xcb, 0xf8, 0xac, 0xc4, 0x1b, 0x82, 0x08, 0xda, 0xe4, 0xb7, 0xee, 0x5d, 0x64],
-        nonce: [0x63, 0x4f, 0x99, 0xe8, 0x8e, 0x23, 0x7e, 0xf0],
-        plain_text: vec!(0x09, 0xee, 0x59, 0x82, 0xc5, 0x74, 0x3f, 0x39, 0x6d, 0x0c, 0x29, 0xc1, 0x3e, 0x3f, 0xbb, 0x8f, 0xb8, 0x9f, 0x61, 0x70, 0x5d, 0xa0, 0x54, 0x66, 0x29, 0x1e, 0x01, 0x0e, 0xff, 0xd5, 0x1a, 0x5c),
-        aad: vec!(0x56, 0x4d, 0xdd, 0xfc, 0xc3, 0x22, 0x7b, 0x41, 0x32, 0x44, 0xf1, 0x10, 0x5b, 0x61, 0x0f, 0x19, 0x2d, 0xec, 0xf1, 0x5c, 0x4c, 0xfa, 0x06, 0x7f, 0x4d, 0x7f, 0xcd, 0x6b, 0xd7, 0xaf, 0x11, 0xb8),
-        cipher_text: vec!(0x32, 0x91, 0x6b, 0x67, 0xa6, 0xf3, 0x27, 0x33, 0x62, 0x33, 0x44, 0xc9, 0x8c, 0x49, 0x77, 0x3f, 0x3e, 0x72, 0x1d, 0xc2, 0xde, 0xd1, 0x05, 0xfb, 0x24, 0x57, 0x99, 0x52, 0x5b, 0xc9, 0xc8, 0x4c),
-        tag: vec!(0xff, 0x46, 0x3c, 0x07, 0xe7, 0xef, 0x83, 0x13, 0x21, 0xd3, 0xfd, 0x77, 0x5f)
-      },
-      TestVector{
-        key: [0x08, 0xba, 0x23, 0x61, 0x6d, 0x91, 0x11, 0x88, 0xf9, 0x1d, 0xa0, 0x63, 0x27, 0x8b, 0xef, 0x12, 0x37, 0xdc, 0xbf, 0x17, 0xf5, 0x25, 0x85, 0xe5, 0x3c, 0x2c, 0x4b, 0x6c, 0xf3, 0xac, 0x9f, 0x0d],
-        nonce: [0x98, 0x9a, 0xe5, 0x93, 0xed, 0xdd, 0x38, 0x74],
-        plain_text: vec!(0x74, 0x91, 0x52, 0xc9, 0x47, 0x89, 0x44, 0xc8, 0x27, 0x1c, 0x0c, 0x11, 0xe0, 0x7b, 0xc1, 0xc5, 0x69, 0xee, 0xc0, 0x14, 0x93, 0xe6, 0x5b, 0x3b, 0x94, 0x84, 0x2a, 0x1b, 0xf5, 0xd7, 0x21, 0xf8),
-        aad: vec!(0xa1, 0x2d, 0x1a, 0x45, 0xb7, 0xc9, 0xb9, 0x1a, 0xb0, 0x87, 0x51, 0xa7, 0x0b, 0x75, 0x37, 0x14, 0x05, 0x2a, 0xd2, 0x4e, 0x0b, 0x26, 0x19, 0xfe, 0x8c, 0x3b, 0xe3, 0x03, 0xc6, 0x5f, 0x2d, 0xbc),
-        cipher_text: vec!(0x34, 0xc4, 0x05, 0x38, 0xee, 0x1d, 0x22, 0xdd, 0xf8, 0xac, 0x29, 0x0d, 0xd7, 0xd4, 0x23, 0xdf, 0xc6, 0x22, 0xb5, 0xcf, 0x8f, 0x34, 0x12, 0xa5, 0x34, 0x3e, 0x27, 0x78, 0x22, 0xae, 0xa7, 0x13),
-        tag: vec!(0x01, 0x4c, 0x7c, 0x67, 0x8e, 0x09, 0x49, 0xe8, 0x80, 0x71, 0xd1, 0xfe, 0x35, 0x31)
-      },
-      TestVector{
-        key: [0xc2, 0xba, 0x8b, 0xed, 0x86, 0x34, 0x15, 0x6a, 0xfc, 0x6b, 0xfe, 0x37, 0x54, 0xc9, 0x17, 0x44, 0xd4, 0x13, 0x1d, 0xe3, 0x9d, 0x05, 0x9f, 0x3a, 0x86, 0x63, 0x99, 0xf9, 0x16, 0x55, 0x3b, 0x5c],
-        nonce: [0x80, 0xfb, 0xf7, 0xb4, 0x33, 0xa4, 0xcd, 0x9c],
-        plain_text: vec!(0x41, 0x9b, 0xe6, 0x62, 0x3e, 0x79, 0x64, 0xf9, 0xf2, 0x60, 0x68, 0xdd, 0x96, 0x9e, 0x4a, 0x13, 0x96, 0x17, 0xe6, 0x7c, 0x5f, 0xfb, 0x26, 0x9b, 0x30, 0x13, 0xc4, 0x33, 0xfe, 0x77, 0x1c, 0x77),
-        aad: vec!(0x39, 0x37, 0x59, 0x2d, 0xb7, 0x8a, 0x61, 0xff, 0x46, 0x96, 0x91, 0xb6, 0x80, 0x07, 0x92, 0x01, 0x9b, 0xc2, 0xb3, 0xd4, 0x25, 0x12, 0xf2, 0x3c, 0x1b, 0x1a, 0x66, 0xa8, 0x27, 0x44, 0x95, 0xcb),
-        cipher_text: vec!(0x9d, 0x5b, 0xd1, 0xc7, 0xe7, 0x66, 0x76, 0x3e, 0xb0, 0x06, 0x84, 0xc0, 0x38, 0x04, 0x31, 0x11, 0xd8, 0xc6, 0x39, 0x0a, 0x8d, 0x6e, 0x17, 0xa1, 0x5e, 0xf9, 0x7c, 0x02, 0xab, 0x16, 0xf0, 0x9c),
-        tag: vec!(0xa6, 0x4d, 0x0e, 0xeb, 0x4a, 0x01, 0x48, 0x1e, 0xc0, 0xce, 0xe8, 0xc1, 0xc3, 0x57, 0xe3)
-      }
-    )
-  }
-}
-
-#[cfg(all(test, feature = "with-bench"))]
-mod bench {
-    use test::Bencher;
-    use chacha20poly1305::ChaCha20Poly1305;
-    use aead::{AeadEncryptor, AeadDecryptor};
-
-    #[bench]
-    pub fn chacha20poly1305_10(bh: & mut Bencher) {
-      let input = [1u8; 10];
-      let aad = [3u8; 10];
-      bh.iter( || {
-          let mut cipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-          let mut decipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-
-          let mut output = [0u8; 10];
-          let mut tag = [0u8; 16];
-          let mut output2 = [0u8; 10];
-          cipher.encrypt(&input, &mut output, &mut tag);
-          decipher.decrypt(&output, &mut output2, &tag);
-
-        });
-        bh.bytes = 10u64;
-    }
-
-
-    #[bench]
-    pub fn chacha20poly1305_1k(bh: & mut Bencher) {
-      let input = [1u8; 1024];
-      let aad = [3u8; 1024];
-      bh.iter( || {
-        let mut cipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-        let mut decipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-
-        let mut output = [0u8; 1024];
-        let mut tag = [0u8; 16];
-        let mut output2 = [0u8; 1024];
-
-        cipher.encrypt(&input, &mut output, &mut tag);
-        decipher.decrypt(&output, &mut output2, &tag);
-        });
-      bh.bytes = 1024u64;
-
-    }
-
-    #[bench]
-    pub fn chacha20poly1305_64k(bh: & mut Bencher) {
-      let input = [1u8; 65536];
-      let aad = [3u8; 65536];
-        bh.iter( || {
-          let mut cipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-          let mut decipher = ChaCha20Poly1305::new(&[0; 32], &[0; 8], &aad);
-
-          let mut output = [0u8; 65536];
-          let mut tag = [0u8; 16];
-          let mut output2 = [0u8; 65536];
-
-          cipher.encrypt(&input, &mut output, &mut tag);
-          decipher.decrypt(&output, &mut output2, &tag);
-
-        });
-         bh.bytes = 65536u64;
-
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/cryptoutil.rs b/rustc_deps/vendor/rust-crypto/src/cryptoutil.rs
deleted file mode 100644
index e908ab6..0000000
--- a/rustc_deps/vendor/rust-crypto/src/cryptoutil.rs
+++ /dev/null
@@ -1,592 +0,0 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std;
-use std::{io, mem};
-use std::ptr;
-
-use buffer::{ReadBuffer, WriteBuffer, BufferResult};
-use buffer::BufferResult::{BufferUnderflow, BufferOverflow};
-use symmetriccipher::{SynchronousStreamCipher, SymmetricCipherError};
-
-/// Write a u64 into a vector, which must be 8 bytes long. The value is written in big-endian
-/// format.
-pub fn write_u64_be(dst: &mut[u8], mut input: u64) {
-    assert!(dst.len() == 8);
-    input = input.to_be();
-    unsafe {
-        let tmp = &input as *const _ as *const u8;
-        ptr::copy_nonoverlapping(tmp, dst.get_unchecked_mut(0), 8);
-    }
-}
-
-/// Write a u64 into a vector, which must be 8 bytes long. The value is written in little-endian
-/// format.
-pub fn write_u64_le(dst: &mut[u8], mut input: u64) {
-    assert!(dst.len() == 8);
-    input = input.to_le();
-    unsafe {
-        let tmp = &input as *const _ as *const u8;
-        ptr::copy_nonoverlapping(tmp, dst.get_unchecked_mut(0), 8);
-    }
-}
-
-/// Write a vector of u64s into a vector of bytes. The values are written in little-endian format.
-pub fn write_u64v_le(dst: &mut[u8], input: &[u64]) {
-    assert!(dst.len() == 8 * input.len());
-    unsafe {
-        let mut x: *mut u8 = dst.get_unchecked_mut(0);
-        let mut y: *const u64 = input.get_unchecked(0);
-        for _ in 0..input.len() {
-            let tmp = (*y).to_le();
-            ptr::copy_nonoverlapping(&tmp as *const _ as *const u8, x, 8);
-            x = x.offset(8);
-            y = y.offset(1);
-        }
-    }
-}
-
-/// Write a u32 into a vector, which must be 4 bytes long. The value is written in big-endian
-/// format.
-pub fn write_u32_be(dst: &mut [u8], mut input: u32) {
-    assert!(dst.len() == 4);
-    input = input.to_be();
-    unsafe {
-        let tmp = &input as *const _ as *const u8;
-        ptr::copy_nonoverlapping(tmp, dst.get_unchecked_mut(0), 4);
-    }
-}
-
-/// Write a u32 into a vector, which must be 4 bytes long. The value is written in little-endian
-/// format.
-pub fn write_u32_le(dst: &mut[u8], mut input: u32) {
-    assert!(dst.len() == 4);
-    input = input.to_le();
-    unsafe {
-        let tmp = &input as *const _ as *const u8;
-        ptr::copy_nonoverlapping(tmp, dst.get_unchecked_mut(0), 4);
-    }
-}
-
-/// Write a vector of u32s into a vector of bytes. The values are written in little-endian format.
-pub fn write_u32v_le (dst: &mut[u8], input: &[u32]) {
-    assert!(dst.len() == 4 * input.len());
-    unsafe {
-        let mut x: *mut u8 = dst.get_unchecked_mut(0);
-        let mut y: *const u32 = input.get_unchecked(0);
-        for _ in 0..input.len() {
-            let tmp = (*y).to_le();
-            ptr::copy_nonoverlapping(&tmp as *const _ as *const u8, x, 4);
-            x = x.offset(4);
-            y = y.offset(1);
-        }
-    }
-}
-
-/// Read a vector of bytes into a vector of u64s. The values are read in big-endian format.
-pub fn read_u64v_be(dst: &mut[u64], input: &[u8]) {
-    assert!(dst.len() * 8 == input.len());
-    unsafe {
-        let mut x: *mut u64 = dst.get_unchecked_mut(0);
-        let mut y: *const u8 = input.get_unchecked(0);
-        for _ in 0..dst.len() {
-            let mut tmp: u64 = mem::uninitialized();
-            ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 8);
-            *x = u64::from_be(tmp);
-            x = x.offset(1);
-            y = y.offset(8);
-        }
-    }
-}
-
-/// Read a vector of bytes into a vector of u64s. The values are read in little-endian format.
-pub fn read_u64v_le(dst: &mut[u64], input: &[u8]) {
-    assert!(dst.len() * 8 == input.len());
-    unsafe {
-        let mut x: *mut u64 = dst.get_unchecked_mut(0);
-        let mut y: *const u8 = input.get_unchecked(0);
-        for _ in 0..dst.len() {
-            let mut tmp: u64 = mem::uninitialized();
-            ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 8);
-            *x = u64::from_le(tmp);
-            x = x.offset(1);
-            y = y.offset(8);
-        }
-    }
-}
-
-/// Read a vector of bytes into a vector of u32s. The values are read in big-endian format.
-pub fn read_u32v_be(dst: &mut[u32], input: &[u8]) {
-    assert!(dst.len() * 4 == input.len());
-    unsafe {
-        let mut x: *mut u32 = dst.get_unchecked_mut(0);
-        let mut y: *const u8 = input.get_unchecked(0);
-        for _ in 0..dst.len() {
-            let mut tmp: u32 = mem::uninitialized();
-            ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 4);
-            *x = u32::from_be(tmp);
-            x = x.offset(1);
-            y = y.offset(4);
-        }
-    }
-}
-
-/// Read a vector of bytes into a vector of u32s. The values are read in little-endian format.
-pub fn read_u32v_le(dst: &mut[u32], input: &[u8]) {
-    assert!(dst.len() * 4 == input.len());
-    unsafe {
-        let mut x: *mut u32 = dst.get_unchecked_mut(0);
-        let mut y: *const u8 = input.get_unchecked(0);
-        for _ in 0..dst.len() {
-            let mut tmp: u32 = mem::uninitialized();
-            ptr::copy_nonoverlapping(y, &mut tmp as *mut _ as *mut u8, 4);
-            *x = u32::from_le(tmp);
-            x = x.offset(1);
-            y = y.offset(4);
-        }
-    }
-}
-
-/// Read the value of a vector of bytes as a u32 value in little-endian format.
-pub fn read_u32_le(input: &[u8]) -> u32 {
-    assert!(input.len() == 4);
-    unsafe {
-        let mut tmp: u32 = mem::uninitialized();
-        ptr::copy_nonoverlapping(input.get_unchecked(0), &mut tmp as *mut _ as *mut u8, 4);
-        u32::from_le(tmp)
-    }
-}
-
-/// Read the value of a vector of bytes as a u32 value in big-endian format.
-pub fn read_u32_be(input: &[u8]) -> u32 {
-    assert!(input.len() == 4);
-    unsafe {
-        let mut tmp: u32 = mem::uninitialized();
-        ptr::copy_nonoverlapping(input.get_unchecked(0), &mut tmp as *mut _ as *mut u8, 4);
-        u32::from_be(tmp)
-    }
-}
-
-/// XOR plaintext and keystream, storing the result in dst.
-pub fn xor_keystream(dst: &mut[u8], plaintext: &[u8], keystream: &[u8]) {
-    assert!(dst.len() == plaintext.len());
-    assert!(plaintext.len() <= keystream.len());
-
-    // Do one byte at a time, using unsafe to skip bounds checking.
-    let p = plaintext.as_ptr();
-    let k = keystream.as_ptr();
-    let d = dst.as_mut_ptr();
-    for i in 0isize..plaintext.len() as isize {
-        unsafe{ *d.offset(i) = *p.offset(i) ^ *k.offset(i) };
-    }
-}
-
-/// Copy bytes from src to dest
-#[inline]
-pub fn copy_memory(src: &[u8], dst: &mut [u8]) {
-    assert!(dst.len() >= src.len());
-    unsafe {
-        let srcp = src.as_ptr();
-        let dstp = dst.as_mut_ptr();
-        ptr::copy_nonoverlapping(srcp, dstp, src.len());
-    }
-}
-
-/// Zero all bytes in dst
-#[inline]
-pub fn zero(dst: &mut [u8]) {
-    unsafe {
-        ptr::write_bytes(dst.as_mut_ptr(), 0, dst.len());
-    }
-}
-
-/// An extension trait to implement a few useful serialization
-/// methods on types that implement Write
-pub trait WriteExt {
-    fn write_u8(&mut self, val: u8) -> io::Result<()>;
-    fn write_u32_le(&mut self, val: u32) -> io::Result<()>;
-    fn write_u32_be(&mut self, val: u32) -> io::Result<()>;
-    fn write_u64_le(&mut self, val: u64) -> io::Result<()>;
-    fn write_u64_be(&mut self, val: u64) -> io::Result<()>;
-}
-
-impl <T> WriteExt for T where T: io::Write {
-    fn write_u8(&mut self, val: u8) -> io::Result<()> {
-        let buff = [val];
-        self.write_all(&buff)
-    }
-    fn write_u32_le(&mut self, val: u32) -> io::Result<()> {
-        let mut buff = [0u8; 4];
-        write_u32_le(&mut buff, val);
-        self.write_all(&buff)
-    }
-    fn write_u32_be(&mut self, val: u32) -> io::Result<()> {
-        let mut buff = [0u8; 4];
-        write_u32_be(&mut buff, val);
-        self.write_all(&buff)
-    }
-    fn write_u64_le(&mut self, val: u64) -> io::Result<()> {
-        let mut buff = [0u8; 8];
-        write_u64_le(&mut buff, val);
-        self.write_all(&buff)
-    }
-    fn write_u64_be(&mut self, val: u64) -> io::Result<()> {
-        let mut buff = [0u8; 8];
-        write_u64_be(&mut buff, val);
-        self.write_all(&buff)
-    }
-}
-
-/// symm_enc_or_dec() implements the necessary functionality to turn a SynchronousStreamCipher into
-/// an Encryptor or Decryptor
-pub fn symm_enc_or_dec<S: SynchronousStreamCipher, R: ReadBuffer, W: WriteBuffer>(
-        c: &mut S,
-        input: &mut R,
-        output: &mut W) ->
-        Result<BufferResult, SymmetricCipherError> {
-    let count = std::cmp::min(input.remaining(), output.remaining());
-    c.process(input.take_next(count), output.take_next(count));
-    if input.is_empty() {
-        Ok(BufferUnderflow)
-    } else {
-        Ok(BufferOverflow)
-    }
-}
-
-/// Convert the value in bytes to the number of bits, a tuple where the 1st item is the
-/// high-order value and the 2nd item is the low order value.
-fn to_bits(x: u64) -> (u64, u64) {
-    (x >> 61, x << 3)
-}
-
-/// Adds the specified number of bytes to the bit count. panic!() if this would cause numeric
-/// overflow.
-pub fn add_bytes_to_bits(bits: u64, bytes: u64) -> u64 {
-    let (new_high_bits, new_low_bits) = to_bits(bytes);
-
-    if new_high_bits > 0 {
-        panic!("Numeric overflow occured.")
-    }
-
-    bits.checked_add(new_low_bits).expect("Numeric overflow occured.")
-}
-
-/// Adds the specified number of bytes to the bit count, which is a tuple where the first element is
-/// the high order value. panic!() if this would cause numeric overflow.
-pub fn add_bytes_to_bits_tuple
-        (bits: (u64, u64), bytes: u64) -> (u64, u64) {
-    let (new_high_bits, new_low_bits) = to_bits(bytes);
-    let (hi, low) = bits;
-
-    // Add the low order value - if there is no overflow, then add the high order values
-    // If the addition of the low order values causes overflow, add one to the high order values
-    // before adding them.
-    match low.checked_add(new_low_bits) {
-        Some(x) => {
-            if new_high_bits == 0 {
-                // This is the fast path - every other alternative will rarely occur in practice
-                // considering how large an input would need to be for those paths to be used.
-                return (hi, x);
-            } else {
-                match hi.checked_add(new_high_bits) {
-                    Some(y) => return (y, x),
-                    None => panic!("Numeric overflow occured.")
-                }
-            }
-        },
-        None => {
-            let z = match new_high_bits.checked_add(1) {
-                Some(w) => w,
-                None => panic!("Numeric overflow occured.")
-            };
-            match hi.checked_add(z) {
-                // This re-executes the addition that was already performed earlier when overflow
-                // occured, this time allowing the overflow to happen. Technically, this could be
-                // avoided by using the checked add intrinsic directly, but that involves using
-                // unsafe code and is not really worthwhile considering how infrequently code will
-                // run in practice. This is the reason that this function requires that the type T
-                // be UnsignedInt - overflow is not defined for Signed types. This function could
-                // be implemented for signed types as well if that were needed.
-                Some(y) => return (y, low.wrapping_add(new_low_bits)),
-                None => panic!("Numeric overflow occured.")
-            }
-        }
-    }
-}
-
-
-/// A FixedBuffer, likes its name implies, is a fixed size buffer. When the buffer becomes full, it
-/// must be processed. The input() method takes care of processing and then clearing the buffer
-/// automatically. However, other methods do not and require the caller to process the buffer. Any
-/// method that modifies the buffer directory or provides the caller with bytes that can be modifies
-/// results in those bytes being marked as used by the buffer.
-pub trait FixedBuffer {
-    /// Input a vector of bytes. If the buffer becomes full, process it with the provided
-    /// function and then clear the buffer.
-    fn input<F: FnMut(&[u8])>(&mut self, input: &[u8], func: F);
-
-    /// Reset the buffer.
-    fn reset(&mut self);
-
-    /// Zero the buffer up until the specified index. The buffer position currently must not be
-    /// greater than that index.
-    fn zero_until(&mut self, idx: usize);
-
-    /// Get a slice of the buffer of the specified size. There must be at least that many bytes
-    /// remaining in the buffer.
-    fn next<'s>(&'s mut self, len: usize) -> &'s mut [u8];
-
-    /// Get the current buffer. The buffer must already be full. This clears the buffer as well.
-    fn full_buffer<'s>(&'s mut self) -> &'s [u8];
-
-     /// Get the current buffer.
-    fn current_buffer<'s>(&'s mut self) -> &'s [u8];
-
-    /// Get the current position of the buffer.
-    fn position(&self) -> usize;
-
-    /// Get the number of bytes remaining in the buffer until it is full.
-    fn remaining(&self) -> usize;
-
-    /// Get the size of the buffer
-    fn size(&self) -> usize;
-}
-
-macro_rules! impl_fixed_buffer( ($name:ident, $size:expr) => (
-    impl FixedBuffer for $name {
-        fn input<F: FnMut(&[u8])>(&mut self, input: &[u8], mut func: F) {
-            let mut i = 0;
-
-            // FIXME: #6304 - This local variable shouldn't be necessary.
-            let size = $size;
-
-            // If there is already data in the buffer, copy as much as we can into it and process
-            // the data if the buffer becomes full.
-            if self.buffer_idx != 0 {
-                let buffer_remaining = size - self.buffer_idx;
-                if input.len() >= buffer_remaining {
-                        copy_memory(
-                            &input[..buffer_remaining],
-                            &mut self.buffer[self.buffer_idx..size]);
-                    self.buffer_idx = 0;
-                    func(&self.buffer);
-                    i += buffer_remaining;
-                } else {
-                    copy_memory(
-                        input,
-                        &mut self.buffer[self.buffer_idx..self.buffer_idx + input.len()]);
-                    self.buffer_idx += input.len();
-                    return;
-                }
-            }
-
-            // While we have at least a full buffer size chunks's worth of data, process that data
-            // without copying it into the buffer
-            while input.len() - i >= size {
-                func(&input[i..i + size]);
-                i += size;
-            }
-
-            // Copy any input data into the buffer. At this point in the method, the ammount of
-            // data left in the input vector will be less than the buffer size and the buffer will
-            // be empty.
-            let input_remaining = input.len() - i;
-            copy_memory(
-                &input[i..],
-                &mut self.buffer[0..input_remaining]);
-            self.buffer_idx += input_remaining;
-        }
-
-        fn reset(&mut self) {
-            self.buffer_idx = 0;
-        }
-
-        fn zero_until(&mut self, idx: usize) {
-            assert!(idx >= self.buffer_idx);
-            zero(&mut self.buffer[self.buffer_idx..idx]);
-            self.buffer_idx = idx;
-        }
-
-        fn next<'s>(&'s mut self, len: usize) -> &'s mut [u8] {
-            self.buffer_idx += len;
-            &mut self.buffer[self.buffer_idx - len..self.buffer_idx]
-        }
-
-        fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
-            assert!(self.buffer_idx == $size);
-            self.buffer_idx = 0;
-            &self.buffer[..$size]
-        }
-
-        fn current_buffer<'s>(&'s mut self) -> &'s [u8] {
-            let tmp = self.buffer_idx;
-            self.buffer_idx = 0;
-            &self.buffer[..tmp]
-        }
-
-        fn position(&self) -> usize { self.buffer_idx }
-
-        fn remaining(&self) -> usize { $size - self.buffer_idx }
-
-        fn size(&self) -> usize { $size }
-    }
-));
-
-/// A fixed size buffer of 64 bytes useful for cryptographic operations.
-#[derive(Copy)]
-pub struct FixedBuffer64 {
-    buffer: [u8; 64],
-    buffer_idx: usize,
-}
-
-impl Clone for FixedBuffer64 { fn clone(&self) -> FixedBuffer64 { *self } }
-
-impl FixedBuffer64 {
-    /// Create a new buffer
-    pub fn new() -> FixedBuffer64 {
-        FixedBuffer64 {
-            buffer: [0u8; 64],
-            buffer_idx: 0
-        }
-    }
-}
-
-impl_fixed_buffer!(FixedBuffer64, 64);
-
-/// A fixed size buffer of 128 bytes useful for cryptographic operations.
-#[derive(Copy)]
-pub struct FixedBuffer128 {
-    buffer: [u8; 128],
-    buffer_idx: usize,
-}
-
-impl Clone for FixedBuffer128 { fn clone(&self) -> FixedBuffer128 { *self } }
-
-impl FixedBuffer128 {
-    /// Create a new buffer
-    pub fn new() -> FixedBuffer128 {
-        FixedBuffer128 {
-            buffer: [0u8; 128],
-            buffer_idx: 0
-        }
-    }
-}
-
-impl_fixed_buffer!(FixedBuffer128, 128);
-
-
-/// The StandardPadding trait adds a method useful for various hash algorithms to a FixedBuffer
-/// struct.
-pub trait StandardPadding {
-    /// Add standard padding to the buffer. The buffer must not be full when this method is called
-    /// and is guaranteed to have exactly rem remaining bytes when it returns. If there are not at
-    /// least rem bytes available, the buffer will be zero padded, processed, cleared, and then
-    /// filled with zeros again until only rem bytes are remaining.
-    fn standard_padding<F: FnMut(&[u8])>(&mut self, rem: usize, func: F);
-}
-
-impl <T: FixedBuffer> StandardPadding for T {
-    fn standard_padding<F: FnMut(&[u8])>(&mut self, rem: usize, mut func: F) {
-        let size = self.size();
-
-        self.next(1)[0] = 128;
-
-        if self.remaining() < rem {
-            self.zero_until(size);
-            func(self.full_buffer());
-        }
-
-        self.zero_until(size - rem);
-    }
-}
-
-
-#[cfg(test)]
-pub mod test {
-    use std;
-    use std::iter::repeat;
-
-    use rand::IsaacRng;
-    use rand::distributions::{IndependentSample, Range};
-
-    use cryptoutil::{add_bytes_to_bits, add_bytes_to_bits_tuple};
-    use digest::Digest;
-
-    /// Feed 1,000,000 'a's into the digest with varying input sizes and check that the result is
-    /// correct.
-    pub fn test_digest_1million_random<D: Digest>(digest: &mut D, blocksize: usize, expected: &str) {
-        let total_size = 1000000;
-        let buffer: Vec<u8> = repeat('a' as u8).take(blocksize * 2).collect();
-        let mut rng = IsaacRng::new_unseeded();
-        let range = Range::new(0, 2 * blocksize + 1);
-        let mut count = 0;
-
-        digest.reset();
-
-        while count < total_size {
-            let next = range.ind_sample(&mut rng);
-            let remaining = total_size - count;
-            let size = if next > remaining { remaining } else { next };
-            digest.input(&buffer[..size]);
-            count += size;
-        }
-
-        let result_str = digest.result_str();
-
-        assert!(expected == &result_str[..]);
-    }
-
-    // A normal addition - no overflow occurs
-    #[test]
-    fn test_add_bytes_to_bits_ok() {
-        assert!(add_bytes_to_bits(100, 10) == 180);
-    }
-
-    // A simple failure case - adding 1 to the max value
-    #[test]
-    #[should_panic]
-    fn test_add_bytes_to_bits_overflow() {
-        add_bytes_to_bits(std::u64::MAX, 1);
-    }
-
-    // A normal addition - no overflow occurs (fast path)
-    #[test]
-    fn test_add_bytes_to_bits_tuple_ok() {
-        assert!(add_bytes_to_bits_tuple((5, 100), 10) == (5, 180));
-    }
-
-    // The low order value overflows into the high order value
-    #[test]
-    fn test_add_bytes_to_bits_tuple_ok2() {
-        assert!(add_bytes_to_bits_tuple((5, std::u64::MAX), 1) == (6, 7));
-    }
-
-    // The value to add is too large to be converted into bits without overflowing its type
-    #[test]
-    fn test_add_bytes_to_bits_tuple_ok3() {
-        assert!(add_bytes_to_bits_tuple((5, 0), 0x4000000000000001) == (7, 8));
-    }
-
-    // A simple failure case - adding 1 to the max value
-    #[test]
-    #[should_panic]
-    fn test_add_bytes_to_bits_tuple_overflow() {
-        add_bytes_to_bits_tuple((std::u64::MAX, std::u64::MAX), 1);
-    }
-
-    // The value to add is too large to convert to bytes without overflowing its type, but the high
-    // order value from this conversion overflows when added to the existing high order value
-    #[test]
-    #[should_panic]
-    fn test_add_bytes_to_bits_tuple_overflow2() {
-        let value: u64 = std::u64::MAX;
-        add_bytes_to_bits_tuple((value - 1, 0), 0x8000000000000000);
-    }
-}
diff --git a/rustc_deps/vendor/rust-crypto/src/curve25519.rs b/rustc_deps/vendor/rust-crypto/src/curve25519.rs
deleted file mode 100644
index 873a2c4..0000000
--- a/rustc_deps/vendor/rust-crypto/src/curve25519.rs
+++ /dev/null
@@ -1,3642 +0,0 @@
-use std::ops::{Add, Sub, Mul};
-use std::cmp::{Eq, PartialEq,min};
-use util::{fixed_time_eq};
-use step_by::RangeExt;
-
-/*
-fe means field element.
-Here the field is \Z/(2^255-19).
-An element t, entries t[0]...t[9], represents the integer
-t[0]+2^26 t[1]+2^51 t[2]+2^77 t[3]+2^102 t[4]+...+2^230 t[9].
-Bounds on each t[i] vary depending on context.
-*/
-
-#[derive(Clone, Copy)]
-pub struct Fe(pub [i32; 10]);
-
-impl PartialEq for Fe {
-    fn eq(&self, other: &Fe) -> bool {
-        let &Fe(self_elems) = self;
-        let &Fe(other_elems) = other;
-        self_elems.to_vec() == other_elems.to_vec()
-    }
-}
-impl Eq for Fe { }
-
-static FE_ZERO : Fe = Fe([0,0,0,0,0,0,0,0,0,0]);
-static FE_ONE : Fe = Fe([1,0,0,0,0,0,0,0,0,0]);
-static FE_SQRTM1 : Fe = Fe([-32595792,-7943725,9377950,3500415,12389472,-272473,-25146209,-2005654,326686,11406482]);
-static FE_D : Fe = Fe([-10913610,13857413,-15372611,6949391,114729,-8787816,-6275908,-3247719,-18696448,-12055116]);
-static FE_D2 : Fe = Fe([-21827239,-5839606,-30745221,13898782,229458,15978800,-12551817,-6495438,29715968,9444199]);
-
-
-fn load_4u(s: &[u8]) -> u64 {
-    (s[0] as u64)
-        | ((s[1] as u64)<<8)
-        | ((s[2] as u64)<<16)
-        | ((s[3] as u64)<<24)
-}
-fn load_4i(s: &[u8]) -> i64 {
-    load_4u(s) as i64
-}
-fn load_3u(s: &[u8]) -> u64 {
-    (s[0] as u64)
-        | ((s[1] as u64)<<8)
-        | ((s[2] as u64)<<16)
-}
-fn load_3i(s: &[u8]) -> i64 {
-    load_3u(s) as i64
-}
-
-impl Add for Fe {
-    type Output = Fe;
-
-    /*
-    h = f + g
-    Can overlap h with f or g.
-
-    Preconditions:
-       |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-       |g| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-
-    Postconditions:
-       |h| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-    */
-    fn add(self, _rhs: Fe) -> Fe {
-        let Fe(f) = self;
-        let Fe(g) = _rhs;
-
-        let f0 = f[0];
-        let f1 = f[1];
-        let f2 = f[2];
-        let f3 = f[3];
-        let f4 = f[4];
-        let f5 = f[5];
-        let f6 = f[6];
-        let f7 = f[7];
-        let f8 = f[8];
-        let f9 = f[9];
-        let g0 = g[0];
-        let g1 = g[1];
-        let g2 = g[2];
-        let g3 = g[3];
-        let g4 = g[4];
-        let g5 = g[5];
-        let g6 = g[6];
-        let g7 = g[7];
-        let g8 = g[8];
-        let g9 = g[9];
-        let h0 = f0 + g0;
-        let h1 = f1 + g1;
-        let h2 = f2 + g2;
-        let h3 = f3 + g3;
-        let h4 = f4 + g4;
-        let h5 = f5 + g5;
-        let h6 = f6 + g6;
-        let h7 = f7 + g7;
-        let h8 = f8 + g8;
-        let h9 = f9 + g9;
-        Fe([h0, h1, h2, h3, h4, h5, h6, h7, h8, h9])
-    }
-}
-
-impl Sub for Fe {
-    type Output = Fe;
-
-    /*
-    h = f - g
-    Can overlap h with f or g.
-
-    Preconditions:
-       |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-       |g| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-
-    Postconditions:
-       |h| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-    */
-    fn sub(self, _rhs: Fe) -> Fe {
-        let Fe(f) = self;
-        let Fe(g) = _rhs;
-
-        let f0 = f[0];
-        let f1 = f[1];
-        let f2 = f[2];
-        let f3 = f[3];
-        let f4 = f[4];
-        let f5 = f[5];
-        let f6 = f[6];
-        let f7 = f[7];
-        let f8 = f[8];
-        let f9 = f[9];
-        let g0 = g[0];
-        let g1 = g[1];
-        let g2 = g[2];
-        let g3 = g[3];
-        let g4 = g[4];
-        let g5 = g[5];
-        let g6 = g[6];
-        let g7 = g[7];
-        let g8 = g[8];
-        let g9 = g[9];
-        let h0 = f0 - g0;
-        let h1 = f1 - g1;
-        let h2 = f2 - g2;
-        let h3 = f3 - g3;
-        let h4 = f4 - g4;
-        let h5 = f5 - g5;
-        let h6 = f6 - g6;
-        let h7 = f7 - g7;
-        let h8 = f8 - g8;
-        let h9 = f9 - g9;
-        Fe([h0, h1, h2, h3, h4, h5, h6, h7, h8, h9])
-    }
-}
-
-impl Mul for Fe {
-    type Output = Fe;
-
-    /*
-    h = f * g
-    Can overlap h with f or g.
-
-    Preconditions:
-       |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-       |g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-
-    Postconditions:
-       |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-    */
-
-    /*
-    Notes on implementation strategy:
-
-    Using schoolbook multiplication.
-    Karatsuba would save a little in some cost models.
-
-    Most multiplications by 2 and 19 are 32-bit precomputations;
-    cheaper than 64-bit postcomputations.
-
-    There is one remaining multiplication by 19 in the carry chain;
-    one *19 precomputation can be merged into this,
-    but the resulting data flow is considerably less clean.
-
-    There are 12 carries below.
-    10 of them are 2-way parallelizable and vectorizable.
-    Can get away with 11 carries, but then data flow is much deeper.
-
-    With tighter constraints on inputs can squeeze carries into int32.
-    */
-
-    fn mul(self, _rhs: Fe) -> Fe {
-        let Fe(f) = self;
-        let Fe(g) = _rhs;
-        let f0 = f[0];
-        let f1 = f[1];
-        let f2 = f[2];
-        let f3 = f[3];
-        let f4 = f[4];
-        let f5 = f[5];
-        let f6 = f[6];
-        let f7 = f[7];
-        let f8 = f[8];
-        let f9 = f[9];
-        let g0 = g[0];
-        let g1 = g[1];
-        let g2 = g[2];
-        let g3 = g[3];
-        let g4 = g[4];
-        let g5 = g[5];
-        let g6 = g[6];
-        let g7 = g[7];
-        let g8 = g[8];
-        let g9 = g[9];
-        let g1_19 = 19 * g1; /* 1.4*2^29 */
-        let g2_19 = 19 * g2; /* 1.4*2^30; still ok */
-        let g3_19 = 19 * g3;
-        let g4_19 = 19 * g4;
-        let g5_19 = 19 * g5;
-        let g6_19 = 19 * g6;
-        let g7_19 = 19 * g7;
-        let g8_19 = 19 * g8;
-        let g9_19 = 19 * g9;
-        let f1_2 = 2 * f1;
-        let f3_2 = 2 * f3;
-        let f5_2 = 2 * f5;
-        let f7_2 = 2 * f7;
-        let f9_2 = 2 * f9;
-        let f0g0    = (f0   as i64) * (g0 as i64);
-        let f0g1    = (f0   as i64) * (g1 as i64);
-        let f0g2    = (f0   as i64) * (g2 as i64);
-        let f0g3    = (f0   as i64) * (g3 as i64);
-        let f0g4    = (f0   as i64) * (g4 as i64);
-        let f0g5    = (f0   as i64) * (g5 as i64);
-        let f0g6    = (f0   as i64) * (g6 as i64);
-        let f0g7    = (f0   as i64) * (g7 as i64);
-        let f0g8    = (f0   as i64) * (g8 as i64);
-        let f0g9    = (f0   as i64) * (g9 as i64);
-        let f1g0    = (f1   as i64) * (g0 as i64);
-        let f1g1_2  = (f1_2 as i64) * (g1 as i64);
-        let f1g2    = (f1   as i64) * (g2 as i64);
-        let f1g3_2  = (f1_2 as i64) * (g3 as i64);
-        let f1g4    = (f1   as i64) * (g4 as i64);
-        let f1g5_2  = (f1_2 as i64) * (g5 as i64);
-        let f1g6    = (f1   as i64) * (g6 as i64);
-        let f1g7_2  = (f1_2 as i64) * (g7 as i64);
-        let f1g8    = (f1   as i64) * (g8 as i64);
-        let f1g9_38 = (f1_2 as i64) * (g9_19 as i64);
-        let f2g0    = (f2   as i64) * (g0 as i64);
-        let f2g1    = (f2   as i64) * (g1 as i64);
-        let f2g2    = (f2   as i64) * (g2 as i64);
-        let f2g3    = (f2   as i64) * (g3 as i64);
-        let f2g4    = (f2   as i64) * (g4 as i64);
-        let f2g5    = (f2   as i64) * (g5 as i64);
-        let f2g6    = (f2   as i64) * (g6 as i64);
-        let f2g7    = (f2   as i64) * (g7 as i64);
-        let f2g8_19 = (f2   as i64) * (g8_19 as i64);
-        let f2g9_19 = (f2   as i64) * (g9_19 as i64);
-        let f3g0    = (f3   as i64) * (g0 as i64);
-        let f3g1_2  = (f3_2 as i64) * (g1 as i64);
-        let f3g2    = (f3   as i64) * (g2 as i64);
-        let f3g3_2  = (f3_2 as i64) * (g3 as i64);
-        let f3g4    = (f3   as i64) * (g4 as i64);
-        let f3g5_2  = (f3_2 as i64) * (g5 as i64);
-        let f3g6    = (f3   as i64) * (g6 as i64);
-        let f3g7_38 = (f3_2 as i64) * (g7_19 as i64);
-        let f3g8_19 = (f3   as i64) * (g8_19 as i64);
-        let f3g9_38 = (f3_2 as i64) * (g9_19 as i64);
-        let f4g0    = (f4   as i64) * (g0 as i64);
-        let f4g1    = (f4   as i64) * (g1 as i64);
-        let f4g2    = (f4   as i64) * (g2 as i64);
-        let f4g3    = (f4   as i64) * (g3 as i64);
-        let f4g4    = (f4   as i64) * (g4 as i64);
-        let f4g5    = (f4   as i64) * (g5 as i64);
-        let f4g6_19 = (f4   as i64) * (g6_19 as i64);
-        let f4g7_19 = (f4   as i64) * (g7_19 as i64);
-        let f4g8_19 = (f4   as i64) * (g8_19 as i64);
-        let f4g9_19 = (f4   as i64) * (g9_19 as i64);
-        let f5g0    = (f5   as i64) * (g0 as i64);
-        let f5g1_2  = (f5_2 as i64) * (g1 as i64);
-        let f5g2    = (f5   as i64) * (g2 as i64);
-        let f5g3_2  = (f5_2 as i64) * (g3 as i64);
-        let f5g4    = (f5   as i64) * (g4 as i64);
-        let f5g5_38 = (f5_2 as i64) * (g5_19 as i64);
-        let f5g6_19 = (f5   as i64) * (g6_19 as i64);
-        let f5g7_38 = (f5_2 as i64) * (g7_19 as i64);
-        let f5g8_19 = (f5   as i64) * (g8_19 as i64);
-        let f5g9_38 = (f5_2 as i64) * (g9_19 as i64);
-        let f6g0    = (f6   as i64) * (g0 as i64);
-        let f6g1    = (f6   as i64) * (g1 as i64);
-        let f6g2    = (f6   as i64) * (g2 as i64);
-        let f6g3    = (f6   as i64) * (g3 as i64);
-        let f6g4_19 = (f6   as i64) * (g4_19 as i64);
-        let f6g5_19 = (f6   as i64) * (g5_19 as i64);
-        let f6g6_19 = (f6   as i64) * (g6_19 as i64);
-        let f6g7_19 = (f6   as i64) * (g7_19 as i64);
-        let f6g8_19 = (f6   as i64) * (g8_19 as i64);
-        let f6g9_19 = (f6   as i64) * (g9_19 as i64);
-        let f7g0    = (f7   as i64) * (g0 as i64);
-        let f7g1_2  = (f7_2 as i64) * (g1 as i64);
-        let f7g2    = (f7   as i64) * (g2 as i64);
-        let f7g3_38 = (f7_2 as i64) * (g3_19 as i64);
-        let f7g4_19 = (f7   as i64) * (g4_19 as i64);
-        let f7g5_38 = (f7_2 as i64) * (g5_19 as i64);
-        let f7g6_19 = (f7   as i64) * (g6_19 as i64);
-        let f7g7_38 = (f7_2 as i64) * (g7_19 as i64);
-        let f7g8_19 = (f7   as i64) * (g8_19 as i64);
-        let f7g9_38 = (f7_2 as i64) * (g9_19 as i64);
-        let f8g0    = (f8   as i64) * (g0 as i64);
-        let f8g1    = (f8   as i64) * (g1 as i64);
-        let f8g2_19 = (f8   as i64) * (g2_19 as i64);
-        let f8g3_19 = (f8   as i64) * (g3_19 as i64);
-        let f8g4_19 = (f8   as i64) * (g4_19 as i64);
-        let f8g5_19 = (f8   as i64) * (g5_19 as i64);
-        let f8g6_19 = (f8   as i64) * (g6_19 as i64);
-        let f8g7_19 = (f8   as i64) * (g7_19 as i64);
-        let f8g8_19 = (f8   as i64) * (g8_19 as i64);
-        let f8g9_19 = (f8   as i64) * (g9_19 as i64);
-        let f9g0    = (f9   as i64) * (g0 as i64);
-        let f9g1_38 = (f9_2 as i64) * (g1_19 as i64);
-        let f9g2_19 = (f9   as i64) * (g2_19 as i64);
-        let f9g3_38 = (f9_2 as i64) * (g3_19 as i64);
-        let f9g4_19 = (f9   as i64) * (g4_19 as i64);
-        let f9g5_38 = (f9_2 as i64) * (g5_19 as i64);
-        let f9g6_19 = (f9   as i64) * (g6_19 as i64);
-        let f9g7_38 = (f9_2 as i64) * (g7_19 as i64);
-        let f9g8_19 = (f9   as i64) * (g8_19 as i64);
-        let f9g9_38 = (f9_2 as i64) * (g9_19 as i64);
-        let mut h0 = f0g0+f1g9_38+f2g8_19+f3g7_38+f4g6_19+f5g5_38+f6g4_19+f7g3_38+f8g2_19+f9g1_38;
-        let mut h1 = f0g1+f1g0   +f2g9_19+f3g8_19+f4g7_19+f5g6_19+f6g5_19+f7g4_19+f8g3_19+f9g2_19;
-        let mut h2 = f0g2+f1g1_2 +f2g0   +f3g9_38+f4g8_19+f5g7_38+f6g6_19+f7g5_38+f8g4_19+f9g3_38;
-        let mut h3 = f0g3+f1g2   +f2g1   +f3g0   +f4g9_19+f5g8_19+f6g7_19+f7g6_19+f8g5_19+f9g4_19;
-        let mut h4 = f0g4+f1g3_2 +f2g2   +f3g1_2 +f4g0   +f5g9_38+f6g8_19+f7g7_38+f8g6_19+f9g5_38;
-        let mut h5 = f0g5+f1g4   +f2g3   +f3g2   +f4g1   +f5g0   +f6g9_19+f7g8_19+f8g7_19+f9g6_19;
-        let mut h6 = f0g6+f1g5_2 +f2g4   +f3g3_2 +f4g2   +f5g1_2 +f6g0   +f7g9_38+f8g8_19+f9g7_38;
-        let mut h7 = f0g7+f1g6   +f2g5   +f3g4   +f4g3   +f5g2   +f6g1   +f7g0   +f8g9_19+f9g8_19;
-        let mut h8 = f0g8+f1g7_2 +f2g6   +f3g5_2 +f4g4   +f5g3_2 +f6g2   +f7g1_2 +f8g0   +f9g9_38;
-        let mut h9 = f0g9+f1g8   +f2g7   +f3g6   +f4g5   +f5g4   +f6g3   +f7g2   +f8g1   +f9g0   ;
-        let mut carry0;
-        let carry1;
-        let carry2;
-        let carry3;
-        let mut carry4;
-        let carry5;
-        let carry6;
-        let carry7;
-        let carry8;
-        let carry9;
-
-        /*
-        |h0| <= (1.1*1.1*2^52*(1+19+19+19+19)+1.1*1.1*2^50*(38+38+38+38+38))
-          i.e. |h0| <= 1.2*2^59; narrower ranges for h2, h4, h6, h8
-        |h1| <= (1.1*1.1*2^51*(1+1+19+19+19+19+19+19+19+19))
-          i.e. |h1| <= 1.5*2^58; narrower ranges for h3, h5, h7, h9
-        */
-
-        carry0 = (h0 + (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
-        carry4 = (h4 + (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
-        /* |h0| <= 2^25 */
-        /* |h4| <= 2^25 */
-        /* |h1| <= 1.51*2^58 */
-        /* |h5| <= 1.51*2^58 */
-
-        carry1 = (h1 + (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
-        carry5 = (h5 + (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
-        /* |h1| <= 2^24; from now on fits into int32 */
-        /* |h5| <= 2^24; from now on fits into int32 */
-        /* |h2| <= 1.21*2^59 */
-        /* |h6| <= 1.21*2^59 */
-
-        carry2 = (h2 + (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
-        carry6 = (h6 + (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
-        /* |h2| <= 2^25; from now on fits into int32 unchanged */
-        /* |h6| <= 2^25; from now on fits into int32 unchanged */
-        /* |h3| <= 1.51*2^58 */
-        /* |h7| <= 1.51*2^58 */
-
-        carry3 = (h3 + (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
-        carry7 = (h7 + (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
-        /* |h3| <= 2^24; from now on fits into int32 unchanged */
-        /* |h7| <= 2^24; from now on fits into int32 unchanged */
-        /* |h4| <= 1.52*2^33 */
-        /* |h8| <= 1.52*2^33 */
-
-        carry4 = (h4 + (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
-        carry8 = (h8 + (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
-        /* |h4| <= 2^25; from now on fits into int32 unchanged */
-        /* |h8| <= 2^25; from now on fits into int32 unchanged */
-        /* |h5| <= 1.01*2^24 */
-        /* |h9| <= 1.51*2^58 */
-
-        carry9 = (h9 + (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
-        /* |h9| <= 2^24; from now on fits into int32 unchanged */
-        /* |h0| <= 1.8*2^37 */
-
-        carry0 = (h0 + (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
-        /* |h0| <= 2^25; from now on fits into int32 unchanged */
-        /* |h1| <= 1.01*2^24 */
-
-        Fe([h0 as i32, h1 as i32, h2 as i32, h3 as i32, h4 as i32,
-            h5 as i32, h6 as i32, h7 as i32, h8 as i32, h9 as i32])
-    }
-}
-
-impl Fe {
-    pub fn from_bytes(s: &[u8]) -> Fe {
-        let mut h0 = load_4i(&s[0..4]);
-        let mut h1 = load_3i(&s[4..7]) << 6;
-        let mut h2 = load_3i(&s[7..10]) << 5;
-        let mut h3 = load_3i(&s[10..13]) << 3;
-        let mut h4 = load_3i(&s[13..16]) << 2;
-        let mut h5 = load_4i(&s[16..20]);
-        let mut h6 = load_3i(&s[20..23]) << 7;
-        let mut h7 = load_3i(&s[23..26]) << 5;
-        let mut h8 = load_3i(&s[26..29]) << 4;
-        let mut h9 = (load_3i(&s[29..32]) & 8388607) << 2;
-
-        let carry9 = (h9 + (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
-        let carry1 = (h1 + (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
-        let carry3 = (h3 + (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
-        let carry5 = (h5 + (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
-        let carry7 = (h7 + (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
-
-        let carry0 = (h0 + (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
-        let carry2 = (h2 + (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
-        let carry4 = (h4 + (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
-        let carry6 = (h6 + (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
-        let carry8 = (h8 + (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
-
-        Fe([h0 as i32, h1 as i32, h2 as i32, h3 as i32, h4 as i32,
-            h5 as i32, h6 as i32, h7 as i32, h8 as i32, h9 as i32])
-    }
-
-    /*
-    Preconditions:
-      |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-
-    Write p=2^255-19; q=floor(h/p).
-    Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).
-
-    Proof:
-      Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
-      Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4.
-
-      Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
-      Then 0<y<1.
-
-      Write r=h-pq.
-      Have 0<=r<=p-1=2^255-20.
-      Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.
-
-      Write x=r+19(2^-255)r+y.
-      Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.
-
-      Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
-      so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.
-    */
-
-    pub fn to_bytes(&self) -> [u8; 32] {
-        let &Fe(es) = self;
-        let mut h0 = es[0];
-        let mut h1 = es[1];
-        let mut h2 = es[2];
-        let mut h3 = es[3];
-        let mut h4 = es[4];
-        let mut h5 = es[5];
-        let mut h6 = es[6];
-        let mut h7 = es[7];
-        let mut h8 = es[8];
-        let mut h9 = es[9];
-        let mut q;
-
-        q = (19 * h9 + (1 << 24)) >> 25;
-        q = (h0 + q) >> 26;
-        q = (h1 + q) >> 25;
-        q = (h2 + q) >> 26;
-        q = (h3 + q) >> 25;
-        q = (h4 + q) >> 26;
-        q = (h5 + q) >> 25;
-        q = (h6 + q) >> 26;
-        q = (h7 + q) >> 25;
-        q = (h8 + q) >> 26;
-        q = (h9 + q) >> 25;
-
-        /* Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20. */
-        h0 += 19 * q;
-        /* Goal: Output h-2^255 q, which is between 0 and 2^255-20. */
-
-        let carry0 = h0 >> 26; h1 += carry0; h0 -= carry0 << 26;
-        let carry1 = h1 >> 25; h2 += carry1; h1 -= carry1 << 25;
-        let carry2 = h2 >> 26; h3 += carry2; h2 -= carry2 << 26;
-        let carry3 = h3 >> 25; h4 += carry3; h3 -= carry3 << 25;
-        let carry4 = h4 >> 26; h5 += carry4; h4 -= carry4 << 26;
-        let carry5 = h5 >> 25; h6 += carry5; h5 -= carry5 << 25;
-        let carry6 = h6 >> 26; h7 += carry6; h6 -= carry6 << 26;
-        let carry7 = h7 >> 25; h8 += carry7; h7 -= carry7 << 25;
-        let carry8 = h8 >> 26; h9 += carry8; h8 -= carry8 << 26;
-        let carry9 = h9 >> 25;               h9 -= carry9 << 25;
-                            /* h10 = carry9 */
-
-        /*
-        Goal: Output h0+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
-        Have h0+...+2^230 h9 between 0 and 2^255-1;
-        evidently 2^255 h10-2^255 q = 0.
-        Goal: Output h0+...+2^230 h9.
-        */
-        [
-            (h0 >> 0) as u8,
-            (h0 >> 8) as u8,
-            (h0 >> 16) as u8,
-            ((h0 >> 24) | (h1 << 2)) as u8,
-            (h1 >> 6) as u8,
-            (h1 >> 14) as u8,
-            ((h1 >> 22) | (h2 << 3)) as u8,
-            (h2 >> 5) as u8,
-            (h2 >> 13) as u8,
-            ((h2 >> 21) | (h3 << 5)) as u8,
-            (h3 >> 3) as u8,
-            (h3 >> 11) as u8,
-            ((h3 >> 19) | (h4 << 6)) as u8,
-            (h4 >> 2) as u8,
-            (h4 >> 10) as u8,
-            (h4 >> 18) as u8,
-            (h5 >> 0) as u8,
-            (h5 >> 8) as u8,
-            (h5 >> 16) as u8,
-            ((h5 >> 24) | (h6 << 1)) as u8,
-            (h6 >> 7) as u8,
-            (h6 >> 15) as u8,
-            ((h6 >> 23) | (h7 << 3)) as u8,
-            (h7 >> 5) as u8,
-            (h7 >> 13) as u8,
-            ((h7 >> 21) | (h8 << 4)) as u8,
-            (h8 >> 4) as u8,
-            (h8 >> 12) as u8,
-            ((h8 >> 20) | (h9 << 6)) as u8,
-            (h9 >> 2) as u8,
-            (h9 >> 10) as u8,
-            (h9 >> 18) as u8,
-        ]
-    }
-
-    pub fn maybe_swap_with(&mut self, other: &mut Fe, do_swap: i32) {
-        let &mut Fe(f) = self;
-        let &mut Fe(g) = other;
-        let f0 = f[0];
-        let f1 = f[1];
-        let f2 = f[2];
-        let f3 = f[3];
-        let f4 = f[4];
-        let f5 = f[5];
-        let f6 = f[6];
-        let f7 = f[7];
-        let f8 = f[8];
-        let f9 = f[9];
-        let g0 = g[0];
-        let g1 = g[1];
-        let g2 = g[2];
-        let g3 = g[3];
-        let g4 = g[4];
-        let g5 = g[5];
-        let g6 = g[6];
-        let g7 = g[7];
-        let g8 = g[8];
-        let g9 = g[9];
-        let mut x0 = f0 ^ g0;
-        let mut x1 = f1 ^ g1;
-        let mut x2 = f2 ^ g2;
-        let mut x3 = f3 ^ g3;
-        let mut x4 = f4 ^ g4;
-        let mut x5 = f5 ^ g5;
-        let mut x6 = f6 ^ g6;
-        let mut x7 = f7 ^ g7;
-        let mut x8 = f8 ^ g8;
-        let mut x9 = f9 ^ g9;
-        let b = -do_swap;
-        x0 &= b;
-        x1 &= b;
-        x2 &= b;
-        x3 &= b;
-        x4 &= b;
-        x5 &= b;
-        x6 &= b;
-        x7 &= b;
-        x8 &= b;
-        x9 &= b;
-        *self  = Fe([f0^x0, f1^x1, f2^x2, f3^x3, f4^x4,
-                     f5^x5, f6^x6, f7^x7, f8^x8, f9^x9]);
-        *other = Fe([g0^x0, g1^x1, g2^x2, g3^x3, g4^x4,
-                     g5^x5, g6^x6, g7^x7, g8^x8, g9^x9]);
-    }
-
-    pub fn maybe_set(&mut self, other: &Fe, do_swap: i32) {
-        let &mut Fe(f) = self;
-        let &Fe(g) = other;
-        let f0 = f[0];
-        let f1 = f[1];
-        let f2 = f[2];
-        let f3 = f[3];
-        let f4 = f[4];
-        let f5 = f[5];
-        let f6 = f[6];
-        let f7 = f[7];
-        let f8 = f[8];
-        let f9 = f[9];
-        let g0 = g[0];
-        let g1 = g[1];
-        let g2 = g[2];
-        let g3 = g[3];
-        let g4 = g[4];
-        let g5 = g[5];
-        let g6 = g[6];
-        let g7 = g[7];
-        let g8 = g[8];
-        let g9 = g[9];
-        let mut x0 = f0 ^ g0;
-        let mut x1 = f1 ^ g1;
-        let mut x2 = f2 ^ g2;
-        let mut x3 = f3 ^ g3;
-        let mut x4 = f4 ^ g4;
-        let mut x5 = f5 ^ g5;
-        let mut x6 = f6 ^ g6;
-        let mut x7 = f7 ^ g7;
-        let mut x8 = f8 ^ g8;
-        let mut x9 = f9 ^ g9;
-        let b = -do_swap;
-        x0 &= b;
-        x1 &= b;
-        x2 &= b;
-        x3 &= b;
-        x4 &= b;
-        x5 &= b;
-        x6 &= b;
-        x7 &= b;
-        x8 &= b;
-        x9 &= b;
-        *self  = Fe([f0^x0, f1^x1, f2^x2, f3^x3, f4^x4,
-                     f5^x5, f6^x6, f7^x7, f8^x8, f9^x9]);
-    }
-
-    /*
-    h = f * 121666
-    Can overlap h with f.
-
-    Preconditions:
-       |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-
-    Postconditions:
-       |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-    */
-
-    fn mul_121666(&self) -> Fe {
-        let &Fe(f) = self;
-
-        let mut h0 = (f[0] as i64) * 121666;
-        let mut h1 = (f[1] as i64) * 121666;
-        let mut h2 = (f[2] as i64) * 121666;
-        let mut h3 = (f[3] as i64) * 121666;
-        let mut h4 = (f[4] as i64) * 121666;
-        let mut h5 = (f[5] as i64) * 121666;
-        let mut h6 = (f[6] as i64) * 121666;
-        let mut h7 = (f[7] as i64) * 121666;
-        let mut h8 = (f[8] as i64) * 121666;
-        let mut h9 = (f[9] as i64) * 121666;
-
-        let carry9 = (h9 + (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
-        let carry1 = (h1 + (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
-        let carry3 = (h3 + (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
-        let carry5 = (h5 + (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
-        let carry7 = (h7 + (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
-
-        let carry0 = (h0 + (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
-        let carry2 = (h2 + (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
-        let carry4 = (h4 + (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
-        let carry6 = (h6 + (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
-        let carry8 = (h8 + (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
-
-        Fe([h0 as i32, h1 as i32, h2 as i32, h3 as i32, h4 as i32,
-            h5 as i32, h6 as i32, h7 as i32, h8 as i32, h9 as i32])
-    }
-
-
-    /*
-    h = f * f
-    Can overlap h with f.
-
-    Preconditions:
-       |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-
-    Postconditions:
-       |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-    */
-
-    /*
-    See fe_mul.c for discussion of implementation strategy.
-    */
-    fn square(&self) -> Fe {
-        let &Fe(f) = self;
-
-        let f0 = f[0];
-        let f1 = f[1];
-        let f2 = f[2];
-        let f3 = f[3];
-        let f4 = f[4];
-        let f5 = f[5];
-        let f6 = f[6];
-        let f7 = f[7];
-        let f8 = f[8];
-        let f9 = f[9];
-        let f0_2 = 2 * f0;
-        let f1_2 = 2 * f1;
-        let f2_2 = 2 * f2;
-        let f3_2 = 2 * f3;
-        let f4_2 = 2 * f4;
-        let f5_2 = 2 * f5;
-        let f6_2 = 2 * f6;
-        let f7_2 = 2 * f7;
-        let f5_38 = 38 * f5; /* 1.31*2^30 */
-        let f6_19 = 19 * f6; /* 1.31*2^30 */
-        let f7_38 = 38 * f7; /* 1.31*2^30 */
-        let f8_19 = 19 * f8; /* 1.31*2^30 */
-        let f9_38 = 38 * f9; /* 1.31*2^30 */
-        let f0f0    = (f0   as i64) * (f0 as i64);
-        let f0f1_2  = (f0_2 as i64) * (f1 as i64);
-        let f0f2_2  = (f0_2 as i64) * (f2 as i64);
-        let f0f3_2  = (f0_2 as i64) * (f3 as i64);
-        let f0f4_2  = (f0_2 as i64) * (f4 as i64);
-        let f0f5_2  = (f0_2 as i64) * (f5 as i64);
-        let f0f6_2  = (f0_2 as i64) * (f6 as i64);
-        let f0f7_2  = (f0_2 as i64) * (f7 as i64);
-        let f0f8_2  = (f0_2 as i64) * (f8 as i64);
-        let f0f9_2  = (f0_2 as i64) * (f9 as i64);
-        let f1f1_2  = (f1_2 as i64) * (f1 as i64);
-        let f1f2_2  = (f1_2 as i64) * (f2 as i64);
-        let f1f3_4  = (f1_2 as i64) * (f3_2 as i64);
-        let f1f4_2  = (f1_2 as i64) * (f4 as i64);
-        let f1f5_4  = (f1_2 as i64) * (f5_2 as i64);
-        let f1f6_2  = (f1_2 as i64) * (f6 as i64);
-        let f1f7_4  = (f1_2 as i64) * (f7_2 as i64);
-        let f1f8_2  = (f1_2 as i64) * (f8 as i64);
-        let f1f9_76 = (f1_2 as i64) * (f9_38 as i64);
-        let f2f2    = (f2   as i64) * (f2 as i64);
-        let f2f3_2  = (f2_2 as i64) * (f3 as i64);
-        let f2f4_2  = (f2_2 as i64) * (f4 as i64);
-        let f2f5_2  = (f2_2 as i64) * (f5 as i64);
-        let f2f6_2  = (f2_2 as i64) * (f6 as i64);
-        let f2f7_2  = (f2_2 as i64) * (f7 as i64);
-        let f2f8_38 = (f2_2 as i64) * (f8_19 as i64);
-        let f2f9_38 = (f2   as i64) * (f9_38 as i64);
-        let f3f3_2  = (f3_2 as i64) * (f3 as i64);
-        let f3f4_2  = (f3_2 as i64) * (f4 as i64);
-        let f3f5_4  = (f3_2 as i64) * (f5_2 as i64);
-        let f3f6_2  = (f3_2 as i64) * (f6 as i64);
-        let f3f7_76 = (f3_2 as i64) * (f7_38 as i64);
-        let f3f8_38 = (f3_2 as i64) * (f8_19 as i64);
-        let f3f9_76 = (f3_2 as i64) * (f9_38 as i64);
-        let f4f4    = (f4   as i64) * (f4 as i64);
-        let f4f5_2  = (f4_2 as i64) * (f5 as i64);
-        let f4f6_38 = (f4_2 as i64) * (f6_19 as i64);
-        let f4f7_38 = (f4   as i64) * (f7_38 as i64);
-        let f4f8_38 = (f4_2 as i64) * (f8_19 as i64);
-        let f4f9_38 = (f4   as i64) * (f9_38 as i64);
-        let f5f5_38 = (f5   as i64) * (f5_38 as i64);
-        let f5f6_38 = (f5_2 as i64) * (f6_19 as i64);
-        let f5f7_76 = (f5_2 as i64) * (f7_38 as i64);
-        let f5f8_38 = (f5_2 as i64) * (f8_19 as i64);
-        let f5f9_76 = (f5_2 as i64) * (f9_38 as i64);
-        let f6f6_19 = (f6   as i64) * (f6_19 as i64);
-        let f6f7_38 = (f6   as i64) * (f7_38 as i64);
-        let f6f8_38 = (f6_2 as i64) * (f8_19 as i64);
-        let f6f9_38 = (f6   as i64) * (f9_38 as i64);
-        let f7f7_38 = (f7   as i64) * (f7_38 as i64);
-        let f7f8_38 = (f7_2 as i64) * (f8_19 as i64);
-        let f7f9_76 = (f7_2 as i64) * (f9_38 as i64);
-        let f8f8_19 = (f8   as i64) * (f8_19 as i64);
-        let f8f9_38 = (f8   as i64) * (f9_38 as i64);
-        let f9f9_38 = (f9   as i64) * (f9_38 as i64);
-        let mut h0 = f0f0  +f1f9_76+f2f8_38+f3f7_76+f4f6_38+f5f5_38;
-        let mut h1 = f0f1_2+f2f9_38+f3f8_38+f4f7_38+f5f6_38;
-        let mut h2 = f0f2_2+f1f1_2 +f3f9_76+f4f8_38+f5f7_76+f6f6_19;
-        let mut h3 = f0f3_2+f1f2_2 +f4f9_38+f5f8_38+f6f7_38;
-        let mut h4 = f0f4_2+f1f3_4 +f2f2   +f5f9_76+f6f8_38+f7f7_38;
-        let mut h5 = f0f5_2+f1f4_2 +f2f3_2 +f6f9_38+f7f8_38;
-        let mut h6 = f0f6_2+f1f5_4 +f2f4_2 +f3f3_2 +f7f9_76+f8f8_19;
-        let mut h7 = f0f7_2+f1f6_2 +f2f5_2 +f3f4_2 +f8f9_38;
-        let mut h8 = f0f8_2+f1f7_4 +f2f6_2 +f3f5_4 +f4f4   +f9f9_38;
-        let mut h9 = f0f9_2+f1f8_2 +f2f7_2 +f3f6_2 +f4f5_2;
-
-        let carry0 = (h0 + (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
-        let carry4 = (h4 + (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
-
-        let carry1 = (h1 + (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
-        let carry5 = (h5 + (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
-
-        let carry2 = (h2 + (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
-        let carry6 = (h6 + (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
-
-        let carry3 = (h3 + (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
-        let carry7 = (h7 + (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
-
-        let carry4 = (h4 + (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
-        let carry8 = (h8 + (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
-
-        let carry9 = (h9 + (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
-
-        let carrya = (h0 + (1<<25)) >> 26; h1 += carrya; h0 -= carrya << 26;
-
-        Fe([h0 as i32, h1 as i32, h2 as i32, h3 as i32, h4 as i32,
-            h5 as i32, h6 as i32, h7 as i32, h8 as i32, h9 as i32])
-    }
-
-    fn square_and_double(&self) -> Fe {
-        let &Fe(f) = self;
-
-        let f0 = f[0];
-        let f1 = f[1];
-        let f2 = f[2];
-        let f3 = f[3];
-        let f4 = f[4];
-        let f5 = f[5];
-        let f6 = f[6];
-        let f7 = f[7];
-        let f8 = f[8];
-        let f9 = f[9];
-        let f0_2 = 2 * f0;
-        let f1_2 = 2 * f1;
-        let f2_2 = 2 * f2;
-        let f3_2 = 2 * f3;
-        let f4_2 = 2 * f4;
-        let f5_2 = 2 * f5;
-        let f6_2 = 2 * f6;
-        let f7_2 = 2 * f7;
-        let f5_38 = 38 * f5; /* 1.959375*2^30 */
-        let f6_19 = 19 * f6; /* 1.959375*2^30 */
-        let f7_38 = 38 * f7; /* 1.959375*2^30 */
-        let f8_19 = 19 * f8; /* 1.959375*2^30 */
-        let f9_38 = 38 * f9; /* 1.959375*2^30 */
-        let f0f0    = (f0    as i64) * (f0 as i64);
-        let f0f1_2  = (f0_2  as i64) * (f1 as i64);
-        let f0f2_2  = (f0_2  as i64) * (f2 as i64);
-        let f0f3_2  = (f0_2  as i64) * (f3 as i64);
-        let f0f4_2  = (f0_2  as i64) * (f4 as i64);
-        let f0f5_2  = (f0_2  as i64) * (f5 as i64);
-        let f0f6_2  = (f0_2  as i64) * (f6 as i64);
-        let f0f7_2  = (f0_2  as i64) * (f7 as i64);
-        let f0f8_2  = (f0_2  as i64) * (f8 as i64);
-        let f0f9_2  = (f0_2  as i64) * (f9 as i64);
-        let f1f1_2  = (f1_2  as i64) * (f1 as i64);
-        let f1f2_2  = (f1_2  as i64) * (f2 as i64);
-        let f1f3_4  = (f1_2  as i64) * (f3_2 as i64);
-        let f1f4_2  = (f1_2  as i64) * (f4 as i64);
-        let f1f5_4  = (f1_2  as i64) * (f5_2 as i64);
-        let f1f6_2  = (f1_2  as i64) * (f6 as i64);
-        let f1f7_4  = (f1_2  as i64) * (f7_2 as i64);
-        let f1f8_2  = (f1_2  as i64) * (f8 as i64);
-        let f1f9_76 = (f1_2  as i64) * (f9_38 as i64);
-        let f2f2    = (f2    as i64) * (f2 as i64);
-        let f2f3_2  = (f2_2  as i64) * (f3 as i64);
-        let f2f4_2  = (f2_2  as i64) * (f4 as i64);
-        let f2f5_2  = (f2_2  as i64) * (f5 as i64);
-        let f2f6_2  = (f2_2  as i64) * (f6 as i64);
-        let f2f7_2  = (f2_2  as i64) * (f7 as i64);
-        let f2f8_38 = (f2_2  as i64) * (f8_19 as i64);
-        let f2f9_38 = (f2    as i64) * (f9_38 as i64);
-        let f3f3_2  = (f3_2  as i64) * (f3 as i64);
-        let f3f4_2  = (f3_2  as i64) * (f4 as i64);
-        let f3f5_4  = (f3_2  as i64) * (f5_2 as i64);
-        let f3f6_2  = (f3_2  as i64) * (f6 as i64);
-        let f3f7_76 = (f3_2  as i64) * (f7_38 as i64);
-        let f3f8_38 = (f3_2  as i64) * (f8_19 as i64);
-        let f3f9_76 = (f3_2  as i64) * (f9_38 as i64);
-        let f4f4    = (f4    as i64) * (f4 as i64);
-        let f4f5_2  = (f4_2  as i64) * (f5 as i64);
-        let f4f6_38 = (f4_2  as i64) * (f6_19 as i64);
-        let f4f7_38 = (f4    as i64) * (f7_38 as i64);
-        let f4f8_38 = (f4_2  as i64) * (f8_19 as i64);
-        let f4f9_38 = (f4    as i64) * (f9_38 as i64);
-        let f5f5_38 = (f5    as i64) * (f5_38 as i64);
-        let f5f6_38 = (f5_2  as i64) * (f6_19 as i64);
-        let f5f7_76 = (f5_2  as i64) * (f7_38 as i64);
-        let f5f8_38 = (f5_2  as i64) * (f8_19 as i64);
-        let f5f9_76 = (f5_2  as i64) * (f9_38 as i64);
-        let f6f6_19 = (f6    as i64) * (f6_19 as i64);
-        let f6f7_38 = (f6    as i64) * (f7_38 as i64);
-        let f6f8_38 = (f6_2  as i64) * (f8_19 as i64);
-        let f6f9_38 = (f6    as i64) * (f9_38 as i64);
-        let f7f7_38 = (f7    as i64) * (f7_38 as i64);
-        let f7f8_38 = (f7_2  as i64) * (f8_19 as i64);
-        let f7f9_76 = (f7_2  as i64) * (f9_38 as i64);
-        let f8f8_19 = (f8    as i64) * (f8_19 as i64);
-        let f8f9_38 = (f8    as i64) * (f9_38 as i64);
-        let f9f9_38 = (f9    as i64) * (f9_38 as i64);
-        let mut h0 = f0f0  +f1f9_76+f2f8_38+f3f7_76+f4f6_38+f5f5_38;
-        let mut h1 = f0f1_2+f2f9_38+f3f8_38+f4f7_38+f5f6_38;
-        let mut h2 = f0f2_2+f1f1_2 +f3f9_76+f4f8_38+f5f7_76+f6f6_19;
-        let mut h3 = f0f3_2+f1f2_2 +f4f9_38+f5f8_38+f6f7_38;
-        let mut h4 = f0f4_2+f1f3_4 +f2f2   +f5f9_76+f6f8_38+f7f7_38;
-        let mut h5 = f0f5_2+f1f4_2 +f2f3_2 +f6f9_38+f7f8_38;
-        let mut h6 = f0f6_2+f1f5_4 +f2f4_2 +f3f3_2 +f7f9_76+f8f8_19;
-        let mut h7 = f0f7_2+f1f6_2 +f2f5_2 +f3f4_2 +f8f9_38;
-        let mut h8 = f0f8_2+f1f7_4 +f2f6_2 +f3f5_4 +f4f4   +f9f9_38;
-        let mut h9 = f0f9_2+f1f8_2 +f2f7_2 +f3f6_2 +f4f5_2;
-        let mut carry0: i64;
-        let carry1: i64;
-        let carry2: i64;
-        let carry3: i64;
-        let mut carry4: i64;
-        let carry5: i64;
-        let carry6: i64;
-        let carry7: i64;
-        let carry8: i64;
-        let carry9: i64;
-
-        h0 += h0;
-        h1 += h1;
-        h2 += h2;
-        h3 += h3;
-        h4 += h4;
-        h5 += h5;
-        h6 += h6;
-        h7 += h7;
-        h8 += h8;
-        h9 += h9;
-
-        carry0 = (h0 + (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
-        carry4 = (h4 + (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
-
-        carry1 = (h1 + (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
-        carry5 = (h5 + (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
-
-        carry2 = (h2 + (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
-        carry6 = (h6 + (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
-
-        carry3 = (h3 + (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
-        carry7 = (h7 + (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
-
-        carry4 = (h4 + (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
-        carry8 = (h8 + (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
-
-        carry9 = (h9 + (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
-
-        carry0 = (h0 + (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
-
-        Fe([h0 as i32, h1 as i32, h2 as i32, h3 as i32, h4 as i32,
-            h5 as i32, h6 as i32, h7 as i32, h8 as i32, h9 as i32])
-    }
-
-    pub fn invert(&self) -> Fe {
-        let z1 = *self;
-
-        /* qhasm: z2 = z1^2^1 */
-        let z2 = z1.square();
-        /* qhasm: z8 = z2^2^2 */
-        let z8 = z2.square().square();
-        /* qhasm: z9 = z1*z8 */
-        let z9 = z1*z8;
-
-        /* qhasm: z11 = z2*z9 */
-        let z11 = z2*z9;
-
-        /* qhasm: z22 = z11^2^1 */
-        let z22 = z11.square();
-
-        /* qhasm: z_5_0 = z9*z22 */
-        let z_5_0 = z9*z22;
-
-        /* qhasm: z_10_5 = z_5_0^2^5 */
-        let z_10_5 = (0..5).fold(z_5_0, |z_5_n, _| z_5_n.square());
-
-        /* qhasm: z_10_0 = z_10_5*z_5_0 */
-        let z_10_0 = z_10_5*z_5_0;
-
-        /* qhasm: z_20_10 = z_10_0^2^10 */
-        let z_20_10 = (0..10).fold(z_10_0, |x, _| x.square());
-
-        /* qhasm: z_20_0 = z_20_10*z_10_0 */
-        let z_20_0 = z_20_10*z_10_0;
-
-        /* qhasm: z_40_20 = z_20_0^2^20 */
-        let z_40_20 = (0..20).fold(z_20_0, |x, _| x.square());
-
-        /* qhasm: z_40_0 = z_40_20*z_20_0 */
-        let z_40_0 = z_40_20*z_20_0;
-
-        /* qhasm: z_50_10 = z_40_0^2^10 */
-        let z_50_10 = (0..10).fold(z_40_0, |x, _| x.square());
-
-        /* qhasm: z_50_0 = z_50_10*z_10_0 */
-        let z_50_0 = z_50_10*z_10_0;
-
-        /* qhasm: z_100_50 = z_50_0^2^50 */
-        let z_100_50 = (0..50).fold(z_50_0, |x, _| x.square());
-
-        /* qhasm: z_100_0 = z_100_50*z_50_0 */
-        let z_100_0 = z_100_50*z_50_0;
-
-        /* qhasm: z_200_100 = z_100_0^2^100 */
-        let z_200_100 = (0..100).fold(z_100_0, |x, _| x.square());
-
-        /* qhasm: z_200_0 = z_200_100*z_100_0 */
-        /* asm 1: fe_mul(>z_200_0=fe#3,<z_200_100=fe#4,<z_100_0=fe#3); */
-        /* asm 2: fe_mul(>z_200_0=t2,<z_200_100=t3,<z_100_0=t2); */
-        let z_200_0 = z_200_100*z_100_0;
-
-        /* qhasm: z_250_50 = z_200_0^2^50 */
-        let z_250_50 = (0..50).fold(z_200_0, |x, _| x.square());
-
-        /* qhasm: z_250_0 = z_250_50*z_50_0 */
-        let z_250_0 = z_250_50*z_50_0;
-
-        /* qhasm: z_255_5 = z_250_0^2^5 */
-        let z_255_5 = (0..5).fold(z_250_0, |x, _| x.square());
-
-        /* qhasm: z_255_21 = z_255_5*z11 */
-        /* asm 1: fe_mul(>z_255_21=fe#12,<z_255_5=fe#2,<z11=fe#1); */
-        /* asm 2: fe_mul(>z_255_21=out,<z_255_5=t1,<z11=t0); */
-        let z_255_21 = z_255_5*z11;
-
-        z_255_21
-    }
-
-
-    fn is_nonzero(&self) -> bool {
-        let bs = self.to_bytes();
-        let zero = [0; 32];
-        !fixed_time_eq(bs.as_ref(), zero.as_ref())
-    }
-
-    fn is_negative(&self) -> bool {
-        (self.to_bytes()[0] & 1) != 0
-    }
-
-    fn neg(&self) -> Fe {
-        let &Fe(f) = self;
-        Fe([-f[0], -f[1], -f[2], -f[3], -f[4],
-            -f[5], -f[6], -f[7], -f[8], -f[9]])
-    }
-
-    fn pow25523(&self) -> Fe {
-        let z2 = self.square();
-        let z8 = (0..2).fold(z2, |x, _| x.square());
-        let z9 = *self * z8;
-        let z11 = z2 * z9;
-        let z22 = z11.square();
-        let z_5_0 = z9 * z22;
-        let z_10_5 = (0..5).fold(z_5_0, |x, _| x.square());
-        let z_10_0 = z_10_5 * z_5_0;
-        let z_20_10 = (0..10).fold(z_10_0, |x, _| x.square());
-        let z_20_0 = z_20_10 * z_10_0;
-        let z_40_20 = (0..20).fold(z_20_0, |x, _| x.square());
-        let z_40_0 = z_40_20 * z_20_0;
-        let z_50_10 = (0..10).fold(z_40_0, |x, _| x.square());
-        let z_50_0 = z_50_10 * z_10_0;
-        let z_100_50 = (0..50).fold(z_50_0, |x, _| x.square());
-        let z_100_0 = z_100_50 * z_50_0;
-        let z_200_100 = (0..100).fold(z_100_0, |x, _| x.square());
-        let z_200_0 = z_200_100 * z_100_0;
-        let z_250_50 = (0..50).fold(z_200_0, |x, _| x.square());
-        let z_250_0 = z_250_50 * z_50_0;
-        let z_252_2 = (0..2).fold(z_250_0, |x, _| x.square());
-        let z_252_3 = z_252_2 * *self;
-
-        z_252_3
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct GeP2 {
-    x: Fe,
-    y: Fe,
-    z: Fe,
-}
-
-#[derive(Clone, Copy)]
-pub struct GeP3 {
-    x: Fe,
-    y: Fe,
-    z: Fe,
-    t: Fe,
-}
-
-#[derive(Clone, Copy)]
-pub struct GeP1P1 {
-    x: Fe,
-    y: Fe,
-    z: Fe,
-    t: Fe,
-}
-
-#[derive(Clone, Copy)]
-pub struct GePrecomp {
-    y_plus_x: Fe,
-    y_minus_x: Fe,
-    xy2d: Fe,
-}
-
-#[derive(Clone, Copy)]
-pub struct GeCached {
-    y_plus_x: Fe,
-    y_minus_x: Fe,
-    z: Fe,
-    t2d: Fe,
-}
-
-impl GeP1P1 {
-    fn to_p2(&self) -> GeP2 {
-        GeP2 {
-            x: self.x * self.t,
-            y: self.y * self.z,
-            z: self.z * self.t,
-        }
-    }
-
-
-    fn to_p3(&self) -> GeP3 {
-        GeP3 {
-            x: self.x * self.t,
-            y: self.y * self.z,
-            z: self.z * self.t,
-            t: self.x * self.y,
-        }
-    }
-
-}
-
-impl GeP2 {
-    fn zero() -> GeP2 {
-        GeP2 {
-            x: FE_ZERO,
-            y: FE_ONE,
-            z: FE_ONE,
-        }
-    }
-
-    pub fn to_bytes(&self) -> [u8; 32] {
-        let recip = self.z.invert();
-        let x = self.x * recip;
-        let y = self.y * recip;
-        let mut bs = y.to_bytes();
-        bs[31] ^= (if x.is_negative() { 1 } else { 0 }) << 7;
-        bs
-    }
-
-    fn dbl(&self) -> GeP1P1 {
-        let xx = self.x.square();
-        let yy = self.y.square();
-        let b = self.z.square_and_double();
-        let a = self.x + self.y;
-        let aa = a.square();
-        let y3 = yy + xx;
-        let z3 = yy - xx;
-        let x3 = aa - y3;
-        let t3 = b - z3;
-
-        GeP1P1 { x: x3, y: y3, z: z3, t: t3 }
-    }
-
-    fn slide(a: &[u8]) -> [i8; 256] {
-        let mut r = [0i8; 256];
-        for i in 0..256 {
-            r[i] = (1 & (a[i >> 3] >> (i & 7))) as i8;
-        }
-        for i in 0..256 {
-            if r[i]!=0 {
-                for b in 1..min(7, 256-i) {
-                    if r[i + b] != 0 {
-                        if r[i] + (r[i + b] << b) <= 15 {
-                            r[i] += r[i + b] << b; r[i + b] = 0;
-                        } else if r[i] - (r[i + b] << b) >= -15 {
-                            r[i] -= r[i + b] << b;
-                            for k in i+b..256 {
-                                if r[k]==0 {
-                                    r[k] = 1;
-                                    break;
-                                }
-                                r[k] = 0;
-                            }
-                        } else {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        r
-    }
-
-    /*
-    r = a * A + b * B
-    where a = a[0]+256*a[1]+...+256^31 a[31].
-    and b = b[0]+256*b[1]+...+256^31 b[31].
-    B is the Ed25519 base point (x,4/5) with x positive.
-    */
-    pub fn double_scalarmult_vartime(a_scalar: &[u8], a_point: GeP3, b_scalar: &[u8]) -> GeP2 {
-        let aslide = GeP2::slide(a_scalar);
-        let bslide = GeP2::slide(b_scalar);
-
-        let mut ai = [GeCached{y_plus_x:FE_ZERO, y_minus_x: FE_ZERO, z: FE_ZERO, t2d: FE_ZERO}; 8]; /* A,3A,5A,7A,9A,11A,13A,15A */
-        ai[0] = a_point.to_cached();
-        let a2 = a_point.dbl().to_p3();
-        ai[1] = (a2 + ai[0]).to_p3().to_cached();
-        ai[2] = (a2 + ai[1]).to_p3().to_cached();
-        ai[3] = (a2 + ai[2]).to_p3().to_cached();
-        ai[4] = (a2 + ai[3]).to_p3().to_cached();
-        ai[5] = (a2 + ai[4]).to_p3().to_cached();
-        ai[6] = (a2 + ai[5]).to_p3().to_cached();
-        ai[7] = (a2 + ai[6]).to_p3().to_cached();
-
-        let mut r = GeP2::zero();
-
-        let mut i: usize = 255;
-        loop {
-            if aslide[i]!=0 || bslide[i]!=0 {
-                break;
-            }
-            if i==0 {
-                return r;
-            }
-            i -= 1;
-        }
-
-        loop {
-            let mut t = r.dbl();
-            if aslide[i] > 0 {
-                t = t.to_p3() + ai[(aslide[i]/2) as usize];
-            } else if aslide[i] < 0 {
-                t = t.to_p3() - ai[(-aslide[i]/2) as usize];
-            }
-
-            if bslide[i] > 0 {
-                t = t.to_p3() + BI[(bslide[i]/2) as usize];
-            } else if bslide[i] < 0 {
-                t = t.to_p3() - BI[(-bslide[i]/2) as usize];
-            }
-
-            r = t.to_p2();
-
-            if i==0 {
-                return r;
-            }
-            i -= 1;
-        }
-    }
-
-}
-
-impl GeP3 {
-    pub fn from_bytes_negate_vartime(s: &[u8]) -> Option<GeP3> {
-        let y = Fe::from_bytes(s);
-        let z = FE_ONE;
-        let y_squared = y.square();
-        let u = y_squared - FE_ONE;
-        let v = (y_squared * FE_D) + FE_ONE;
-        let v_raise_3 = v.square() * v;
-        let v_raise_7 = v_raise_3.square() * v;
-        let uv7 = v_raise_7 * u;// Is this commutative? u comes second in the code, but not in the notation...
-
-        let mut x = uv7.pow25523() * v_raise_3 * u;
-
-        let vxx = x.square() * v;
-        let check = vxx - u;
-        if check.is_nonzero() {
-            let check2 = vxx + u;
-            if check2.is_nonzero() {
-                return None;
-            }
-            x = x * FE_SQRTM1;
-        }
-
-        if x.is_negative() == ((s[31]>>7)!=0) {
-            x = x.neg();
-        }
-
-        let t = x * y;
-
-        Some(GeP3{x: x, y: y, z: z, t: t})
-    }
-
-    fn to_p2(&self) -> GeP2 {
-        GeP2 {
-            x: self.x,
-            y: self.y,
-            z: self.z,
-        }
-    }
-
-    fn to_cached(&self) -> GeCached {
-        GeCached {
-            y_plus_x: self.y + self.x,
-            y_minus_x: self.y - self.x,
-            z: self.z,
-            t2d: self.t * FE_D2
-        }
-    }
-
-    fn zero() -> GeP3 {
-        GeP3 {
-            x: FE_ZERO,
-            y: FE_ONE,
-            z: FE_ONE,
-            t: FE_ZERO,
-        }
-    }
-
-    fn dbl(&self) -> GeP1P1 {
-        self.to_p2().dbl()
-    }
-
-    pub fn to_bytes(&self) -> [u8; 32] {
-        let recip = self.z.invert();
-        let x = self.x * recip;
-        let y = self.y * recip;
-        let mut bs = y.to_bytes();
-        bs[31] ^= (if x.is_negative() { 1 } else { 0 }) << 7;
-        bs
-    }
-
-
-}
-
-impl Add<GeCached> for GeP3 {
-    type Output = GeP1P1;
-
-    fn add(self, _rhs: GeCached) -> GeP1P1 {
-        let y1_plus_x1 = self.y + self.x;
-        let y1_minus_x1 = self.y - self.x;
-        let a = y1_plus_x1 * _rhs.y_plus_x;
-        let b = y1_minus_x1 * _rhs.y_minus_x;
-        let c = _rhs.t2d * self.t;
-        let zz = self.z * _rhs.z;
-        let d = zz + zz;
-        let x3 = a - b;
-        let y3 = a + b;
-        let z3 = d + c;
-        let t3 = d - c;
-
-        GeP1P1 { x: x3, y: y3, z: z3, t: t3 }
-    }
-}
-
-impl Add<GePrecomp> for GeP3 {
-    type Output = GeP1P1;
-
-    fn add(self, _rhs: GePrecomp) -> GeP1P1 {
-        let y1_plus_x1 = self.y + self.x;
-        let y1_minus_x1 = self.y - self.x;
-        let a = y1_plus_x1 * _rhs.y_plus_x;
-        let b = y1_minus_x1 * _rhs.y_minus_x;
-        let c = _rhs.xy2d * self.t;
-        let d = self.z + self.z;
-        let x3 = a - b;
-        let y3 = a + b;
-        let z3 = d + c;
-        let t3 = d - c;
-
-        GeP1P1 { x: x3, y: y3, z: z3, t: t3 }
-    }
-}
-
-impl Sub<GeCached> for GeP3 {
-    type Output = GeP1P1;
-
-    fn sub(self, _rhs: GeCached) -> GeP1P1 {
-        let y1_plus_x1 = self.y + self.x;
-        let y1_minus_x1 = self.y - self.x;
-        let a = y1_plus_x1 * _rhs.y_minus_x;
-        let b = y1_minus_x1 * _rhs.y_plus_x;
-        let c = _rhs.t2d * self.t;
-        let zz = self.z * _rhs.z;
-        let d = zz + zz;
-        let x3 = a - b;
-        let y3 = a + b;
-        let z3 = d - c;
-        let t3 = d + c;
-
-        GeP1P1 { x: x3, y: y3, z: z3, t: t3 }
-    }
-}
-
-impl Sub<GePrecomp> for GeP3 {
-    type Output = GeP1P1;
-
-    fn sub(self, _rhs: GePrecomp) -> GeP1P1 {
-        let y1_plus_x1 = self.y + self.x;
-        let y1_minus_x1 = self.y - self.x;
-        let a = y1_plus_x1 * _rhs.y_minus_x;
-        let b = y1_minus_x1 * _rhs.y_plus_x;
-        let c = _rhs.xy2d * self.t;
-        let d = self.z + self.z;
-        let x3 = a - b;
-        let y3 = a + b;
-        let z3 = d - c;
-        let t3 = d + c;
-
-        GeP1P1 { x: x3, y: y3, z: z3, t: t3 }
-    }
-}
-
-fn equal(b: u8, c: u8) -> i32 {
-    let x = b ^ c; /* 0: yes; 1..255: no */
-    let mut y = x as u32; /* 0: yes; 1..255: no */
-    y = y.wrapping_sub(1); /* 4294967295: yes; 0..254: no */
-    y >>= 31; /* 1: yes; 0: no */
-    y as i32
-}
-
-
-
-impl GePrecomp {
-    fn zero() -> GePrecomp {
-        GePrecomp {
-            y_plus_x: FE_ONE,
-            y_minus_x: FE_ONE,
-            xy2d: FE_ZERO,
-        }
-    }
-
-    pub fn maybe_set(&mut self, other: &GePrecomp, do_swap: i32) {
-        self.y_plus_x.maybe_set(&other.y_plus_x, do_swap);
-        self.y_minus_x.maybe_set(&other.y_minus_x, do_swap);
-        self.xy2d.maybe_set(&other.xy2d, do_swap);
-    }
-
-    pub fn select(pos: usize, b: i8) -> GePrecomp {
-       let bnegative = (b as u8) >> 7;
-       let babs: u8 = (b - (((-(bnegative as i8)) & b) << 1)) as u8;
-       let mut t = GePrecomp::zero();
-       t.maybe_set(&GE_PRECOMP_BASE[pos][0], equal(babs, 1));
-       t.maybe_set(&GE_PRECOMP_BASE[pos][1], equal(babs, 2));
-       t.maybe_set(&GE_PRECOMP_BASE[pos][2], equal(babs, 3));
-       t.maybe_set(&GE_PRECOMP_BASE[pos][3], equal(babs, 4));
-       t.maybe_set(&GE_PRECOMP_BASE[pos][4], equal(babs, 5));
-       t.maybe_set(&GE_PRECOMP_BASE[pos][5], equal(babs, 6));
-       t.maybe_set(&GE_PRECOMP_BASE[pos][6], equal(babs, 7));
-       t.maybe_set(&GE_PRECOMP_BASE[pos][7], equal(babs, 8));
-       let minus_t = GePrecomp {
-           y_plus_x: t.y_minus_x,
-           y_minus_x: t.y_plus_x,
-           xy2d: t.xy2d.neg(),
-       };
-       t.maybe_set(&minus_t, bnegative as i32);
-       t
-    }
-}
-
-/*
-h = a * B
-where a = a[0]+256*a[1]+...+256^31 a[31]
-B is the Ed25519 base point (x,4/5) with x positive.
-
-Preconditions:
-  a[31] <= 127
-*/
-pub fn ge_scalarmult_base(a: &[u8]) -> GeP3 {
-    let mut es: [i8; 64] = [0; 64];
-    let mut r: GeP1P1;
-    let mut s: GeP2;
-    let mut t: GePrecomp;
-
-    for i in 0..32 {
-        es[2 * i + 0] = ((a[i] >> 0) & 15) as i8;
-        es[2 * i + 1] = ((a[i] >> 4) & 15) as i8;
-    }
-    /* each es[i] is between 0 and 15 */
-    /* es[63] is between 0 and 7 */
-
-    let mut carry: i8 = 0;
-    for i in 0..63 {
-        es[i] += carry;
-        carry = es[i] + 8;
-        carry >>= 4;
-        es[i] -= carry << 4;
-    }
-    es[63] += carry;
-    /* each es[i] is between -8 and 8 */
-
-    let mut h = GeP3::zero();
-    for i in (1..64).step_up(2) {
-        t = GePrecomp::select(i/2, es[i]);
-        r = h + t;
-        h = r.to_p3();
-    }
-
-    r = h.dbl(); s = r.to_p2();
-    r = s.dbl(); s = r.to_p2();
-    r = s.dbl(); s = r.to_p2();
-    r = s.dbl(); h = r.to_p3();
-
-    for i in (0..64).step_up(2) {
-        t = GePrecomp::select(i/2, es[i]);
-        r = h + t;
-        h = r.to_p3();
-    }
-
-    h
-}
-/*
-Input:
-    s[0]+256*s[1]+...+256^63*s[63] = s
-
-Output:
-    s[0]+256*s[1]+...+256^31*s[31] = s mod l
-    where l = 2^252 + 27742317777372353535851937790883648493.
-    Overwrites s in place.
-*/
-pub fn sc_reduce(s: &mut [u8]) {
-    let mut s0: i64 = 2097151 & load_3i(s);
-    let mut s1: i64 = 2097151 & (load_4i(&s[2..6]) >> 5);
-    let mut s2: i64 = 2097151 & (load_3i(&s[5..8]) >> 2);
-    let mut s3: i64 = 2097151 & (load_4i(&s[7..11]) >> 7);
-    let mut s4: i64 = 2097151 & (load_4i(&s[10..14]) >> 4);
-    let mut s5: i64 = 2097151 & (load_3i(&s[13..16]) >> 1);
-    let mut s6: i64 = 2097151 & (load_4i(&s[15..19]) >> 6);
-    let mut s7: i64 = 2097151 & (load_3i(&s[18..21]) >> 3);
-    let mut s8: i64 = 2097151 & load_3i(&s[21..24]);
-    let mut s9: i64 = 2097151 & (load_4i(&s[23..27]) >> 5);
-    let mut s10: i64 = 2097151 & (load_3i(&s[26..29]) >> 2);
-    let mut s11: i64 = 2097151 & (load_4i(&s[28..32]) >> 7);
-    let mut s12: i64 = 2097151 & (load_4i(&s[31..35]) >> 4);
-    let mut s13: i64 = 2097151 & (load_3i(&s[34..37]) >> 1);
-    let mut s14: i64 = 2097151 & (load_4i(&s[36..40]) >> 6);
-    let mut s15: i64 = 2097151 & (load_3i(&s[39..42]) >> 3);
-    let mut s16: i64 = 2097151 & load_3i(&s[42..45]);
-    let mut s17: i64 = 2097151 & (load_4i(&s[44..48]) >> 5);
-    let s18: i64 = 2097151 & (load_3i(&s[47..50]) >> 2);
-    let s19: i64 = 2097151 & (load_4i(&s[49..53]) >> 7);
-    let s20: i64 = 2097151 & (load_4i(&s[52..56]) >> 4);
-    let s21: i64 = 2097151 & (load_3i(&s[55..58]) >> 1);
-    let s22: i64 = 2097151 & (load_4i(&s[57..61]) >> 6);
-    let s23: i64 = load_4i(&s[60..64]) >> 3;
-    let mut carry0: i64;
-    let mut carry1: i64;
-    let mut carry2: i64;
-    let mut carry3: i64;
-    let mut carry4: i64;
-    let mut carry5: i64;
-    let mut carry6: i64;
-    let mut carry7: i64;
-    let mut carry8: i64;
-    let mut carry9: i64;
-    let mut carry10: i64;
-    let mut carry11: i64;
-    let carry12: i64;
-    let carry13: i64;
-    let carry14: i64;
-    let carry15: i64;
-    let carry16: i64;
-
-    s11 += s23 * 666643;
-    s12 += s23 * 470296;
-    s13 += s23 * 654183;
-    s14 -= s23 * 997805;
-    s15 += s23 * 136657;
-    s16 -= s23 * 683901;
-
-
-    s10 += s22 * 666643;
-    s11 += s22 * 470296;
-    s12 += s22 * 654183;
-    s13 -= s22 * 997805;
-    s14 += s22 * 136657;
-    s15 -= s22 * 683901;
-
-
-    s9 += s21 * 666643;
-    s10 += s21 * 470296;
-    s11 += s21 * 654183;
-    s12 -= s21 * 997805;
-    s13 += s21 * 136657;
-    s14 -= s21 * 683901;
-
-
-    s8 += s20 * 666643;
-    s9 += s20 * 470296;
-    s10 += s20 * 654183;
-    s11 -= s20 * 997805;
-    s12 += s20 * 136657;
-    s13 -= s20 * 683901;
-
-
-    s7 += s19 * 666643;
-    s8 += s19 * 470296;
-    s9 += s19 * 654183;
-    s10 -= s19 * 997805;
-    s11 += s19 * 136657;
-    s12 -= s19 * 683901;
-
-
-    s6 += s18 * 666643;
-    s7 += s18 * 470296;
-    s8 += s18 * 654183;
-    s9 -= s18 * 997805;
-    s10 += s18 * 136657;
-    s11 -= s18 * 683901;
-
-
-    carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
-    carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
-    carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
-    carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
-    carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
-    carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
-
-    carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
-    carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
-    carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
-    carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
-    carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
-
-    s5 += s17 * 666643;
-    s6 += s17 * 470296;
-    s7 += s17 * 654183;
-    s8 -= s17 * 997805;
-    s9 += s17 * 136657;
-    s10 -= s17 * 683901;
-
-
-    s4 += s16 * 666643;
-    s5 += s16 * 470296;
-    s6 += s16 * 654183;
-    s7 -= s16 * 997805;
-    s8 += s16 * 136657;
-    s9 -= s16 * 683901;
-
-
-    s3 += s15 * 666643;
-    s4 += s15 * 470296;
-    s5 += s15 * 654183;
-    s6 -= s15 * 997805;
-    s7 += s15 * 136657;
-    s8 -= s15 * 683901;
-
-
-    s2 += s14 * 666643;
-    s3 += s14 * 470296;
-    s4 += s14 * 654183;
-    s5 -= s14 * 997805;
-    s6 += s14 * 136657;
-    s7 -= s14 * 683901;
-
-
-    s1 += s13 * 666643;
-    s2 += s13 * 470296;
-    s3 += s13 * 654183;
-    s4 -= s13 * 997805;
-    s5 += s13 * 136657;
-    s6 -= s13 * 683901;
-
-
-    s0 += s12 * 666643;
-    s1 += s12 * 470296;
-    s2 += s12 * 654183;
-    s3 -= s12 * 997805;
-    s4 += s12 * 136657;
-    s5 -= s12 * 683901;
-    s12 = 0;
-
-    carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
-    carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
-    carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
-    carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
-    carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
-    carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
-
-    carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
-    carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
-    carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
-    carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
-    carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
-    carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
-
-    s0 += s12 * 666643;
-    s1 += s12 * 470296;
-    s2 += s12 * 654183;
-    s3 -= s12 * 997805;
-    s4 += s12 * 136657;
-    s5 -= s12 * 683901;
-    s12 = 0;
-
-    carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
-    carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
-    carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
-    carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
-    carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
-    carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
-    carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
-    carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
-    carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
-    carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
-    carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
-    carry11 = s11 >> 21; s12 += carry11; s11 -= carry11 << 21;
-
-    s0 += s12 * 666643;
-    s1 += s12 * 470296;
-    s2 += s12 * 654183;
-    s3 -= s12 * 997805;
-    s4 += s12 * 136657;
-    s5 -= s12 * 683901;
-
-
-    carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
-    carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
-    carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
-    carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
-    carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
-    carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
-    carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
-    carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
-    carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
-    carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
-    carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
-
-    s[0] = (s0 >> 0) as u8;
-    s[1] = (s0 >> 8) as u8;
-    s[2] = ((s0 >> 16) | (s1 << 5)) as u8;
-    s[3] = (s1 >> 3) as u8;
-    s[4] = (s1 >> 11) as u8;
-    s[5] = ((s1 >> 19) | (s2 << 2)) as u8;
-    s[6] = (s2 >> 6) as u8;
-    s[7] = ((s2 >> 14) | (s3 << 7)) as u8;
-    s[8] = (s3 >> 1) as u8;
-    s[9] = (s3 >> 9) as u8;
-    s[10] = ((s3 >> 17) | (s4 << 4)) as u8;
-    s[11] = (s4 >> 4) as u8;
-    s[12] = (s4 >> 12) as u8;
-    s[13] = ((s4 >> 20) | (s5 << 1)) as u8;
-    s[14] = (s5 >> 7) as u8;
-    s[15] = ((s5 >> 15) | (s6 << 6)) as u8;
-    s[16] = (s6 >> 2) as u8;
-    s[17] = (s6 >> 10) as u8;
-    s[18] = ((s6 >> 18) | (s7 << 3)) as u8;
-    s[19] = (s7 >> 5) as u8;
-    s[20] = (s7 >> 13) as u8;
-    s[21] = (s8 >> 0) as u8;
-    s[22] = (s8 >> 8) as u8;
-    s[23] = ((s8 >> 16) | (s9 << 5)) as u8;
-    s[24] = (s9 >> 3) as u8;
-    s[25] = (s9 >> 11) as u8;
-    s[26] = ((s9 >> 19) | (s10 << 2)) as u8;
-    s[27] = (s10 >> 6) as u8;
-    s[28] = ((s10 >> 14) | (s11 << 7)) as u8;
-    s[29] = (s11 >> 1) as u8;
-    s[30] = (s11 >> 9) as u8;
-    s[31] = (s11 >> 17) as u8;
-}
-
-
-/*
-Input:
-    a[0]+256*a[1]+...+256^31*a[31] = a
-    b[0]+256*b[1]+...+256^31*b[31] = b
-    c[0]+256*c[1]+...+256^31*c[31] = c
-
-Output:
-    s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
-    where l = 2^252 + 27742317777372353535851937790883648493.
-*/
-pub fn sc_muladd(s: &mut[u8], a: &[u8], b: &[u8], c: &[u8]) {
-    let a0 = 2097151 & load_3i(&a[0..3]);
-    let a1 = 2097151 & (load_4i(&a[2..6]) >> 5);
-    let a2 = 2097151 & (load_3i(&a[5..8]) >> 2);
-    let a3 = 2097151 & (load_4i(&a[7..11]) >> 7);
-    let a4 = 2097151 & (load_4i(&a[10..14]) >> 4);
-    let a5 = 2097151 & (load_3i(&a[13..16]) >> 1);
-    let a6 = 2097151 & (load_4i(&a[15..19]) >> 6);
-    let a7 = 2097151 & (load_3i(&a[18..21]) >> 3);
-    let a8 = 2097151 & load_3i(&a[21..24]);
-    let a9 = 2097151 & (load_4i(&a[23..27]) >> 5);
-    let a10 = 2097151 & (load_3i(&a[26..29]) >> 2);
-    let a11 = load_4i(&a[28..32]) >> 7;
-    let b0 = 2097151 & load_3i(&b[0..3]);
-    let b1 = 2097151 & (load_4i(&b[2..6]) >> 5);
-    let b2 = 2097151 & (load_3i(&b[5..8]) >> 2);
-    let b3 = 2097151 & (load_4i(&b[7..11]) >> 7);
-    let b4 = 2097151 & (load_4i(&b[10..14]) >> 4);
-    let b5 = 2097151 & (load_3i(&b[13..16]) >> 1);
-    let b6 = 2097151 & (load_4i(&b[15..19]) >> 6);
-    let b7 = 2097151 & (load_3i(&b[18..21]) >> 3);
-    let b8 = 2097151 & load_3i(&b[21..24]);
-    let b9 = 2097151 & (load_4i(&b[23..27]) >> 5);
-    let b10 = 2097151 & (load_3i(&b[26..29]) >> 2);
-    let b11 = load_4i(&b[28..32]) >> 7;
-    let c0 = 2097151 & load_3i(&c[0..3]);
-    let c1 = 2097151 & (load_4i(&c[2..6]) >> 5);
-    let c2 = 2097151 & (load_3i(&c[5..8]) >> 2);
-    let c3 = 2097151 & (load_4i(&c[7..11]) >> 7);
-    let c4 = 2097151 & (load_4i(&c[10..14]) >> 4);
-    let c5 = 2097151 & (load_3i(&c[13..16]) >> 1);
-    let c6 = 2097151 & (load_4i(&c[15..19]) >> 6);
-    let c7 = 2097151 & (load_3i(&c[18..21]) >> 3);
-    let c8 = 2097151 & load_3i(&c[21..24]);
-    let c9 = 2097151 & (load_4i(&c[23..27]) >> 5);
-    let c10 = 2097151 & (load_3i(&c[26..29]) >> 2);
-    let c11 = load_4i(&c[28..32]) >> 7;
-    let mut s0: i64;
-    let mut s1: i64;
-    let mut s2: i64;
-    let mut s3: i64;
-    let mut s4: i64;
-    let mut s5: i64;
-    let mut s6: i64;
-    let mut s7: i64;
-    let mut s8: i64;
-    let mut s9: i64;
-    let mut s10: i64;
-    let mut s11: i64;
-    let mut s12: i64;
-    let mut s13: i64;
-    let mut s14: i64;
-    let mut s15: i64;
-    let mut s16: i64;
-    let mut s17: i64;
-    let mut s18: i64;
-    let mut s19: i64;
-    let mut s20: i64;
-    let mut s21: i64;
-    let mut s22: i64;
-    let mut s23: i64;
-    let mut carry0: i64;
-    let mut carry1: i64;
-    let mut carry2: i64;
-    let mut carry3: i64;
-    let mut carry4: i64;
-    let mut carry5: i64;
-    let mut carry6: i64;
-    let mut carry7: i64;
-    let mut carry8: i64;
-    let mut carry9: i64;
-    let mut carry10: i64;
-    let mut carry11: i64;
-    let mut carry12: i64;
-    let mut carry13: i64;
-    let mut carry14: i64;
-    let mut carry15: i64;
-    let mut carry16: i64;
-    let carry17: i64;
-    let carry18: i64;
-    let carry19: i64;
-    let carry20: i64;
-    let carry21: i64;
-    let carry22: i64;
-
-    s0 = c0 + a0*b0;
-    s1 = c1 + a0*b1 + a1*b0;
-    s2 = c2 + a0*b2 + a1*b1 + a2*b0;
-    s3 = c3 + a0*b3 + a1*b2 + a2*b1 + a3*b0;
-    s4 = c4 + a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0;
-    s5 = c5 + a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0;
-    s6 = c6 + a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0;
-    s7 = c7 + a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0;
-    s8 = c8 + a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0;
-    s9 = c9 + a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0;
-    s10 = c10 + a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0;
-    s11 = c11 + a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0;
-    s12 = a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1;
-    s13 = a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2;
-    s14 = a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3;
-    s15 = a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4;
-    s16 = a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5;
-    s17 = a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6;
-    s18 = a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7;
-    s19 = a8*b11 + a9*b10 + a10*b9 + a11*b8;
-    s20 = a9*b11 + a10*b10 + a11*b9;
-    s21 = a10*b11 + a11*b10;
-    s22 = a11*b11;
-    s23 = 0;
-
-    carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
-    carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
-    carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
-    carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
-    carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
-    carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
-    carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
-    carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
-    carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
-    carry18 = (s18 + (1<<20)) >> 21; s19 += carry18; s18 -= carry18 << 21;
-    carry20 = (s20 + (1<<20)) >> 21; s21 += carry20; s20 -= carry20 << 21;
-    carry22 = (s22 + (1<<20)) >> 21; s23 += carry22; s22 -= carry22 << 21;
-
-    carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
-    carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
-    carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
-    carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
-    carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
-    carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
-    carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
-    carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
-    carry17 = (s17 + (1<<20)) >> 21; s18 += carry17; s17 -= carry17 << 21;
-    carry19 = (s19 + (1<<20)) >> 21; s20 += carry19; s19 -= carry19 << 21;
-    carry21 = (s21 + (1<<20)) >> 21; s22 += carry21; s21 -= carry21 << 21;
-
-    s11 += s23 * 666643;
-    s12 += s23 * 470296;
-    s13 += s23 * 654183;
-    s14 -= s23 * 997805;
-    s15 += s23 * 136657;
-    s16 -= s23 * 683901;
-
-
-    s10 += s22 * 666643;
-    s11 += s22 * 470296;
-    s12 += s22 * 654183;
-    s13 -= s22 * 997805;
-    s14 += s22 * 136657;
-    s15 -= s22 * 683901;
-
-
-    s9 += s21 * 666643;
-    s10 += s21 * 470296;
-    s11 += s21 * 654183;
-    s12 -= s21 * 997805;
-    s13 += s21 * 136657;
-    s14 -= s21 * 683901;
-
-
-    s8 += s20 * 666643;
-    s9 += s20 * 470296;
-    s10 += s20 * 654183;
-    s11 -= s20 * 997805;
-    s12 += s20 * 136657;
-    s13 -= s20 * 683901;
-
-
-    s7 += s19 * 666643;
-    s8 += s19 * 470296;
-    s9 += s19 * 654183;
-    s10 -= s19 * 997805;
-    s11 += s19 * 136657;
-    s12 -= s19 * 683901;
-
-
-    s6 += s18 * 666643;
-    s7 += s18 * 470296;
-    s8 += s18 * 654183;
-    s9 -= s18 * 997805;
-    s10 += s18 * 136657;
-    s11 -= s18 * 683901;
-
-
-    carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
-    carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
-    carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
-    carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
-    carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
-    carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
-
-    carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
-    carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
-    carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
-    carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
-    carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
-
-    s5 += s17 * 666643;
-    s6 += s17 * 470296;
-    s7 += s17 * 654183;
-    s8 -= s17 * 997805;
-    s9 += s17 * 136657;
-    s10 -= s17 * 683901;
-
-
-    s4 += s16 * 666643;
-    s5 += s16 * 470296;
-    s6 += s16 * 654183;
-    s7 -= s16 * 997805;
-    s8 += s16 * 136657;
-    s9 -= s16 * 683901;
-
-
-    s3 += s15 * 666643;
-    s4 += s15 * 470296;
-    s5 += s15 * 654183;
-    s6 -= s15 * 997805;
-    s7 += s15 * 136657;
-    s8 -= s15 * 683901;
-
-
-    s2 += s14 * 666643;
-    s3 += s14 * 470296;
-    s4 += s14 * 654183;
-    s5 -= s14 * 997805;
-    s6 += s14 * 136657;
-    s7 -= s14 * 683901;
-
-
-    s1 += s13 * 666643;
-    s2 += s13 * 470296;
-    s3 += s13 * 654183;
-    s4 -= s13 * 997805;
-    s5 += s13 * 136657;
-    s6 -= s13 * 683901;
-
-
-    s0 += s12 * 666643;
-    s1 += s12 * 470296;
-    s2 += s12 * 654183;
-    s3 -= s12 * 997805;
-    s4 += s12 * 136657;
-    s5 -= s12 * 683901;
-    s12 = 0;
-
-    carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
-    carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
-    carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
-    carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
-    carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
-    carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
-
-    carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
-    carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
-    carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
-    carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
-    carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
-    carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
-
-    s0 += s12 * 666643;
-    s1 += s12 * 470296;