[ring][rustls] Bump ring to 0.14.3, rustls to 0.15.0

This bumps ring to 0.14.3, and rustls to 0.15.0. This also
incidentally:

* update base64 to 0.10.0
* update sct to 0.5.0
* update webpki to 0.19.1

Test: CQ
Change-Id: I8498cad3d729a6c4f5e484aa2defc7ac1e042592
diff --git a/rustc_deps/Cargo.lock b/rustc_deps/Cargo.lock
index 3a57fe9..3ce7018 100644
--- a/rustc_deps/Cargo.lock
+++ b/rustc_deps/Cargo.lock
@@ -104,6 +104,14 @@
 ]
 
 [[package]]
+name = "base64"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "byteorder 1.2.7 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
 name = "bincode"
 version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -522,11 +530,11 @@
  "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ring 0.13.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ring 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "rouille 2.2.0 (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)",
- "rustls 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustls 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "rusttype 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.84 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.84 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1417,7 +1425,7 @@
 
 [[package]]
 name = "ring"
-version = "0.13.5"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "cc 1.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1481,15 +1489,15 @@
 
 [[package]]
 name = "rustls"
-version = "0.14.0"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "ring 0.13.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "sct 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ring 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "sct 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "untrusted 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "webpki 0.18.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "webpki 0.19.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1544,10 +1552,10 @@
 
 [[package]]
 name = "sct"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "ring 0.13.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ring 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "untrusted 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -2010,10 +2018,10 @@
 
 [[package]]
 name = "webpki"
-version = "0.18.1"
+version = "0.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "ring 0.13.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ring 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "untrusted 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -2121,6 +2129,7 @@
 "checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652"
 "checksum autocfg 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4e5f34df7a019573fb8bdc7e24a2bfebe51a2a1d6bfdbaeccedb3c41fc574727"
 "checksum backtrace 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)" = "b5b493b66e03090ebc4343eb02f94ff944e0cbc9ac6571491d170ba026741eb5"
+"checksum base64 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "621fc7ecb8008f86d7fb9b95356cd692ce9514b80a86d85b397f32a22da7b9e2"
 "checksum base64 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7c4a342b450b268e1be8036311e2c613d7f8a7ed31214dff1cc3b60852a3168d"
 "checksum base64 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"
 "checksum bincode 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9a6301db0b49fb63551bc15b5ae348147101cdf323242b93ec7546d5002ff1af"
@@ -2263,12 +2272,12 @@
 "checksum regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "37e7cbbd370869ce2e8dff25c7018702d10b21a20ef7135316f8daecd6c25b7f"
 "checksum regex-syntax 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4e47a2ed29da7a9e1960e1639e7a982e6edc6d49be308a3b02daf511504a16d1"
 "checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
-"checksum ring 0.13.5 (registry+https://github.com/rust-lang/crates.io-index)" = "2c4db68a2e35f3497146b7e4563df7d4773a2433230c5e4b448328e31740458a"
+"checksum ring 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)" = "be5386a5f59e5f5bcaea38b50ad26c09e3918a0abc0610640b3be5cfd85d6894"
 "checksum rouille 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0845b9c39ba772da769fe2aaa4d81bfd10695a7ea051d0510702260ff4159841"
 "checksum rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "adacaae16d02b6ec37fdc7acfcddf365978de76d1983d3ee22afc260e1ca9619"
 "checksum rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)" = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
 "checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-"checksum rustls 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8b7891791343c75b73ed9a18cadcafd8c8563d11a88ebe2d87f5b8a3182654d9"
+"checksum rustls 0.15.0 (registry+https://github.com/rust-lang/crates.io-index)" = "658a37e5aa4f69d50c5b1fff01cff75551be9576cedcadb63df97f7ddbb16d5f"
 "checksum rusttype 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "436c67ae0d0d24f14e1177c3ed96780ee16db82b405f0fba1bb80b46c9a30625"
 "checksum rusty-fork 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9591f190d2852720b679c21f66ad929f9f1d7bb09d1193c26167586029d8489c"
 "checksum ryu 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "eb9e9b8cde282a9fe6a42dd4681319bfb63f121b8a8ee9439c6f4107e58a46f7"
@@ -2276,7 +2285,7 @@
 "checksum safemem 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8dca453248a96cb0749e36ccdfe2b0b4e54a61bfef89fb97ec621eb8e0a93dd9"
 "checksum same-file 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8f20c4be53a8a1ff4c1f1b2bd14570d2f634628709752f0702ecdd2b3f9a5267"
 "checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
-"checksum sct 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "cb8f61f9e6eadd062a71c380043d28036304a4706b3c4dd001ff3387ed00745a"
+"checksum sct 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2f5adf8fbd58e1b1b52699dc8bed2630faecb6d8c7bee77d009d6bbe4af569b9"
 "checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
 "checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 "checksum serde 1.0.84 (registry+https://github.com/rust-lang/crates.io-index)" = "0e732ed5a5592c17d961555e3b552985baf98d50ce418b7b655f31f6ba7eb1b7"
@@ -2335,7 +2344,7 @@
 "checksum wait-timeout 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "b9f3bf741a801531993db6478b95682117471f76916f5e690dd8d45395b09349"
 "checksum walkdir 2.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "9d9d7ed3431229a144296213105a390676cc49c9b6a72bd19f3176c98e129fa1"
 "checksum want 0.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "797464475f30ddb8830cc529aaaae648d581f99e2036a928877dfde027ddf6b3"
-"checksum webpki 0.18.1 (registry+https://github.com/rust-lang/crates.io-index)" = "17d7967316d8411ca3b01821ee6c332bde138ba4363becdb492f12e514daa17f"
+"checksum webpki 0.19.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4f7e1cd7900a3a6b65a3e8780c51a3e6b59c0e2c55c6dc69578c288d69f7d082"
 "checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
 "checksum xml-rs 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c1cb601d29fe2c2ac60a2b2e5e293994d87a1f6fa9687a31a15270f909be9c2"
 "checksum xml-rs 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "541b12c998c5b56aa2b4e6f18f03664eef9a4fd0a246a55594efae6cc2d964b5"
diff --git a/rustc_deps/Cargo.toml b/rustc_deps/Cargo.toml
index 00ab0d3..b42af17 100644
--- a/rustc_deps/Cargo.toml
+++ b/rustc_deps/Cargo.toml
@@ -52,12 +52,12 @@
 pest_derive = "2.1"
 proptest = "0.8.7"
 rand = "0.5"
-ring = { version = "0.13", features = [ "rsa_signing" ] }
+ring = "0.14"
 regex = "1.0.6"
 rouille = "2.1.0"
 rust-crypto = "0.2"
 rustc-serialize = "0.3"
-rustls = "0.14"
+rustls = "0.15"
 rusttype = "0.7.3"
 serde = "1"
 serde_derive = "1"
diff --git a/rustc_deps/vendor/base64-0.9.3/.cargo-checksum.json b/rustc_deps/vendor/base64-0.9.3/.cargo-checksum.json
new file mode 100644
index 0000000..87b3839
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"c155ba2131467bbda05a4c8aca4cf40c4a62d2ddce183a79695513948470aee7","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0dd882e53de11566d50f8e8e2d5a651bcf3fabee4987d70f306233cf39094ba7","README.md":"f4319521a3683eebd5bf96d166b4d5a8c52fb8480b8b7724661ac38a9b89d7aa","RELEASE-NOTES.md":"a9eb191e951b968e230a9499e955f22056687a184f05fb7f138b30cbc4669f5a","benches/benchmarks.rs":"bfc990dfa1716acf5bbd7189b3d7438145a9441833d6e4a796d2ce4428e55e14","examples/make_tables.rs":"e7c3e665874faa10ff1906420eb5182d1b725bcd30ff0d6da719bb368683e197","src/chunked_encoder.rs":"3d92a8241ed6d1a402ad1c1a8c7aa9c736b62cecc4071f44bc29b1b7cc70488c","src/decode.rs":"968c9c13746338ea307d3ff0b528df7a4fa20c7a1071c6adc1fb23c573741b57","src/display.rs":"d8ec9fa3f2b03640b026bbdfd817cd76454e1bb9b6ae53bd793334cd0a4ac62e","src/encode.rs":"c38c64582105ea698c5d1ec1596f5f1d99cfc1fb894226b79c5c8e96f73e6541","src/lib.rs":"4aeed1db6057b03532b20c34dbb822c1edcb0b5a2c21cdd50e7ac6b06858843a","src/line_wrap.rs":"fd136457629b803417bd25eb191fd3665bb57b8726fc4d74e7325e499e4e88af","src/tables.rs":"10b09997ed9765dc46c2d1f0df21b915d88c4f47a292b5c7df5c1851e724fb03","src/tests.rs":"cf0ddeb01b2149041b7ea99a881b6f149b1630110c5c2eedee6b1f44e873ea6c","tests/decode.rs":"c06a7595a0ac708961a180d4a8393f6d377b56028f75b29e6e34fd8451d84226","tests/encode.rs":"2eb3c8f81a4f807be69d1dfb0857625130017b0fa7037f7168f434c886cc851b","tests/helpers.rs":"a76015e4a4e8f98213bdbaa592cd9574ccdc95a28e1b1f835a2753e09fa6037f","tests/tests.rs":"13929406ba13504ff49d1a16a2578a87c560834fba0eaad78edecf0793261b0e"},"package":"489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/base64-0.9.3/Cargo.toml b/rustc_deps/vendor/base64-0.9.3/Cargo.toml
new file mode 100644
index 0000000..667272d
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/Cargo.toml
@@ -0,0 +1,32 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g. crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "base64"
+version = "0.9.3"
+authors = ["Alice Maz <alice@alicemaz.com>", "Marshall Pierce <marshall@mpierce.org>"]
+description = "encodes and decodes base64 as bytes or utf8"
+documentation = "https://github.com/alicemaz/rust-base64/blob/master/README.md"
+readme = "README.md"
+keywords = ["base64", "utf8", "encode", "decode"]
+categories = ["encoding"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/alicemaz/rust-base64"
+[profile.bench]
+debug = true
+[dependencies.byteorder]
+version = "1.1.0"
+
+[dependencies.safemem]
+version = "0.3"
+[dev-dependencies.rand]
+version = "0.4"
diff --git a/rustc_deps/vendor/base64-0.9.3/LICENSE-APACHE b/rustc_deps/vendor/base64-0.9.3/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/rustc_deps/vendor/base64-0.9.3/LICENSE-MIT b/rustc_deps/vendor/base64-0.9.3/LICENSE-MIT
new file mode 100644
index 0000000..7bc10f8
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/LICENSE-MIT
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Alice Maz
+
+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/base64-0.9.3/README.md b/rustc_deps/vendor/base64-0.9.3/README.md
new file mode 100644
index 0000000..0805bd2
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/README.md
@@ -0,0 +1,102 @@
+[base64](https://crates.io/crates/base64)
+===
+[![](https://img.shields.io/crates/v/base64.svg)](https://crates.io/crates/base64) [![Docs](https://docs.rs/base64/badge.svg)](https://docs.rs/base64)
+
+It's base64. What more could anyone want?
+
+Example
+---
+
+```rust
+extern crate base64;
+
+use base64::{encode, decode};
+
+fn main() {
+    let a = b"hello world";
+    let b = "aGVsbG8gd29ybGQ=";
+
+    assert_eq!(encode(a), b);
+    assert_eq!(a, &decode(b).unwrap()[..]);
+}
+```
+
+See the [docs](https://docs.rs/base64) for all the details.
+
+Purpose
+---
+
+I have a fondness for small dependency footprints, ecosystems where you can pick and choose what functionality you need, and no more. Unix philosophy sort of thing I guess, many tiny utilities interoperating across a common interface. One time making a Twitter bot, I ran into the need to correctly pluralize arbitrary words. I found on npm a module that did nothing but pluralize words. Nothing else, just a couple of functions. I'd like for this to be that "just a couple of functions."
+
+Developing
+---
+
+Benchmarks are in `benches/`. Running them requires nightly rust, but `rustup` makes it easy:
+
+```
+rustup run nightly cargo bench
+```
+
+Decoding is aided by some pre-calculated tables, which are generated by:
+
+```
+cargo run --example make_tables > src/tables.rs.tmp && mv src/tables.rs.tmp src/tables.rs
+```
+
+Profiling
+---
+
+On Linux, you can use [perf](https://perf.wiki.kernel.org/index.php/Main_Page) for profiling. Then compile the benchmarks with `rustup nightly run cargo bench --no-run`.
+
+Run the benchmark binary with `perf` (shown here filtering to one particular benchmark, which will make the results easier to read). `perf` is only available to the root user on most systems as it fiddles with event counters in your CPU, so use `sudo`. We need to run the actual benchmark binary, hence the path into `target`. You can see the actual full path with `rustup run nightly cargo bench -v`; it will print out the commands it runs. If you use the exact path that `bench` outputs, make sure you get the one that's for the benchmarks, not the tests. You may also want to `cargo clean` so you have only one `benchmarks-` binary (they tend to accumulate).
+
+```
+sudo perf record target/release/deps/benchmarks-* --bench decode_10mib_reuse
+```
+
+Then analyze the results, again with perf:
+
+```
+sudo perf annotate -l
+```
+
+You'll see a bunch of interleaved rust source and assembly like this. The section with `lib.rs:327` is telling us that 4.02% of samples saw the `movzbl` aka bit shift as the active instruction. However, this percentage is not as exact as it seems due to a phenomenon called *skid*. Basically, a consequence of how fancy modern CPUs are is that this sort of instruction profiling is inherently inaccurate, especially in branch-heavy code.
+
+```
+ lib.rs:322    0.70 :     10698:       mov    %rdi,%rax
+    2.82 :        1069b:       shr    $0x38,%rax
+         :                  if morsel == decode_tables::INVALID_VALUE {
+         :                      bad_byte_index = input_index;
+         :                      break;
+         :                  };
+         :                  accum = (morsel as u64) << 58;
+ lib.rs:327    4.02 :     1069f:       movzbl (%r9,%rax,1),%r15d
+         :              // fast loop of 8 bytes at a time
+         :              while input_index < length_of_full_chunks {
+         :                  let mut accum: u64;
+         :
+         :                  let input_chunk = BigEndian::read_u64(&input_bytes[input_index..(input_index + 8)]);
+         :                  morsel = decode_table[(input_chunk >> 56) as usize];
+ lib.rs:322    3.68 :     106a4:       cmp    $0xff,%r15
+         :                  if morsel == decode_tables::INVALID_VALUE {
+    0.00 :        106ab:       je     1090e <base64::decode_config_buf::hbf68a45fefa299c1+0x46e>
+```
+
+
+Fuzzing
+---
+
+This uses [cargo-fuzz](https://github.com/rust-fuzz/cargo-fuzz). See `fuzz/fuzzers` for the available fuzzing scripts. To run, use an invocation like these:
+
+```
+cargo +nightly fuzz run roundtrip
+cargo +nightly fuzz run roundtrip_no_pad
+cargo +nightly fuzz run roundtrip_mime -- -max_len=10240
+cargo +nightly fuzz run roundtrip_random_config -- -max_len=10240
+```
+
+
+License
+---
+
+This project is dual-licensed under MIT and Apache 2.0.
diff --git a/rustc_deps/vendor/base64-0.9.3/RELEASE-NOTES.md b/rustc_deps/vendor/base64-0.9.3/RELEASE-NOTES.md
new file mode 100644
index 0000000..c15de78
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/RELEASE-NOTES.md
@@ -0,0 +1,62 @@
+# 0.9.3
+
+- Update safemem
+
+# 0.9.2
+
+- Derive `Clone` for `DecodeError`.
+
+# 0.9.1
+
+- Add support for `crypt(3)`'s base64 variant.
+
+# 0.9.0
+
+- `decode_config_slice` function for no-allocation decoding, analogous to `encode_config_slice`
+- Decode performance optimization
+
+# 0.8.0
+
+- `encode_config_slice` function for no-allocation encoding
+
+# 0.7.0
+
+- `STANDARD_NO_PAD` config
+- `Base64Display` heap-free wrapper for use in format strings, etc
+
+# 0.6.0
+
+- Decode performance improvements
+- Use `unsafe` in fewer places
+- Added fuzzers
+
+# 0.5.2
+
+- Avoid usize overflow when calculating length
+- Better line wrapping performance
+
+# 0.5.1
+
+- Temporarily disable line wrapping
+- Add Apache 2.0 license
+
+# 0.5.0
+
+- MIME support, including configurable line endings and line wrapping
+- Removed `decode_ws`
+- Renamed `Base64Error` to `DecodeError`
+
+# 0.4.1
+
+- Allow decoding a `AsRef<[u8]>` instead of just a `&str`
+
+# 0.4.0
+
+- Configurable padding
+- Encode performance improvements
+
+# 0.3.0
+
+- Added encode/decode functions that do not allocate their own storage
+- Decode performance improvements
+- Extraneous padding bytes are no longer ignored. Now, an error will be returned.
diff --git a/rustc_deps/vendor/base64-0.9.3/benches/benchmarks.rs b/rustc_deps/vendor/base64-0.9.3/benches/benchmarks.rs
new file mode 100644
index 0000000..533bea8
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/benches/benchmarks.rs
@@ -0,0 +1,345 @@
+#![feature(test)]
+
+extern crate base64;
+extern crate rand;
+extern crate test;
+
+use base64::display;
+use base64::{decode, decode_config_buf, decode_config_slice, encode, encode_config_buf,
+             encode_config_slice, Config, MIME, STANDARD};
+
+use rand::Rng;
+use test::Bencher;
+
+#[bench]
+fn encode_3b(b: &mut Bencher) {
+    do_encode_bench(b, 3)
+}
+
+#[bench]
+fn encode_3b_reuse_buf(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 3, STANDARD)
+}
+
+#[bench]
+fn encode_3b_slice(b: &mut Bencher) {
+    do_encode_bench_slice(b, 3, STANDARD)
+}
+
+#[bench]
+fn encode_50b(b: &mut Bencher) {
+    do_encode_bench(b, 50)
+}
+
+#[bench]
+fn encode_50b_display(b: &mut Bencher) {
+    do_encode_bench_display(b, 50)
+}
+
+#[bench]
+fn encode_50b_reuse_buf(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 50, STANDARD)
+}
+
+#[bench]
+fn encode_50b_slice(b: &mut Bencher) {
+    do_encode_bench_slice(b, 50, STANDARD)
+}
+
+#[bench]
+fn encode_100b(b: &mut Bencher) {
+    do_encode_bench(b, 100)
+}
+
+#[bench]
+fn encode_100b_reuse_buf(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 100, STANDARD)
+}
+
+#[bench]
+fn encode_500b(b: &mut Bencher) {
+    do_encode_bench(b, 500)
+}
+
+#[bench]
+fn encode_500b_reuse_buf(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 500, STANDARD)
+}
+
+#[bench]
+fn encode_500b_reuse_buf_mime(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 500, MIME)
+}
+
+#[bench]
+fn encode_3kib(b: &mut Bencher) {
+    do_encode_bench(b, 3 * 1024)
+}
+
+#[bench]
+fn encode_3kib_display(b: &mut Bencher) {
+    do_encode_bench_display(b, 3 * 1024)
+}
+
+#[bench]
+fn encode_3kib_reuse_buf(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 3 * 1024, STANDARD)
+}
+
+#[bench]
+fn encode_3kib_slice(b: &mut Bencher) {
+    do_encode_bench_slice(b, 3 * 1024, STANDARD)
+}
+
+#[bench]
+fn encode_3kib_reuse_buf_mime(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 3 * 1024, MIME)
+}
+
+#[bench]
+fn encode_3mib(b: &mut Bencher) {
+    do_encode_bench(b, 3 * 1024 * 1024)
+}
+
+#[bench]
+fn encode_3mib_display(b: &mut Bencher) {
+    do_encode_bench_display(b, 3 * 1024 * 1024)
+}
+
+#[bench]
+fn encode_3mib_reuse_buf(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 3 * 1024 * 1024, STANDARD)
+}
+
+#[bench]
+fn encode_3mib_slice(b: &mut Bencher) {
+    do_encode_bench_slice(b, 3 * 1024 * 1024, STANDARD)
+}
+
+#[bench]
+fn encode_10mib(b: &mut Bencher) {
+    do_encode_bench(b, 10 * 1024 * 1024)
+}
+
+#[bench]
+fn encode_10mib_reuse_buf(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 10 * 1024 * 1024, STANDARD)
+}
+
+#[bench]
+fn encode_30mib(b: &mut Bencher) {
+    do_encode_bench(b, 30 * 1024 * 1024)
+}
+
+#[bench]
+fn encode_30mib_reuse_buf(b: &mut Bencher) {
+    do_encode_bench_reuse_buf(b, 30 * 1024 * 1024, STANDARD)
+}
+
+#[bench]
+fn encode_30mib_slice(b: &mut Bencher) {
+    do_encode_bench_slice(b, 30 * 1024 * 1024, STANDARD)
+}
+
+#[bench]
+fn decode_3b(b: &mut Bencher) {
+    do_decode_bench(b, 3)
+}
+
+#[bench]
+fn decode_3b_reuse_buf(b: &mut Bencher) {
+    do_decode_bench_reuse_buf(b, 3)
+}
+
+#[bench]
+fn decode_3b_slice(b: &mut Bencher) {
+    do_decode_bench_slice(b, 3)
+}
+
+#[bench]
+fn decode_50b(b: &mut Bencher) {
+    do_decode_bench(b, 50)
+}
+
+#[bench]
+fn decode_50b_reuse_buf(b: &mut Bencher) {
+    do_decode_bench_reuse_buf(b, 50)
+}
+
+#[bench]
+fn decode_50b_slice(b: &mut Bencher) {
+    do_decode_bench_slice(b, 50)
+}
+
+#[bench]
+fn decode_100b(b: &mut Bencher) {
+    do_decode_bench(b, 100)
+}
+
+#[bench]
+fn decode_100b_reuse_buf(b: &mut Bencher) {
+    do_decode_bench_reuse_buf(b, 100)
+}
+
+#[bench]
+fn decode_500b(b: &mut Bencher) {
+    do_decode_bench(b, 500)
+}
+
+#[bench]
+fn decode_500b_reuse_buf(b: &mut Bencher) {
+    do_decode_bench_reuse_buf(b, 500)
+}
+
+#[bench]
+fn decode_3kib(b: &mut Bencher) {
+    do_decode_bench(b, 3 * 1024)
+}
+
+#[bench]
+fn decode_3kib_reuse_buf(b: &mut Bencher) {
+    do_decode_bench_reuse_buf(b, 3 * 1024)
+}
+
+#[bench]
+fn decode_3kib_slice(b: &mut Bencher) {
+    do_decode_bench_slice(b, 3 * 1024)
+}
+
+#[bench]
+fn decode_3mib(b: &mut Bencher) {
+    do_decode_bench(b, 3 * 1024 * 1024)
+}
+
+#[bench]
+fn decode_3mib_reuse_buf(b: &mut Bencher) {
+    do_decode_bench_reuse_buf(b, 3 * 1024 * 1024)
+}
+
+#[bench]
+fn decode_3mib_slice(b: &mut Bencher) {
+    do_decode_bench_slice(b, 3 * 1024 * 1024)
+}
+
+#[bench]
+fn decode_10mib(b: &mut Bencher) {
+    do_decode_bench(b, 10 * 1024 * 1024)
+}
+
+#[bench]
+fn decode_10mib_reuse_buf(b: &mut Bencher) {
+    do_decode_bench_reuse_buf(b, 10 * 1024 * 1024)
+}
+
+#[bench]
+fn decode_30mib(b: &mut Bencher) {
+    do_decode_bench(b, 30 * 1024 * 1024)
+}
+
+#[bench]
+fn decode_30mib_reuse_buf(b: &mut Bencher) {
+    do_decode_bench_reuse_buf(b, 30 * 1024 * 1024)
+}
+
+#[bench]
+fn decode_30mib_slice(b: &mut Bencher) {
+    do_decode_bench_slice(b, 30 * 1024 * 1024)
+}
+
+fn do_decode_bench(b: &mut Bencher, size: usize) {
+    let mut v: Vec<u8> = Vec::with_capacity(size * 3 / 4);
+    fill(&mut v);
+    let encoded = encode(&v);
+
+    b.bytes = encoded.len() as u64;
+    b.iter(|| {
+        let orig = decode(&encoded);
+        test::black_box(&orig);
+    });
+}
+
+fn do_decode_bench_reuse_buf(b: &mut Bencher, size: usize) {
+    let mut v: Vec<u8> = Vec::with_capacity(size * 3 / 4);
+    fill(&mut v);
+    let encoded = encode(&v);
+
+    let mut buf = Vec::new();
+    b.bytes = encoded.len() as u64;
+    b.iter(|| {
+        decode_config_buf(&encoded, STANDARD, &mut buf).unwrap();
+        test::black_box(&buf);
+        buf.clear();
+    });
+}
+
+fn do_decode_bench_slice(b: &mut Bencher, size: usize) {
+    let mut v: Vec<u8> = Vec::with_capacity(size * 3 / 4);
+    fill(&mut v);
+    let encoded = encode(&v);
+
+    let mut buf = Vec::new();
+    buf.resize(size, 0);
+    b.bytes = encoded.len() as u64;
+    b.iter(|| {
+        decode_config_slice(&encoded, STANDARD, &mut buf).unwrap();
+        test::black_box(&buf);
+    });
+}
+
+fn do_encode_bench(b: &mut Bencher, size: usize) {
+    let mut v: Vec<u8> = Vec::with_capacity(size);
+    fill(&mut v);
+
+    b.bytes = v.len() as u64;
+    b.iter(|| {
+        let e = encode(&v);
+        test::black_box(&e);
+    });
+}
+
+fn do_encode_bench_display(b: &mut Bencher, size: usize) {
+    let mut v: Vec<u8> = Vec::with_capacity(size);
+    fill(&mut v);
+
+    b.bytes = v.len() as u64;
+    b.iter(|| {
+        let e = format!("{}", display::Base64Display::standard(&v));
+        test::black_box(&e);
+    });
+}
+
+fn do_encode_bench_reuse_buf(b: &mut Bencher, size: usize, config: Config) {
+    let mut v: Vec<u8> = Vec::with_capacity(size);
+    fill(&mut v);
+
+    let mut buf = String::new();
+
+    b.bytes = v.len() as u64;
+    b.iter(|| {
+        encode_config_buf(&v, config, &mut buf);
+        buf.clear();
+    });
+}
+
+fn do_encode_bench_slice(b: &mut Bencher, size: usize, config: Config) {
+    let mut v: Vec<u8> = Vec::with_capacity(size);
+    fill(&mut v);
+
+    let mut buf = Vec::new();
+
+    b.bytes = v.len() as u64;
+    // conservative estimate of encoded size
+    buf.resize(size * 2, 0);
+    b.iter(|| {
+        encode_config_slice(&v, config, &mut buf);
+    });
+}
+
+fn fill(v: &mut Vec<u8>) {
+    let cap = v.capacity();
+    // weak randomness is plenty; we just want to not be completely friendly to the branch predictor
+    let mut r = rand::weak_rng();
+    while v.len() < cap {
+        v.push(r.gen::<u8>());
+    }
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/examples/make_tables.rs b/rustc_deps/vendor/base64-0.9.3/examples/make_tables.rs
new file mode 100644
index 0000000..f8d6f37
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/examples/make_tables.rs
@@ -0,0 +1,116 @@
+use std::collections::HashMap;
+use std::iter::Iterator;
+
+fn main() {
+    println!("pub const INVALID_VALUE: u8 = 255;");
+
+    // A-Z
+    let standard_alphabet: Vec<u8> = (0x41..0x5B)
+        // a-z
+        .chain(0x61..0x7B)
+        // 0-9
+        .chain(0x30..0x3A)
+        // +
+        .chain(0x2B..0x2C)
+        // /
+        .chain(0x2F..0x30)
+        .collect();
+    print_encode_table(&standard_alphabet, "STANDARD_ENCODE", 0);
+    print_decode_table(&standard_alphabet, "STANDARD_DECODE", 0);
+
+    // A-Z
+    let url_alphabet: Vec<u8> = (0x41..0x5B)
+        // a-z
+        .chain(0x61..0x7B)
+        // 0-9
+        .chain(0x30..0x3A)
+        // -
+        .chain(0x2D..0x2E)
+        // _s
+        .chain(0x5F..0x60)
+        .collect();
+    print_encode_table(&url_alphabet, "URL_SAFE_ENCODE", 0);
+    print_decode_table(&url_alphabet, "URL_SAFE_DECODE", 0);
+
+    // ./0123456789
+    let crypt_alphabet: Vec<u8> = (b'.'..(b'9'+1))
+        // A-Z
+        .chain(b'A'..(b'Z'+1))
+        // a-z
+        .chain(b'a'..(b'z'+1))
+        .collect();
+    print_encode_table(&crypt_alphabet, "CRYPT_ENCODE", 0);
+    print_decode_table(&crypt_alphabet, "CRYPT_DECODE", 0);
+}
+
+fn print_encode_table(alphabet: &[u8], const_name: &str, indent_depth: usize) {
+    println!("#[cfg_attr(rustfmt, rustfmt_skip)]");
+    println!(
+        "{:width$}pub const {}: &'static [u8; 64] = &[",
+        "",
+        const_name,
+        width = indent_depth
+    );
+
+    for (i, b) in alphabet.iter().enumerate() {
+        println!(
+            "{:width$}{}, // input {} (0x{:X}) => '{}' (0x{:X})",
+            "",
+            b,
+            i,
+            i,
+            String::from_utf8(vec![*b as u8]).unwrap(),
+            b,
+            width = indent_depth + 4
+        );
+    }
+
+    println!("{:width$}];", "", width = indent_depth);
+}
+
+fn print_decode_table(alphabet: &[u8], const_name: &str, indent_depth: usize) {
+    // map of alphabet bytes to 6-bit morsels
+    let mut input_to_morsel = HashMap::<u8, u8>::new();
+
+    // standard base64 alphabet bytes, in order
+    for (morsel, ascii_byte) in alphabet.iter().enumerate() {
+        // truncation cast is fine here
+        let _ = input_to_morsel.insert(*ascii_byte, morsel as u8);
+    }
+
+    println!("#[cfg_attr(rustfmt, rustfmt_skip)]");
+    println!(
+        "{:width$}pub const {}: &'static [u8; 256] = &[",
+        "",
+        const_name,
+        width = indent_depth
+    );
+    for ascii_byte in 0..256 {
+        let (value, comment) = match input_to_morsel.get(&(ascii_byte as u8)) {
+            None => (
+                "INVALID_VALUE".to_string(),
+                format!("input {} (0x{:X})", ascii_byte, ascii_byte),
+            ),
+            Some(v) => (
+                format!("{}", *v),
+                format!(
+                    "input {} (0x{:X} char '{}') => {} (0x{:X})",
+                    ascii_byte,
+                    ascii_byte,
+                    String::from_utf8(vec![ascii_byte as u8]).unwrap(),
+                    *v,
+                    *v
+                ),
+            ),
+        };
+
+        println!(
+            "{:width$}{}, // {}",
+            "",
+            value,
+            comment,
+            width = indent_depth + 4
+        );
+    }
+    println!("{:width$}];", "", width = indent_depth);
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/src/chunked_encoder.rs b/rustc_deps/vendor/base64-0.9.3/src/chunked_encoder.rs
new file mode 100644
index 0000000..e472b07
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/src/chunked_encoder.rs
@@ -0,0 +1,509 @@
+use encode::{add_padding, encode_to_slice};
+use line_wrap::line_wrap;
+use std::cmp;
+use {Config, LineEnding, LineWrap};
+
+/// The output mechanism for ChunkedEncoder's encoded bytes.
+pub trait Sink {
+    type Error;
+
+    /// Handle a chunk of encoded base64 data (as UTF-8 bytes)
+    fn write_encoded_bytes(&mut self, encoded: &[u8]) -> Result<(), Self::Error>;
+}
+
+#[derive(Debug, PartialEq)]
+pub enum ChunkedEncoderError {
+    /// If wrapping is configured, the line length must be a multiple of 4, and must not be absurdly
+    /// large (see BUF_SIZE).
+    InvalidLineLength,
+}
+
+const BUF_SIZE: usize = 1024;
+
+/// A base64 encoder that emits encoded bytes in chunks without heap allocation.
+pub struct ChunkedEncoder {
+    config: Config,
+    max_input_chunk_len: usize,
+}
+
+impl ChunkedEncoder {
+    pub fn new(config: Config) -> Result<ChunkedEncoder, ChunkedEncoderError> {
+        Ok(ChunkedEncoder {
+            config,
+            max_input_chunk_len: max_input_length(BUF_SIZE, &config)?,
+        })
+    }
+
+    pub fn encode<S: Sink>(&self, bytes: &[u8], sink: &mut S) -> Result<(), S::Error> {
+        let mut encode_buf: [u8; BUF_SIZE] = [0; BUF_SIZE];
+        let encode_table = self.config.char_set.encode_table();
+
+        let mut input_index = 0;
+
+        while input_index < bytes.len() {
+            // either the full input chunk size, or it's the last iteration
+            let input_chunk_len = cmp::min(self.max_input_chunk_len, bytes.len() - input_index);
+
+            let chunk = &bytes[input_index..(input_index + input_chunk_len)];
+
+            let mut b64_bytes_written = encode_to_slice(chunk, &mut encode_buf, encode_table);
+
+            input_index += input_chunk_len;
+            let more_input_left = input_index < bytes.len();
+
+            if self.config.pad && !more_input_left {
+                // no more input, add padding if needed. Buffer will have room because
+                // max_input_length leaves room for it.
+                b64_bytes_written += add_padding(bytes.len(), &mut encode_buf[b64_bytes_written..]);
+            }
+
+            let line_ending_bytes = match self.config.line_wrap {
+                LineWrap::NoWrap => 0,
+                LineWrap::Wrap(line_len, line_ending) => {
+                    let initial_line_ending_bytes =
+                        line_wrap(&mut encode_buf, b64_bytes_written, line_len, line_ending);
+
+                    if more_input_left {
+                        assert_eq!(input_chunk_len, self.max_input_chunk_len);
+                        // If there are more bytes of input, then we know we didn't just do the
+                        // last chunk. line_wrap() doesn't put an ending after the last line, so we
+                        // append one more line ending here. Since the chunk just encoded was not
+                        // the last one, it was multiple of the line length (max_input_chunk_len),
+                        // and therefore we can just put the line ending bytes at the end of the
+                        // contents of the buffer.
+                        match line_ending {
+                            LineEnding::LF => {
+                                encode_buf[b64_bytes_written + initial_line_ending_bytes] = b'\n';
+                                initial_line_ending_bytes + 1
+                            }
+                            LineEnding::CRLF => {
+                                encode_buf[b64_bytes_written + initial_line_ending_bytes] = b'\r';
+                                encode_buf[b64_bytes_written + initial_line_ending_bytes + 1] =
+                                    b'\n';
+                                initial_line_ending_bytes + 2
+                            }
+                        }
+                    } else {
+                        initial_line_ending_bytes
+                    }
+                }
+            };
+
+            let total_bytes_written = b64_bytes_written + line_ending_bytes;
+
+            sink.write_encoded_bytes(&encode_buf[0..total_bytes_written])?;
+        }
+
+        Ok(())
+    }
+}
+
+/// Calculate the longest input that can be encoded for the given output buffer size.
+///
+/// If config requires line wrap, the calculated input length will be the maximum number of input
+/// lines that can fit in the output buffer after each line has had its line ending appended.
+///
+/// If the config requires padding, two bytes of buffer space will be set aside so that the last
+/// chunk of input can be encoded safely.
+///
+/// The input length will always be a multiple of 3 so that no encoding state has to be carried over
+/// between chunks.
+///
+/// If the configured line length is not divisible by 4 (and therefore would require carrying
+/// encoder state between chunks), or if the line length is too big for the buffer, an error will be
+/// returned.
+///
+/// Note that the last overall line of input should *not* have an ending appended, but this will
+/// conservatively calculate space as if it should because encoding is done in chunks, and all the
+/// chunks before the last one will need a line ending after the last encoded line in that chunk.
+fn max_input_length(encoded_buf_len: usize, config: &Config) -> Result<usize, ChunkedEncoderError> {
+    let effective_buf_len = if config.pad {
+        // make room for padding
+        encoded_buf_len
+            .checked_sub(2)
+            .expect("Don't use a tiny buffer")
+    } else {
+        encoded_buf_len
+    };
+
+    match config.line_wrap {
+        // No wrapping, no padding, so just normal base64 expansion.
+        LineWrap::NoWrap => Ok((effective_buf_len / 4) * 3),
+        LineWrap::Wrap(line_len, line_ending) => {
+            // To avoid complicated encode buffer shuffling, only allow line lengths that are
+            // multiples of 4 (which map to input lengths that are multiples of 3).
+            // line_len is never 0.
+            if line_len % 4 != 0 {
+                return Err(ChunkedEncoderError::InvalidLineLength);
+            }
+
+            let single_encoded_full_line_with_ending_len = line_len
+                .checked_add(line_ending.len())
+                .expect("Encoded line length with ending exceeds usize");
+
+            // max number of complete lines with endings that will fit in buffer
+            let num_encoded_wrapped_lines_in_buffer =
+                effective_buf_len / single_encoded_full_line_with_ending_len;
+
+            if num_encoded_wrapped_lines_in_buffer == 0 {
+                // line + ending is longer than can fit into encode buffer; give up
+                Err(ChunkedEncoderError::InvalidLineLength)
+            } else {
+                let input_len_for_line_len = (line_len / 4) * 3;
+
+                let input_len = input_len_for_line_len
+                    .checked_mul(num_encoded_wrapped_lines_in_buffer)
+                    .expect("Max input size exceeds usize");
+
+                assert!(input_len % 3 == 0 && input_len > 1);
+
+                Ok(input_len)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    extern crate rand;
+
+    use super::*;
+    use tests::random_config;
+    use *;
+
+    use std::str;
+
+    use self::rand::distributions::{IndependentSample, Range};
+    use self::rand::Rng;
+
+    #[test]
+    fn chunked_encode_empty() {
+        assert_eq!("", chunked_encode_str(&[], STANDARD));
+    }
+
+    #[test]
+    fn chunked_encode_intermediate_fast_loop() {
+        // > 8 bytes input, will enter the pretty fast loop
+        assert_eq!(
+            "Zm9vYmFyYmF6cXV4",
+            chunked_encode_str(b"foobarbazqux", STANDARD)
+        );
+    }
+
+    #[test]
+    fn chunked_encode_fast_loop() {
+        // > 32 bytes input, will enter the uber fast loop
+        assert_eq!(
+            "Zm9vYmFyYmF6cXV4cXV1eGNvcmdlZ3JhdWx0Z2FycGx5eg==",
+            chunked_encode_str(b"foobarbazquxquuxcorgegraultgarplyz", STANDARD)
+        );
+    }
+
+    #[test]
+    fn chunked_encode_slow_loop_only() {
+        // < 8 bytes input, slow loop only
+        assert_eq!("Zm9vYmFy", chunked_encode_str(b"foobar", STANDARD));
+    }
+
+    #[test]
+    fn chunked_encode_line_wrap_padding() {
+        // < 8 bytes input, slow loop only
+        let config = config_wrap(true, 4, LineEnding::LF);
+        assert_eq!(
+            "Zm9v\nYmFy\nZm9v\nYmFy\nZg==",
+            chunked_encode_str(b"foobarfoobarf", config)
+        );
+    }
+
+    #[test]
+    fn chunked_encode_longer_than_one_buffer_adds_final_line_wrap_lf() {
+        // longest line len possible
+        let config = config_wrap(false, 1020, LineEnding::LF);
+        let input = vec![0xFF; 768];
+        let encoded = chunked_encode_str(&input, config);
+        // got a line wrap
+        assert_eq!(1024 + 1, encoded.len());
+
+        for &b in encoded.as_bytes()[0..1020].iter() {
+            // ascii /
+            assert_eq!(47, b);
+        }
+
+        assert_eq!(10, encoded.as_bytes()[1020]);
+
+        for &b in encoded.as_bytes()[1021..].iter() {
+            // ascii /
+            assert_eq!(47, b);
+        }
+    }
+
+    #[test]
+    fn chunked_encode_longer_than_one_buffer_adds_final_line_wrap_crlf() {
+        // longest line len possible
+        let config = config_wrap(false, 1020, LineEnding::CRLF);
+        let input = vec![0xFF; 768];
+        let encoded = chunked_encode_str(&input, config);
+        // got a line wrap
+        assert_eq!(1024 + 2, encoded.len());
+
+        for &b in encoded.as_bytes()[0..1020].iter() {
+            // ascii /
+            assert_eq!(47, b);
+        }
+
+        assert_eq!(13, encoded.as_bytes()[1020]);
+        assert_eq!(10, encoded.as_bytes()[1021]);
+
+        for &b in encoded.as_bytes()[1022..].iter() {
+            // ascii /
+            assert_eq!(47, b);
+        }
+    }
+
+    #[test]
+    fn chunked_encode_matches_normal_encode_random_string_sink() {
+        let helper = StringSinkTestHelper;
+        chunked_encode_matches_normal_encode_random(&helper);
+    }
+
+    #[test]
+    fn max_input_length_no_wrap_no_pad() {
+        let config = config_no_wrap(false);
+        assert_eq!(768, max_input_length(1024, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_no_wrap_with_pad_decrements_one_triple() {
+        let config = config_no_wrap(true);
+        assert_eq!(765, max_input_length(1024, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_no_wrap_with_pad_one_byte_short() {
+        let config = config_no_wrap(true);
+        assert_eq!(765, max_input_length(1025, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_no_wrap_with_pad_fits_exactly() {
+        let config = config_no_wrap(true);
+        assert_eq!(768, max_input_length(1026, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_lf_fits_exactly_no_pad() {
+        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
+        let config = config_wrap(false, 72, LineEnding::LF);
+        assert_eq!(540, max_input_length(730, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_lf_fits_one_spare_byte_no_pad() {
+        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
+        let config = config_wrap(false, 72, LineEnding::LF);
+        assert_eq!(540, max_input_length(731, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_lf_size_one_byte_short_of_another_line_no_pad() {
+        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
+        // 73 * 11 = 803
+        let config = config_wrap(false, 72, LineEnding::LF);
+        assert_eq!(540, max_input_length(802, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_lf_size_another_line_no_pad() {
+        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
+        // 73 * 11 = 803
+        let config = config_wrap(false, 72, LineEnding::LF);
+        assert_eq!(594, max_input_length(803, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_lf_one_byte_short_with_pad() {
+        // one fewer input line
+        let config = config_wrap(true, 72, LineEnding::LF);
+        assert_eq!(486, max_input_length(731, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_lf_fits_exactly_with_pad() {
+        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
+        let config = config_wrap(true, 72, LineEnding::LF);
+        assert_eq!(540, max_input_length(732, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_line_len_wont_fit_one_line_lf() {
+        // 300 bytes is 400 encoded, + 1 for LF
+        let config = config_wrap(false, 400, LineEnding::LF);
+        assert_eq!(
+            ChunkedEncoderError::InvalidLineLength,
+            max_input_length(400, &config).unwrap_err()
+        );
+    }
+
+    #[test]
+    fn max_input_length_wrap_line_len_just_fits_one_line_lf() {
+        // 300 bytes is 400 encoded, + 1 for LF
+        let config = Config::new(
+            CharacterSet::Standard,
+            false,
+            false,
+            LineWrap::Wrap(400, LineEnding::LF),
+        );
+        assert_eq!(300, max_input_length(401, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_crlf_fits_exactly_no_pad() {
+        // 10 * (72 + 2) = 740. 54 input bytes = 72 encoded bytes, + 2 for CRLF.
+        let config = config_wrap(false, 72, LineEnding::CRLF);
+        assert_eq!(540, max_input_length(740, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_crlf_fits_one_spare_byte_no_pad() {
+        // 10 * (72 + 2) = 740. 54 input bytes = 72 encoded bytes, + 2 for CRLF.
+        let config = config_wrap(false, 72, LineEnding::CRLF);
+        assert_eq!(540, max_input_length(741, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_crlf_size_one_byte_short_of_another_line_no_pad() {
+        // 10 * (72 + 2) = 740. 54 input bytes = 72 encoded bytes, + 2 for CRLF.
+        // 74 * 11 = 814
+        let config = config_wrap(false, 72, LineEnding::CRLF);
+        assert_eq!(540, max_input_length(813, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_with_crlf_size_another_line_no_pad() {
+        // 10 * (72 + 2) = 740. 54 input bytes = 72 encoded bytes, + 2 for CRLF.
+        // 74 * 11 = 814
+        let config = config_wrap(false, 72, LineEnding::CRLF);
+        assert_eq!(594, max_input_length(814, &config).unwrap());
+    }
+
+    #[test]
+    fn max_input_length_wrap_line_len_not_multiple_of_4_rejected() {
+        let config = config_wrap(false, 41, LineEnding::LF);
+        assert_eq!(
+            ChunkedEncoderError::InvalidLineLength,
+            max_input_length(400, &config).unwrap_err()
+        );
+    }
+
+    pub fn chunked_encode_matches_normal_encode_random<S: SinkTestHelper>(sink_test_helper: &S) {
+        let mut input_buf: Vec<u8> = Vec::new();
+        let mut output_buf = String::new();
+        let mut rng = rand::weak_rng();
+        let line_len_range = Range::new(1, 1020);
+        let input_len_range = Range::new(1, 10_000);
+
+        for _ in 0..5_000 {
+            input_buf.clear();
+            output_buf.clear();
+
+            let buf_len = input_len_range.ind_sample(&mut rng);
+            for _ in 0..buf_len {
+                input_buf.push(rng.gen());
+            }
+
+            let config = random_config_for_chunked_encoder(&mut rng, &line_len_range);
+
+            let chunk_encoded_string = sink_test_helper.encode_to_string(config, &input_buf);
+            encode_config_buf(&input_buf, config, &mut output_buf);
+
+            assert_eq!(
+                output_buf, chunk_encoded_string,
+                "input len={}, config: pad={}, wrap={:?}",
+                buf_len, config.pad, config.line_wrap
+            );
+        }
+    }
+
+    fn chunked_encode_str(bytes: &[u8], config: Config) -> String {
+        let mut sink = StringSink::new();
+
+        {
+            let encoder = ChunkedEncoder::new(config).unwrap();
+            encoder.encode(bytes, &mut sink).unwrap();
+        }
+
+        return sink.string;
+    }
+
+    fn random_config_for_chunked_encoder<R: Rng>(
+        rng: &mut R,
+        line_len_range: &Range<usize>,
+    ) -> Config {
+        loop {
+            let config = random_config(rng, line_len_range);
+
+            // only use a config with line_len that is divisible by 4
+            match config.line_wrap {
+                LineWrap::NoWrap => return config,
+                LineWrap::Wrap(line_len, _) => if line_len % 4 == 0 {
+                    return config;
+                },
+            }
+        }
+    }
+
+    fn config_no_wrap(pad: bool) -> Config {
+        Config::new(CharacterSet::Standard, pad, false, LineWrap::NoWrap)
+    }
+
+    fn config_wrap(pad: bool, line_len: usize, line_ending: LineEnding) -> Config {
+        Config::new(
+            CharacterSet::Standard,
+            pad,
+            false,
+            LineWrap::Wrap(line_len, line_ending),
+        )
+    }
+
+    // An abstraction around sinks so that we can have tests that easily to any sink implementation
+    pub trait SinkTestHelper {
+        fn encode_to_string(&self, config: Config, bytes: &[u8]) -> String;
+    }
+
+    // A really simple sink that just appends to a string for testing
+    struct StringSink {
+        string: String,
+    }
+
+    impl StringSink {
+        fn new() -> StringSink {
+            StringSink {
+                string: String::new(),
+            }
+        }
+    }
+
+    impl Sink for StringSink {
+        type Error = ();
+
+        fn write_encoded_bytes(&mut self, s: &[u8]) -> Result<(), Self::Error> {
+            self.string.push_str(str::from_utf8(s).unwrap());
+
+            Ok(())
+        }
+    }
+
+    struct StringSinkTestHelper;
+
+    impl SinkTestHelper for StringSinkTestHelper {
+        fn encode_to_string(&self, config: Config, bytes: &[u8]) -> String {
+            let encoder = ChunkedEncoder::new(config).unwrap();
+            let mut sink = StringSink::new();
+
+            encoder.encode(bytes, &mut sink).unwrap();
+
+            sink.string
+        }
+    }
+
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/src/decode.rs b/rustc_deps/vendor/base64-0.9.3/src/decode.rs
new file mode 100644
index 0000000..e25b752
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/src/decode.rs
@@ -0,0 +1,710 @@
+use byteorder::{BigEndian, ByteOrder};
+use {tables, CharacterSet, Config, STANDARD};
+
+use std::{error, fmt, str};
+
+// decode logic operates on chunks of 8 input bytes without padding
+const INPUT_CHUNK_LEN: usize = 8;
+const DECODED_CHUNK_LEN: usize = 6;
+// we read a u64 and write a u64, but a u64 of input only yields 6 bytes of output, so the last
+// 2 bytes of any output u64 should not be counted as written to (but must be available in a
+// slice).
+const DECODED_CHUNK_SUFFIX: usize = 2;
+
+// how many u64's of input to handle at a time
+const CHUNKS_PER_FAST_LOOP_BLOCK: usize = 4;
+const INPUT_BLOCK_LEN: usize = CHUNKS_PER_FAST_LOOP_BLOCK * INPUT_CHUNK_LEN;
+// includes the trailing 2 bytes for the final u64 write
+const DECODED_BLOCK_LEN: usize =
+    CHUNKS_PER_FAST_LOOP_BLOCK * DECODED_CHUNK_LEN + DECODED_CHUNK_SUFFIX;
+
+/// Errors that can occur while decoding.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum DecodeError {
+    /// An invalid byte was found in the input. The offset and offending byte are provided.
+    InvalidByte(usize, u8),
+    /// The length of the input is invalid.
+    InvalidLength,
+}
+
+impl fmt::Display for DecodeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            DecodeError::InvalidByte(index, byte) => {
+                write!(f, "Invalid byte {}, offset {}.", byte, index)
+            }
+            DecodeError::InvalidLength => write!(f, "Encoded text cannot have a 6-bit remainder."),
+        }
+    }
+}
+
+impl error::Error for DecodeError {
+    fn description(&self) -> &str {
+        match *self {
+            DecodeError::InvalidByte(_, _) => "invalid byte",
+            DecodeError::InvalidLength => "invalid length",
+        }
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
+///Decode from string reference as octets.
+///Returns a Result containing a Vec<u8>.
+///Convenience `decode_config(input, base64::STANDARD);`.
+///
+///# Example
+///
+///```rust
+///extern crate base64;
+///
+///fn main() {
+///    let bytes = base64::decode("aGVsbG8gd29ybGQ=").unwrap();
+///    println!("{:?}", bytes);
+///}
+///```
+pub fn decode<T: ?Sized + AsRef<[u8]>>(input: &T) -> Result<Vec<u8>, DecodeError> {
+    decode_config(input, STANDARD)
+}
+
+///Decode from string reference as octets.
+///Returns a Result containing a Vec<u8>.
+///
+///# Example
+///
+///```rust
+///extern crate base64;
+///
+///fn main() {
+///    let bytes = base64::decode_config("aGVsbG8gd29ybGR+Cg==", base64::STANDARD).unwrap();
+///    println!("{:?}", bytes);
+///
+///    let bytes_url = base64::decode_config("aGVsbG8gaW50ZXJuZXR-Cg==", base64::URL_SAFE).unwrap();
+///    println!("{:?}", bytes_url);
+///}
+///```
+pub fn decode_config<T: ?Sized + AsRef<[u8]>>(
+    input: &T,
+    config: Config,
+) -> Result<Vec<u8>, DecodeError> {
+    let mut buffer = Vec::<u8>::with_capacity(input.as_ref().len() * 4 / 3);
+
+    decode_config_buf(input, config, &mut buffer).map(|_| buffer)
+}
+
+///Decode from string reference as octets.
+///Writes into the supplied buffer to avoid allocation.
+///Returns a Result containing an empty tuple, aka ().
+///
+///# Example
+///
+///```rust
+///extern crate base64;
+///
+///fn main() {
+///    let mut buffer = Vec::<u8>::new();
+///    base64::decode_config_buf("aGVsbG8gd29ybGR+Cg==", base64::STANDARD, &mut buffer).unwrap();
+///    println!("{:?}", buffer);
+///
+///    buffer.clear();
+///
+///    base64::decode_config_buf("aGVsbG8gaW50ZXJuZXR-Cg==", base64::URL_SAFE, &mut buffer)
+///        .unwrap();
+///    println!("{:?}", buffer);
+///}
+///```
+pub fn decode_config_buf<T: ?Sized + AsRef<[u8]>>(
+    input: &T,
+    config: Config,
+    buffer: &mut Vec<u8>,
+) -> Result<(), DecodeError> {
+    let input_copy;
+    let input_bytes = if config.strip_whitespace {
+        input_copy = copy_without_whitespace(input.as_ref());
+        input_copy.as_ref()
+    } else {
+        input.as_ref()
+    };
+
+    let starting_output_len = buffer.len();
+
+    let num_chunks = num_chunks(input_bytes);
+    let decoded_len_estimate = num_chunks
+        .checked_mul(DECODED_CHUNK_LEN)
+        .and_then(|p| p.checked_add(starting_output_len))
+        .expect("Overflow when calculating output buffer length");
+    buffer.resize(decoded_len_estimate, 0);
+
+    let bytes_written;
+    {
+        let buffer_slice = &mut buffer.as_mut_slice()[starting_output_len..];
+        bytes_written = decode_helper(input_bytes, num_chunks, &config.char_set, buffer_slice)?;
+    }
+
+    buffer.truncate(starting_output_len + bytes_written);
+
+    Ok(())
+}
+
+/// Decode the input into the provided output slice.
+///
+/// This will not write any bytes past exactly what is decoded (no stray garbage bytes at the end).
+///
+/// If you don't know ahead of time what the decoded length should be, size your buffer with a
+/// conservative estimate for the decoded length of an input: 3 bytes of output for every 4 bytes of
+/// input, rounded up, or in other words `(input_len + 3) / 4 * 3`.
+///
+/// If the slice is not large enough, this will panic.
+pub fn decode_config_slice<T: ?Sized + AsRef<[u8]>>(
+    input: &T,
+    config: Config,
+    output: &mut [u8],
+) -> Result<usize, DecodeError> {
+    let input_copy;
+    let input_bytes = if config.strip_whitespace {
+        input_copy = copy_without_whitespace(input.as_ref());
+        input_copy.as_ref()
+    } else {
+        input.as_ref()
+    };
+
+    decode_helper(
+        input_bytes,
+        num_chunks(input_bytes),
+        &config.char_set,
+        output,
+    )
+}
+
+/// Return the number of input chunks (including a possibly partial final chunk) in the input
+fn num_chunks(input: &[u8]) -> usize {
+    input
+        .len()
+        .checked_add(INPUT_CHUNK_LEN - 1)
+        .expect("Overflow when calculating number of chunks in input") / INPUT_CHUNK_LEN
+}
+
+fn copy_without_whitespace(input: &[u8]) -> Vec<u8> {
+    let mut input_copy = Vec::<u8>::with_capacity(input.len());
+    input_copy.extend(input.iter().filter(|b| !b" \n\t\r\x0b\x0c".contains(b)));
+
+    input_copy
+}
+
+/// Helper to avoid duplicating num_chunks calculation, which is costly on short inputs.
+/// Returns the number of bytes written, or an error.
+// We're on the fragile edge of compiler heuristics here. If this is not inlined, slow. If this is
+// inlined(always), a different slow. plain ol' inline makes the benchmarks happiest at the moment,
+// but this is fragile and the best setting changes with only minor code modifications.
+#[inline]
+fn decode_helper(
+    input: &[u8],
+    num_chunks: usize,
+    char_set: &CharacterSet,
+    output: &mut [u8],
+) -> Result<usize, DecodeError> {
+    let decode_table = char_set.decode_table();
+
+    let remainder_len = input.len() % INPUT_CHUNK_LEN;
+
+    // Because the fast decode loop writes in groups of 8 bytes (unrolled to
+    // CHUNKS_PER_FAST_LOOP_BLOCK times 8 bytes, where possible) and outputs 8 bytes at a time (of
+    // which only 6 are valid data), we need to be sure that we stop using the fast decode loop
+    // soon enough that there will always be 2 more bytes of valid data written after that loop.
+    let trailing_bytes_to_skip = match remainder_len {
+        // if input is a multiple of the chunk size, ignore the last chunk as it may have padding,
+        // and the fast decode logic cannot handle padding
+        0 => INPUT_CHUNK_LEN,
+        // 1 and 5 trailing bytes are illegal: can't decode 6 bits of input into a byte
+        1 | 5 => return Err(DecodeError::InvalidLength),
+        // This will decode to one output byte, which isn't enough to overwrite the 2 extra bytes
+        // written by the fast decode loop. So, we have to ignore both these 2 bytes and the
+        // previous chunk.
+        2 => INPUT_CHUNK_LEN + 2,
+        // If this is 3 unpadded chars, then it would actually decode to 2 bytes. However, if this
+        // is an erroneous 2 chars + 1 pad char that would decode to 1 byte, then it should fail
+        // with an error, not panic from going past the bounds of the output slice, so we let it
+        // use stage 3 + 4.
+        3 => INPUT_CHUNK_LEN + 3,
+        // This can also decode to one output byte because it may be 2 input chars + 2 padding
+        // chars, which would decode to 1 byte.
+        4 => INPUT_CHUNK_LEN + 4,
+        // Everything else is a legal decode len (given that we don't require padding), and will
+        // decode to at least 2 bytes of output.
+        _ => remainder_len,
+    };
+
+    // rounded up to include partial chunks
+    let mut remaining_chunks = num_chunks;
+
+    let mut input_index = 0;
+    let mut output_index = 0;
+
+    {
+        let length_of_fast_decode_chunks = input.len().saturating_sub(trailing_bytes_to_skip);
+
+        // Fast loop, stage 1
+        // manual unroll to CHUNKS_PER_FAST_LOOP_BLOCK of u64s to amortize slice bounds checks
+        if let Some(max_start_index) = length_of_fast_decode_chunks.checked_sub(INPUT_BLOCK_LEN) {
+            while input_index <= max_start_index {
+                let input_slice = &input[input_index..(input_index + INPUT_BLOCK_LEN)];
+                let output_slice = &mut output[output_index..(output_index + DECODED_BLOCK_LEN)];
+
+                decode_chunk(
+                    &input_slice[0..],
+                    input_index,
+                    decode_table,
+                    &mut output_slice[0..],
+                )?;
+                decode_chunk(
+                    &input_slice[8..],
+                    input_index + 8,
+                    decode_table,
+                    &mut output_slice[6..],
+                )?;
+                decode_chunk(
+                    &input_slice[16..],
+                    input_index + 16,
+                    decode_table,
+                    &mut output_slice[12..],
+                )?;
+                decode_chunk(
+                    &input_slice[24..],
+                    input_index + 24,
+                    decode_table,
+                    &mut output_slice[18..],
+                )?;
+
+                input_index += INPUT_BLOCK_LEN;
+                output_index += DECODED_BLOCK_LEN - DECODED_CHUNK_SUFFIX;
+                remaining_chunks -= CHUNKS_PER_FAST_LOOP_BLOCK;
+            }
+        }
+
+        // Fast loop, stage 2 (aka still pretty fast loop)
+        // 8 bytes at a time for whatever we didn't do in stage 1.
+        if let Some(max_start_index) = length_of_fast_decode_chunks.checked_sub(INPUT_CHUNK_LEN) {
+            while input_index < max_start_index {
+                decode_chunk(
+                    &input[input_index..(input_index + INPUT_CHUNK_LEN)],
+                    input_index,
+                    decode_table,
+                    &mut output
+                        [output_index..(output_index + DECODED_CHUNK_LEN + DECODED_CHUNK_SUFFIX)],
+                )?;
+
+                output_index += DECODED_CHUNK_LEN;
+                input_index += INPUT_CHUNK_LEN;
+                remaining_chunks -= 1;
+            }
+        }
+    }
+
+    // Stage 3
+    // If input length was such that a chunk had to be deferred until after the fast loop
+    // because decoding it would have produced 2 trailing bytes that wouldn't then be
+    // overwritten, we decode that chunk here. This way is slower but doesn't write the 2
+    // trailing bytes.
+    // However, we still need to avoid the last chunk (partial or complete) because it could
+    // have padding, so we always do 1 fewer to avoid the last chunk.
+    for _ in 1..remaining_chunks {
+        decode_chunk_precise(
+            &input[input_index..],
+            input_index,
+            decode_table,
+            &mut output[output_index..(output_index + DECODED_CHUNK_LEN)],
+        )?;
+
+        input_index += INPUT_CHUNK_LEN;
+        output_index += DECODED_CHUNK_LEN;
+    }
+
+    // Stage 4
+    // Finally, decode any leftovers that aren't a complete input block of 8 bytes.
+    // Use a u64 as a stack-resident 8 byte buffer.
+    let mut leftover_bits: u64 = 0;
+    let mut morsels_in_leftover = 0;
+    let mut padding_bytes = 0;
+    let mut first_padding_index: usize = 0;
+    let start_of_leftovers = input_index;
+    for (i, b) in input[start_of_leftovers..].iter().enumerate() {
+        // '=' padding
+        if *b == 0x3D {
+            // There can be bad padding in a few ways:
+            // 1 - Padding with non-padding characters after it
+            // 2 - Padding after zero or one non-padding characters before it
+            //     in the current quad.
+            // 3 - More than two characters of padding. If 3 or 4 padding chars
+            //     are in the same quad, that implies it will be caught by #2.
+            //     If it spreads from one quad to another, it will be caught by
+            //     #2 in the second quad.
+
+            if i % 4 < 2 {
+                // Check for case #2.
+                let bad_padding_index = start_of_leftovers + if padding_bytes > 0 {
+                    // If we've already seen padding, report the first padding index.
+                    // This is to be consistent with the faster logic above: it will report an
+                    // error on the first padding character (since it doesn't expect to see
+                    // anything but actual encoded data).
+                    first_padding_index
+                } else {
+                    // haven't seen padding before, just use where we are now
+                    i
+                };
+                return Err(DecodeError::InvalidByte(bad_padding_index, *b));
+            }
+
+            if padding_bytes == 0 {
+                first_padding_index = i;
+            }
+
+            padding_bytes += 1;
+            continue;
+        }
+
+        // Check for case #1.
+        // To make '=' handling consistent with the main loop, don't allow
+        // non-suffix '=' in trailing chunk either. Report error as first
+        // erroneous padding.
+        if padding_bytes > 0 {
+            return Err(DecodeError::InvalidByte(
+                start_of_leftovers + first_padding_index,
+                0x3D,
+            ));
+        }
+
+        // can use up to 8 * 6 = 48 bits of the u64, if last chunk has no padding.
+        // To minimize shifts, pack the leftovers from left to right.
+        let shift = 64 - (morsels_in_leftover + 1) * 6;
+        // tables are all 256 elements, lookup with a u8 index always succeeds
+        let morsel = decode_table[*b as usize];
+        if morsel == tables::INVALID_VALUE {
+            return Err(DecodeError::InvalidByte(start_of_leftovers + i, *b));
+        }
+
+        leftover_bits |= (morsel as u64) << shift;
+        morsels_in_leftover += 1;
+    }
+
+    let leftover_bits_ready_to_append = match morsels_in_leftover {
+        0 => 0,
+        2 => 8,
+        3 => 16,
+        4 => 24,
+        6 => 32,
+        7 => 40,
+        8 => 48,
+        _ => unreachable!(
+            "Impossible: must only have 0 to 8 input bytes in last chunk, with no invalid lengths"
+        ),
+    };
+
+    let mut leftover_bits_appended_to_buf = 0;
+    while leftover_bits_appended_to_buf < leftover_bits_ready_to_append {
+        // `as` simply truncates the higher bits, which is what we want here
+        let selected_bits = (leftover_bits >> (56 - leftover_bits_appended_to_buf)) as u8;
+        output[output_index] = selected_bits;
+        output_index += 1;
+
+        leftover_bits_appended_to_buf += 8;
+    }
+
+    Ok(output_index)
+}
+
+/// Decode 8 bytes of input into 6 bytes of output. 8 bytes of output will be written, but only the
+/// first 6 of those contain meaningful data.
+///
+/// `input` is the bytes to decode, of which the first 8 bytes will be processed.
+/// `index_at_start_of_input` is the offset in the overall input (used for reporting errors
+/// accurately)
+/// `decode_table` is the lookup table for the particular base64 alphabet.
+/// `output` will have its first 8 bytes overwritten, of which only the first 6 are valid decoded
+/// data.
+// yes, really inline (worth 30-50% speedup)
+#[inline(always)]
+fn decode_chunk(
+    input: &[u8],
+    index_at_start_of_input: usize,
+    decode_table: &[u8; 256],
+    output: &mut [u8],
+) -> Result<(), DecodeError> {
+    let mut accum: u64;
+
+    let morsel = decode_table[input[0] as usize];
+    if morsel == tables::INVALID_VALUE {
+        return Err(DecodeError::InvalidByte(index_at_start_of_input, input[0]));
+    }
+    accum = (morsel as u64) << 58;
+
+    let morsel = decode_table[input[1] as usize];
+    if morsel == tables::INVALID_VALUE {
+        return Err(DecodeError::InvalidByte(
+            index_at_start_of_input + 1,
+            input[1],
+        ));
+    }
+    accum |= (morsel as u64) << 52;
+
+    let morsel = decode_table[input[2] as usize];
+    if morsel == tables::INVALID_VALUE {
+        return Err(DecodeError::InvalidByte(
+            index_at_start_of_input + 2,
+            input[2],
+        ));
+    }
+    accum |= (morsel as u64) << 46;
+
+    let morsel = decode_table[input[3] as usize];
+    if morsel == tables::INVALID_VALUE {
+        return Err(DecodeError::InvalidByte(
+            index_at_start_of_input + 3,
+            input[3],
+        ));
+    }
+    accum |= (morsel as u64) << 40;
+
+    let morsel = decode_table[input[4] as usize];
+    if morsel == tables::INVALID_VALUE {
+        return Err(DecodeError::InvalidByte(
+            index_at_start_of_input + 4,
+            input[4],
+        ));
+    }
+    accum |= (morsel as u64) << 34;
+
+    let morsel = decode_table[input[5] as usize];
+    if morsel == tables::INVALID_VALUE {
+        return Err(DecodeError::InvalidByte(
+            index_at_start_of_input + 5,
+            input[5],
+        ));
+    }
+    accum |= (morsel as u64) << 28;
+
+    let morsel = decode_table[input[6] as usize];
+    if morsel == tables::INVALID_VALUE {
+        return Err(DecodeError::InvalidByte(
+            index_at_start_of_input + 6,
+            input[6],
+        ));
+    }
+    accum |= (morsel as u64) << 22;
+
+    let morsel = decode_table[input[7] as usize];
+    if morsel == tables::INVALID_VALUE {
+        return Err(DecodeError::InvalidByte(
+            index_at_start_of_input + 7,
+            input[7],
+        ));
+    }
+    accum |= (morsel as u64) << 16;
+
+    BigEndian::write_u64(output, accum);
+
+    Ok(())
+}
+
+/// Decode an 8-byte chunk, but only write the 6 bytes actually decoded instead of including 2
+/// trailing garbage bytes.
+#[inline]
+fn decode_chunk_precise(
+    input: &[u8],
+    index_at_start_of_input: usize,
+    decode_table: &[u8; 256],
+    output: &mut [u8],
+) -> Result<(), DecodeError> {
+    let mut tmp_buf = [0_u8; 8];
+
+    decode_chunk(
+        input,
+        index_at_start_of_input,
+        decode_table,
+        &mut tmp_buf[..],
+    )?;
+
+    output[0..6].copy_from_slice(&tmp_buf[0..6]);
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate rand;
+
+    use super::*;
+    use encode::encode_config_buf;
+    use tests::{assert_encode_sanity, random_config};
+
+    use self::rand::distributions::{IndependentSample, Range};
+    use self::rand::Rng;
+
+    #[test]
+    fn decode_chunk_precise_writes_only_6_bytes() {
+        let input = b"Zm9vYmFy"; // "foobar"
+        let mut output = [0_u8, 1, 2, 3, 4, 5, 6, 7];
+        decode_chunk_precise(&input[..], 0, tables::STANDARD_DECODE, &mut output).unwrap();
+        assert_eq!(&vec![b'f', b'o', b'o', b'b', b'a', b'r', 6, 7], &output);
+    }
+
+    #[test]
+    fn decode_chunk_writes_8_bytes() {
+        let input = b"Zm9vYmFy"; // "foobar"
+        let mut output = [0_u8, 1, 2, 3, 4, 5, 6, 7];
+        decode_chunk(&input[..], 0, tables::STANDARD_DECODE, &mut output).unwrap();
+        assert_eq!(&vec![b'f', b'o', b'o', b'b', b'a', b'r', 0, 0], &output);
+    }
+
+    #[test]
+    fn decode_into_nonempty_vec_doesnt_clobber_existing_prefix() {
+        let mut orig_data = Vec::new();
+        let mut encoded_data = String::new();
+        let mut decoded_with_prefix = Vec::new();
+        let mut decoded_without_prefix = Vec::new();
+        let mut prefix = Vec::new();
+
+        let prefix_len_range = Range::new(0, 1000);
+        let input_len_range = Range::new(0, 1000);
+        let line_len_range = Range::new(1, 1000);
+
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..10_000 {
+            orig_data.clear();
+            encoded_data.clear();
+            decoded_with_prefix.clear();
+            decoded_without_prefix.clear();
+            prefix.clear();
+
+            let input_len = input_len_range.ind_sample(&mut rng);
+
+            for _ in 0..input_len {
+                orig_data.push(rng.gen());
+            }
+
+            let config = random_config(&mut rng, &line_len_range);
+            encode_config_buf(&orig_data, config, &mut encoded_data);
+            assert_encode_sanity(&encoded_data, &config, input_len);
+
+            let prefix_len = prefix_len_range.ind_sample(&mut rng);
+
+            // fill the buf with a prefix
+            for _ in 0..prefix_len {
+                prefix.push(rng.gen());
+            }
+
+            decoded_with_prefix.resize(prefix_len, 0);
+            decoded_with_prefix.copy_from_slice(&prefix);
+
+            // decode into the non-empty buf
+            decode_config_buf(&encoded_data, config, &mut decoded_with_prefix).unwrap();
+            // also decode into the empty buf
+            decode_config_buf(&encoded_data, config, &mut decoded_without_prefix).unwrap();
+
+            assert_eq!(
+                prefix_len + decoded_without_prefix.len(),
+                decoded_with_prefix.len()
+            );
+            assert_eq!(orig_data, decoded_without_prefix);
+
+            // append plain decode onto prefix
+            prefix.append(&mut decoded_without_prefix);
+
+            assert_eq!(prefix, decoded_with_prefix);
+        }
+    }
+
+    #[test]
+    fn decode_into_slice_doesnt_clobber_existing_prefix_or_suffix() {
+        let mut orig_data = Vec::new();
+        let mut encoded_data = String::new();
+        let mut decode_buf = Vec::new();
+        let mut decode_buf_copy: Vec<u8> = Vec::new();
+
+        let input_len_range = Range::new(0, 1000);
+        let line_len_range = Range::new(1, 1000);
+
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..10_000 {
+            orig_data.clear();
+            encoded_data.clear();
+            decode_buf.clear();
+            decode_buf_copy.clear();
+
+            let input_len = input_len_range.ind_sample(&mut rng);
+
+            for _ in 0..input_len {
+                orig_data.push(rng.gen());
+            }
+
+            let config = random_config(&mut rng, &line_len_range);
+            encode_config_buf(&orig_data, config, &mut encoded_data);
+            assert_encode_sanity(&encoded_data, &config, input_len);
+
+            // fill the buffer with random garbage, long enough to have some room before and after
+            for _ in 0..5000 {
+                decode_buf.push(rng.gen());
+            }
+
+            // keep a copy for later comparison
+            decode_buf_copy.extend(decode_buf.iter());
+
+            let offset = 1000;
+
+            // decode into the non-empty buf
+            let decode_bytes_written =
+                decode_config_slice(&encoded_data, config, &mut decode_buf[offset..]).unwrap();
+
+            assert_eq!(orig_data.len(), decode_bytes_written);
+            assert_eq!(
+                orig_data,
+                &decode_buf[offset..(offset + decode_bytes_written)]
+            );
+            assert_eq!(&decode_buf_copy[0..offset], &decode_buf[0..offset]);
+            assert_eq!(
+                &decode_buf_copy[offset + decode_bytes_written..],
+                &decode_buf[offset + decode_bytes_written..]
+            );
+        }
+    }
+
+    #[test]
+    fn decode_into_slice_fits_in_precisely_sized_slice() {
+        let mut orig_data = Vec::new();
+        let mut encoded_data = String::new();
+        let mut decode_buf = Vec::new();
+
+        let input_len_range = Range::new(0, 1000);
+        let line_len_range = Range::new(1, 1000);
+
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..10_000 {
+            orig_data.clear();
+            encoded_data.clear();
+            decode_buf.clear();
+
+            let input_len = input_len_range.ind_sample(&mut rng);
+
+            for _ in 0..input_len {
+                orig_data.push(rng.gen());
+            }
+
+            let config = random_config(&mut rng, &line_len_range);
+            encode_config_buf(&orig_data, config, &mut encoded_data);
+            assert_encode_sanity(&encoded_data, &config, input_len);
+
+            decode_buf.resize(input_len, 0);
+
+            // decode into the non-empty buf
+            let decode_bytes_written =
+                decode_config_slice(&encoded_data, config, &mut decode_buf[..]).unwrap();
+
+            assert_eq!(orig_data.len(), decode_bytes_written);
+            assert_eq!(orig_data, decode_buf);
+        }
+    }
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/src/display.rs b/rustc_deps/vendor/base64-0.9.3/src/display.rs
new file mode 100644
index 0000000..53ee1d7
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/src/display.rs
@@ -0,0 +1,112 @@
+//! Enables base64'd output anywhere you might use a `Display` implementation, like a format string.
+//!
+//! ```
+//! use base64::display::Base64Display;
+//!
+//! let data = vec![0x0, 0x1, 0x2, 0x3];
+//! let wrapper = Base64Display::standard(&data);
+//!
+//! assert_eq!("base64: AAECAw==", format!("base64: {}", wrapper));
+//! ```
+
+use super::chunked_encoder::{ChunkedEncoder, ChunkedEncoderError};
+use super::Config;
+use std::fmt::{Display, Formatter};
+use std::{fmt, str};
+
+// I'm not convinced that we should expose ChunkedEncoder or its error type since it's just an
+// implementation detail, so use a different error type.
+/// Errors that can occur initializing a Base64Display.
+#[derive(Debug, PartialEq)]
+pub enum DisplayError {
+    /// If wrapping is configured, the line length must be a multiple of 4, and must not be absurdly
+    /// large (currently capped at 1024, subject to change).
+    InvalidLineLength,
+}
+
+/// A convenience wrapper for base64'ing bytes into a format string without heap allocation.
+pub struct Base64Display<'a> {
+    bytes: &'a [u8],
+    chunked_encoder: ChunkedEncoder,
+}
+
+impl<'a> Base64Display<'a> {
+    /// Create a `Base64Display` with the provided config.
+    pub fn with_config(bytes: &[u8], config: Config) -> Result<Base64Display, DisplayError> {
+        ChunkedEncoder::new(config)
+            .map(|c| Base64Display {
+                bytes,
+                chunked_encoder: c,
+            })
+            .map_err(|e| match e {
+                ChunkedEncoderError::InvalidLineLength => DisplayError::InvalidLineLength,
+            })
+    }
+
+    /// Convenience method for creating a `Base64Display` with the `STANDARD` configuration.
+    pub fn standard(bytes: &[u8]) -> Base64Display {
+        Base64Display::with_config(bytes, super::STANDARD).expect("STANDARD is valid")
+    }
+
+    /// Convenience method for creating a `Base64Display` with the `URL_SAFE` configuration.
+    pub fn url_safe(bytes: &[u8]) -> Base64Display {
+        Base64Display::with_config(bytes, super::URL_SAFE).expect("URL_SAFE is valid")
+    }
+}
+
+impl<'a> Display for Base64Display<'a> {
+    fn fmt(&self, formatter: &mut Formatter) -> Result<(), fmt::Error> {
+        let mut sink = FormatterSink { f: formatter };
+        self.chunked_encoder.encode(self.bytes, &mut sink)
+    }
+}
+
+struct FormatterSink<'a, 'b: 'a> {
+    f: &'a mut Formatter<'b>,
+}
+
+impl<'a, 'b: 'a> super::chunked_encoder::Sink for FormatterSink<'a, 'b> {
+    type Error = fmt::Error;
+
+    fn write_encoded_bytes(&mut self, encoded: &[u8]) -> Result<(), Self::Error> {
+        // Avoid unsafe. If max performance is needed, write your own display wrapper that uses
+        // unsafe here to gain about 10-15%.
+        self.f
+            .write_str(str::from_utf8(encoded).expect("base64 data was not utf8"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::chunked_encoder::tests::{chunked_encode_matches_normal_encode_random,
+                                               SinkTestHelper};
+    use super::super::*;
+    use super::*;
+
+    #[test]
+    fn basic_display() {
+        assert_eq!(
+            "~$Zm9vYmFy#*",
+            format!("~${}#*", Base64Display::standard("foobar".as_bytes()))
+        );
+        assert_eq!(
+            "~$Zm9vYmFyZg==#*",
+            format!("~${}#*", Base64Display::standard("foobarf".as_bytes()))
+        );
+    }
+
+    #[test]
+    fn display_encode_matches_normal_encode() {
+        let helper = DisplaySinkTestHelper;
+        chunked_encode_matches_normal_encode_random(&helper);
+    }
+
+    struct DisplaySinkTestHelper;
+
+    impl SinkTestHelper for DisplaySinkTestHelper {
+        fn encode_to_string(&self, config: Config, bytes: &[u8]) -> String {
+            format!("{}", Base64Display::with_config(bytes, config).unwrap())
+        }
+    }
+
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/src/encode.rs b/rustc_deps/vendor/base64-0.9.3/src/encode.rs
new file mode 100644
index 0000000..be1eb86
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/src/encode.rs
@@ -0,0 +1,761 @@
+use byteorder::{BigEndian, ByteOrder};
+use {line_wrap, line_wrap_parameters, Config, LineWrap, STANDARD};
+
+///Encode arbitrary octets as base64.
+///Returns a String.
+///Convenience for `encode_config(input, base64::STANDARD);`.
+///
+///# Example
+///
+///```rust
+///extern crate base64;
+///
+///fn main() {
+///    let b64 = base64::encode(b"hello world");
+///    println!("{}", b64);
+///}
+///```
+pub fn encode<T: ?Sized + AsRef<[u8]>>(input: &T) -> String {
+    encode_config(input, STANDARD)
+}
+
+///Encode arbitrary octets as base64.
+///Returns a String.
+///
+///# Example
+///
+///```rust
+///extern crate base64;
+///
+///fn main() {
+///    let b64 = base64::encode_config(b"hello world~", base64::STANDARD);
+///    println!("{}", b64);
+///
+///    let b64_url = base64::encode_config(b"hello internet~", base64::URL_SAFE);
+///    println!("{}", b64_url);
+///}
+///```
+pub fn encode_config<T: ?Sized + AsRef<[u8]>>(input: &T, config: Config) -> String {
+    let mut buf = match encoded_size(input.as_ref().len(), &config) {
+        Some(n) => String::with_capacity(n),
+        None => panic!("integer overflow when calculating buffer size"),
+    };
+
+    encode_config_buf(input, config, &mut buf);
+
+    buf
+}
+
+///Encode arbitrary octets as base64.
+///Writes into the supplied output buffer, which will grow the buffer if needed.
+///
+///# Example
+///
+///```rust
+///extern crate base64;
+///
+///fn main() {
+///    let mut buf = String::new();
+///    base64::encode_config_buf(b"hello world~", base64::STANDARD, &mut buf);
+///    println!("{}", buf);
+///
+///    buf.clear();
+///    base64::encode_config_buf(b"hello internet~", base64::URL_SAFE, &mut buf);
+///    println!("{}", buf);
+///}
+///```
+pub fn encode_config_buf<T: ?Sized + AsRef<[u8]>>(input: &T, config: Config, buf: &mut String) {
+    let input_bytes = input.as_ref();
+
+    let encoded_size = encoded_size(input_bytes.len(), &config)
+        .expect("usize overflow when calculating buffer size");
+
+    let orig_buf_len = buf.len();
+
+    // we're only going to insert valid utf8
+    let buf_bytes;
+    unsafe {
+        buf_bytes = buf.as_mut_vec();
+    }
+
+    buf_bytes.resize(
+        orig_buf_len
+            .checked_add(encoded_size)
+            .expect("usize overflow when calculating expanded buffer size"),
+        0,
+    );
+
+    let mut b64_output = &mut buf_bytes[orig_buf_len..];
+
+    encode_with_padding_line_wrap(&input_bytes, &config, encoded_size, &mut b64_output);
+}
+
+/// Encode arbitrary octets as base64.
+/// Writes into the supplied output buffer.
+///
+/// This is useful if you wish to avoid allocation entirely (e.g. encoding into a stack-resident
+/// or statically-allocated buffer).
+///
+/// # Panics
+///
+/// If `output` is too small to hold the encoded version of `input`, a panic will result.
+///
+/// # Example
+///
+/// ```rust
+/// extern crate base64;
+///
+/// fn main() {
+///     let s = b"hello internet!";
+///     let mut buf = Vec::new();
+///     // make sure we'll have a slice big enough for base64 + padding
+///     buf.resize(s.len() * 4 / 3 + 4, 0);
+///
+///     let bytes_written = base64::encode_config_slice(s,
+///                             base64::STANDARD, &mut buf);
+///
+///     // shorten our vec down to just what was written
+///     buf.resize(bytes_written, 0);
+///
+///     assert_eq!(s, base64::decode(&buf).unwrap().as_slice());
+/// }
+/// ```
+pub fn encode_config_slice<T: ?Sized + AsRef<[u8]>>(
+    input: &T,
+    config: Config,
+    output: &mut [u8],
+) -> usize {
+    let input_bytes = input.as_ref();
+
+    let encoded_size = encoded_size(input_bytes.len(), &config)
+        .expect("usize overflow when calculating buffer size");
+
+    let mut b64_output = &mut output[0..encoded_size];
+
+    encode_with_padding_line_wrap(&input_bytes, &config, encoded_size, &mut b64_output);
+
+    encoded_size
+}
+
+/// B64-encode, pad, and line wrap (if configured).
+///
+/// This helper exists to avoid recalculating encoded_size, which is relatively expensive on short
+/// inputs.
+///
+/// `encoded_size` is the encoded size calculated for `input`.
+///
+/// `output` must be of size `encoded_size`.
+///
+/// All bytes in `output` will be written to since it is exactly the size of the output.
+pub fn encode_with_padding_line_wrap(
+    input: &[u8],
+    config: &Config,
+    encoded_size: usize,
+    output: &mut [u8],
+) {
+    debug_assert_eq!(encoded_size, output.len());
+
+    let b64_bytes_written = encode_to_slice(input, output, config.char_set.encode_table());
+
+    let padding_bytes = if config.pad {
+        add_padding(input.len(), &mut output[b64_bytes_written..])
+    } else {
+        0
+    };
+
+    let encoded_bytes = b64_bytes_written
+        .checked_add(padding_bytes)
+        .expect("usize overflow when calculating b64 length");
+
+    let line_ending_bytes = if let LineWrap::Wrap(line_len, line_end) = config.line_wrap {
+        line_wrap(output, encoded_bytes, line_len, line_end)
+    } else {
+        0
+    };
+
+    debug_assert_eq!(encoded_size, encoded_bytes + line_ending_bytes);
+}
+
+/// Encode input bytes to utf8 base64 bytes. Does not pad or line wrap.
+/// `output` must be long enough to hold the encoded `input` without padding or line wrapping.
+/// Returns the number of bytes written.
+#[inline]
+pub fn encode_to_slice(input: &[u8], output: &mut [u8], encode_table: &[u8; 64]) -> usize {
+    let mut input_index: usize = 0;
+
+    const BLOCKS_PER_FAST_LOOP: usize = 4;
+    const LOW_SIX_BITS: u64 = 0x3F;
+
+    // we read 8 bytes at a time (u64) but only actually consume 6 of those bytes. Thus, we need
+    // 2 trailing bytes to be available to read..
+    let last_fast_index = input.len().saturating_sub(BLOCKS_PER_FAST_LOOP * 6 + 2);
+    let mut output_index = 0;
+
+    if last_fast_index > 0 {
+        while input_index <= last_fast_index {
+            // Major performance wins from letting the optimizer do the bounds check once, mostly
+            // on the output side
+            let input_chunk = &input[input_index..(input_index + (BLOCKS_PER_FAST_LOOP * 6 + 2))];
+            let output_chunk = &mut output[output_index..(output_index + BLOCKS_PER_FAST_LOOP * 8)];
+
+            // Hand-unrolling for 32 vs 16 or 8 bytes produces yields performance about equivalent
+            // to unsafe pointer code on a Xeon E5-1650v3. 64 byte unrolling was slightly better for
+            // large inputs but significantly worse for 50-byte input, unsurprisingly. I suspect
+            // that it's a not uncommon use case to encode smallish chunks of data (e.g. a 64-byte
+            // SHA-512 digest), so it would be nice if that fit in the unrolled loop at least once.
+            // Plus, single-digit percentage performance differences might well be quite different
+            // on different hardware.
+
+            let input_u64 = BigEndian::read_u64(&input_chunk[0..]);
+
+            output_chunk[0] = encode_table[((input_u64 >> 58) & LOW_SIX_BITS) as usize];
+            output_chunk[1] = encode_table[((input_u64 >> 52) & LOW_SIX_BITS) as usize];
+            output_chunk[2] = encode_table[((input_u64 >> 46) & LOW_SIX_BITS) as usize];
+            output_chunk[3] = encode_table[((input_u64 >> 40) & LOW_SIX_BITS) as usize];
+            output_chunk[4] = encode_table[((input_u64 >> 34) & LOW_SIX_BITS) as usize];
+            output_chunk[5] = encode_table[((input_u64 >> 28) & LOW_SIX_BITS) as usize];
+            output_chunk[6] = encode_table[((input_u64 >> 22) & LOW_SIX_BITS) as usize];
+            output_chunk[7] = encode_table[((input_u64 >> 16) & LOW_SIX_BITS) as usize];
+
+            let input_u64 = BigEndian::read_u64(&input_chunk[6..]);
+
+            output_chunk[8] = encode_table[((input_u64 >> 58) & LOW_SIX_BITS) as usize];
+            output_chunk[9] = encode_table[((input_u64 >> 52) & LOW_SIX_BITS) as usize];
+            output_chunk[10] = encode_table[((input_u64 >> 46) & LOW_SIX_BITS) as usize];
+            output_chunk[11] = encode_table[((input_u64 >> 40) & LOW_SIX_BITS) as usize];
+            output_chunk[12] = encode_table[((input_u64 >> 34) & LOW_SIX_BITS) as usize];
+            output_chunk[13] = encode_table[((input_u64 >> 28) & LOW_SIX_BITS) as usize];
+            output_chunk[14] = encode_table[((input_u64 >> 22) & LOW_SIX_BITS) as usize];
+            output_chunk[15] = encode_table[((input_u64 >> 16) & LOW_SIX_BITS) as usize];
+
+            let input_u64 = BigEndian::read_u64(&input_chunk[12..]);
+
+            output_chunk[16] = encode_table[((input_u64 >> 58) & LOW_SIX_BITS) as usize];
+            output_chunk[17] = encode_table[((input_u64 >> 52) & LOW_SIX_BITS) as usize];
+            output_chunk[18] = encode_table[((input_u64 >> 46) & LOW_SIX_BITS) as usize];
+            output_chunk[19] = encode_table[((input_u64 >> 40) & LOW_SIX_BITS) as usize];
+            output_chunk[20] = encode_table[((input_u64 >> 34) & LOW_SIX_BITS) as usize];
+            output_chunk[21] = encode_table[((input_u64 >> 28) & LOW_SIX_BITS) as usize];
+            output_chunk[22] = encode_table[((input_u64 >> 22) & LOW_SIX_BITS) as usize];
+            output_chunk[23] = encode_table[((input_u64 >> 16) & LOW_SIX_BITS) as usize];
+
+            let input_u64 = BigEndian::read_u64(&input_chunk[18..]);
+
+            output_chunk[24] = encode_table[((input_u64 >> 58) & LOW_SIX_BITS) as usize];
+            output_chunk[25] = encode_table[((input_u64 >> 52) & LOW_SIX_BITS) as usize];
+            output_chunk[26] = encode_table[((input_u64 >> 46) & LOW_SIX_BITS) as usize];
+            output_chunk[27] = encode_table[((input_u64 >> 40) & LOW_SIX_BITS) as usize];
+            output_chunk[28] = encode_table[((input_u64 >> 34) & LOW_SIX_BITS) as usize];
+            output_chunk[29] = encode_table[((input_u64 >> 28) & LOW_SIX_BITS) as usize];
+            output_chunk[30] = encode_table[((input_u64 >> 22) & LOW_SIX_BITS) as usize];
+            output_chunk[31] = encode_table[((input_u64 >> 16) & LOW_SIX_BITS) as usize];
+
+            output_index += BLOCKS_PER_FAST_LOOP * 8;
+            input_index += BLOCKS_PER_FAST_LOOP * 6;
+        }
+    }
+
+    // Encode what's left after the fast loop.
+
+    const LOW_SIX_BITS_U8: u8 = 0x3F;
+
+    let rem = input.len() % 3;
+    let start_of_rem = input.len() - rem;
+
+    // start at the first index not handled by fast loop, which may be 0.
+
+    while input_index < start_of_rem {
+        let input_chunk = &input[input_index..(input_index + 3)];
+        let output_chunk = &mut output[output_index..(output_index + 4)];
+
+        output_chunk[0] = encode_table[(input_chunk[0] >> 2) as usize];
+        output_chunk[1] =
+            encode_table[((input_chunk[0] << 4 | input_chunk[1] >> 4) & LOW_SIX_BITS_U8) as usize];
+        output_chunk[2] =
+            encode_table[((input_chunk[1] << 2 | input_chunk[2] >> 6) & LOW_SIX_BITS_U8) as usize];
+        output_chunk[3] = encode_table[(input_chunk[2] & LOW_SIX_BITS_U8) as usize];
+
+        input_index += 3;
+        output_index += 4;
+    }
+
+    if rem == 2 {
+        output[output_index] = encode_table[(input[start_of_rem] >> 2) as usize];
+        output[output_index + 1] =
+            encode_table[((input[start_of_rem] << 4 | input[start_of_rem + 1] >> 4)
+                             & LOW_SIX_BITS_U8) as usize];
+        output[output_index + 2] =
+            encode_table[((input[start_of_rem + 1] << 2) & LOW_SIX_BITS_U8) as usize];
+        output_index += 3;
+    } else if rem == 1 {
+        output[output_index] = encode_table[(input[start_of_rem] >> 2) as usize];
+        output[output_index + 1] =
+            encode_table[((input[start_of_rem] << 4) & LOW_SIX_BITS_U8) as usize];
+        output_index += 2;
+    }
+
+    output_index
+}
+
+/// calculate the base64 encoded string size, including padding and line wraps if appropriate
+pub fn encoded_size(bytes_len: usize, config: &Config) -> Option<usize> {
+    let rem = bytes_len % 3;
+
+    let complete_input_chunks = bytes_len / 3;
+    let complete_chunk_output = complete_input_chunks.checked_mul(4);
+
+    let encoded_len_no_wrap = if rem > 0 {
+        if config.pad {
+            complete_chunk_output.and_then(|c| c.checked_add(4))
+        } else {
+            let encoded_rem = match rem {
+                1 => 2,
+                2 => 3,
+                _ => unreachable!("Impossible remainder"),
+            };
+            complete_chunk_output.and_then(|c| c.checked_add(encoded_rem))
+        }
+    } else {
+        complete_chunk_output
+    };
+
+    encoded_len_no_wrap.map(|e| match config.line_wrap {
+        LineWrap::NoWrap => e,
+        LineWrap::Wrap(line_len, line_ending) => {
+            line_wrap_parameters(e, line_len, line_ending).total_len
+        }
+    })
+}
+
+/// Write padding characters.
+/// `output` is the slice where padding should be written, of length at least 2.
+///
+/// Returns the number of padding bytes written.
+pub fn add_padding(input_len: usize, output: &mut [u8]) -> usize {
+    let rem = input_len % 3;
+    let mut bytes_written = 0;
+    for _ in 0..((3 - rem) % 3) {
+        output[bytes_written] = b'=';
+        bytes_written += 1;
+    }
+
+    bytes_written
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate rand;
+
+    use super::*;
+    use decode::decode_config_buf;
+    use tests::{assert_encode_sanity, random_config};
+    use {CharacterSet, Config, LineEnding, LineWrap, MIME, STANDARD, URL_SAFE_NO_PAD};
+
+    use self::rand::distributions::{IndependentSample, Range};
+    use self::rand::Rng;
+    use std;
+    use std::str;
+
+    #[test]
+    fn encoded_size_correct_standard() {
+        assert_encoded_length(0, 0, STANDARD);
+
+        assert_encoded_length(1, 4, STANDARD);
+        assert_encoded_length(2, 4, STANDARD);
+        assert_encoded_length(3, 4, STANDARD);
+
+        assert_encoded_length(4, 8, STANDARD);
+        assert_encoded_length(5, 8, STANDARD);
+        assert_encoded_length(6, 8, STANDARD);
+
+        assert_encoded_length(7, 12, STANDARD);
+        assert_encoded_length(8, 12, STANDARD);
+        assert_encoded_length(9, 12, STANDARD);
+
+        assert_encoded_length(54, 72, STANDARD);
+
+        assert_encoded_length(55, 76, STANDARD);
+        assert_encoded_length(56, 76, STANDARD);
+        assert_encoded_length(57, 76, STANDARD);
+
+        assert_encoded_length(58, 80, STANDARD);
+    }
+
+    #[test]
+    fn encoded_size_correct_no_pad_no_wrap() {
+        assert_encoded_length(0, 0, URL_SAFE_NO_PAD);
+
+        assert_encoded_length(1, 2, URL_SAFE_NO_PAD);
+        assert_encoded_length(2, 3, URL_SAFE_NO_PAD);
+        assert_encoded_length(3, 4, URL_SAFE_NO_PAD);
+
+        assert_encoded_length(4, 6, URL_SAFE_NO_PAD);
+        assert_encoded_length(5, 7, URL_SAFE_NO_PAD);
+        assert_encoded_length(6, 8, URL_SAFE_NO_PAD);
+
+        assert_encoded_length(7, 10, URL_SAFE_NO_PAD);
+        assert_encoded_length(8, 11, URL_SAFE_NO_PAD);
+        assert_encoded_length(9, 12, URL_SAFE_NO_PAD);
+
+        assert_encoded_length(54, 72, URL_SAFE_NO_PAD);
+
+        assert_encoded_length(55, 74, URL_SAFE_NO_PAD);
+        assert_encoded_length(56, 75, URL_SAFE_NO_PAD);
+        assert_encoded_length(57, 76, URL_SAFE_NO_PAD);
+
+        assert_encoded_length(58, 78, URL_SAFE_NO_PAD);
+    }
+
+    #[test]
+    fn encoded_size_correct_mime() {
+        assert_encoded_length(0, 0, MIME);
+
+        assert_encoded_length(1, 4, MIME);
+        assert_encoded_length(2, 4, MIME);
+        assert_encoded_length(3, 4, MIME);
+
+        assert_encoded_length(4, 8, MIME);
+        assert_encoded_length(5, 8, MIME);
+        assert_encoded_length(6, 8, MIME);
+
+        assert_encoded_length(7, 12, MIME);
+        assert_encoded_length(8, 12, MIME);
+        assert_encoded_length(9, 12, MIME);
+
+        assert_encoded_length(54, 72, MIME);
+
+        assert_encoded_length(55, 76, MIME);
+        assert_encoded_length(56, 76, MIME);
+        assert_encoded_length(57, 76, MIME);
+
+        assert_encoded_length(58, 82, MIME);
+        assert_encoded_length(59, 82, MIME);
+        assert_encoded_length(60, 82, MIME);
+    }
+
+    #[test]
+    fn encoded_size_correct_lf_pad() {
+        let config = Config::new(
+            CharacterSet::Standard,
+            true,
+            false,
+            LineWrap::Wrap(76, LineEnding::LF),
+        );
+
+        assert_encoded_length(0, 0, config);
+
+        assert_encoded_length(1, 4, config);
+        assert_encoded_length(2, 4, config);
+        assert_encoded_length(3, 4, config);
+
+        assert_encoded_length(4, 8, config);
+        assert_encoded_length(5, 8, config);
+        assert_encoded_length(6, 8, config);
+
+        assert_encoded_length(7, 12, config);
+        assert_encoded_length(8, 12, config);
+        assert_encoded_length(9, 12, config);
+
+        assert_encoded_length(54, 72, config);
+
+        assert_encoded_length(55, 76, config);
+        assert_encoded_length(56, 76, config);
+        assert_encoded_length(57, 76, config);
+
+        // one fewer than MIME
+        assert_encoded_length(58, 81, config);
+        assert_encoded_length(59, 81, config);
+        assert_encoded_length(60, 81, config);
+    }
+
+    #[test]
+    fn encoded_size_overflow() {
+        assert_eq!(None, encoded_size(std::usize::MAX, &STANDARD));
+    }
+
+    #[test]
+    fn encode_config_buf_into_nonempty_buffer_doesnt_clobber_prefix() {
+        let mut orig_data = Vec::new();
+        let mut prefix = String::new();
+        let mut encoded_data_no_prefix = String::new();
+        let mut encoded_data_with_prefix = String::new();
+        let mut decoded = Vec::new();
+
+        let prefix_len_range = Range::new(0, 1000);
+        let input_len_range = Range::new(0, 1000);
+        let line_len_range = Range::new(1, 1000);
+
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..10_000 {
+            orig_data.clear();
+            prefix.clear();
+            encoded_data_no_prefix.clear();
+            encoded_data_with_prefix.clear();
+            decoded.clear();
+
+            let input_len = input_len_range.ind_sample(&mut rng);
+
+            for _ in 0..input_len {
+                orig_data.push(rng.gen());
+            }
+
+            let prefix_len = prefix_len_range.ind_sample(&mut rng);
+            for _ in 0..prefix_len {
+                // getting convenient random single-byte printable chars that aren't base64 is
+                // annoying
+                prefix.push('#');
+            }
+            encoded_data_with_prefix.push_str(&prefix);
+
+            let config = random_config(&mut rng, &line_len_range);
+            encode_config_buf(&orig_data, config, &mut encoded_data_no_prefix);
+            encode_config_buf(&orig_data, config, &mut encoded_data_with_prefix);
+
+            assert_eq!(
+                encoded_data_no_prefix.len() + prefix_len,
+                encoded_data_with_prefix.len()
+            );
+            assert_encode_sanity(&encoded_data_no_prefix, &config, input_len);
+            assert_encode_sanity(&encoded_data_with_prefix[prefix_len..], &config, input_len);
+
+            // append plain encode onto prefix
+            prefix.push_str(&mut encoded_data_no_prefix);
+
+            assert_eq!(prefix, encoded_data_with_prefix);
+
+            decode_config_buf(&encoded_data_no_prefix, config, &mut decoded).unwrap();
+            assert_eq!(orig_data, decoded);
+        }
+    }
+
+    #[test]
+    fn encode_config_slice_into_nonempty_buffer_doesnt_clobber_suffix() {
+        let mut orig_data = Vec::new();
+        let mut encoded_data = Vec::new();
+        let mut encoded_data_original_state = Vec::new();
+        let mut decoded = Vec::new();
+
+        let input_len_range = Range::new(0, 1000);
+        let line_len_range = Range::new(1, 1000);
+
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..10_000 {
+            orig_data.clear();
+            encoded_data.clear();
+            encoded_data_original_state.clear();
+            decoded.clear();
+
+            let input_len = input_len_range.ind_sample(&mut rng);
+
+            for _ in 0..input_len {
+                orig_data.push(rng.gen());
+            }
+
+            // plenty of existing garbage in the encoded buffer
+            for _ in 0..10 * input_len {
+                encoded_data.push(rng.gen());
+            }
+
+            encoded_data_original_state.extend_from_slice(&encoded_data);
+
+            let config = random_config(&mut rng, &line_len_range);
+
+            let encoded_size = encoded_size(input_len, &config).unwrap();
+
+            assert_eq!(
+                encoded_size,
+                encode_config_slice(&orig_data, config, &mut encoded_data)
+            );
+
+            assert_encode_sanity(
+                std::str::from_utf8(&encoded_data[0..encoded_size]).unwrap(),
+                &config,
+                input_len,
+            );
+
+            assert_eq!(
+                &encoded_data[encoded_size..],
+                &encoded_data_original_state[encoded_size..]
+            );
+
+            decode_config_buf(&encoded_data[0..encoded_size], config, &mut decoded).unwrap();
+            assert_eq!(orig_data, decoded);
+        }
+    }
+
+    #[test]
+    fn encode_config_slice_fits_into_precisely_sized_slice() {
+        let mut orig_data = Vec::new();
+        let mut encoded_data = Vec::new();
+        let mut decoded = Vec::new();
+
+        let input_len_range = Range::new(0, 1000);
+        let line_len_range = Range::new(1, 1000);
+
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..10_000 {
+            orig_data.clear();
+            encoded_data.clear();
+            decoded.clear();
+
+            let input_len = input_len_range.ind_sample(&mut rng);
+
+            for _ in 0..input_len {
+                orig_data.push(rng.gen());
+            }
+
+            let config = random_config(&mut rng, &line_len_range);
+
+            let encoded_size = encoded_size(input_len, &config).unwrap();
+
+            encoded_data.resize(encoded_size, 0);
+
+            assert_eq!(
+                encoded_size,
+                encode_config_slice(&orig_data, config, &mut encoded_data)
+            );
+
+            assert_encode_sanity(
+                std::str::from_utf8(&encoded_data[0..encoded_size]).unwrap(),
+                &config,
+                input_len,
+            );
+
+            decode_config_buf(&encoded_data[0..encoded_size], config, &mut decoded).unwrap();
+            assert_eq!(orig_data, decoded);
+        }
+    }
+
+    #[test]
+    fn encode_to_slice_random_valid_utf8() {
+        let mut input = Vec::new();
+        let mut output = Vec::new();
+
+        let input_len_range = Range::new(0, 1000);
+        let line_len_range = Range::new(1, 1000);
+
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..10_000 {
+            input.clear();
+            output.clear();
+
+            let input_len = input_len_range.ind_sample(&mut rng);
+
+            for _ in 0..input_len {
+                input.push(rng.gen());
+            }
+
+            let config = random_config(&mut rng, &line_len_range);
+
+            // fill up the output buffer with garbage
+            let encoded_size = encoded_size(input_len, &config).unwrap();
+            for _ in 0..encoded_size {
+                output.push(rng.gen());
+            }
+
+            let orig_output_buf = output.to_vec();
+
+            let bytes_written =
+                encode_to_slice(&input, &mut output, config.char_set.encode_table());
+
+            // make sure the part beyond bytes_written is the same garbage it was before
+            assert_eq!(orig_output_buf[bytes_written..], output[bytes_written..]);
+
+            // make sure the encoded bytes are UTF-8
+            let _ = str::from_utf8(&output[0..bytes_written]).unwrap();
+        }
+    }
+
+    #[test]
+    fn encode_with_padding_line_wrap_random_valid_utf8() {
+        let mut input = Vec::new();
+        let mut output = Vec::new();
+
+        let input_len_range = Range::new(0, 1000);
+        let line_len_range = Range::new(1, 1000);
+
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..10_000 {
+            input.clear();
+            output.clear();
+
+            let input_len = input_len_range.ind_sample(&mut rng);
+
+            for _ in 0..input_len {
+                input.push(rng.gen());
+            }
+
+            let config = random_config(&mut rng, &line_len_range);
+
+            // fill up the output buffer with garbage
+            let encoded_size = encoded_size(input_len, &config).unwrap();
+            for _ in 0..encoded_size + 1000 {
+                output.push(rng.gen());
+            }
+
+            let orig_output_buf = output.to_vec();
+
+            encode_with_padding_line_wrap(
+                &input,
+                &config,
+                encoded_size,
+                &mut output[0..encoded_size],
+            );
+
+            // make sure the part beyond b64 is the same garbage it was before
+            assert_eq!(orig_output_buf[encoded_size..], output[encoded_size..]);
+
+            // make sure the encoded bytes are UTF-8
+            let _ = str::from_utf8(&output[0..encoded_size]).unwrap();
+        }
+    }
+
+    #[test]
+    fn add_padding_random_valid_utf8() {
+        let mut output = Vec::new();
+
+        let mut rng = rand::weak_rng();
+
+        // cover our bases for length % 3
+        for input_len in 0..10 {
+            output.clear();
+
+            // fill output with random
+            for _ in 0..10 {
+                output.push(rng.gen());
+            }
+
+            let orig_output_buf = output.to_vec();
+
+            let bytes_written = add_padding(input_len, &mut output);
+
+            // make sure the part beyond bytes_written is the same garbage it was before
+            assert_eq!(orig_output_buf[bytes_written..], output[bytes_written..]);
+
+            // make sure the encoded bytes are UTF-8
+            let _ = str::from_utf8(&output[0..bytes_written]).unwrap();
+        }
+    }
+
+    fn assert_encoded_length(input_len: usize, encoded_len: usize, config: Config) {
+        assert_eq!(encoded_len, encoded_size(input_len, &config).unwrap());
+
+        let mut bytes: Vec<u8> = Vec::new();
+        let mut rng = rand::weak_rng();
+
+        for _ in 0..input_len {
+            bytes.push(rng.gen());
+        }
+
+        let encoded = encode_config(&bytes, config);
+        assert_encode_sanity(&encoded, &config, input_len);
+
+        assert_eq!(encoded_len, encoded.len());
+    }
+
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/src/lib.rs b/rustc_deps/vendor/base64-0.9.3/src/lib.rs
new file mode 100644
index 0000000..020592f
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/src/lib.rs
@@ -0,0 +1,220 @@
+//! # Configs
+//!
+//! There isn't just one type of Base64; that would be too simple. You need to choose a character
+//! set (standard or URL-safe), padding suffix (yes/no), and line wrap (line length, line ending).
+//! The `Config` struct encapsulates this info. There are some common configs included: `STANDARD`,
+//! `MIME`, etc. You can also make your own `Config` if needed.
+//!
+//! The functions that don't have `config` in the name (e.g. `encode()` and `decode()`) use the
+//! `STANDARD` config .
+//!
+//! The functions that write to a slice (the ones that end in `_slice`) are generally the fastest
+//! because they don't need to resize anything. If it fits in your workflow and you care about
+//! performance, keep using the same buffer (growing as need be) and use the `_slice` methods for
+//! the best performance.
+//!
+//! # Encoding
+//!
+//! Several different encoding functions are available to you depending on your desire for
+//! convenience vs performance.
+//!
+//! | Function                | Output                       | Allocates                      |
+//! | ----------------------- | ---------------------------- | ------------------------------ |
+//! | `encode`                | Returns a new `String`       | Always                         |
+//! | `encode_config`         | Returns a new `String`       | Always                         |
+//! | `encode_config_buf`     | Appends to provided `String` | Only if `String` needs to grow |
+//! | `encode_config_slice`   | Writes to provided `&[u8]`   | Never                          |
+//!
+//! All of the encoding functions that take a `Config` will pad, line wrap, etc, as per the config.
+//!
+//! # Decoding
+//!
+//! Just as for encoding, there are different decoding functions available.
+//!
+//! Note that all decode functions that take a config will allocate a copy of the input if you
+//! specify a config that requires whitespace to be stripped. If you care about speed, don't use
+//! formats that line wrap and then require whitespace stripping.
+//!
+//! | Function                | Output                        | Allocates                      |
+//! | ----------------------- | ----------------------------- | ------------------------------ |
+//! | `decode`                | Returns a new `Vec<u8>`       | Always                         |
+//! | `decode_config`         | Returns a new `Vec<u8>`       | Always                         |
+//! | `decode_config_buf`     | Appends to provided `Vec<u8>` | Only if `Vec` needs to grow    |
+//! | `decode_config_slice`   | Writes to provided `&[u8]`    | Never                          |
+//!
+//! Unlike encoding, where all possible input is valid, decoding can fail (see `DecodeError`).
+//!
+//! Input can be invalid because it has invalid characters or invalid padding. (No padding at all is
+//! valid, but excess padding is not.)
+//!
+//! Whitespace in the input is invalid unless `strip_whitespace` is enabled in the `Config` used.
+//!
+//! # Panics
+//!
+//! If length calculations result in overflowing `usize`, a panic will result.
+//!
+//! The `_slice` flavors of encode or decode will panic if the provided output slice is too small,
+
+#![deny(
+    missing_docs, trivial_casts, trivial_numeric_casts, unused_extern_crates, unused_import_braces,
+    unused_results, variant_size_differences, warnings
+)]
+
+extern crate byteorder;
+
+mod chunked_encoder;
+pub mod display;
+mod line_wrap;
+mod tables;
+
+use line_wrap::{line_wrap, line_wrap_parameters};
+
+mod encode;
+pub use encode::{encode, encode_config, encode_config_buf, encode_config_slice};
+
+mod decode;
+pub use decode::{decode, decode_config, decode_config_buf, decode_config_slice, DecodeError};
+
+#[cfg(test)]
+mod tests;
+
+/// Available encoding character sets
+#[derive(Clone, Copy, Debug)]
+pub enum CharacterSet {
+    /// The standard character set (uses `+` and `/`)
+    Standard,
+    /// The URL safe character set (uses `-` and `_`)
+    UrlSafe,
+    /// The `crypt(3)` character set (uses `./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`)
+    Crypt,
+}
+
+impl CharacterSet {
+    fn encode_table(&self) -> &'static [u8; 64] {
+        match *self {
+            CharacterSet::Standard => tables::STANDARD_ENCODE,
+            CharacterSet::UrlSafe => tables::URL_SAFE_ENCODE,
+            CharacterSet::Crypt => tables::CRYPT_ENCODE,
+        }
+    }
+
+    fn decode_table(&self) -> &'static [u8; 256] {
+        match *self {
+            CharacterSet::Standard => tables::STANDARD_DECODE,
+            CharacterSet::UrlSafe => tables::URL_SAFE_DECODE,
+            CharacterSet::Crypt => tables::CRYPT_DECODE,
+        }
+    }
+}
+
+/// Line ending used in optional line wrapping.
+#[derive(Clone, Copy, Debug)]
+pub enum LineEnding {
+    /// Unix-style \n
+    LF,
+    /// Windows-style \r\n
+    CRLF,
+}
+
+impl LineEnding {
+    fn len(&self) -> usize {
+        match *self {
+            LineEnding::LF => 1,
+            LineEnding::CRLF => 2,
+        }
+    }
+}
+
+/// Line wrap configuration.
+#[derive(Clone, Copy, Debug)]
+pub enum LineWrap {
+    /// Don't wrap.
+    NoWrap,
+    /// Wrap lines with the specified length and line ending. The length must be > 0.
+    Wrap(usize, LineEnding),
+}
+
+/// Contains configuration parameters for base64 encoding
+#[derive(Clone, Copy, Debug)]
+pub struct Config {
+    /// Character set to use
+    char_set: CharacterSet,
+    /// True to pad output with `=` characters
+    pad: bool,
+    /// Remove whitespace before decoding, at the cost of an allocation. Whitespace is defined
+    /// according to POSIX-locale `isspace`, meaning \n \r \f \t \v and space.
+    strip_whitespace: bool,
+    /// ADT signifying whether to linewrap output, and if so by how many characters and with what
+    /// ending
+    line_wrap: LineWrap,
+}
+
+impl Config {
+    /// Create a new `Config`.
+    pub fn new(
+        char_set: CharacterSet,
+        pad: bool,
+        strip_whitespace: bool,
+        input_line_wrap: LineWrap,
+    ) -> Config {
+        let line_wrap = match input_line_wrap {
+            LineWrap::Wrap(0, _) => LineWrap::NoWrap,
+            _ => input_line_wrap,
+        };
+
+        Config {
+            char_set,
+            pad,
+            strip_whitespace,
+            line_wrap,
+        }
+    }
+}
+
+/// Standard character set with padding.
+pub const STANDARD: Config = Config {
+    char_set: CharacterSet::Standard,
+    pad: true,
+    strip_whitespace: false,
+    line_wrap: LineWrap::NoWrap,
+};
+
+/// Standard character set without padding.
+pub const STANDARD_NO_PAD: Config = Config {
+    char_set: CharacterSet::Standard,
+    pad: false,
+    strip_whitespace: false,
+    line_wrap: LineWrap::NoWrap,
+};
+
+/// As per standards for MIME encoded messages
+pub const MIME: Config = Config {
+    char_set: CharacterSet::Standard,
+    pad: true,
+    strip_whitespace: true,
+    line_wrap: LineWrap::Wrap(76, LineEnding::CRLF),
+};
+
+/// URL-safe character set with padding
+pub const URL_SAFE: Config = Config {
+    char_set: CharacterSet::UrlSafe,
+    pad: true,
+    strip_whitespace: false,
+    line_wrap: LineWrap::NoWrap,
+};
+
+/// URL-safe character set without padding
+pub const URL_SAFE_NO_PAD: Config = Config {
+    char_set: CharacterSet::UrlSafe,
+    pad: false,
+    strip_whitespace: false,
+    line_wrap: LineWrap::NoWrap,
+};
+
+/// As per `crypt(3)` requirements
+pub const CRYPT: Config = Config {
+    char_set: CharacterSet::Crypt,
+    pad: false,
+    strip_whitespace: false,
+    line_wrap: LineWrap::NoWrap,
+};
diff --git a/rustc_deps/vendor/base64/src/line_wrap.rs b/rustc_deps/vendor/base64-0.9.3/src/line_wrap.rs
similarity index 100%
rename from rustc_deps/vendor/base64/src/line_wrap.rs
rename to rustc_deps/vendor/base64-0.9.3/src/line_wrap.rs
diff --git a/rustc_deps/vendor/base64-0.9.3/src/tables.rs b/rustc_deps/vendor/base64-0.9.3/src/tables.rs
new file mode 100644
index 0000000..af3950b
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/src/tables.rs
@@ -0,0 +1,979 @@
+pub const INVALID_VALUE: u8 = 255;
+#[cfg_attr(rustfmt, rustfmt_skip)]
+pub const STANDARD_ENCODE: &'static [u8; 64] = &[
+    65, // input 0 (0x0) => 'A' (0x41)
+    66, // input 1 (0x1) => 'B' (0x42)
+    67, // input 2 (0x2) => 'C' (0x43)
+    68, // input 3 (0x3) => 'D' (0x44)
+    69, // input 4 (0x4) => 'E' (0x45)
+    70, // input 5 (0x5) => 'F' (0x46)
+    71, // input 6 (0x6) => 'G' (0x47)
+    72, // input 7 (0x7) => 'H' (0x48)
+    73, // input 8 (0x8) => 'I' (0x49)
+    74, // input 9 (0x9) => 'J' (0x4A)
+    75, // input 10 (0xA) => 'K' (0x4B)
+    76, // input 11 (0xB) => 'L' (0x4C)
+    77, // input 12 (0xC) => 'M' (0x4D)
+    78, // input 13 (0xD) => 'N' (0x4E)
+    79, // input 14 (0xE) => 'O' (0x4F)
+    80, // input 15 (0xF) => 'P' (0x50)
+    81, // input 16 (0x10) => 'Q' (0x51)
+    82, // input 17 (0x11) => 'R' (0x52)
+    83, // input 18 (0x12) => 'S' (0x53)
+    84, // input 19 (0x13) => 'T' (0x54)
+    85, // input 20 (0x14) => 'U' (0x55)
+    86, // input 21 (0x15) => 'V' (0x56)
+    87, // input 22 (0x16) => 'W' (0x57)
+    88, // input 23 (0x17) => 'X' (0x58)
+    89, // input 24 (0x18) => 'Y' (0x59)
+    90, // input 25 (0x19) => 'Z' (0x5A)
+    97, // input 26 (0x1A) => 'a' (0x61)
+    98, // input 27 (0x1B) => 'b' (0x62)
+    99, // input 28 (0x1C) => 'c' (0x63)
+    100, // input 29 (0x1D) => 'd' (0x64)
+    101, // input 30 (0x1E) => 'e' (0x65)
+    102, // input 31 (0x1F) => 'f' (0x66)
+    103, // input 32 (0x20) => 'g' (0x67)
+    104, // input 33 (0x21) => 'h' (0x68)
+    105, // input 34 (0x22) => 'i' (0x69)
+    106, // input 35 (0x23) => 'j' (0x6A)
+    107, // input 36 (0x24) => 'k' (0x6B)
+    108, // input 37 (0x25) => 'l' (0x6C)
+    109, // input 38 (0x26) => 'm' (0x6D)
+    110, // input 39 (0x27) => 'n' (0x6E)
+    111, // input 40 (0x28) => 'o' (0x6F)
+    112, // input 41 (0x29) => 'p' (0x70)
+    113, // input 42 (0x2A) => 'q' (0x71)
+    114, // input 43 (0x2B) => 'r' (0x72)
+    115, // input 44 (0x2C) => 's' (0x73)
+    116, // input 45 (0x2D) => 't' (0x74)
+    117, // input 46 (0x2E) => 'u' (0x75)
+    118, // input 47 (0x2F) => 'v' (0x76)
+    119, // input 48 (0x30) => 'w' (0x77)
+    120, // input 49 (0x31) => 'x' (0x78)
+    121, // input 50 (0x32) => 'y' (0x79)
+    122, // input 51 (0x33) => 'z' (0x7A)
+    48, // input 52 (0x34) => '0' (0x30)
+    49, // input 53 (0x35) => '1' (0x31)
+    50, // input 54 (0x36) => '2' (0x32)
+    51, // input 55 (0x37) => '3' (0x33)
+    52, // input 56 (0x38) => '4' (0x34)
+    53, // input 57 (0x39) => '5' (0x35)
+    54, // input 58 (0x3A) => '6' (0x36)
+    55, // input 59 (0x3B) => '7' (0x37)
+    56, // input 60 (0x3C) => '8' (0x38)
+    57, // input 61 (0x3D) => '9' (0x39)
+    43, // input 62 (0x3E) => '+' (0x2B)
+    47, // input 63 (0x3F) => '/' (0x2F)
+];
+#[cfg_attr(rustfmt, rustfmt_skip)]
+pub const STANDARD_DECODE: &'static [u8; 256] = &[
+    INVALID_VALUE, // input 0 (0x0)
+    INVALID_VALUE, // input 1 (0x1)
+    INVALID_VALUE, // input 2 (0x2)
+    INVALID_VALUE, // input 3 (0x3)
+    INVALID_VALUE, // input 4 (0x4)
+    INVALID_VALUE, // input 5 (0x5)
+    INVALID_VALUE, // input 6 (0x6)
+    INVALID_VALUE, // input 7 (0x7)
+    INVALID_VALUE, // input 8 (0x8)
+    INVALID_VALUE, // input 9 (0x9)
+    INVALID_VALUE, // input 10 (0xA)
+    INVALID_VALUE, // input 11 (0xB)
+    INVALID_VALUE, // input 12 (0xC)
+    INVALID_VALUE, // input 13 (0xD)
+    INVALID_VALUE, // input 14 (0xE)
+    INVALID_VALUE, // input 15 (0xF)
+    INVALID_VALUE, // input 16 (0x10)
+    INVALID_VALUE, // input 17 (0x11)
+    INVALID_VALUE, // input 18 (0x12)
+    INVALID_VALUE, // input 19 (0x13)
+    INVALID_VALUE, // input 20 (0x14)
+    INVALID_VALUE, // input 21 (0x15)
+    INVALID_VALUE, // input 22 (0x16)
+    INVALID_VALUE, // input 23 (0x17)
+    INVALID_VALUE, // input 24 (0x18)
+    INVALID_VALUE, // input 25 (0x19)
+    INVALID_VALUE, // input 26 (0x1A)
+    INVALID_VALUE, // input 27 (0x1B)
+    INVALID_VALUE, // input 28 (0x1C)
+    INVALID_VALUE, // input 29 (0x1D)
+    INVALID_VALUE, // input 30 (0x1E)
+    INVALID_VALUE, // input 31 (0x1F)
+    INVALID_VALUE, // input 32 (0x20)
+    INVALID_VALUE, // input 33 (0x21)
+    INVALID_VALUE, // input 34 (0x22)
+    INVALID_VALUE, // input 35 (0x23)
+    INVALID_VALUE, // input 36 (0x24)
+    INVALID_VALUE, // input 37 (0x25)
+    INVALID_VALUE, // input 38 (0x26)
+    INVALID_VALUE, // input 39 (0x27)
+    INVALID_VALUE, // input 40 (0x28)
+    INVALID_VALUE, // input 41 (0x29)
+    INVALID_VALUE, // input 42 (0x2A)
+    62, // input 43 (0x2B char '+') => 62 (0x3E)
+    INVALID_VALUE, // input 44 (0x2C)
+    INVALID_VALUE, // input 45 (0x2D)
+    INVALID_VALUE, // input 46 (0x2E)
+    63, // input 47 (0x2F char '/') => 63 (0x3F)
+    52, // input 48 (0x30 char '0') => 52 (0x34)
+    53, // input 49 (0x31 char '1') => 53 (0x35)
+    54, // input 50 (0x32 char '2') => 54 (0x36)
+    55, // input 51 (0x33 char '3') => 55 (0x37)
+    56, // input 52 (0x34 char '4') => 56 (0x38)
+    57, // input 53 (0x35 char '5') => 57 (0x39)
+    58, // input 54 (0x36 char '6') => 58 (0x3A)
+    59, // input 55 (0x37 char '7') => 59 (0x3B)
+    60, // input 56 (0x38 char '8') => 60 (0x3C)
+    61, // input 57 (0x39 char '9') => 61 (0x3D)
+    INVALID_VALUE, // input 58 (0x3A)
+    INVALID_VALUE, // input 59 (0x3B)
+    INVALID_VALUE, // input 60 (0x3C)
+    INVALID_VALUE, // input 61 (0x3D)
+    INVALID_VALUE, // input 62 (0x3E)
+    INVALID_VALUE, // input 63 (0x3F)
+    INVALID_VALUE, // input 64 (0x40)
+    0, // input 65 (0x41 char 'A') => 0 (0x0)
+    1, // input 66 (0x42 char 'B') => 1 (0x1)
+    2, // input 67 (0x43 char 'C') => 2 (0x2)
+    3, // input 68 (0x44 char 'D') => 3 (0x3)
+    4, // input 69 (0x45 char 'E') => 4 (0x4)
+    5, // input 70 (0x46 char 'F') => 5 (0x5)
+    6, // input 71 (0x47 char 'G') => 6 (0x6)
+    7, // input 72 (0x48 char 'H') => 7 (0x7)
+    8, // input 73 (0x49 char 'I') => 8 (0x8)
+    9, // input 74 (0x4A char 'J') => 9 (0x9)
+    10, // input 75 (0x4B char 'K') => 10 (0xA)
+    11, // input 76 (0x4C char 'L') => 11 (0xB)
+    12, // input 77 (0x4D char 'M') => 12 (0xC)
+    13, // input 78 (0x4E char 'N') => 13 (0xD)
+    14, // input 79 (0x4F char 'O') => 14 (0xE)
+    15, // input 80 (0x50 char 'P') => 15 (0xF)
+    16, // input 81 (0x51 char 'Q') => 16 (0x10)
+    17, // input 82 (0x52 char 'R') => 17 (0x11)
+    18, // input 83 (0x53 char 'S') => 18 (0x12)
+    19, // input 84 (0x54 char 'T') => 19 (0x13)
+    20, // input 85 (0x55 char 'U') => 20 (0x14)
+    21, // input 86 (0x56 char 'V') => 21 (0x15)
+    22, // input 87 (0x57 char 'W') => 22 (0x16)
+    23, // input 88 (0x58 char 'X') => 23 (0x17)
+    24, // input 89 (0x59 char 'Y') => 24 (0x18)
+    25, // input 90 (0x5A char 'Z') => 25 (0x19)
+    INVALID_VALUE, // input 91 (0x5B)
+    INVALID_VALUE, // input 92 (0x5C)
+    INVALID_VALUE, // input 93 (0x5D)
+    INVALID_VALUE, // input 94 (0x5E)
+    INVALID_VALUE, // input 95 (0x5F)
+    INVALID_VALUE, // input 96 (0x60)
+    26, // input 97 (0x61 char 'a') => 26 (0x1A)
+    27, // input 98 (0x62 char 'b') => 27 (0x1B)
+    28, // input 99 (0x63 char 'c') => 28 (0x1C)
+    29, // input 100 (0x64 char 'd') => 29 (0x1D)
+    30, // input 101 (0x65 char 'e') => 30 (0x1E)
+    31, // input 102 (0x66 char 'f') => 31 (0x1F)
+    32, // input 103 (0x67 char 'g') => 32 (0x20)
+    33, // input 104 (0x68 char 'h') => 33 (0x21)
+    34, // input 105 (0x69 char 'i') => 34 (0x22)
+    35, // input 106 (0x6A char 'j') => 35 (0x23)
+    36, // input 107 (0x6B char 'k') => 36 (0x24)
+    37, // input 108 (0x6C char 'l') => 37 (0x25)
+    38, // input 109 (0x6D char 'm') => 38 (0x26)
+    39, // input 110 (0x6E char 'n') => 39 (0x27)
+    40, // input 111 (0x6F char 'o') => 40 (0x28)
+    41, // input 112 (0x70 char 'p') => 41 (0x29)
+    42, // input 113 (0x71 char 'q') => 42 (0x2A)
+    43, // input 114 (0x72 char 'r') => 43 (0x2B)
+    44, // input 115 (0x73 char 's') => 44 (0x2C)
+    45, // input 116 (0x74 char 't') => 45 (0x2D)
+    46, // input 117 (0x75 char 'u') => 46 (0x2E)
+    47, // input 118 (0x76 char 'v') => 47 (0x2F)
+    48, // input 119 (0x77 char 'w') => 48 (0x30)
+    49, // input 120 (0x78 char 'x') => 49 (0x31)
+    50, // input 121 (0x79 char 'y') => 50 (0x32)
+    51, // input 122 (0x7A char 'z') => 51 (0x33)
+    INVALID_VALUE, // input 123 (0x7B)
+    INVALID_VALUE, // input 124 (0x7C)
+    INVALID_VALUE, // input 125 (0x7D)
+    INVALID_VALUE, // input 126 (0x7E)
+    INVALID_VALUE, // input 127 (0x7F)
+    INVALID_VALUE, // input 128 (0x80)
+    INVALID_VALUE, // input 129 (0x81)
+    INVALID_VALUE, // input 130 (0x82)
+    INVALID_VALUE, // input 131 (0x83)
+    INVALID_VALUE, // input 132 (0x84)
+    INVALID_VALUE, // input 133 (0x85)
+    INVALID_VALUE, // input 134 (0x86)
+    INVALID_VALUE, // input 135 (0x87)
+    INVALID_VALUE, // input 136 (0x88)
+    INVALID_VALUE, // input 137 (0x89)
+    INVALID_VALUE, // input 138 (0x8A)
+    INVALID_VALUE, // input 139 (0x8B)
+    INVALID_VALUE, // input 140 (0x8C)
+    INVALID_VALUE, // input 141 (0x8D)
+    INVALID_VALUE, // input 142 (0x8E)
+    INVALID_VALUE, // input 143 (0x8F)
+    INVALID_VALUE, // input 144 (0x90)
+    INVALID_VALUE, // input 145 (0x91)
+    INVALID_VALUE, // input 146 (0x92)
+    INVALID_VALUE, // input 147 (0x93)
+    INVALID_VALUE, // input 148 (0x94)
+    INVALID_VALUE, // input 149 (0x95)
+    INVALID_VALUE, // input 150 (0x96)
+    INVALID_VALUE, // input 151 (0x97)
+    INVALID_VALUE, // input 152 (0x98)
+    INVALID_VALUE, // input 153 (0x99)
+    INVALID_VALUE, // input 154 (0x9A)
+    INVALID_VALUE, // input 155 (0x9B)
+    INVALID_VALUE, // input 156 (0x9C)
+    INVALID_VALUE, // input 157 (0x9D)
+    INVALID_VALUE, // input 158 (0x9E)
+    INVALID_VALUE, // input 159 (0x9F)
+    INVALID_VALUE, // input 160 (0xA0)
+    INVALID_VALUE, // input 161 (0xA1)
+    INVALID_VALUE, // input 162 (0xA2)
+    INVALID_VALUE, // input 163 (0xA3)
+    INVALID_VALUE, // input 164 (0xA4)
+    INVALID_VALUE, // input 165 (0xA5)
+    INVALID_VALUE, // input 166 (0xA6)
+    INVALID_VALUE, // input 167 (0xA7)
+    INVALID_VALUE, // input 168 (0xA8)
+    INVALID_VALUE, // input 169 (0xA9)
+    INVALID_VALUE, // input 170 (0xAA)
+    INVALID_VALUE, // input 171 (0xAB)
+    INVALID_VALUE, // input 172 (0xAC)
+    INVALID_VALUE, // input 173 (0xAD)
+    INVALID_VALUE, // input 174 (0xAE)
+    INVALID_VALUE, // input 175 (0xAF)
+    INVALID_VALUE, // input 176 (0xB0)
+    INVALID_VALUE, // input 177 (0xB1)
+    INVALID_VALUE, // input 178 (0xB2)
+    INVALID_VALUE, // input 179 (0xB3)
+    INVALID_VALUE, // input 180 (0xB4)
+    INVALID_VALUE, // input 181 (0xB5)
+    INVALID_VALUE, // input 182 (0xB6)
+    INVALID_VALUE, // input 183 (0xB7)
+    INVALID_VALUE, // input 184 (0xB8)
+    INVALID_VALUE, // input 185 (0xB9)
+    INVALID_VALUE, // input 186 (0xBA)
+    INVALID_VALUE, // input 187 (0xBB)
+    INVALID_VALUE, // input 188 (0xBC)
+    INVALID_VALUE, // input 189 (0xBD)
+    INVALID_VALUE, // input 190 (0xBE)
+    INVALID_VALUE, // input 191 (0xBF)
+    INVALID_VALUE, // input 192 (0xC0)
+    INVALID_VALUE, // input 193 (0xC1)
+    INVALID_VALUE, // input 194 (0xC2)
+    INVALID_VALUE, // input 195 (0xC3)
+    INVALID_VALUE, // input 196 (0xC4)
+    INVALID_VALUE, // input 197 (0xC5)
+    INVALID_VALUE, // input 198 (0xC6)
+    INVALID_VALUE, // input 199 (0xC7)
+    INVALID_VALUE, // input 200 (0xC8)
+    INVALID_VALUE, // input 201 (0xC9)
+    INVALID_VALUE, // input 202 (0xCA)
+    INVALID_VALUE, // input 203 (0xCB)
+    INVALID_VALUE, // input 204 (0xCC)
+    INVALID_VALUE, // input 205 (0xCD)
+    INVALID_VALUE, // input 206 (0xCE)
+    INVALID_VALUE, // input 207 (0xCF)
+    INVALID_VALUE, // input 208 (0xD0)
+    INVALID_VALUE, // input 209 (0xD1)
+    INVALID_VALUE, // input 210 (0xD2)
+    INVALID_VALUE, // input 211 (0xD3)
+    INVALID_VALUE, // input 212 (0xD4)
+    INVALID_VALUE, // input 213 (0xD5)
+    INVALID_VALUE, // input 214 (0xD6)
+    INVALID_VALUE, // input 215 (0xD7)
+    INVALID_VALUE, // input 216 (0xD8)
+    INVALID_VALUE, // input 217 (0xD9)
+    INVALID_VALUE, // input 218 (0xDA)
+    INVALID_VALUE, // input 219 (0xDB)
+    INVALID_VALUE, // input 220 (0xDC)
+    INVALID_VALUE, // input 221 (0xDD)
+    INVALID_VALUE, // input 222 (0xDE)
+    INVALID_VALUE, // input 223 (0xDF)
+    INVALID_VALUE, // input 224 (0xE0)
+    INVALID_VALUE, // input 225 (0xE1)
+    INVALID_VALUE, // input 226 (0xE2)
+    INVALID_VALUE, // input 227 (0xE3)
+    INVALID_VALUE, // input 228 (0xE4)
+    INVALID_VALUE, // input 229 (0xE5)
+    INVALID_VALUE, // input 230 (0xE6)
+    INVALID_VALUE, // input 231 (0xE7)
+    INVALID_VALUE, // input 232 (0xE8)
+    INVALID_VALUE, // input 233 (0xE9)
+    INVALID_VALUE, // input 234 (0xEA)
+    INVALID_VALUE, // input 235 (0xEB)
+    INVALID_VALUE, // input 236 (0xEC)
+    INVALID_VALUE, // input 237 (0xED)
+    INVALID_VALUE, // input 238 (0xEE)
+    INVALID_VALUE, // input 239 (0xEF)
+    INVALID_VALUE, // input 240 (0xF0)
+    INVALID_VALUE, // input 241 (0xF1)
+    INVALID_VALUE, // input 242 (0xF2)
+    INVALID_VALUE, // input 243 (0xF3)
+    INVALID_VALUE, // input 244 (0xF4)
+    INVALID_VALUE, // input 245 (0xF5)
+    INVALID_VALUE, // input 246 (0xF6)
+    INVALID_VALUE, // input 247 (0xF7)
+    INVALID_VALUE, // input 248 (0xF8)
+    INVALID_VALUE, // input 249 (0xF9)
+    INVALID_VALUE, // input 250 (0xFA)
+    INVALID_VALUE, // input 251 (0xFB)
+    INVALID_VALUE, // input 252 (0xFC)
+    INVALID_VALUE, // input 253 (0xFD)
+    INVALID_VALUE, // input 254 (0xFE)
+    INVALID_VALUE, // input 255 (0xFF)
+];
+#[cfg_attr(rustfmt, rustfmt_skip)]
+pub const URL_SAFE_ENCODE: &'static [u8; 64] = &[
+    65, // input 0 (0x0) => 'A' (0x41)
+    66, // input 1 (0x1) => 'B' (0x42)
+    67, // input 2 (0x2) => 'C' (0x43)
+    68, // input 3 (0x3) => 'D' (0x44)
+    69, // input 4 (0x4) => 'E' (0x45)
+    70, // input 5 (0x5) => 'F' (0x46)
+    71, // input 6 (0x6) => 'G' (0x47)
+    72, // input 7 (0x7) => 'H' (0x48)
+    73, // input 8 (0x8) => 'I' (0x49)
+    74, // input 9 (0x9) => 'J' (0x4A)
+    75, // input 10 (0xA) => 'K' (0x4B)
+    76, // input 11 (0xB) => 'L' (0x4C)
+    77, // input 12 (0xC) => 'M' (0x4D)
+    78, // input 13 (0xD) => 'N' (0x4E)
+    79, // input 14 (0xE) => 'O' (0x4F)
+    80, // input 15 (0xF) => 'P' (0x50)
+    81, // input 16 (0x10) => 'Q' (0x51)
+    82, // input 17 (0x11) => 'R' (0x52)
+    83, // input 18 (0x12) => 'S' (0x53)
+    84, // input 19 (0x13) => 'T' (0x54)
+    85, // input 20 (0x14) => 'U' (0x55)
+    86, // input 21 (0x15) => 'V' (0x56)
+    87, // input 22 (0x16) => 'W' (0x57)
+    88, // input 23 (0x17) => 'X' (0x58)
+    89, // input 24 (0x18) => 'Y' (0x59)
+    90, // input 25 (0x19) => 'Z' (0x5A)
+    97, // input 26 (0x1A) => 'a' (0x61)
+    98, // input 27 (0x1B) => 'b' (0x62)
+    99, // input 28 (0x1C) => 'c' (0x63)
+    100, // input 29 (0x1D) => 'd' (0x64)
+    101, // input 30 (0x1E) => 'e' (0x65)
+    102, // input 31 (0x1F) => 'f' (0x66)
+    103, // input 32 (0x20) => 'g' (0x67)
+    104, // input 33 (0x21) => 'h' (0x68)
+    105, // input 34 (0x22) => 'i' (0x69)
+    106, // input 35 (0x23) => 'j' (0x6A)
+    107, // input 36 (0x24) => 'k' (0x6B)
+    108, // input 37 (0x25) => 'l' (0x6C)
+    109, // input 38 (0x26) => 'm' (0x6D)
+    110, // input 39 (0x27) => 'n' (0x6E)
+    111, // input 40 (0x28) => 'o' (0x6F)
+    112, // input 41 (0x29) => 'p' (0x70)
+    113, // input 42 (0x2A) => 'q' (0x71)
+    114, // input 43 (0x2B) => 'r' (0x72)
+    115, // input 44 (0x2C) => 's' (0x73)
+    116, // input 45 (0x2D) => 't' (0x74)
+    117, // input 46 (0x2E) => 'u' (0x75)
+    118, // input 47 (0x2F) => 'v' (0x76)
+    119, // input 48 (0x30) => 'w' (0x77)
+    120, // input 49 (0x31) => 'x' (0x78)
+    121, // input 50 (0x32) => 'y' (0x79)
+    122, // input 51 (0x33) => 'z' (0x7A)
+    48, // input 52 (0x34) => '0' (0x30)
+    49, // input 53 (0x35) => '1' (0x31)
+    50, // input 54 (0x36) => '2' (0x32)
+    51, // input 55 (0x37) => '3' (0x33)
+    52, // input 56 (0x38) => '4' (0x34)
+    53, // input 57 (0x39) => '5' (0x35)
+    54, // input 58 (0x3A) => '6' (0x36)
+    55, // input 59 (0x3B) => '7' (0x37)
+    56, // input 60 (0x3C) => '8' (0x38)
+    57, // input 61 (0x3D) => '9' (0x39)
+    45, // input 62 (0x3E) => '-' (0x2D)
+    95, // input 63 (0x3F) => '_' (0x5F)
+];
+#[cfg_attr(rustfmt, rustfmt_skip)]
+pub const URL_SAFE_DECODE: &'static [u8; 256] = &[
+    INVALID_VALUE, // input 0 (0x0)
+    INVALID_VALUE, // input 1 (0x1)
+    INVALID_VALUE, // input 2 (0x2)
+    INVALID_VALUE, // input 3 (0x3)
+    INVALID_VALUE, // input 4 (0x4)
+    INVALID_VALUE, // input 5 (0x5)
+    INVALID_VALUE, // input 6 (0x6)
+    INVALID_VALUE, // input 7 (0x7)
+    INVALID_VALUE, // input 8 (0x8)
+    INVALID_VALUE, // input 9 (0x9)
+    INVALID_VALUE, // input 10 (0xA)
+    INVALID_VALUE, // input 11 (0xB)
+    INVALID_VALUE, // input 12 (0xC)
+    INVALID_VALUE, // input 13 (0xD)
+    INVALID_VALUE, // input 14 (0xE)
+    INVALID_VALUE, // input 15 (0xF)
+    INVALID_VALUE, // input 16 (0x10)
+    INVALID_VALUE, // input 17 (0x11)
+    INVALID_VALUE, // input 18 (0x12)
+    INVALID_VALUE, // input 19 (0x13)
+    INVALID_VALUE, // input 20 (0x14)
+    INVALID_VALUE, // input 21 (0x15)
+    INVALID_VALUE, // input 22 (0x16)
+    INVALID_VALUE, // input 23 (0x17)
+    INVALID_VALUE, // input 24 (0x18)
+    INVALID_VALUE, // input 25 (0x19)
+    INVALID_VALUE, // input 26 (0x1A)
+    INVALID_VALUE, // input 27 (0x1B)
+    INVALID_VALUE, // input 28 (0x1C)
+    INVALID_VALUE, // input 29 (0x1D)
+    INVALID_VALUE, // input 30 (0x1E)
+    INVALID_VALUE, // input 31 (0x1F)
+    INVALID_VALUE, // input 32 (0x20)
+    INVALID_VALUE, // input 33 (0x21)
+    INVALID_VALUE, // input 34 (0x22)
+    INVALID_VALUE, // input 35 (0x23)
+    INVALID_VALUE, // input 36 (0x24)
+    INVALID_VALUE, // input 37 (0x25)
+    INVALID_VALUE, // input 38 (0x26)
+    INVALID_VALUE, // input 39 (0x27)
+    INVALID_VALUE, // input 40 (0x28)
+    INVALID_VALUE, // input 41 (0x29)
+    INVALID_VALUE, // input 42 (0x2A)
+    INVALID_VALUE, // input 43 (0x2B)
+    INVALID_VALUE, // input 44 (0x2C)
+    62, // input 45 (0x2D char '-') => 62 (0x3E)
+    INVALID_VALUE, // input 46 (0x2E)
+    INVALID_VALUE, // input 47 (0x2F)
+    52, // input 48 (0x30 char '0') => 52 (0x34)
+    53, // input 49 (0x31 char '1') => 53 (0x35)
+    54, // input 50 (0x32 char '2') => 54 (0x36)
+    55, // input 51 (0x33 char '3') => 55 (0x37)
+    56, // input 52 (0x34 char '4') => 56 (0x38)
+    57, // input 53 (0x35 char '5') => 57 (0x39)
+    58, // input 54 (0x36 char '6') => 58 (0x3A)
+    59, // input 55 (0x37 char '7') => 59 (0x3B)
+    60, // input 56 (0x38 char '8') => 60 (0x3C)
+    61, // input 57 (0x39 char '9') => 61 (0x3D)
+    INVALID_VALUE, // input 58 (0x3A)
+    INVALID_VALUE, // input 59 (0x3B)
+    INVALID_VALUE, // input 60 (0x3C)
+    INVALID_VALUE, // input 61 (0x3D)
+    INVALID_VALUE, // input 62 (0x3E)
+    INVALID_VALUE, // input 63 (0x3F)
+    INVALID_VALUE, // input 64 (0x40)
+    0, // input 65 (0x41 char 'A') => 0 (0x0)
+    1, // input 66 (0x42 char 'B') => 1 (0x1)
+    2, // input 67 (0x43 char 'C') => 2 (0x2)
+    3, // input 68 (0x44 char 'D') => 3 (0x3)
+    4, // input 69 (0x45 char 'E') => 4 (0x4)
+    5, // input 70 (0x46 char 'F') => 5 (0x5)
+    6, // input 71 (0x47 char 'G') => 6 (0x6)
+    7, // input 72 (0x48 char 'H') => 7 (0x7)
+    8, // input 73 (0x49 char 'I') => 8 (0x8)
+    9, // input 74 (0x4A char 'J') => 9 (0x9)
+    10, // input 75 (0x4B char 'K') => 10 (0xA)
+    11, // input 76 (0x4C char 'L') => 11 (0xB)
+    12, // input 77 (0x4D char 'M') => 12 (0xC)
+    13, // input 78 (0x4E char 'N') => 13 (0xD)
+    14, // input 79 (0x4F char 'O') => 14 (0xE)
+    15, // input 80 (0x50 char 'P') => 15 (0xF)
+    16, // input 81 (0x51 char 'Q') => 16 (0x10)
+    17, // input 82 (0x52 char 'R') => 17 (0x11)
+    18, // input 83 (0x53 char 'S') => 18 (0x12)
+    19, // input 84 (0x54 char 'T') => 19 (0x13)
+    20, // input 85 (0x55 char 'U') => 20 (0x14)
+    21, // input 86 (0x56 char 'V') => 21 (0x15)
+    22, // input 87 (0x57 char 'W') => 22 (0x16)
+    23, // input 88 (0x58 char 'X') => 23 (0x17)
+    24, // input 89 (0x59 char 'Y') => 24 (0x18)
+    25, // input 90 (0x5A char 'Z') => 25 (0x19)
+    INVALID_VALUE, // input 91 (0x5B)
+    INVALID_VALUE, // input 92 (0x5C)
+    INVALID_VALUE, // input 93 (0x5D)
+    INVALID_VALUE, // input 94 (0x5E)
+    63, // input 95 (0x5F char '_') => 63 (0x3F)
+    INVALID_VALUE, // input 96 (0x60)
+    26, // input 97 (0x61 char 'a') => 26 (0x1A)
+    27, // input 98 (0x62 char 'b') => 27 (0x1B)
+    28, // input 99 (0x63 char 'c') => 28 (0x1C)
+    29, // input 100 (0x64 char 'd') => 29 (0x1D)
+    30, // input 101 (0x65 char 'e') => 30 (0x1E)
+    31, // input 102 (0x66 char 'f') => 31 (0x1F)
+    32, // input 103 (0x67 char 'g') => 32 (0x20)
+    33, // input 104 (0x68 char 'h') => 33 (0x21)
+    34, // input 105 (0x69 char 'i') => 34 (0x22)
+    35, // input 106 (0x6A char 'j') => 35 (0x23)
+    36, // input 107 (0x6B char 'k') => 36 (0x24)
+    37, // input 108 (0x6C char 'l') => 37 (0x25)
+    38, // input 109 (0x6D char 'm') => 38 (0x26)
+    39, // input 110 (0x6E char 'n') => 39 (0x27)
+    40, // input 111 (0x6F char 'o') => 40 (0x28)
+    41, // input 112 (0x70 char 'p') => 41 (0x29)
+    42, // input 113 (0x71 char 'q') => 42 (0x2A)
+    43, // input 114 (0x72 char 'r') => 43 (0x2B)
+    44, // input 115 (0x73 char 's') => 44 (0x2C)
+    45, // input 116 (0x74 char 't') => 45 (0x2D)
+    46, // input 117 (0x75 char 'u') => 46 (0x2E)
+    47, // input 118 (0x76 char 'v') => 47 (0x2F)
+    48, // input 119 (0x77 char 'w') => 48 (0x30)
+    49, // input 120 (0x78 char 'x') => 49 (0x31)
+    50, // input 121 (0x79 char 'y') => 50 (0x32)
+    51, // input 122 (0x7A char 'z') => 51 (0x33)
+    INVALID_VALUE, // input 123 (0x7B)
+    INVALID_VALUE, // input 124 (0x7C)
+    INVALID_VALUE, // input 125 (0x7D)
+    INVALID_VALUE, // input 126 (0x7E)
+    INVALID_VALUE, // input 127 (0x7F)
+    INVALID_VALUE, // input 128 (0x80)
+    INVALID_VALUE, // input 129 (0x81)
+    INVALID_VALUE, // input 130 (0x82)
+    INVALID_VALUE, // input 131 (0x83)
+    INVALID_VALUE, // input 132 (0x84)
+    INVALID_VALUE, // input 133 (0x85)
+    INVALID_VALUE, // input 134 (0x86)
+    INVALID_VALUE, // input 135 (0x87)
+    INVALID_VALUE, // input 136 (0x88)
+    INVALID_VALUE, // input 137 (0x89)
+    INVALID_VALUE, // input 138 (0x8A)
+    INVALID_VALUE, // input 139 (0x8B)
+    INVALID_VALUE, // input 140 (0x8C)
+    INVALID_VALUE, // input 141 (0x8D)
+    INVALID_VALUE, // input 142 (0x8E)
+    INVALID_VALUE, // input 143 (0x8F)
+    INVALID_VALUE, // input 144 (0x90)
+    INVALID_VALUE, // input 145 (0x91)
+    INVALID_VALUE, // input 146 (0x92)
+    INVALID_VALUE, // input 147 (0x93)
+    INVALID_VALUE, // input 148 (0x94)
+    INVALID_VALUE, // input 149 (0x95)
+    INVALID_VALUE, // input 150 (0x96)
+    INVALID_VALUE, // input 151 (0x97)
+    INVALID_VALUE, // input 152 (0x98)
+    INVALID_VALUE, // input 153 (0x99)
+    INVALID_VALUE, // input 154 (0x9A)
+    INVALID_VALUE, // input 155 (0x9B)
+    INVALID_VALUE, // input 156 (0x9C)
+    INVALID_VALUE, // input 157 (0x9D)
+    INVALID_VALUE, // input 158 (0x9E)
+    INVALID_VALUE, // input 159 (0x9F)
+    INVALID_VALUE, // input 160 (0xA0)
+    INVALID_VALUE, // input 161 (0xA1)
+    INVALID_VALUE, // input 162 (0xA2)
+    INVALID_VALUE, // input 163 (0xA3)
+    INVALID_VALUE, // input 164 (0xA4)
+    INVALID_VALUE, // input 165 (0xA5)
+    INVALID_VALUE, // input 166 (0xA6)
+    INVALID_VALUE, // input 167 (0xA7)
+    INVALID_VALUE, // input 168 (0xA8)
+    INVALID_VALUE, // input 169 (0xA9)
+    INVALID_VALUE, // input 170 (0xAA)
+    INVALID_VALUE, // input 171 (0xAB)
+    INVALID_VALUE, // input 172 (0xAC)
+    INVALID_VALUE, // input 173 (0xAD)
+    INVALID_VALUE, // input 174 (0xAE)
+    INVALID_VALUE, // input 175 (0xAF)
+    INVALID_VALUE, // input 176 (0xB0)
+    INVALID_VALUE, // input 177 (0xB1)
+    INVALID_VALUE, // input 178 (0xB2)
+    INVALID_VALUE, // input 179 (0xB3)
+    INVALID_VALUE, // input 180 (0xB4)
+    INVALID_VALUE, // input 181 (0xB5)
+    INVALID_VALUE, // input 182 (0xB6)
+    INVALID_VALUE, // input 183 (0xB7)
+    INVALID_VALUE, // input 184 (0xB8)
+    INVALID_VALUE, // input 185 (0xB9)
+    INVALID_VALUE, // input 186 (0xBA)
+    INVALID_VALUE, // input 187 (0xBB)
+    INVALID_VALUE, // input 188 (0xBC)
+    INVALID_VALUE, // input 189 (0xBD)
+    INVALID_VALUE, // input 190 (0xBE)
+    INVALID_VALUE, // input 191 (0xBF)
+    INVALID_VALUE, // input 192 (0xC0)
+    INVALID_VALUE, // input 193 (0xC1)
+    INVALID_VALUE, // input 194 (0xC2)
+    INVALID_VALUE, // input 195 (0xC3)
+    INVALID_VALUE, // input 196 (0xC4)
+    INVALID_VALUE, // input 197 (0xC5)
+    INVALID_VALUE, // input 198 (0xC6)
+    INVALID_VALUE, // input 199 (0xC7)
+    INVALID_VALUE, // input 200 (0xC8)
+    INVALID_VALUE, // input 201 (0xC9)
+    INVALID_VALUE, // input 202 (0xCA)
+    INVALID_VALUE, // input 203 (0xCB)
+    INVALID_VALUE, // input 204 (0xCC)
+    INVALID_VALUE, // input 205 (0xCD)
+    INVALID_VALUE, // input 206 (0xCE)
+    INVALID_VALUE, // input 207 (0xCF)
+    INVALID_VALUE, // input 208 (0xD0)
+    INVALID_VALUE, // input 209 (0xD1)
+    INVALID_VALUE, // input 210 (0xD2)
+    INVALID_VALUE, // input 211 (0xD3)
+    INVALID_VALUE, // input 212 (0xD4)
+    INVALID_VALUE, // input 213 (0xD5)
+    INVALID_VALUE, // input 214 (0xD6)
+    INVALID_VALUE, // input 215 (0xD7)
+    INVALID_VALUE, // input 216 (0xD8)
+    INVALID_VALUE, // input 217 (0xD9)
+    INVALID_VALUE, // input 218 (0xDA)
+    INVALID_VALUE, // input 219 (0xDB)
+    INVALID_VALUE, // input 220 (0xDC)
+    INVALID_VALUE, // input 221 (0xDD)
+    INVALID_VALUE, // input 222 (0xDE)
+    INVALID_VALUE, // input 223 (0xDF)
+    INVALID_VALUE, // input 224 (0xE0)
+    INVALID_VALUE, // input 225 (0xE1)
+    INVALID_VALUE, // input 226 (0xE2)
+    INVALID_VALUE, // input 227 (0xE3)
+    INVALID_VALUE, // input 228 (0xE4)
+    INVALID_VALUE, // input 229 (0xE5)
+    INVALID_VALUE, // input 230 (0xE6)
+    INVALID_VALUE, // input 231 (0xE7)
+    INVALID_VALUE, // input 232 (0xE8)
+    INVALID_VALUE, // input 233 (0xE9)
+    INVALID_VALUE, // input 234 (0xEA)
+    INVALID_VALUE, // input 235 (0xEB)
+    INVALID_VALUE, // input 236 (0xEC)
+    INVALID_VALUE, // input 237 (0xED)
+    INVALID_VALUE, // input 238 (0xEE)
+    INVALID_VALUE, // input 239 (0xEF)
+    INVALID_VALUE, // input 240 (0xF0)
+    INVALID_VALUE, // input 241 (0xF1)
+    INVALID_VALUE, // input 242 (0xF2)
+    INVALID_VALUE, // input 243 (0xF3)
+    INVALID_VALUE, // input 244 (0xF4)
+    INVALID_VALUE, // input 245 (0xF5)
+    INVALID_VALUE, // input 246 (0xF6)
+    INVALID_VALUE, // input 247 (0xF7)
+    INVALID_VALUE, // input 248 (0xF8)
+    INVALID_VALUE, // input 249 (0xF9)
+    INVALID_VALUE, // input 250 (0xFA)
+    INVALID_VALUE, // input 251 (0xFB)
+    INVALID_VALUE, // input 252 (0xFC)
+    INVALID_VALUE, // input 253 (0xFD)
+    INVALID_VALUE, // input 254 (0xFE)
+    INVALID_VALUE, // input 255 (0xFF)
+];
+#[cfg_attr(rustfmt, rustfmt_skip)]
+pub const CRYPT_ENCODE: &'static [u8; 64] = &[
+    46, // input 0 (0x0) => '.' (0x2E)
+    47, // input 1 (0x1) => '/' (0x2F)
+    48, // input 2 (0x2) => '0' (0x30)
+    49, // input 3 (0x3) => '1' (0x31)
+    50, // input 4 (0x4) => '2' (0x32)
+    51, // input 5 (0x5) => '3' (0x33)
+    52, // input 6 (0x6) => '4' (0x34)
+    53, // input 7 (0x7) => '5' (0x35)
+    54, // input 8 (0x8) => '6' (0x36)
+    55, // input 9 (0x9) => '7' (0x37)
+    56, // input 10 (0xA) => '8' (0x38)
+    57, // input 11 (0xB) => '9' (0x39)
+    65, // input 12 (0xC) => 'A' (0x41)
+    66, // input 13 (0xD) => 'B' (0x42)
+    67, // input 14 (0xE) => 'C' (0x43)
+    68, // input 15 (0xF) => 'D' (0x44)
+    69, // input 16 (0x10) => 'E' (0x45)
+    70, // input 17 (0x11) => 'F' (0x46)
+    71, // input 18 (0x12) => 'G' (0x47)
+    72, // input 19 (0x13) => 'H' (0x48)
+    73, // input 20 (0x14) => 'I' (0x49)
+    74, // input 21 (0x15) => 'J' (0x4A)
+    75, // input 22 (0x16) => 'K' (0x4B)
+    76, // input 23 (0x17) => 'L' (0x4C)
+    77, // input 24 (0x18) => 'M' (0x4D)
+    78, // input 25 (0x19) => 'N' (0x4E)
+    79, // input 26 (0x1A) => 'O' (0x4F)
+    80, // input 27 (0x1B) => 'P' (0x50)
+    81, // input 28 (0x1C) => 'Q' (0x51)
+    82, // input 29 (0x1D) => 'R' (0x52)
+    83, // input 30 (0x1E) => 'S' (0x53)
+    84, // input 31 (0x1F) => 'T' (0x54)
+    85, // input 32 (0x20) => 'U' (0x55)
+    86, // input 33 (0x21) => 'V' (0x56)
+    87, // input 34 (0x22) => 'W' (0x57)
+    88, // input 35 (0x23) => 'X' (0x58)
+    89, // input 36 (0x24) => 'Y' (0x59)
+    90, // input 37 (0x25) => 'Z' (0x5A)
+    97, // input 38 (0x26) => 'a' (0x61)
+    98, // input 39 (0x27) => 'b' (0x62)
+    99, // input 40 (0x28) => 'c' (0x63)
+    100, // input 41 (0x29) => 'd' (0x64)
+    101, // input 42 (0x2A) => 'e' (0x65)
+    102, // input 43 (0x2B) => 'f' (0x66)
+    103, // input 44 (0x2C) => 'g' (0x67)
+    104, // input 45 (0x2D) => 'h' (0x68)
+    105, // input 46 (0x2E) => 'i' (0x69)
+    106, // input 47 (0x2F) => 'j' (0x6A)
+    107, // input 48 (0x30) => 'k' (0x6B)
+    108, // input 49 (0x31) => 'l' (0x6C)
+    109, // input 50 (0x32) => 'm' (0x6D)
+    110, // input 51 (0x33) => 'n' (0x6E)
+    111, // input 52 (0x34) => 'o' (0x6F)
+    112, // input 53 (0x35) => 'p' (0x70)
+    113, // input 54 (0x36) => 'q' (0x71)
+    114, // input 55 (0x37) => 'r' (0x72)
+    115, // input 56 (0x38) => 's' (0x73)
+    116, // input 57 (0x39) => 't' (0x74)
+    117, // input 58 (0x3A) => 'u' (0x75)
+    118, // input 59 (0x3B) => 'v' (0x76)
+    119, // input 60 (0x3C) => 'w' (0x77)
+    120, // input 61 (0x3D) => 'x' (0x78)
+    121, // input 62 (0x3E) => 'y' (0x79)
+    122, // input 63 (0x3F) => 'z' (0x7A)
+];
+#[cfg_attr(rustfmt, rustfmt_skip)]
+pub const CRYPT_DECODE: &'static [u8; 256] = &[
+    INVALID_VALUE, // input 0 (0x0)
+    INVALID_VALUE, // input 1 (0x1)
+    INVALID_VALUE, // input 2 (0x2)
+    INVALID_VALUE, // input 3 (0x3)
+    INVALID_VALUE, // input 4 (0x4)
+    INVALID_VALUE, // input 5 (0x5)
+    INVALID_VALUE, // input 6 (0x6)
+    INVALID_VALUE, // input 7 (0x7)
+    INVALID_VALUE, // input 8 (0x8)
+    INVALID_VALUE, // input 9 (0x9)
+    INVALID_VALUE, // input 10 (0xA)
+    INVALID_VALUE, // input 11 (0xB)
+    INVALID_VALUE, // input 12 (0xC)
+    INVALID_VALUE, // input 13 (0xD)
+    INVALID_VALUE, // input 14 (0xE)
+    INVALID_VALUE, // input 15 (0xF)
+    INVALID_VALUE, // input 16 (0x10)
+    INVALID_VALUE, // input 17 (0x11)
+    INVALID_VALUE, // input 18 (0x12)
+    INVALID_VALUE, // input 19 (0x13)
+    INVALID_VALUE, // input 20 (0x14)
+    INVALID_VALUE, // input 21 (0x15)
+    INVALID_VALUE, // input 22 (0x16)
+    INVALID_VALUE, // input 23 (0x17)
+    INVALID_VALUE, // input 24 (0x18)
+    INVALID_VALUE, // input 25 (0x19)
+    INVALID_VALUE, // input 26 (0x1A)
+    INVALID_VALUE, // input 27 (0x1B)
+    INVALID_VALUE, // input 28 (0x1C)
+    INVALID_VALUE, // input 29 (0x1D)
+    INVALID_VALUE, // input 30 (0x1E)
+    INVALID_VALUE, // input 31 (0x1F)
+    INVALID_VALUE, // input 32 (0x20)
+    INVALID_VALUE, // input 33 (0x21)
+    INVALID_VALUE, // input 34 (0x22)
+    INVALID_VALUE, // input 35 (0x23)
+    INVALID_VALUE, // input 36 (0x24)
+    INVALID_VALUE, // input 37 (0x25)
+    INVALID_VALUE, // input 38 (0x26)
+    INVALID_VALUE, // input 39 (0x27)
+    INVALID_VALUE, // input 40 (0x28)
+    INVALID_VALUE, // input 41 (0x29)
+    INVALID_VALUE, // input 42 (0x2A)
+    INVALID_VALUE, // input 43 (0x2B)
+    INVALID_VALUE, // input 44 (0x2C)
+    INVALID_VALUE, // input 45 (0x2D)
+    0, // input 46 (0x2E char '.') => 0 (0x0)
+    1, // input 47 (0x2F char '/') => 1 (0x1)
+    2, // input 48 (0x30 char '0') => 2 (0x2)
+    3, // input 49 (0x31 char '1') => 3 (0x3)
+    4, // input 50 (0x32 char '2') => 4 (0x4)
+    5, // input 51 (0x33 char '3') => 5 (0x5)
+    6, // input 52 (0x34 char '4') => 6 (0x6)
+    7, // input 53 (0x35 char '5') => 7 (0x7)
+    8, // input 54 (0x36 char '6') => 8 (0x8)
+    9, // input 55 (0x37 char '7') => 9 (0x9)
+    10, // input 56 (0x38 char '8') => 10 (0xA)
+    11, // input 57 (0x39 char '9') => 11 (0xB)
+    INVALID_VALUE, // input 58 (0x3A)
+    INVALID_VALUE, // input 59 (0x3B)
+    INVALID_VALUE, // input 60 (0x3C)
+    INVALID_VALUE, // input 61 (0x3D)
+    INVALID_VALUE, // input 62 (0x3E)
+    INVALID_VALUE, // input 63 (0x3F)
+    INVALID_VALUE, // input 64 (0x40)
+    12, // input 65 (0x41 char 'A') => 12 (0xC)
+    13, // input 66 (0x42 char 'B') => 13 (0xD)
+    14, // input 67 (0x43 char 'C') => 14 (0xE)
+    15, // input 68 (0x44 char 'D') => 15 (0xF)
+    16, // input 69 (0x45 char 'E') => 16 (0x10)
+    17, // input 70 (0x46 char 'F') => 17 (0x11)
+    18, // input 71 (0x47 char 'G') => 18 (0x12)
+    19, // input 72 (0x48 char 'H') => 19 (0x13)
+    20, // input 73 (0x49 char 'I') => 20 (0x14)
+    21, // input 74 (0x4A char 'J') => 21 (0x15)
+    22, // input 75 (0x4B char 'K') => 22 (0x16)
+    23, // input 76 (0x4C char 'L') => 23 (0x17)
+    24, // input 77 (0x4D char 'M') => 24 (0x18)
+    25, // input 78 (0x4E char 'N') => 25 (0x19)
+    26, // input 79 (0x4F char 'O') => 26 (0x1A)
+    27, // input 80 (0x50 char 'P') => 27 (0x1B)
+    28, // input 81 (0x51 char 'Q') => 28 (0x1C)
+    29, // input 82 (0x52 char 'R') => 29 (0x1D)
+    30, // input 83 (0x53 char 'S') => 30 (0x1E)
+    31, // input 84 (0x54 char 'T') => 31 (0x1F)
+    32, // input 85 (0x55 char 'U') => 32 (0x20)
+    33, // input 86 (0x56 char 'V') => 33 (0x21)
+    34, // input 87 (0x57 char 'W') => 34 (0x22)
+    35, // input 88 (0x58 char 'X') => 35 (0x23)
+    36, // input 89 (0x59 char 'Y') => 36 (0x24)
+    37, // input 90 (0x5A char 'Z') => 37 (0x25)
+    INVALID_VALUE, // input 91 (0x5B)
+    INVALID_VALUE, // input 92 (0x5C)
+    INVALID_VALUE, // input 93 (0x5D)
+    INVALID_VALUE, // input 94 (0x5E)
+    INVALID_VALUE, // input 95 (0x5F)
+    INVALID_VALUE, // input 96 (0x60)
+    38, // input 97 (0x61 char 'a') => 38 (0x26)
+    39, // input 98 (0x62 char 'b') => 39 (0x27)
+    40, // input 99 (0x63 char 'c') => 40 (0x28)
+    41, // input 100 (0x64 char 'd') => 41 (0x29)
+    42, // input 101 (0x65 char 'e') => 42 (0x2A)
+    43, // input 102 (0x66 char 'f') => 43 (0x2B)
+    44, // input 103 (0x67 char 'g') => 44 (0x2C)
+    45, // input 104 (0x68 char 'h') => 45 (0x2D)
+    46, // input 105 (0x69 char 'i') => 46 (0x2E)
+    47, // input 106 (0x6A char 'j') => 47 (0x2F)
+    48, // input 107 (0x6B char 'k') => 48 (0x30)
+    49, // input 108 (0x6C char 'l') => 49 (0x31)
+    50, // input 109 (0x6D char 'm') => 50 (0x32)
+    51, // input 110 (0x6E char 'n') => 51 (0x33)
+    52, // input 111 (0x6F char 'o') => 52 (0x34)
+    53, // input 112 (0x70 char 'p') => 53 (0x35)
+    54, // input 113 (0x71 char 'q') => 54 (0x36)
+    55, // input 114 (0x72 char 'r') => 55 (0x37)
+    56, // input 115 (0x73 char 's') => 56 (0x38)
+    57, // input 116 (0x74 char 't') => 57 (0x39)
+    58, // input 117 (0x75 char 'u') => 58 (0x3A)
+    59, // input 118 (0x76 char 'v') => 59 (0x3B)
+    60, // input 119 (0x77 char 'w') => 60 (0x3C)
+    61, // input 120 (0x78 char 'x') => 61 (0x3D)
+    62, // input 121 (0x79 char 'y') => 62 (0x3E)
+    63, // input 122 (0x7A char 'z') => 63 (0x3F)
+    INVALID_VALUE, // input 123 (0x7B)
+    INVALID_VALUE, // input 124 (0x7C)
+    INVALID_VALUE, // input 125 (0x7D)
+    INVALID_VALUE, // input 126 (0x7E)
+    INVALID_VALUE, // input 127 (0x7F)
+    INVALID_VALUE, // input 128 (0x80)
+    INVALID_VALUE, // input 129 (0x81)
+    INVALID_VALUE, // input 130 (0x82)
+    INVALID_VALUE, // input 131 (0x83)
+    INVALID_VALUE, // input 132 (0x84)
+    INVALID_VALUE, // input 133 (0x85)
+    INVALID_VALUE, // input 134 (0x86)
+    INVALID_VALUE, // input 135 (0x87)
+    INVALID_VALUE, // input 136 (0x88)
+    INVALID_VALUE, // input 137 (0x89)
+    INVALID_VALUE, // input 138 (0x8A)
+    INVALID_VALUE, // input 139 (0x8B)
+    INVALID_VALUE, // input 140 (0x8C)
+    INVALID_VALUE, // input 141 (0x8D)
+    INVALID_VALUE, // input 142 (0x8E)
+    INVALID_VALUE, // input 143 (0x8F)
+    INVALID_VALUE, // input 144 (0x90)
+    INVALID_VALUE, // input 145 (0x91)
+    INVALID_VALUE, // input 146 (0x92)
+    INVALID_VALUE, // input 147 (0x93)
+    INVALID_VALUE, // input 148 (0x94)
+    INVALID_VALUE, // input 149 (0x95)
+    INVALID_VALUE, // input 150 (0x96)
+    INVALID_VALUE, // input 151 (0x97)
+    INVALID_VALUE, // input 152 (0x98)
+    INVALID_VALUE, // input 153 (0x99)
+    INVALID_VALUE, // input 154 (0x9A)
+    INVALID_VALUE, // input 155 (0x9B)
+    INVALID_VALUE, // input 156 (0x9C)
+    INVALID_VALUE, // input 157 (0x9D)
+    INVALID_VALUE, // input 158 (0x9E)
+    INVALID_VALUE, // input 159 (0x9F)
+    INVALID_VALUE, // input 160 (0xA0)
+    INVALID_VALUE, // input 161 (0xA1)
+    INVALID_VALUE, // input 162 (0xA2)
+    INVALID_VALUE, // input 163 (0xA3)
+    INVALID_VALUE, // input 164 (0xA4)
+    INVALID_VALUE, // input 165 (0xA5)
+    INVALID_VALUE, // input 166 (0xA6)
+    INVALID_VALUE, // input 167 (0xA7)
+    INVALID_VALUE, // input 168 (0xA8)
+    INVALID_VALUE, // input 169 (0xA9)
+    INVALID_VALUE, // input 170 (0xAA)
+    INVALID_VALUE, // input 171 (0xAB)
+    INVALID_VALUE, // input 172 (0xAC)
+    INVALID_VALUE, // input 173 (0xAD)
+    INVALID_VALUE, // input 174 (0xAE)
+    INVALID_VALUE, // input 175 (0xAF)
+    INVALID_VALUE, // input 176 (0xB0)
+    INVALID_VALUE, // input 177 (0xB1)
+    INVALID_VALUE, // input 178 (0xB2)
+    INVALID_VALUE, // input 179 (0xB3)
+    INVALID_VALUE, // input 180 (0xB4)
+    INVALID_VALUE, // input 181 (0xB5)
+    INVALID_VALUE, // input 182 (0xB6)
+    INVALID_VALUE, // input 183 (0xB7)
+    INVALID_VALUE, // input 184 (0xB8)
+    INVALID_VALUE, // input 185 (0xB9)
+    INVALID_VALUE, // input 186 (0xBA)
+    INVALID_VALUE, // input 187 (0xBB)
+    INVALID_VALUE, // input 188 (0xBC)
+    INVALID_VALUE, // input 189 (0xBD)
+    INVALID_VALUE, // input 190 (0xBE)
+    INVALID_VALUE, // input 191 (0xBF)
+    INVALID_VALUE, // input 192 (0xC0)
+    INVALID_VALUE, // input 193 (0xC1)
+    INVALID_VALUE, // input 194 (0xC2)
+    INVALID_VALUE, // input 195 (0xC3)
+    INVALID_VALUE, // input 196 (0xC4)
+    INVALID_VALUE, // input 197 (0xC5)
+    INVALID_VALUE, // input 198 (0xC6)
+    INVALID_VALUE, // input 199 (0xC7)
+    INVALID_VALUE, // input 200 (0xC8)
+    INVALID_VALUE, // input 201 (0xC9)
+    INVALID_VALUE, // input 202 (0xCA)
+    INVALID_VALUE, // input 203 (0xCB)
+    INVALID_VALUE, // input 204 (0xCC)
+    INVALID_VALUE, // input 205 (0xCD)
+    INVALID_VALUE, // input 206 (0xCE)
+    INVALID_VALUE, // input 207 (0xCF)
+    INVALID_VALUE, // input 208 (0xD0)
+    INVALID_VALUE, // input 209 (0xD1)
+    INVALID_VALUE, // input 210 (0xD2)
+    INVALID_VALUE, // input 211 (0xD3)
+    INVALID_VALUE, // input 212 (0xD4)
+    INVALID_VALUE, // input 213 (0xD5)
+    INVALID_VALUE, // input 214 (0xD6)
+    INVALID_VALUE, // input 215 (0xD7)
+    INVALID_VALUE, // input 216 (0xD8)
+    INVALID_VALUE, // input 217 (0xD9)
+    INVALID_VALUE, // input 218 (0xDA)
+    INVALID_VALUE, // input 219 (0xDB)
+    INVALID_VALUE, // input 220 (0xDC)
+    INVALID_VALUE, // input 221 (0xDD)
+    INVALID_VALUE, // input 222 (0xDE)
+    INVALID_VALUE, // input 223 (0xDF)
+    INVALID_VALUE, // input 224 (0xE0)
+    INVALID_VALUE, // input 225 (0xE1)
+    INVALID_VALUE, // input 226 (0xE2)
+    INVALID_VALUE, // input 227 (0xE3)
+    INVALID_VALUE, // input 228 (0xE4)
+    INVALID_VALUE, // input 229 (0xE5)
+    INVALID_VALUE, // input 230 (0xE6)
+    INVALID_VALUE, // input 231 (0xE7)
+    INVALID_VALUE, // input 232 (0xE8)
+    INVALID_VALUE, // input 233 (0xE9)
+    INVALID_VALUE, // input 234 (0xEA)
+    INVALID_VALUE, // input 235 (0xEB)
+    INVALID_VALUE, // input 236 (0xEC)
+    INVALID_VALUE, // input 237 (0xED)
+    INVALID_VALUE, // input 238 (0xEE)
+    INVALID_VALUE, // input 239 (0xEF)
+    INVALID_VALUE, // input 240 (0xF0)
+    INVALID_VALUE, // input 241 (0xF1)
+    INVALID_VALUE, // input 242 (0xF2)
+    INVALID_VALUE, // input 243 (0xF3)
+    INVALID_VALUE, // input 244 (0xF4)
+    INVALID_VALUE, // input 245 (0xF5)
+    INVALID_VALUE, // input 246 (0xF6)
+    INVALID_VALUE, // input 247 (0xF7)
+    INVALID_VALUE, // input 248 (0xF8)
+    INVALID_VALUE, // input 249 (0xF9)
+    INVALID_VALUE, // input 250 (0xFA)
+    INVALID_VALUE, // input 251 (0xFB)
+    INVALID_VALUE, // input 252 (0xFC)
+    INVALID_VALUE, // input 253 (0xFD)
+    INVALID_VALUE, // input 254 (0xFE)
+    INVALID_VALUE, // input 255 (0xFF)
+];
diff --git a/rustc_deps/vendor/base64-0.9.3/src/tests.rs b/rustc_deps/vendor/base64-0.9.3/src/tests.rs
new file mode 100644
index 0000000..ff0f4b6
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/src/tests.rs
@@ -0,0 +1,114 @@
+extern crate rand;
+
+use encode::encoded_size;
+use line_wrap::line_wrap_parameters;
+use *;
+
+use std::str;
+
+use self::rand::distributions::{IndependentSample, Range};
+use self::rand::Rng;
+
+#[test]
+fn roundtrip_random_config_short() {
+    // exercise the slower encode/decode routines that operate on shorter buffers more vigorously
+    roundtrip_random_config(Range::new(0, 50), Range::new(0, 50), 10_000);
+}
+
+#[test]
+fn roundtrip_random_config_long() {
+    roundtrip_random_config(Range::new(0, 1000), Range::new(0, 1000), 10_000);
+}
+
+pub fn assert_encode_sanity(encoded: &str, config: &Config, input_len: usize) {
+    let input_rem = input_len % 3;
+    let (expected_padding_len, last_encoded_chunk_len) = if input_rem > 0 {
+        if config.pad {
+            (3 - input_rem, 4)
+        } else {
+            (0, input_rem + 1)
+        }
+    } else {
+        (0, 0)
+    };
+
+    let b64_only_len = (input_len / 3) * 4 + last_encoded_chunk_len;
+
+    let expected_line_ending_len = match config.line_wrap {
+        LineWrap::NoWrap => 0,
+        LineWrap::Wrap(line_len, line_ending) => {
+            line_wrap_parameters(b64_only_len, line_len, line_ending).total_line_endings_len
+        }
+    };
+
+    let expected_encoded_len = encoded_size(input_len, &config).unwrap();
+
+    assert_eq!(expected_encoded_len, encoded.len());
+
+    let line_endings_len = encoded.chars().filter(|&c| c == '\r' || c == '\n').count();
+    let padding_len = encoded.chars().filter(|&c| c == '=').count();
+
+    assert_eq!(expected_padding_len, padding_len);
+    assert_eq!(expected_line_ending_len, line_endings_len);
+
+    let _ = str::from_utf8(encoded.as_bytes()).expect("Base64 should be valid utf8");
+}
+
+fn roundtrip_random_config(
+    input_len_range: Range<usize>,
+    line_len_range: Range<usize>,
+    iterations: u32,
+) {
+    let mut input_buf: Vec<u8> = Vec::new();
+    let mut encoded_buf = String::new();
+    let mut rng = rand::weak_rng();
+
+    for _ in 0..iterations {
+        input_buf.clear();
+        encoded_buf.clear();
+
+        let input_len = input_len_range.ind_sample(&mut rng);
+
+        let config = random_config(&mut rng, &line_len_range);
+
+        for _ in 0..input_len {
+            input_buf.push(rng.gen());
+        }
+
+        encode_config_buf(&input_buf, config, &mut encoded_buf);
+
+        assert_encode_sanity(&encoded_buf, &config, input_len);
+
+        assert_eq!(input_buf, decode_config(&encoded_buf, config).unwrap());
+    }
+}
+
+pub fn random_config<R: Rng>(rng: &mut R, line_len_range: &Range<usize>) -> Config {
+    let line_wrap = if rng.gen() {
+        LineWrap::NoWrap
+    } else {
+        let line_len = line_len_range.ind_sample(rng);
+
+        let line_ending = if rng.gen() {
+            LineEnding::LF
+        } else {
+            LineEnding::CRLF
+        };
+
+        LineWrap::Wrap(line_len, line_ending)
+    };
+
+    const CHARSETS: &[CharacterSet] = &[
+        CharacterSet::UrlSafe,
+        CharacterSet::Standard,
+        CharacterSet::Crypt,
+    ];
+    let charset = *rng.choose(CHARSETS).unwrap();
+
+    let strip_whitespace = match line_wrap {
+        LineWrap::NoWrap => false,
+        _ => true,
+    };
+
+    Config::new(charset, rng.gen(), strip_whitespace, line_wrap)
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/tests/decode.rs b/rustc_deps/vendor/base64-0.9.3/tests/decode.rs
new file mode 100644
index 0000000..1f68a8c
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/tests/decode.rs
@@ -0,0 +1,351 @@
+extern crate base64;
+
+use base64::*;
+
+mod helpers;
+
+use helpers::*;
+
+fn compare_decode_mime(expected: &str, target: &str) {
+    assert_eq!(
+        expected,
+        String::from_utf8(decode_config(target, MIME).unwrap()).unwrap()
+    );
+}
+
+#[test]
+fn decode_rfc4648_0() {
+    compare_decode("", "");
+}
+
+#[test]
+fn decode_rfc4648_1() {
+    compare_decode("f", "Zg==");
+}
+
+#[test]
+fn decode_rfc4648_1_just_a_bit_of_padding() {
+    // allows less padding than required
+    compare_decode("f", "Zg=");
+}
+
+#[test]
+fn decode_rfc4648_1_no_padding() {
+    compare_decode("f", "Zg");
+}
+
+#[test]
+fn decode_rfc4648_2() {
+    compare_decode("fo", "Zm8=");
+}
+
+#[test]
+fn decode_rfc4648_2_no_padding() {
+    compare_decode("fo", "Zm8");
+}
+
+#[test]
+fn decode_rfc4648_3() {
+    compare_decode("foo", "Zm9v");
+}
+
+#[test]
+fn decode_rfc4648_4() {
+    compare_decode("foob", "Zm9vYg==");
+}
+
+#[test]
+fn decode_rfc4648_4_no_padding() {
+    compare_decode("foob", "Zm9vYg");
+}
+
+#[test]
+fn decode_rfc4648_5() {
+    compare_decode("fooba", "Zm9vYmE=");
+}
+
+#[test]
+fn decode_rfc4648_5_no_padding() {
+    compare_decode("fooba", "Zm9vYmE");
+}
+
+#[test]
+fn decode_rfc4648_6() {
+    compare_decode("foobar", "Zm9vYmFy");
+}
+
+#[test]
+fn decode_mime_allow_space() {
+    assert!(decode_config("YWx pY2U=", MIME).is_ok());
+}
+
+#[test]
+fn decode_mime_allow_tab() {
+    assert!(decode_config("YWx\tpY2U=", MIME).is_ok());
+}
+
+#[test]
+fn decode_mime_allow_ff() {
+    assert!(decode_config("YWx\x0cpY2U=", MIME).is_ok());
+}
+
+#[test]
+fn decode_mime_allow_vtab() {
+    assert!(decode_config("YWx\x0bpY2U=", MIME).is_ok());
+}
+
+#[test]
+fn decode_mime_allow_nl() {
+    assert!(decode_config("YWx\npY2U=", MIME).is_ok());
+}
+
+#[test]
+fn decode_mime_allow_crnl() {
+    assert!(decode_config("YWx\r\npY2U=", MIME).is_ok());
+}
+
+#[test]
+fn decode_mime_reject_null() {
+    assert_eq!(
+        DecodeError::InvalidByte(3, 0x0),
+        decode_config("YWx\0pY2U==", MIME).unwrap_err()
+    );
+}
+
+#[test]
+fn decode_mime_absurd_whitespace() {
+    compare_decode_mime(
+        "how could you let this happen",
+        "\n aG93I\n\nG\x0bNvd\r\nWxkI HlvdSB \tsZXQgdGh\rpcyBo\x0cYXBwZW4 =   ",
+    );
+}
+
+#[test]
+fn decode_single_pad_byte_after_2_chars_in_trailing_quad_ok() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("Zg=");
+
+        let input_len = num_quads * 3 + 1;
+
+        // Since there are 3 bytes in the trailing quad, want to be sure this allows for the fact
+        // that it could be bad padding rather than assuming that it will decode to 2 bytes and
+        // therefore allow 1 extra round of fast decode logic (stage 1 / 2).
+
+        let mut decoded = Vec::new();
+        decoded.resize(input_len, 0);
+
+        assert_eq!(
+            input_len,
+            decode_config_slice(&s, STANDARD, &mut decoded).unwrap()
+        );
+    }
+}
+
+//this is a MAY in the rfc: https://tools.ietf.org/html/rfc4648#section-3.3
+#[test]
+fn decode_1_pad_byte_in_fast_loop_then_extra_padding_chunk_error() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("YWxpY2U=====");
+
+        // since the first 8 bytes are handled in stage 1 or 2, the padding is detected as a
+        // generic invalid byte, not specifcally a padding issue.
+        // Could argue that the *next* padding byte (in the next quad) is technically the first
+        // erroneous one, but reporting that accurately is more complex and probably nobody cares
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4 + 7, b'='),
+            decode(&s).unwrap_err()
+        );
+    }
+}
+
+#[test]
+fn decode_2_pad_bytes_in_leftovers_then_extra_padding_chunk_error() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("YWxpY2UABB====");
+
+        // 6 bytes (4 padding) after last 8-byte chunk, so it's decoded by stage 4.
+        // First padding byte is invalid.
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4 + 10, b'='),
+            decode(&s).unwrap_err()
+        );
+    }
+}
+
+#[test]
+fn decode_valid_bytes_after_padding_in_leftovers_error() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("YWxpY2UABB=B");
+
+        // 4 bytes after last 8-byte chunk, so it's decoded by stage 4.
+        // First (and only) padding byte is invalid.
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4 + 10, b'='),
+            decode(&s).unwrap_err()
+        );
+    }
+}
+
+#[test]
+fn decode_absurd_pad_error() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("==Y=Wx===pY=2U=====");
+
+        // Plenty of remaining bytes, so handled by stage 1 or 2.
+        // first padding byte
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4, b'='),
+            decode(&s).unwrap_err()
+        );
+    }
+}
+
+#[test]
+fn decode_extra_padding_after_1_pad_bytes_in_trailing_quad_returns_error() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("EEE===");
+
+        // handled by stage 1, 2, or 4 depending on length
+        // first padding byte -- which would be legal if it was the only padding
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4 + 3, b'='),
+            decode(&s).unwrap_err()
+        );
+    }
+}
+
+#[test]
+fn decode_extra_padding_after_2_pad_bytes_in_trailing_quad_2_returns_error() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("EE====");
+
+        // handled by stage 1, 2, or 4 depending on length
+        // first padding byte -- which would be legal if it was by itself
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4 + 2, b'='),
+            decode(&s).unwrap_err()
+        );
+    }
+}
+
+#[test]
+fn decode_start_quad_with_padding_returns_error() {
+    for num_quads in 0..25 {
+        // add enough padding to ensure that we'll hit all 4 stages at the different lengths
+        for pad_bytes in 1..32 {
+            let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+            let padding: String = std::iter::repeat("=").take(pad_bytes).collect();
+            s.push_str(&padding);
+
+            if pad_bytes % 4 == 1 {
+                // detected in early length check
+                assert_eq!(DecodeError::InvalidLength, decode(&s).unwrap_err());
+            } else {
+                // padding lengths 2 - 8 are handled by stage 4
+                // padding length >= 8 will hit at least one chunk at stages 1, 2, 3 at different
+                // prefix lengths
+                assert_eq!(
+                    DecodeError::InvalidByte(num_quads * 4, b'='),
+                    decode(&s).unwrap_err()
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn decode_padding_followed_by_non_padding_returns_error() {
+    for num_quads in 0..25 {
+        for pad_bytes in 0..31 {
+            let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+            let padding: String = std::iter::repeat("=").take(pad_bytes).collect();
+            s.push_str(&padding);
+            s.push_str("E");
+
+            if pad_bytes % 4 == 0 {
+                assert_eq!(DecodeError::InvalidLength, decode(&s).unwrap_err());
+            } else {
+                // pad len 1 - 8 will be handled by stage 4
+                // pad len 9 (suffix len 10) will have 8 bytes of padding handled by stage 3
+                // first padding byte
+                assert_eq!(
+                    DecodeError::InvalidByte(num_quads * 4, b'='),
+                    decode(&s).unwrap_err()
+                );
+            }
+        }
+    }
+}
+
+#[test]
+fn decode_one_char_in_quad_with_padding_error() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("E=");
+
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4 + 1, b'='),
+            decode(&s).unwrap_err()
+        );
+
+        // more padding doesn't change the error
+        s.push_str("=");
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4 + 1, b'='),
+            decode(&s).unwrap_err()
+        );
+
+        s.push_str("=");
+        assert_eq!(
+            DecodeError::InvalidByte(num_quads * 4 + 1, b'='),
+            decode(&s).unwrap_err()
+        );
+    }
+}
+
+#[test]
+fn decode_one_char_in_quad_without_padding_error() {
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push('E');
+
+        assert_eq!(DecodeError::InvalidLength, decode(&s).unwrap_err());
+    }
+}
+
+#[test]
+fn decode_reject_invalid_bytes_with_correct_error() {
+    for length in 1..100 {
+        for index in 0_usize..length {
+            for invalid_byte in " \t\n\r\x0C\x0B\x00%*.".bytes() {
+                let prefix: String = std::iter::repeat("A").take(index).collect();
+                let suffix: String = std::iter::repeat("B").take(length - index - 1).collect();
+
+                let input = prefix + &String::from_utf8(vec![invalid_byte]).unwrap() + &suffix;
+                assert_eq!(
+                    length,
+                    input.len(),
+                    "length {} error position {}",
+                    length,
+                    index
+                );
+
+                if length % 4 == 1 {
+                    assert_eq!(DecodeError::InvalidLength, decode(&input).unwrap_err());
+                } else {
+                    assert_eq!(
+                        DecodeError::InvalidByte(index, invalid_byte),
+                        decode(&input).unwrap_err()
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/tests/encode.rs b/rustc_deps/vendor/base64-0.9.3/tests/encode.rs
new file mode 100644
index 0000000..e23f015
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/tests/encode.rs
@@ -0,0 +1,149 @@
+extern crate base64;
+
+use base64::*;
+
+fn compare_encode(expected: &str, target: &[u8]) {
+    assert_eq!(expected, encode(target));
+}
+
+#[test]
+fn encode_rfc4648_0() {
+    compare_encode("", b"");
+}
+
+#[test]
+fn encode_rfc4648_1() {
+    compare_encode("Zg==", b"f");
+}
+
+#[test]
+fn encode_rfc4648_2() {
+    compare_encode("Zm8=", b"fo");
+}
+
+#[test]
+fn encode_rfc4648_3() {
+    compare_encode("Zm9v", b"foo");
+}
+
+#[test]
+fn encode_rfc4648_4() {
+    compare_encode("Zm9vYg==", b"foob");
+}
+
+#[test]
+fn encode_rfc4648_5() {
+    compare_encode("Zm9vYmE=", b"fooba");
+}
+
+#[test]
+fn encode_rfc4648_6() {
+    compare_encode("Zm9vYmFy", b"foobar");
+}
+
+#[test]
+fn encode_all_ascii() {
+    let mut ascii = Vec::<u8>::with_capacity(128);
+
+    for i in 0..128 {
+        ascii.push(i);
+    }
+
+    compare_encode(
+        "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7P\
+         D0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8\
+         =",
+        &ascii,
+    );
+}
+
+#[test]
+fn encode_all_bytes() {
+    let mut bytes = Vec::<u8>::with_capacity(256);
+
+    for i in 0..255 {
+        bytes.push(i);
+    }
+    bytes.push(255); //bug with "overflowing" ranges?
+
+    compare_encode(
+        "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7P\
+         D0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\
+         +AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6\
+         /wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==",
+        &bytes,
+    );
+}
+
+#[test]
+fn encode_all_bytes_url() {
+    let mut bytes = Vec::<u8>::with_capacity(256);
+
+    for i in 0..255 {
+        bytes.push(i);
+    }
+    bytes.push(255); //bug with "overflowing" ranges?
+
+    assert_eq!(
+        "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0\
+         -P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\
+         -AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq\
+         -wsbKztLW2t7i5uru8vb6_wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t_g4eLj5OXm5-jp6uvs7e7v8PHy\
+         8_T19vf4-fr7_P3-_w==",
+        encode_config(&bytes, URL_SAFE)
+    );
+}
+
+#[test]
+fn encode_line_ending_lf_partial_last_line() {
+    let config = Config::new(
+        CharacterSet::Standard,
+        true,
+        false,
+        LineWrap::Wrap(3, LineEnding::LF),
+    );
+    assert_eq!("Zm9\nvYm\nFy", encode_config(b"foobar", config));
+}
+
+#[test]
+fn encode_line_ending_crlf_partial_last_line() {
+    let config = Config::new(
+        CharacterSet::Standard,
+        true,
+        false,
+        LineWrap::Wrap(3, LineEnding::CRLF),
+    );
+    assert_eq!("Zm9\r\nvYm\r\nFy", encode_config(b"foobar", config));
+}
+
+#[test]
+fn encode_line_ending_lf_full_last_line() {
+    let config = Config::new(
+        CharacterSet::Standard,
+        true,
+        false,
+        LineWrap::Wrap(4, LineEnding::LF),
+    );
+    assert_eq!("Zm9v\nYmFy", encode_config(b"foobar", config));
+}
+
+#[test]
+fn encode_line_ending_crlf_full_last_line() {
+    let config = Config::new(
+        CharacterSet::Standard,
+        true,
+        false,
+        LineWrap::Wrap(4, LineEnding::CRLF),
+    );
+    assert_eq!("Zm9v\r\nYmFy", encode_config(b"foobar", config));
+}
+
+#[test]
+fn encode_url_safe_without_padding() {
+    let encoded = encode_config(b"alice", URL_SAFE_NO_PAD);
+    assert_eq!(&encoded, "YWxpY2U");
+    assert_eq!(
+        String::from_utf8(decode(&encoded).unwrap()).unwrap(),
+        "alice"
+    );
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/tests/helpers.rs b/rustc_deps/vendor/base64-0.9.3/tests/helpers.rs
new file mode 100644
index 0000000..5144988
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/tests/helpers.rs
@@ -0,0 +1,14 @@
+extern crate base64;
+
+use base64::*;
+
+pub fn compare_decode(expected: &str, target: &str) {
+    assert_eq!(
+        expected,
+        String::from_utf8(decode(target).unwrap()).unwrap()
+    );
+    assert_eq!(
+        expected,
+        String::from_utf8(decode(target.as_bytes()).unwrap()).unwrap()
+    );
+}
diff --git a/rustc_deps/vendor/base64-0.9.3/tests/tests.rs b/rustc_deps/vendor/base64-0.9.3/tests/tests.rs
new file mode 100644
index 0000000..5ad3ec7
--- /dev/null
+++ b/rustc_deps/vendor/base64-0.9.3/tests/tests.rs
@@ -0,0 +1,191 @@
+extern crate base64;
+extern crate rand;
+
+use rand::Rng;
+
+use base64::*;
+
+mod helpers;
+use helpers::*;
+
+// generate random contents of the specified length and test encode/decode roundtrip
+fn roundtrip_random(
+    byte_buf: &mut Vec<u8>,
+    str_buf: &mut String,
+    config: Config,
+    byte_len: usize,
+    approx_values_per_byte: u8,
+    max_rounds: u64,
+) {
+    // let the short ones be short but don't let it get too crazy large
+    let num_rounds = calculate_number_of_rounds(byte_len, approx_values_per_byte, max_rounds);
+    let mut r = rand::weak_rng();
+    let mut decode_buf = Vec::new();
+
+    for _ in 0..num_rounds {
+        byte_buf.clear();
+        str_buf.clear();
+        decode_buf.clear();
+        while byte_buf.len() < byte_len {
+            byte_buf.push(r.gen::<u8>());
+        }
+
+        encode_config_buf(&byte_buf, config, str_buf);
+        decode_config_buf(&str_buf, config, &mut decode_buf).unwrap();
+
+        assert_eq!(byte_buf, &decode_buf);
+    }
+}
+
+fn calculate_number_of_rounds(byte_len: usize, approx_values_per_byte: u8, max: u64) -> u64 {
+    // don't overflow
+    let mut prod = approx_values_per_byte as u64;
+
+    for _ in 0..byte_len {
+        if prod > max {
+            return max;
+        }
+
+        prod = prod.saturating_mul(prod);
+    }
+
+    prod
+}
+
+fn no_pad_config() -> Config {
+    Config::new(CharacterSet::Standard, false, false, LineWrap::NoWrap)
+}
+
+#[test]
+fn roundtrip_random_short_standard() {
+    let mut byte_buf: Vec<u8> = Vec::new();
+    let mut str_buf = String::new();
+
+    for input_len in 0..40 {
+        roundtrip_random(&mut byte_buf, &mut str_buf, STANDARD, input_len, 4, 10000);
+    }
+}
+
+#[test]
+fn roundtrip_random_with_fast_loop_standard() {
+    let mut byte_buf: Vec<u8> = Vec::new();
+    let mut str_buf = String::new();
+
+    for input_len in 40..100 {
+        roundtrip_random(&mut byte_buf, &mut str_buf, STANDARD, input_len, 4, 1000);
+    }
+}
+
+#[test]
+fn roundtrip_random_short_no_padding() {
+    let mut byte_buf: Vec<u8> = Vec::new();
+    let mut str_buf = String::new();
+
+    for input_len in 0..40 {
+        roundtrip_random(
+            &mut byte_buf,
+            &mut str_buf,
+            no_pad_config(),
+            input_len,
+            4,
+            10000,
+        );
+    }
+}
+
+#[test]
+fn roundtrip_random_no_padding() {
+    let mut byte_buf: Vec<u8> = Vec::new();
+    let mut str_buf = String::new();
+
+    for input_len in 40..100 {
+        roundtrip_random(
+            &mut byte_buf,
+            &mut str_buf,
+            no_pad_config(),
+            input_len,
+            4,
+            1000,
+        );
+    }
+}
+
+#[test]
+fn roundtrip_decode_trailing_10_bytes() {
+    // This is a special case because we decode 8 byte blocks of input at a time as much as we can,
+    // ideally unrolled to 32 bytes at a time, in stages 1 and 2. Since we also write a u64's worth
+    // of bytes (8) to the output, we always write 2 garbage bytes that then will be overwritten by
+    // the NEXT block. However, if the next block only contains 2 bytes, it will decode to 1 byte,
+    // and therefore be too short to cover up the trailing 2 garbage bytes. Thus, we have stage 3
+    // to handle that case.
+
+    for num_quads in 0..25 {
+        let mut s: String = std::iter::repeat("ABCD").take(num_quads).collect();
+        s.push_str("EFGHIJKLZg");
+
+        let decoded = decode(&s).unwrap();
+        assert_eq!(num_quads * 3 + 7, decoded.len());
+
+        assert_eq!(s, encode_config(&decoded, STANDARD_NO_PAD));
+    }
+}
+
+#[test]
+fn display_wrapper_matches_normal_encode() {
+    let mut bytes = Vec::<u8>::with_capacity(256);
+
+    for i in 0..255 {
+        bytes.push(i);
+    }
+    bytes.push(255);
+
+    assert_eq!(
+        encode(&bytes),
+        format!("{}", base64::display::Base64Display::standard(&bytes))
+    );
+}
+
+#[test]
+fn because_we_can() {
+    compare_decode("alice", "YWxpY2U=");
+    compare_decode("alice", &encode(b"alice"));
+    compare_decode("alice", &encode(&decode(&encode(b"alice")).unwrap()));
+}
+
+#[test]
+fn encode_config_slice_can_use_inline_buffer() {
+    let mut buf: [u8; 22] = [0; 22];
+    let mut larger_buf: [u8; 24] = [0; 24];
+    let mut input: [u8; 16] = [0; 16];
+
+    let mut rng = rand::weak_rng();
+    for elt in &mut input {
+        *elt = rng.gen();
+    }
+
+    assert_eq!(22, encode_config_slice(&input, STANDARD_NO_PAD, &mut buf));
+    let decoded = decode_config(&buf, STANDARD_NO_PAD).unwrap();
+
+    assert_eq!(decoded, input);
+
+    // let's try it again with padding
+
+    assert_eq!(24, encode_config_slice(&input, STANDARD, &mut larger_buf));
+    let decoded = decode_config(&buf, STANDARD).unwrap();
+
+    assert_eq!(decoded, input);
+}
+
+#[test]
+#[should_panic(expected = "index 24 out of range for slice of length 22")]
+fn encode_config_slice_panics_when_buffer_too_small() {
+    let mut buf: [u8; 22] = [0; 22];
+    let mut input: [u8; 16] = [0; 16];
+
+    let mut rng = rand::weak_rng();
+    for elt in &mut input {
+        *elt = rng.gen();
+    }
+
+    encode_config_slice(&input, STANDARD, &mut buf);
+}
diff --git a/rustc_deps/vendor/base64/.cargo-checksum.json b/rustc_deps/vendor/base64/.cargo-checksum.json
index 87b3839..fa3e5a6 100644
--- a/rustc_deps/vendor/base64/.cargo-checksum.json
+++ b/rustc_deps/vendor/base64/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"c155ba2131467bbda05a4c8aca4cf40c4a62d2ddce183a79695513948470aee7","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0dd882e53de11566d50f8e8e2d5a651bcf3fabee4987d70f306233cf39094ba7","README.md":"f4319521a3683eebd5bf96d166b4d5a8c52fb8480b8b7724661ac38a9b89d7aa","RELEASE-NOTES.md":"a9eb191e951b968e230a9499e955f22056687a184f05fb7f138b30cbc4669f5a","benches/benchmarks.rs":"bfc990dfa1716acf5bbd7189b3d7438145a9441833d6e4a796d2ce4428e55e14","examples/make_tables.rs":"e7c3e665874faa10ff1906420eb5182d1b725bcd30ff0d6da719bb368683e197","src/chunked_encoder.rs":"3d92a8241ed6d1a402ad1c1a8c7aa9c736b62cecc4071f44bc29b1b7cc70488c","src/decode.rs":"968c9c13746338ea307d3ff0b528df7a4fa20c7a1071c6adc1fb23c573741b57","src/display.rs":"d8ec9fa3f2b03640b026bbdfd817cd76454e1bb9b6ae53bd793334cd0a4ac62e","src/encode.rs":"c38c64582105ea698c5d1ec1596f5f1d99cfc1fb894226b79c5c8e96f73e6541","src/lib.rs":"4aeed1db6057b03532b20c34dbb822c1edcb0b5a2c21cdd50e7ac6b06858843a","src/line_wrap.rs":"fd136457629b803417bd25eb191fd3665bb57b8726fc4d74e7325e499e4e88af","src/tables.rs":"10b09997ed9765dc46c2d1f0df21b915d88c4f47a292b5c7df5c1851e724fb03","src/tests.rs":"cf0ddeb01b2149041b7ea99a881b6f149b1630110c5c2eedee6b1f44e873ea6c","tests/decode.rs":"c06a7595a0ac708961a180d4a8393f6d377b56028f75b29e6e34fd8451d84226","tests/encode.rs":"2eb3c8f81a4f807be69d1dfb0857625130017b0fa7037f7168f434c886cc851b","tests/helpers.rs":"a76015e4a4e8f98213bdbaa592cd9574ccdc95a28e1b1f835a2753e09fa6037f","tests/tests.rs":"13929406ba13504ff49d1a16a2578a87c560834fba0eaad78edecf0793261b0e"},"package":"489d6c0ed21b11d038c31b6ceccca973e65d73ba3bd8ecb9a2babf5546164643"}
\ No newline at end of file
+{"files":{"Cargo.toml":"89131475d69542cea57da56ce5ba4a782188f969a1d1dc399eb254b93284a278","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0dd882e53de11566d50f8e8e2d5a651bcf3fabee4987d70f306233cf39094ba7","README.md":"7269a723029fe3254ee94efd2967ccf3521c17978d32d064b93e693271323c43","RELEASE-NOTES.md":"405f7c5f06c7e81b232d78111ddac6bc63878528bea4781645866d5f62a9f2bf","benches/benchmarks.rs":"dbdb26bea4d0d214e39176fb7ab5af5afb78863fb345d11bf6e743344ffd36d3","examples/make_tables.rs":"e7c3e665874faa10ff1906420eb5182d1b725bcd30ff0d6da719bb368683e197","src/chunked_encoder.rs":"fe2d6d65d0c5e30f8f5d0ec7a95bf5a5028c47ae338ee8c5ef8d0d7c1d968031","src/decode.rs":"f08cdf315ba7ebad7fbd06ec3b6cb3612a52d9ce16662ce0d7f3d191862f7b17","src/display.rs":"59a9ca41f5fe42be0db700a9180e58e33eaff7a08fcbfd7b24f0286544613915","src/encode.rs":"7f6413ad27bf135f1fe38866a661a7300610905d8c858aff52eff2fd9e02a441","src/lib.rs":"893155d20c55525ebcf0b46de76c4cbdf1e0e43518f911d52e2de357ec7e29a6","src/tables.rs":"10b09997ed9765dc46c2d1f0df21b915d88c4f47a292b5c7df5c1851e724fb03","src/tests.rs":"4c72499a5b13f9ed793f275445bf9d1d631530bb7c39494de96d08e5c0602430","src/write/encoder.rs":"58ded8c942b0b96e8466f9ff667fcb96c262a492c67d76414521baa1e6f32b24","src/write/encoder_tests.rs":"9e7f165650bde35858d05bdb1655ae009f4e44014e296dab6cf6e789f5271de4","src/write/mod.rs":"124b223f3effcb1d85671a4173a635cdfae480341b032217c77876647344176b","tests/decode.rs":"dc7167f8127a3ece7234f3631664e5a0987a0e2b7333f2d93bfc7e88db2f9ad6","tests/encode.rs":"5efb6904c36c6f899a05078e5c9be756fc58af1ee9940edfa8dea1ee53675364","tests/helpers.rs":"a76015e4a4e8f98213bdbaa592cd9574ccdc95a28e1b1f835a2753e09fa6037f","tests/tests.rs":"eec857210322f4ea1531f67afe1aeacfc5626ec50781ee39f91c0b2a677b9846"},"package":"621fc7ecb8008f86d7fb9b95356cd692ce9514b80a86d85b397f32a22da7b9e2"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/base64/Cargo.toml b/rustc_deps/vendor/base64/Cargo.toml
index 667272d..2d284fd 100644
--- a/rustc_deps/vendor/base64/Cargo.toml
+++ b/rustc_deps/vendor/base64/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "base64"
-version = "0.9.3"
+version = "0.10.0"
 authors = ["Alice Maz <alice@alicemaz.com>", "Marshall Pierce <marshall@mpierce.org>"]
 description = "encodes and decodes base64 as bytes or utf8"
 documentation = "https://github.com/alicemaz/rust-base64/blob/master/README.md"
@@ -24,9 +24,6 @@
 [profile.bench]
 debug = true
 [dependencies.byteorder]
-version = "1.1.0"
-
-[dependencies.safemem]
-version = "0.3"
+version = "1.2.6"
 [dev-dependencies.rand]
-version = "0.4"
+version = "0.5.5"
diff --git a/rustc_deps/vendor/base64/README.md b/rustc_deps/vendor/base64/README.md
index 0805bd2..4f65289 100644
--- a/rustc_deps/vendor/base64/README.md
+++ b/rustc_deps/vendor/base64/README.md
@@ -1,6 +1,7 @@
 [base64](https://crates.io/crates/base64)
 ===
-[![](https://img.shields.io/crates/v/base64.svg)](https://crates.io/crates/base64) [![Docs](https://docs.rs/base64/badge.svg)](https://docs.rs/base64)
+
+[![](https://img.shields.io/crates/v/base64.svg)](https://crates.io/crates/base64) [![Docs](https://docs.rs/base64/badge.svg)](https://docs.rs/base64) [![Build](https://travis-ci.org/alicemaz/rust-base64.svg?branch=master)](https://travis-ci.org/alicemaz/rust-base64) [![codecov](https://codecov.io/gh/alicemaz/rust-base64/branch/master/graph/badge.svg)](https://codecov.io/gh/alicemaz/rust-base64)
 
 It's base64. What more could anyone want?
 
@@ -91,7 +92,6 @@
 ```
 cargo +nightly fuzz run roundtrip
 cargo +nightly fuzz run roundtrip_no_pad
-cargo +nightly fuzz run roundtrip_mime -- -max_len=10240
 cargo +nightly fuzz run roundtrip_random_config -- -max_len=10240
 ```
 
diff --git a/rustc_deps/vendor/base64/RELEASE-NOTES.md b/rustc_deps/vendor/base64/RELEASE-NOTES.md
index c15de78..4d893f1 100644
--- a/rustc_deps/vendor/base64/RELEASE-NOTES.md
+++ b/rustc_deps/vendor/base64/RELEASE-NOTES.md
@@ -1,3 +1,13 @@
+# 0.10.0
+
+- Remove line wrapping. Line wrapping was never a great conceptual fit in this library, and other features (streaming encoding, etc) either couldn't support it or could support only special cases of it with a great increase in complexity. Line wrapping has been pulled out into a [line-wrap](https://crates.io/crates/line-wrap) crate, so it's still available if you need it.
+  - `Base64Display` creation no longer uses a `Result` because it can't fail, which means its helper methods for common
+  configs that `unwrap()` for you are no longer needed
+- Add a streaming encoder `Write` impl to transparently base64 as you write.
+- Remove the remaining `unsafe` code.
+- Remove whitespace stripping to simplify `no_std` support. No out of the box configs use it, and it's trivial to do yourself if needed: `filter(|b| !b" \n\t\r\x0b\x0c".contains(b)`.
+- Detect invalid trailing symbols when decoding and return an error rather than silently ignoring them.
+
 # 0.9.3
 
 - Update safemem
diff --git a/rustc_deps/vendor/base64/benches/benchmarks.rs b/rustc_deps/vendor/base64/benches/benchmarks.rs
index 533bea8..acc90f0 100644
--- a/rustc_deps/vendor/base64/benches/benchmarks.rs
+++ b/rustc_deps/vendor/base64/benches/benchmarks.rs
@@ -6,9 +6,10 @@
 
 use base64::display;
 use base64::{decode, decode_config_buf, decode_config_slice, encode, encode_config_buf,
-             encode_config_slice, Config, MIME, STANDARD};
+             encode_config_slice, write, Config, STANDARD};
 
-use rand::Rng;
+use rand::{Rng, FromEntropy};
+use std::io::Write;
 use test::Bencher;
 
 #[bench]
@@ -67,11 +68,6 @@
 }
 
 #[bench]
-fn encode_500b_reuse_buf_mime(b: &mut Bencher) {
-    do_encode_bench_reuse_buf(b, 500, MIME)
-}
-
-#[bench]
 fn encode_3kib(b: &mut Bencher) {
     do_encode_bench(b, 3 * 1024)
 }
@@ -92,8 +88,8 @@
 }
 
 #[bench]
-fn encode_3kib_reuse_buf_mime(b: &mut Bencher) {
-    do_encode_bench_reuse_buf(b, 3 * 1024, MIME)
+fn encode_3kib_reuse_buf_stream(b: &mut Bencher) {
+    do_encode_bench_stream(b, 3 * 1024, STANDARD)
 }
 
 #[bench]
@@ -303,7 +299,7 @@
 
     b.bytes = v.len() as u64;
     b.iter(|| {
-        let e = format!("{}", display::Base64Display::standard(&v));
+        let e = format!("{}", display::Base64Display::with_config(&v, STANDARD));
         test::black_box(&e);
     });
 }
@@ -335,10 +331,27 @@
     });
 }
 
+fn do_encode_bench_stream(b: &mut Bencher, size: usize, config: Config) {
+    let mut v: Vec<u8> = Vec::with_capacity(size);
+    fill(&mut v);
+
+    let mut buf = Vec::new();
+
+    b.bytes = v.len() as u64;
+
+    buf.reserve(size * 2);
+    b.iter(|| {
+        buf.clear();
+        let mut stream_enc = write::EncoderWriter::new(&mut buf, config);
+        stream_enc.write_all(&v).unwrap();
+        stream_enc.flush().unwrap();
+    });
+}
+
 fn fill(v: &mut Vec<u8>) {
     let cap = v.capacity();
     // weak randomness is plenty; we just want to not be completely friendly to the branch predictor
-    let mut r = rand::weak_rng();
+    let mut r = rand::rngs::SmallRng::from_entropy();
     while v.len() < cap {
         v.push(r.gen::<u8>());
     }
diff --git a/rustc_deps/vendor/base64/src/chunked_encoder.rs b/rustc_deps/vendor/base64/src/chunked_encoder.rs
index e472b07..8becab6 100644
--- a/rustc_deps/vendor/base64/src/chunked_encoder.rs
+++ b/rustc_deps/vendor/base64/src/chunked_encoder.rs
@@ -1,7 +1,6 @@
 use encode::{add_padding, encode_to_slice};
-use line_wrap::line_wrap;
-use std::cmp;
-use {Config, LineEnding, LineWrap};
+use std::{cmp, str};
+use Config;
 
 /// The output mechanism for ChunkedEncoder's encoded bytes.
 pub trait Sink {
@@ -11,13 +10,6 @@
     fn write_encoded_bytes(&mut self, encoded: &[u8]) -> Result<(), Self::Error>;
 }
 
-#[derive(Debug, PartialEq)]
-pub enum ChunkedEncoderError {
-    /// If wrapping is configured, the line length must be a multiple of 4, and must not be absurdly
-    /// large (see BUF_SIZE).
-    InvalidLineLength,
-}
-
 const BUF_SIZE: usize = 1024;
 
 /// A base64 encoder that emits encoded bytes in chunks without heap allocation.
@@ -27,11 +19,11 @@
 }
 
 impl ChunkedEncoder {
-    pub fn new(config: Config) -> Result<ChunkedEncoder, ChunkedEncoderError> {
-        Ok(ChunkedEncoder {
+    pub fn new(config: Config) -> ChunkedEncoder {
+        ChunkedEncoder {
             config,
-            max_input_chunk_len: max_input_length(BUF_SIZE, &config)?,
-        })
+            max_input_chunk_len: max_input_length(BUF_SIZE, &config),
+        }
     }
 
     pub fn encode<S: Sink>(&self, bytes: &[u8], sink: &mut S) -> Result<(), S::Error> {
@@ -57,41 +49,7 @@
                 b64_bytes_written += add_padding(bytes.len(), &mut encode_buf[b64_bytes_written..]);
             }
 
-            let line_ending_bytes = match self.config.line_wrap {
-                LineWrap::NoWrap => 0,
-                LineWrap::Wrap(line_len, line_ending) => {
-                    let initial_line_ending_bytes =
-                        line_wrap(&mut encode_buf, b64_bytes_written, line_len, line_ending);
-
-                    if more_input_left {
-                        assert_eq!(input_chunk_len, self.max_input_chunk_len);
-                        // If there are more bytes of input, then we know we didn't just do the
-                        // last chunk. line_wrap() doesn't put an ending after the last line, so we
-                        // append one more line ending here. Since the chunk just encoded was not
-                        // the last one, it was multiple of the line length (max_input_chunk_len),
-                        // and therefore we can just put the line ending bytes at the end of the
-                        // contents of the buffer.
-                        match line_ending {
-                            LineEnding::LF => {
-                                encode_buf[b64_bytes_written + initial_line_ending_bytes] = b'\n';
-                                initial_line_ending_bytes + 1
-                            }
-                            LineEnding::CRLF => {
-                                encode_buf[b64_bytes_written + initial_line_ending_bytes] = b'\r';
-                                encode_buf[b64_bytes_written + initial_line_ending_bytes + 1] =
-                                    b'\n';
-                                initial_line_ending_bytes + 2
-                            }
-                        }
-                    } else {
-                        initial_line_ending_bytes
-                    }
-                }
-            };
-
-            let total_bytes_written = b64_bytes_written + line_ending_bytes;
-
-            sink.write_encoded_bytes(&encode_buf[0..total_bytes_written])?;
+            sink.write_encoded_bytes(&encode_buf[0..b64_bytes_written])?;
         }
 
         Ok(())
@@ -100,23 +58,12 @@
 
 /// Calculate the longest input that can be encoded for the given output buffer size.
 ///
-/// If config requires line wrap, the calculated input length will be the maximum number of input
-/// lines that can fit in the output buffer after each line has had its line ending appended.
-///
 /// If the config requires padding, two bytes of buffer space will be set aside so that the last
 /// chunk of input can be encoded safely.
 ///
 /// The input length will always be a multiple of 3 so that no encoding state has to be carried over
 /// between chunks.
-///
-/// If the configured line length is not divisible by 4 (and therefore would require carrying
-/// encoder state between chunks), or if the line length is too big for the buffer, an error will be
-/// returned.
-///
-/// Note that the last overall line of input should *not* have an ending appended, but this will
-/// conservatively calculate space as if it should because encoding is done in chunks, and all the
-/// chunks before the last one will need a line ending after the last encoded line in that chunk.
-fn max_input_length(encoded_buf_len: usize, config: &Config) -> Result<usize, ChunkedEncoderError> {
+fn max_input_length(encoded_buf_len: usize, config: &Config) -> usize {
     let effective_buf_len = if config.pad {
         // make room for padding
         encoded_buf_len
@@ -126,43 +73,34 @@
         encoded_buf_len
     };
 
-    match config.line_wrap {
-        // No wrapping, no padding, so just normal base64 expansion.
-        LineWrap::NoWrap => Ok((effective_buf_len / 4) * 3),
-        LineWrap::Wrap(line_len, line_ending) => {
-            // To avoid complicated encode buffer shuffling, only allow line lengths that are
-            // multiples of 4 (which map to input lengths that are multiples of 3).
-            // line_len is never 0.
-            if line_len % 4 != 0 {
-                return Err(ChunkedEncoderError::InvalidLineLength);
-            }
+    // No padding, so just normal base64 expansion.
+    (effective_buf_len / 4) * 3
+}
 
-            let single_encoded_full_line_with_ending_len = line_len
-                .checked_add(line_ending.len())
-                .expect("Encoded line length with ending exceeds usize");
 
-            // max number of complete lines with endings that will fit in buffer
-            let num_encoded_wrapped_lines_in_buffer =
-                effective_buf_len / single_encoded_full_line_with_ending_len;
+// A really simple sink that just appends to a string
+pub(crate) struct StringSink<'a> {
+    string: &'a mut String,
+}
 
-            if num_encoded_wrapped_lines_in_buffer == 0 {
-                // line + ending is longer than can fit into encode buffer; give up
-                Err(ChunkedEncoderError::InvalidLineLength)
-            } else {
-                let input_len_for_line_len = (line_len / 4) * 3;
-
-                let input_len = input_len_for_line_len
-                    .checked_mul(num_encoded_wrapped_lines_in_buffer)
-                    .expect("Max input size exceeds usize");
-
-                assert!(input_len % 3 == 0 && input_len > 1);
-
-                Ok(input_len)
-            }
+impl<'a> StringSink<'a> {
+    pub(crate) fn new(s: &mut String) -> StringSink {
+        StringSink {
+            string: s,
         }
     }
 }
 
+impl<'a> Sink for StringSink<'a> {
+    type Error = ();
+
+    fn write_encoded_bytes(&mut self, s: &[u8]) -> Result<(), Self::Error> {
+        self.string.push_str(str::from_utf8(s).unwrap());
+
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 pub mod tests {
     extern crate rand;
@@ -171,10 +109,8 @@
     use tests::random_config;
     use *;
 
-    use std::str;
-
-    use self::rand::distributions::{IndependentSample, Range};
-    use self::rand::Rng;
+    use self::rand::distributions::{Distribution, Range};
+    use self::rand::{Rng, FromEntropy};
 
     #[test]
     fn chunked_encode_empty() {
@@ -206,263 +142,85 @@
     }
 
     #[test]
-    fn chunked_encode_line_wrap_padding() {
-        // < 8 bytes input, slow loop only
-        let config = config_wrap(true, 4, LineEnding::LF);
-        assert_eq!(
-            "Zm9v\nYmFy\nZm9v\nYmFy\nZg==",
-            chunked_encode_str(b"foobarfoobarf", config)
-        );
-    }
-
-    #[test]
-    fn chunked_encode_longer_than_one_buffer_adds_final_line_wrap_lf() {
-        // longest line len possible
-        let config = config_wrap(false, 1020, LineEnding::LF);
-        let input = vec![0xFF; 768];
-        let encoded = chunked_encode_str(&input, config);
-        // got a line wrap
-        assert_eq!(1024 + 1, encoded.len());
-
-        for &b in encoded.as_bytes()[0..1020].iter() {
-            // ascii /
-            assert_eq!(47, b);
-        }
-
-        assert_eq!(10, encoded.as_bytes()[1020]);
-
-        for &b in encoded.as_bytes()[1021..].iter() {
-            // ascii /
-            assert_eq!(47, b);
-        }
-    }
-
-    #[test]
-    fn chunked_encode_longer_than_one_buffer_adds_final_line_wrap_crlf() {
-        // longest line len possible
-        let config = config_wrap(false, 1020, LineEnding::CRLF);
-        let input = vec![0xFF; 768];
-        let encoded = chunked_encode_str(&input, config);
-        // got a line wrap
-        assert_eq!(1024 + 2, encoded.len());
-
-        for &b in encoded.as_bytes()[0..1020].iter() {
-            // ascii /
-            assert_eq!(47, b);
-        }
-
-        assert_eq!(13, encoded.as_bytes()[1020]);
-        assert_eq!(10, encoded.as_bytes()[1021]);
-
-        for &b in encoded.as_bytes()[1022..].iter() {
-            // ascii /
-            assert_eq!(47, b);
-        }
-    }
-
-    #[test]
     fn chunked_encode_matches_normal_encode_random_string_sink() {
         let helper = StringSinkTestHelper;
         chunked_encode_matches_normal_encode_random(&helper);
     }
 
     #[test]
-    fn max_input_length_no_wrap_no_pad() {
-        let config = config_no_wrap(false);
-        assert_eq!(768, max_input_length(1024, &config).unwrap());
+    fn max_input_length_no_pad() {
+        let config = config_with_pad(false);
+        assert_eq!(768, max_input_length(1024, &config));
     }
 
     #[test]
-    fn max_input_length_no_wrap_with_pad_decrements_one_triple() {
-        let config = config_no_wrap(true);
-        assert_eq!(765, max_input_length(1024, &config).unwrap());
+    fn max_input_length_with_pad_decrements_one_triple() {
+        let config = config_with_pad(true);
+        assert_eq!(765, max_input_length(1024, &config));
     }
 
     #[test]
-    fn max_input_length_no_wrap_with_pad_one_byte_short() {
-        let config = config_no_wrap(true);
-        assert_eq!(765, max_input_length(1025, &config).unwrap());
+    fn max_input_length_with_pad_one_byte_short() {
+        let config = config_with_pad(true);
+        assert_eq!(765, max_input_length(1025, &config));
     }
 
     #[test]
-    fn max_input_length_no_wrap_with_pad_fits_exactly() {
-        let config = config_no_wrap(true);
-        assert_eq!(768, max_input_length(1026, &config).unwrap());
+    fn max_input_length_with_pad_fits_exactly() {
+        let config = config_with_pad(true);
+        assert_eq!(768, max_input_length(1026, &config));
     }
 
     #[test]
-    fn max_input_length_wrap_with_lf_fits_exactly_no_pad() {
-        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
-        let config = config_wrap(false, 72, LineEnding::LF);
-        assert_eq!(540, max_input_length(730, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_lf_fits_one_spare_byte_no_pad() {
-        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
-        let config = config_wrap(false, 72, LineEnding::LF);
-        assert_eq!(540, max_input_length(731, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_lf_size_one_byte_short_of_another_line_no_pad() {
-        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
-        // 73 * 11 = 803
-        let config = config_wrap(false, 72, LineEnding::LF);
-        assert_eq!(540, max_input_length(802, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_lf_size_another_line_no_pad() {
-        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
-        // 73 * 11 = 803
-        let config = config_wrap(false, 72, LineEnding::LF);
-        assert_eq!(594, max_input_length(803, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_lf_one_byte_short_with_pad() {
-        // one fewer input line
-        let config = config_wrap(true, 72, LineEnding::LF);
-        assert_eq!(486, max_input_length(731, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_lf_fits_exactly_with_pad() {
-        // 10 * (72 + 1) = 730. 54 input bytes = 72 encoded bytes, + 1 for LF.
-        let config = config_wrap(true, 72, LineEnding::LF);
-        assert_eq!(540, max_input_length(732, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_line_len_wont_fit_one_line_lf() {
-        // 300 bytes is 400 encoded, + 1 for LF
-        let config = config_wrap(false, 400, LineEnding::LF);
-        assert_eq!(
-            ChunkedEncoderError::InvalidLineLength,
-            max_input_length(400, &config).unwrap_err()
-        );
-    }
-
-    #[test]
-    fn max_input_length_wrap_line_len_just_fits_one_line_lf() {
-        // 300 bytes is 400 encoded, + 1 for LF
+    fn max_input_length_cant_use_extra_single_encoded_byte() {
         let config = Config::new(
             CharacterSet::Standard,
             false,
-            false,
-            LineWrap::Wrap(400, LineEnding::LF),
         );
-        assert_eq!(300, max_input_length(401, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_crlf_fits_exactly_no_pad() {
-        // 10 * (72 + 2) = 740. 54 input bytes = 72 encoded bytes, + 2 for CRLF.
-        let config = config_wrap(false, 72, LineEnding::CRLF);
-        assert_eq!(540, max_input_length(740, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_crlf_fits_one_spare_byte_no_pad() {
-        // 10 * (72 + 2) = 740. 54 input bytes = 72 encoded bytes, + 2 for CRLF.
-        let config = config_wrap(false, 72, LineEnding::CRLF);
-        assert_eq!(540, max_input_length(741, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_crlf_size_one_byte_short_of_another_line_no_pad() {
-        // 10 * (72 + 2) = 740. 54 input bytes = 72 encoded bytes, + 2 for CRLF.
-        // 74 * 11 = 814
-        let config = config_wrap(false, 72, LineEnding::CRLF);
-        assert_eq!(540, max_input_length(813, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_with_crlf_size_another_line_no_pad() {
-        // 10 * (72 + 2) = 740. 54 input bytes = 72 encoded bytes, + 2 for CRLF.
-        // 74 * 11 = 814
-        let config = config_wrap(false, 72, LineEnding::CRLF);
-        assert_eq!(594, max_input_length(814, &config).unwrap());
-    }
-
-    #[test]
-    fn max_input_length_wrap_line_len_not_multiple_of_4_rejected() {
-        let config = config_wrap(false, 41, LineEnding::LF);
-        assert_eq!(
-            ChunkedEncoderError::InvalidLineLength,
-            max_input_length(400, &config).unwrap_err()
-        );
+        assert_eq!(300, max_input_length(401, &config));
     }
 
     pub fn chunked_encode_matches_normal_encode_random<S: SinkTestHelper>(sink_test_helper: &S) {
         let mut input_buf: Vec<u8> = Vec::new();
         let mut output_buf = String::new();
-        let mut rng = rand::weak_rng();
-        let line_len_range = Range::new(1, 1020);
+        let mut rng = rand::rngs::SmallRng::from_entropy();
         let input_len_range = Range::new(1, 10_000);
 
         for _ in 0..5_000 {
             input_buf.clear();
             output_buf.clear();
 
-            let buf_len = input_len_range.ind_sample(&mut rng);
+            let buf_len = input_len_range.sample(&mut rng);
             for _ in 0..buf_len {
                 input_buf.push(rng.gen());
             }
 
-            let config = random_config_for_chunked_encoder(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
 
             let chunk_encoded_string = sink_test_helper.encode_to_string(config, &input_buf);
             encode_config_buf(&input_buf, config, &mut output_buf);
 
             assert_eq!(
                 output_buf, chunk_encoded_string,
-                "input len={}, config: pad={}, wrap={:?}",
-                buf_len, config.pad, config.line_wrap
+                "input len={}, config: pad={}",
+                buf_len, config.pad
             );
         }
     }
 
     fn chunked_encode_str(bytes: &[u8], config: Config) -> String {
-        let mut sink = StringSink::new();
-
+        let mut s = String::new();
         {
-            let encoder = ChunkedEncoder::new(config).unwrap();
+            let mut sink = StringSink::new(&mut s);
+            let encoder = ChunkedEncoder::new(config);
             encoder.encode(bytes, &mut sink).unwrap();
         }
 
-        return sink.string;
+        return s;
     }
 
-    fn random_config_for_chunked_encoder<R: Rng>(
-        rng: &mut R,
-        line_len_range: &Range<usize>,
-    ) -> Config {
-        loop {
-            let config = random_config(rng, line_len_range);
-
-            // only use a config with line_len that is divisible by 4
-            match config.line_wrap {
-                LineWrap::NoWrap => return config,
-                LineWrap::Wrap(line_len, _) => if line_len % 4 == 0 {
-                    return config;
-                },
-            }
-        }
-    }
-
-    fn config_no_wrap(pad: bool) -> Config {
-        Config::new(CharacterSet::Standard, pad, false, LineWrap::NoWrap)
-    }
-
-    fn config_wrap(pad: bool, line_len: usize, line_ending: LineEnding) -> Config {
-        Config::new(
-            CharacterSet::Standard,
-            pad,
-            false,
-            LineWrap::Wrap(line_len, line_ending),
-        )
+    fn config_with_pad(pad: bool) -> Config {
+        Config::new(CharacterSet::Standard, pad)
     }
 
     // An abstraction around sinks so that we can have tests that easily to any sink implementation
@@ -470,39 +228,18 @@
         fn encode_to_string(&self, config: Config, bytes: &[u8]) -> String;
     }
 
-    // A really simple sink that just appends to a string for testing
-    struct StringSink {
-        string: String,
-    }
-
-    impl StringSink {
-        fn new() -> StringSink {
-            StringSink {
-                string: String::new(),
-            }
-        }
-    }
-
-    impl Sink for StringSink {
-        type Error = ();
-
-        fn write_encoded_bytes(&mut self, s: &[u8]) -> Result<(), Self::Error> {
-            self.string.push_str(str::from_utf8(s).unwrap());
-
-            Ok(())
-        }
-    }
-
     struct StringSinkTestHelper;
 
     impl SinkTestHelper for StringSinkTestHelper {
         fn encode_to_string(&self, config: Config, bytes: &[u8]) -> String {
-            let encoder = ChunkedEncoder::new(config).unwrap();
-            let mut sink = StringSink::new();
+            let encoder = ChunkedEncoder::new(config);
+            let mut s = String::new();
+            {
+                let mut sink = StringSink::new(&mut s);
+                encoder.encode(bytes, &mut sink).unwrap();
+            }
 
-            encoder.encode(bytes, &mut sink).unwrap();
-
-            sink.string
+            s
         }
     }
 
diff --git a/rustc_deps/vendor/base64/src/decode.rs b/rustc_deps/vendor/base64/src/decode.rs
index e25b752..9e5a762 100644
--- a/rustc_deps/vendor/base64/src/decode.rs
+++ b/rustc_deps/vendor/base64/src/decode.rs
@@ -25,6 +25,11 @@
     InvalidByte(usize, u8),
     /// The length of the input is invalid.
     InvalidLength,
+    /// The last non-padding input symbol's encoded 6 bits have nonzero bits that will be discarded.
+    /// This is indicative of corrupted or truncated Base64.
+    /// Unlike InvalidByte, which reports symbols that aren't in the alphabet, this error is for
+    /// symbols that are in the alphabet but represent nonsensical encodings.
+    InvalidLastSymbol(usize, u8),
 }
 
 impl fmt::Display for DecodeError {
@@ -34,6 +39,9 @@
                 write!(f, "Invalid byte {}, offset {}.", byte, index)
             }
             DecodeError::InvalidLength => write!(f, "Encoded text cannot have a 6-bit remainder."),
+            DecodeError::InvalidLastSymbol(index, byte) => {
+                write!(f, "Invalid last symbol {}, offset {}.", byte, index)
+            }
         }
     }
 }
@@ -43,6 +51,7 @@
         match *self {
             DecodeError::InvalidByte(_, _) => "invalid byte",
             DecodeError::InvalidLength => "invalid length",
+            DecodeError::InvalidLastSymbol(_, _) => "invalid last symbol",
         }
     }
 
@@ -120,13 +129,7 @@
     config: Config,
     buffer: &mut Vec<u8>,
 ) -> Result<(), DecodeError> {
-    let input_copy;
-    let input_bytes = if config.strip_whitespace {
-        input_copy = copy_without_whitespace(input.as_ref());
-        input_copy.as_ref()
-    } else {
-        input.as_ref()
-    };
+    let input_bytes = input.as_ref();
 
     let starting_output_len = buffer.len();
 
@@ -162,13 +165,7 @@
     config: Config,
     output: &mut [u8],
 ) -> Result<usize, DecodeError> {
-    let input_copy;
-    let input_bytes = if config.strip_whitespace {
-        input_copy = copy_without_whitespace(input.as_ref());
-        input_copy.as_ref()
-    } else {
-        input.as_ref()
-    };
+    let input_bytes = input.as_ref();
 
     decode_helper(
         input_bytes,
@@ -186,13 +183,6 @@
         .expect("Overflow when calculating number of chunks in input") / INPUT_CHUNK_LEN
 }
 
-fn copy_without_whitespace(input: &[u8]) -> Vec<u8> {
-    let mut input_copy = Vec::<u8>::with_capacity(input.len());
-    input_copy.extend(input.iter().filter(|b| !b" \n\t\r\x0b\x0c".contains(b)));
-
-    input_copy
-}
-
 /// Helper to avoid duplicating num_chunks calculation, which is costly on short inputs.
 /// Returns the number of bytes written, or an error.
 // We're on the fragile edge of compiler heuristics here. If this is not inlined, slow. If this is
@@ -321,6 +311,10 @@
         output_index += DECODED_CHUNK_LEN;
     }
 
+    // always have one more (possibly partial) block of 8 input
+    debug_assert!(input.len() - input_index > 1 || input.len() == 0);
+    debug_assert!(input.len() - input_index <= 8);
+
     // Stage 4
     // Finally, decode any leftovers that aren't a complete input block of 8 bytes.
     // Use a u64 as a stack-resident 8 byte buffer.
@@ -328,6 +322,7 @@
     let mut morsels_in_leftover = 0;
     let mut padding_bytes = 0;
     let mut first_padding_index: usize = 0;
+    let mut last_symbol = 0_u8;
     let start_of_leftovers = input_index;
     for (i, b) in input[start_of_leftovers..].iter().enumerate() {
         // '=' padding
@@ -374,6 +369,7 @@
                 0x3D,
             ));
         }
+        last_symbol = *b;
 
         // can use up to 8 * 6 = 48 bits of the u64, if last chunk has no padding.
         // To minimize shifts, pack the leftovers from left to right.
@@ -401,6 +397,14 @@
         ),
     };
 
+    // if there are bits set outside the bits we care about, last symbol encodes trailing bits that
+    // will not be included in the output
+    let mask = !0 >> leftover_bits_ready_to_append;
+    if (leftover_bits & mask) != 0 {
+        // last morsel is at `morsels_in_leftover` - 1
+        return Err(DecodeError::InvalidLastSymbol(start_of_leftovers + morsels_in_leftover - 1, last_symbol));
+    }
+
     let mut leftover_bits_appended_to_buf = 0;
     while leftover_bits_appended_to_buf < leftover_bits_ready_to_append {
         // `as` simply truncates the higher bits, which is what we want here
@@ -538,8 +542,9 @@
     use encode::encode_config_buf;
     use tests::{assert_encode_sanity, random_config};
 
-    use self::rand::distributions::{IndependentSample, Range};
-    use self::rand::Rng;
+    use self::rand::distributions::{Distribution, Range};
+    use self::rand::{Rng, FromEntropy};
+
 
     #[test]
     fn decode_chunk_precise_writes_only_6_bytes() {
@@ -567,9 +572,8 @@
 
         let prefix_len_range = Range::new(0, 1000);
         let input_len_range = Range::new(0, 1000);
-        let line_len_range = Range::new(1, 1000);
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {
             orig_data.clear();
@@ -578,17 +582,17 @@
             decoded_without_prefix.clear();
             prefix.clear();
 
-            let input_len = input_len_range.ind_sample(&mut rng);
+            let input_len = input_len_range.sample(&mut rng);
 
             for _ in 0..input_len {
                 orig_data.push(rng.gen());
             }
 
-            let config = random_config(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
             encode_config_buf(&orig_data, config, &mut encoded_data);
             assert_encode_sanity(&encoded_data, &config, input_len);
 
-            let prefix_len = prefix_len_range.ind_sample(&mut rng);
+            let prefix_len = prefix_len_range.sample(&mut rng);
 
             // fill the buf with a prefix
             for _ in 0..prefix_len {
@@ -624,9 +628,8 @@
         let mut decode_buf_copy: Vec<u8> = Vec::new();
 
         let input_len_range = Range::new(0, 1000);
-        let line_len_range = Range::new(1, 1000);
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {
             orig_data.clear();
@@ -634,13 +637,13 @@
             decode_buf.clear();
             decode_buf_copy.clear();
 
-            let input_len = input_len_range.ind_sample(&mut rng);
+            let input_len = input_len_range.sample(&mut rng);
 
             for _ in 0..input_len {
                 orig_data.push(rng.gen());
             }
 
-            let config = random_config(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
             encode_config_buf(&orig_data, config, &mut encoded_data);
             assert_encode_sanity(&encoded_data, &config, input_len);
 
@@ -678,22 +681,21 @@
         let mut decode_buf = Vec::new();
 
         let input_len_range = Range::new(0, 1000);
-        let line_len_range = Range::new(1, 1000);
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {
             orig_data.clear();
             encoded_data.clear();
             decode_buf.clear();
 
-            let input_len = input_len_range.ind_sample(&mut rng);
+            let input_len = input_len_range.sample(&mut rng);
 
             for _ in 0..input_len {
                 orig_data.push(rng.gen());
             }
 
-            let config = random_config(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
             encode_config_buf(&orig_data, config, &mut encoded_data);
             assert_encode_sanity(&encoded_data, &config, input_len);
 
@@ -707,4 +709,107 @@
             assert_eq!(orig_data, decode_buf);
         }
     }
+
+    #[test]
+    fn detect_invalid_last_symbol_two_bytes() {
+        // example from https://github.com/alicemaz/rust-base64/issues/75
+        assert!(decode("iYU=").is_ok());
+        // trailing 01
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(2, b'V')), decode("iYV="));
+        // trailing 10
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(2, b'W')), decode("iYW="));
+        // trailing 11
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(2, b'X')), decode("iYX="));
+
+        // also works when there are 2 quads in the last block
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(6, b'X')), decode("AAAAiYX="));
+    }
+
+    #[test]
+    fn detect_invalid_last_symbol_one_byte() {
+        // 0xFF -> "/w==", so all letters > w, 0-9, and '+', '/' should get InvalidLastSymbol
+
+        assert!(decode("/w==").is_ok());
+        // trailing 01
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(1, b'x')), decode("/x=="));
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(1, b'z')), decode("/z=="));
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(1, b'0')), decode("/0=="));
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(1, b'9')), decode("/9=="));
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(1, b'+')), decode("/+=="));
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(1, b'/')), decode("//=="));
+
+        // also works when there are 2 quads in the last block
+        assert_eq!(Err(DecodeError::InvalidLastSymbol(5, b'x')), decode("AAAA/x=="));
+    }
+
+    #[test]
+    fn detect_invalid_last_symbol_every_possible_three_symbols() {
+        let mut base64_to_bytes = ::std::collections::HashMap::new();
+
+        let mut bytes = [0_u8; 2];
+        for b1 in 0_u16..256 {
+            bytes[0] = b1 as u8;
+            for b2 in 0_u16..256 {
+                bytes[1] = b2 as u8;
+                let mut b64 = vec![0_u8; 4];
+                assert_eq!(4, ::encode_config_slice(&bytes, STANDARD, &mut b64[..]));
+                let mut v = ::std::vec::Vec::with_capacity(2);
+                v.extend_from_slice(&bytes[..]);
+
+                assert!(base64_to_bytes.insert(b64, v).is_none());
+            };
+        }
+
+        // every possible combination of symbols must either decode to 2 bytes or get InvalidLastSymbol
+
+        let mut symbols = [0_u8; 4];
+        for &s1 in STANDARD.char_set.encode_table().iter() {
+            symbols[0] = s1;
+            for &s2 in STANDARD.char_set.encode_table().iter() {
+                symbols[1] = s2;
+                for &s3 in STANDARD.char_set.encode_table().iter() {
+                    symbols[2] = s3;
+                    symbols[3] = b'=';
+
+                    match base64_to_bytes.get(&symbols[..]) {
+                        Some(bytes) => assert_eq!(Ok(bytes.to_vec()), decode_config(&symbols, STANDARD)),
+                        None => assert_eq!(Err(DecodeError::InvalidLastSymbol(2, s3)),
+                                           decode_config(&symbols[..], STANDARD))
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn detect_invalid_last_symbol_every_possible_two_symbols() {
+        let mut base64_to_bytes = ::std::collections::HashMap::new();
+
+        for b in 0_u16..256 {
+            let mut b64 = vec![0_u8; 4];
+            assert_eq!(4, ::encode_config_slice(&[b as u8], STANDARD, &mut b64[..]));
+            let mut v = ::std::vec::Vec::with_capacity(1);
+            v.push(b as u8);
+
+            assert!(base64_to_bytes.insert(b64, v).is_none());
+        };
+
+        // every possible combination of symbols must either decode to 1 byte or get InvalidLastSymbol
+
+        let mut symbols = [0_u8; 4];
+        for &s1 in STANDARD.char_set.encode_table().iter() {
+            symbols[0] = s1;
+            for &s2 in STANDARD.char_set.encode_table().iter() {
+                symbols[1] = s2;
+                symbols[2] = b'=';
+                symbols[3] = b'=';
+
+                match base64_to_bytes.get(&symbols[..]) {
+                    Some(bytes) => assert_eq!(Ok(bytes.to_vec()), decode_config(&symbols, STANDARD)),
+                    None => assert_eq!(Err(DecodeError::InvalidLastSymbol(1, s2)),
+                                       decode_config(&symbols[..], STANDARD))
+                }
+            }
+        }
+    }
 }
diff --git a/rustc_deps/vendor/base64/src/display.rs b/rustc_deps/vendor/base64/src/display.rs
index 53ee1d7..464b6be 100644
--- a/rustc_deps/vendor/base64/src/display.rs
+++ b/rustc_deps/vendor/base64/src/display.rs
@@ -4,26 +4,16 @@
 //! use base64::display::Base64Display;
 //!
 //! let data = vec![0x0, 0x1, 0x2, 0x3];
-//! let wrapper = Base64Display::standard(&data);
+//! let wrapper = Base64Display::with_config(&data, base64::STANDARD);
 //!
 //! assert_eq!("base64: AAECAw==", format!("base64: {}", wrapper));
 //! ```
 
-use super::chunked_encoder::{ChunkedEncoder, ChunkedEncoderError};
+use super::chunked_encoder::ChunkedEncoder;
 use super::Config;
 use std::fmt::{Display, Formatter};
 use std::{fmt, str};
 
-// I'm not convinced that we should expose ChunkedEncoder or its error type since it's just an
-// implementation detail, so use a different error type.
-/// Errors that can occur initializing a Base64Display.
-#[derive(Debug, PartialEq)]
-pub enum DisplayError {
-    /// If wrapping is configured, the line length must be a multiple of 4, and must not be absurdly
-    /// large (currently capped at 1024, subject to change).
-    InvalidLineLength,
-}
-
 /// A convenience wrapper for base64'ing bytes into a format string without heap allocation.
 pub struct Base64Display<'a> {
     bytes: &'a [u8],
@@ -32,25 +22,11 @@
 
 impl<'a> Base64Display<'a> {
     /// Create a `Base64Display` with the provided config.
-    pub fn with_config(bytes: &[u8], config: Config) -> Result<Base64Display, DisplayError> {
-        ChunkedEncoder::new(config)
-            .map(|c| Base64Display {
-                bytes,
-                chunked_encoder: c,
-            })
-            .map_err(|e| match e {
-                ChunkedEncoderError::InvalidLineLength => DisplayError::InvalidLineLength,
-            })
-    }
-
-    /// Convenience method for creating a `Base64Display` with the `STANDARD` configuration.
-    pub fn standard(bytes: &[u8]) -> Base64Display {
-        Base64Display::with_config(bytes, super::STANDARD).expect("STANDARD is valid")
-    }
-
-    /// Convenience method for creating a `Base64Display` with the `URL_SAFE` configuration.
-    pub fn url_safe(bytes: &[u8]) -> Base64Display {
-        Base64Display::with_config(bytes, super::URL_SAFE).expect("URL_SAFE is valid")
+    pub fn with_config(bytes: &[u8], config: Config) -> Base64Display {
+        Base64Display {
+            bytes,
+            chunked_encoder: ChunkedEncoder::new(config),
+        }
     }
 }
 
@@ -87,11 +63,11 @@
     fn basic_display() {
         assert_eq!(
             "~$Zm9vYmFy#*",
-            format!("~${}#*", Base64Display::standard("foobar".as_bytes()))
+            format!("~${}#*", Base64Display::with_config(b"foobar", STANDARD))
         );
         assert_eq!(
             "~$Zm9vYmFyZg==#*",
-            format!("~${}#*", Base64Display::standard("foobarf".as_bytes()))
+            format!("~${}#*", Base64Display::with_config(b"foobarf", STANDARD))
         );
     }
 
@@ -105,8 +81,7 @@
 
     impl SinkTestHelper for DisplaySinkTestHelper {
         fn encode_to_string(&self, config: Config, bytes: &[u8]) -> String {
-            format!("{}", Base64Display::with_config(bytes, config).unwrap())
+            format!("{}", Base64Display::with_config(bytes, config))
         }
     }
-
 }
diff --git a/rustc_deps/vendor/base64/src/encode.rs b/rustc_deps/vendor/base64/src/encode.rs
index be1eb86..e563582 100644
--- a/rustc_deps/vendor/base64/src/encode.rs
+++ b/rustc_deps/vendor/base64/src/encode.rs
@@ -1,5 +1,5 @@
 use byteorder::{BigEndian, ByteOrder};
-use {line_wrap, line_wrap_parameters, Config, LineWrap, STANDARD};
+use {Config, STANDARD};
 
 ///Encode arbitrary octets as base64.
 ///Returns a String.
@@ -37,13 +37,14 @@
 ///```
 pub fn encode_config<T: ?Sized + AsRef<[u8]>>(input: &T, config: Config) -> String {
     let mut buf = match encoded_size(input.as_ref().len(), &config) {
-        Some(n) => String::with_capacity(n),
+        Some(n) => vec![0; n],
         None => panic!("integer overflow when calculating buffer size"),
     };
 
-    encode_config_buf(input, config, &mut buf);
+    let encoded_len = encode_config_slice(input.as_ref(), config, &mut buf[..]);
+    debug_assert_eq!(encoded_len, buf.len());
 
-    buf
+    return String::from_utf8(buf).expect("Invalid UTF8");
 }
 
 ///Encode arbitrary octets as base64.
@@ -67,27 +68,13 @@
 pub fn encode_config_buf<T: ?Sized + AsRef<[u8]>>(input: &T, config: Config, buf: &mut String) {
     let input_bytes = input.as_ref();
 
-    let encoded_size = encoded_size(input_bytes.len(), &config)
-        .expect("usize overflow when calculating buffer size");
+    {
+        let mut sink = ::chunked_encoder::StringSink::new(buf);
+        let encoder = ::chunked_encoder::ChunkedEncoder::new(config);
 
-    let orig_buf_len = buf.len();
-
-    // we're only going to insert valid utf8
-    let buf_bytes;
-    unsafe {
-        buf_bytes = buf.as_mut_vec();
+        encoder.encode(input_bytes, &mut sink).expect("Writing to a String shouldn't fail")
     }
 
-    buf_bytes.resize(
-        orig_buf_len
-            .checked_add(encoded_size)
-            .expect("usize overflow when calculating expanded buffer size"),
-        0,
-    );
-
-    let mut b64_output = &mut buf_bytes[orig_buf_len..];
-
-    encode_with_padding_line_wrap(&input_bytes, &config, encoded_size, &mut b64_output);
 }
 
 /// Encode arbitrary octets as base64.
@@ -132,12 +119,12 @@
 
     let mut b64_output = &mut output[0..encoded_size];
 
-    encode_with_padding_line_wrap(&input_bytes, &config, encoded_size, &mut b64_output);
+    encode_with_padding(&input_bytes, &config, encoded_size, &mut b64_output);
 
     encoded_size
 }
 
-/// B64-encode, pad, and line wrap (if configured).
+/// B64-encode and pad (if configured).
 ///
 /// This helper exists to avoid recalculating encoded_size, which is relatively expensive on short
 /// inputs.
@@ -147,7 +134,7 @@
 /// `output` must be of size `encoded_size`.
 ///
 /// All bytes in `output` will be written to since it is exactly the size of the output.
-pub fn encode_with_padding_line_wrap(
+fn encode_with_padding(
     input: &[u8],
     config: &Config,
     encoded_size: usize,
@@ -167,17 +154,11 @@
         .checked_add(padding_bytes)
         .expect("usize overflow when calculating b64 length");
 
-    let line_ending_bytes = if let LineWrap::Wrap(line_len, line_end) = config.line_wrap {
-        line_wrap(output, encoded_bytes, line_len, line_end)
-    } else {
-        0
-    };
-
-    debug_assert_eq!(encoded_size, encoded_bytes + line_ending_bytes);
+    debug_assert_eq!(encoded_size, encoded_bytes);
 }
 
-/// Encode input bytes to utf8 base64 bytes. Does not pad or line wrap.
-/// `output` must be long enough to hold the encoded `input` without padding or line wrapping.
+/// Encode input bytes to utf8 base64 bytes. Does not pad.
+/// `output` must be long enough to hold the encoded `input` without padding.
 /// Returns the number of bytes written.
 #[inline]
 pub fn encode_to_slice(input: &[u8], output: &mut [u8], encode_table: &[u8; 64]) -> usize {
@@ -297,14 +278,14 @@
     output_index
 }
 
-/// calculate the base64 encoded string size, including padding and line wraps if appropriate
+/// calculate the base64 encoded string size, including padding if appropriate
 pub fn encoded_size(bytes_len: usize, config: &Config) -> Option<usize> {
     let rem = bytes_len % 3;
 
     let complete_input_chunks = bytes_len / 3;
     let complete_chunk_output = complete_input_chunks.checked_mul(4);
 
-    let encoded_len_no_wrap = if rem > 0 {
+    if rem > 0 {
         if config.pad {
             complete_chunk_output.and_then(|c| c.checked_add(4))
         } else {
@@ -317,14 +298,7 @@
         }
     } else {
         complete_chunk_output
-    };
-
-    encoded_len_no_wrap.map(|e| match config.line_wrap {
-        LineWrap::NoWrap => e,
-        LineWrap::Wrap(line_len, line_ending) => {
-            line_wrap_parameters(e, line_len, line_ending).total_len
-        }
-    })
+    }
 }
 
 /// Write padding characters.
@@ -349,10 +323,10 @@
     use super::*;
     use decode::decode_config_buf;
     use tests::{assert_encode_sanity, random_config};
-    use {CharacterSet, Config, LineEnding, LineWrap, MIME, STANDARD, URL_SAFE_NO_PAD};
+    use {Config, STANDARD, URL_SAFE_NO_PAD};
 
-    use self::rand::distributions::{IndependentSample, Range};
-    use self::rand::Rng;
+    use self::rand::distributions::{Distribution, Range};
+    use self::rand::{Rng, FromEntropy};
     use std;
     use std::str;
 
@@ -382,7 +356,7 @@
     }
 
     #[test]
-    fn encoded_size_correct_no_pad_no_wrap() {
+    fn encoded_size_correct_no_pad() {
         assert_encoded_length(0, 0, URL_SAFE_NO_PAD);
 
         assert_encoded_length(1, 2, URL_SAFE_NO_PAD);
@@ -407,68 +381,6 @@
     }
 
     #[test]
-    fn encoded_size_correct_mime() {
-        assert_encoded_length(0, 0, MIME);
-
-        assert_encoded_length(1, 4, MIME);
-        assert_encoded_length(2, 4, MIME);
-        assert_encoded_length(3, 4, MIME);
-
-        assert_encoded_length(4, 8, MIME);
-        assert_encoded_length(5, 8, MIME);
-        assert_encoded_length(6, 8, MIME);
-
-        assert_encoded_length(7, 12, MIME);
-        assert_encoded_length(8, 12, MIME);
-        assert_encoded_length(9, 12, MIME);
-
-        assert_encoded_length(54, 72, MIME);
-
-        assert_encoded_length(55, 76, MIME);
-        assert_encoded_length(56, 76, MIME);
-        assert_encoded_length(57, 76, MIME);
-
-        assert_encoded_length(58, 82, MIME);
-        assert_encoded_length(59, 82, MIME);
-        assert_encoded_length(60, 82, MIME);
-    }
-
-    #[test]
-    fn encoded_size_correct_lf_pad() {
-        let config = Config::new(
-            CharacterSet::Standard,
-            true,
-            false,
-            LineWrap::Wrap(76, LineEnding::LF),
-        );
-
-        assert_encoded_length(0, 0, config);
-
-        assert_encoded_length(1, 4, config);
-        assert_encoded_length(2, 4, config);
-        assert_encoded_length(3, 4, config);
-
-        assert_encoded_length(4, 8, config);
-        assert_encoded_length(5, 8, config);
-        assert_encoded_length(6, 8, config);
-
-        assert_encoded_length(7, 12, config);
-        assert_encoded_length(8, 12, config);
-        assert_encoded_length(9, 12, config);
-
-        assert_encoded_length(54, 72, config);
-
-        assert_encoded_length(55, 76, config);
-        assert_encoded_length(56, 76, config);
-        assert_encoded_length(57, 76, config);
-
-        // one fewer than MIME
-        assert_encoded_length(58, 81, config);
-        assert_encoded_length(59, 81, config);
-        assert_encoded_length(60, 81, config);
-    }
-
-    #[test]
     fn encoded_size_overflow() {
         assert_eq!(None, encoded_size(std::usize::MAX, &STANDARD));
     }
@@ -483,9 +395,8 @@
 
         let prefix_len_range = Range::new(0, 1000);
         let input_len_range = Range::new(0, 1000);
-        let line_len_range = Range::new(1, 1000);
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {
             orig_data.clear();
@@ -494,13 +405,13 @@
             encoded_data_with_prefix.clear();
             decoded.clear();
 
-            let input_len = input_len_range.ind_sample(&mut rng);
+            let input_len = input_len_range.sample(&mut rng);
 
             for _ in 0..input_len {
                 orig_data.push(rng.gen());
             }
 
-            let prefix_len = prefix_len_range.ind_sample(&mut rng);
+            let prefix_len = prefix_len_range.sample(&mut rng);
             for _ in 0..prefix_len {
                 // getting convenient random single-byte printable chars that aren't base64 is
                 // annoying
@@ -508,7 +419,7 @@
             }
             encoded_data_with_prefix.push_str(&prefix);
 
-            let config = random_config(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
             encode_config_buf(&orig_data, config, &mut encoded_data_no_prefix);
             encode_config_buf(&orig_data, config, &mut encoded_data_with_prefix);
 
@@ -537,9 +448,8 @@
         let mut decoded = Vec::new();
 
         let input_len_range = Range::new(0, 1000);
-        let line_len_range = Range::new(1, 1000);
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {
             orig_data.clear();
@@ -547,7 +457,7 @@
             encoded_data_original_state.clear();
             decoded.clear();
 
-            let input_len = input_len_range.ind_sample(&mut rng);
+            let input_len = input_len_range.sample(&mut rng);
 
             for _ in 0..input_len {
                 orig_data.push(rng.gen());
@@ -560,7 +470,7 @@
 
             encoded_data_original_state.extend_from_slice(&encoded_data);
 
-            let config = random_config(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
 
             let encoded_size = encoded_size(input_len, &config).unwrap();
 
@@ -592,22 +502,21 @@
         let mut decoded = Vec::new();
 
         let input_len_range = Range::new(0, 1000);
-        let line_len_range = Range::new(1, 1000);
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {
             orig_data.clear();
             encoded_data.clear();
             decoded.clear();
 
-            let input_len = input_len_range.ind_sample(&mut rng);
+            let input_len = input_len_range.sample(&mut rng);
 
             for _ in 0..input_len {
                 orig_data.push(rng.gen());
             }
 
-            let config = random_config(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
 
             let encoded_size = encoded_size(input_len, &config).unwrap();
 
@@ -635,21 +544,20 @@
         let mut output = Vec::new();
 
         let input_len_range = Range::new(0, 1000);
-        let line_len_range = Range::new(1, 1000);
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {
             input.clear();
             output.clear();
 
-            let input_len = input_len_range.ind_sample(&mut rng);
+            let input_len = input_len_range.sample(&mut rng);
 
             for _ in 0..input_len {
                 input.push(rng.gen());
             }
 
-            let config = random_config(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
 
             // fill up the output buffer with garbage
             let encoded_size = encoded_size(input_len, &config).unwrap();
@@ -671,26 +579,25 @@
     }
 
     #[test]
-    fn encode_with_padding_line_wrap_random_valid_utf8() {
+    fn encode_with_padding_random_valid_utf8() {
         let mut input = Vec::new();
         let mut output = Vec::new();
 
         let input_len_range = Range::new(0, 1000);
-        let line_len_range = Range::new(1, 1000);
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {
             input.clear();
             output.clear();
 
-            let input_len = input_len_range.ind_sample(&mut rng);
+            let input_len = input_len_range.sample(&mut rng);
 
             for _ in 0..input_len {
                 input.push(rng.gen());
             }
 
-            let config = random_config(&mut rng, &line_len_range);
+            let config = random_config(&mut rng);
 
             // fill up the output buffer with garbage
             let encoded_size = encoded_size(input_len, &config).unwrap();
@@ -700,7 +607,7 @@
 
             let orig_output_buf = output.to_vec();
 
-            encode_with_padding_line_wrap(
+            encode_with_padding(
                 &input,
                 &config,
                 encoded_size,
@@ -719,7 +626,7 @@
     fn add_padding_random_valid_utf8() {
         let mut output = Vec::new();
 
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         // cover our bases for length % 3
         for input_len in 0..10 {
@@ -746,7 +653,7 @@
         assert_eq!(encoded_len, encoded_size(input_len, &config).unwrap());
 
         let mut bytes: Vec<u8> = Vec::new();
-        let mut rng = rand::weak_rng();
+        let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..input_len {
             bytes.push(rng.gen());
diff --git a/rustc_deps/vendor/base64/src/lib.rs b/rustc_deps/vendor/base64/src/lib.rs
index 020592f..2c310a5 100644
--- a/rustc_deps/vendor/base64/src/lib.rs
+++ b/rustc_deps/vendor/base64/src/lib.rs
@@ -1,9 +1,9 @@
 //! # Configs
 //!
 //! There isn't just one type of Base64; that would be too simple. You need to choose a character
-//! set (standard or URL-safe), padding suffix (yes/no), and line wrap (line length, line ending).
+//! set (standard, URL-safe, etc) and padding suffix (yes/no).
 //! The `Config` struct encapsulates this info. There are some common configs included: `STANDARD`,
-//! `MIME`, etc. You can also make your own `Config` if needed.
+//! `URL_SAFE`, etc. You can also make your own `Config` if needed.
 //!
 //! The functions that don't have `config` in the name (e.g. `encode()` and `decode()`) use the
 //! `STANDARD` config .
@@ -25,16 +25,12 @@
 //! | `encode_config_buf`     | Appends to provided `String` | Only if `String` needs to grow |
 //! | `encode_config_slice`   | Writes to provided `&[u8]`   | Never                          |
 //!
-//! All of the encoding functions that take a `Config` will pad, line wrap, etc, as per the config.
+//! All of the encoding functions that take a `Config` will pad as per the config.
 //!
 //! # Decoding
 //!
 //! Just as for encoding, there are different decoding functions available.
 //!
-//! Note that all decode functions that take a config will allocate a copy of the input if you
-//! specify a config that requires whitespace to be stripped. If you care about speed, don't use
-//! formats that line wrap and then require whitespace stripping.
-//!
 //! | Function                | Output                        | Allocates                      |
 //! | ----------------------- | ----------------------------- | ------------------------------ |
 //! | `decode`                | Returns a new `Vec<u8>`       | Always                         |
@@ -45,9 +41,7 @@
 //! Unlike encoding, where all possible input is valid, decoding can fail (see `DecodeError`).
 //!
 //! Input can be invalid because it has invalid characters or invalid padding. (No padding at all is
-//! valid, but excess padding is not.)
-//!
-//! Whitespace in the input is invalid unless `strip_whitespace` is enabled in the `Config` used.
+//! valid, but excess padding is not.) Whitespace in the input is invalid.
 //!
 //! # Panics
 //!
@@ -57,18 +51,16 @@
 
 #![deny(
     missing_docs, trivial_casts, trivial_numeric_casts, unused_extern_crates, unused_import_braces,
-    unused_results, variant_size_differences, warnings
+    unused_results, variant_size_differences, warnings, unsafe_code
 )]
 
 extern crate byteorder;
 
 mod chunked_encoder;
 pub mod display;
-mod line_wrap;
+pub mod write;
 mod tables;
 
-use line_wrap::{line_wrap, line_wrap_parameters};
-
 mod encode;
 pub use encode::{encode, encode_config, encode_config_buf, encode_config_slice};
 
@@ -81,11 +73,17 @@
 /// Available encoding character sets
 #[derive(Clone, Copy, Debug)]
 pub enum CharacterSet {
-    /// The standard character set (uses `+` and `/`)
+    /// The standard character set (uses `+` and `/`).
+    ///
+    /// See [RFC 3548](https://tools.ietf.org/html/rfc3548#section-3).
     Standard,
-    /// The URL safe character set (uses `-` and `_`)
+    /// The URL safe character set (uses `-` and `_`).
+    ///
+    /// See [RFC 3548](https://tools.ietf.org/html/rfc3548#section-4).
     UrlSafe,
-    /// The `crypt(3)` character set (uses `./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`)
+    /// The `crypt(3)` character set (uses `./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`).
+    ///
+    /// Not standardized, but folk wisdom on the net asserts that this alphabet is what crypt uses.
     Crypt,
 }
 
@@ -107,33 +105,6 @@
     }
 }
 
-/// Line ending used in optional line wrapping.
-#[derive(Clone, Copy, Debug)]
-pub enum LineEnding {
-    /// Unix-style \n
-    LF,
-    /// Windows-style \r\n
-    CRLF,
-}
-
-impl LineEnding {
-    fn len(&self) -> usize {
-        match *self {
-            LineEnding::LF => 1,
-            LineEnding::CRLF => 2,
-        }
-    }
-}
-
-/// Line wrap configuration.
-#[derive(Clone, Copy, Debug)]
-pub enum LineWrap {
-    /// Don't wrap.
-    NoWrap,
-    /// Wrap lines with the specified length and line ending. The length must be > 0.
-    Wrap(usize, LineEnding),
-}
-
 /// Contains configuration parameters for base64 encoding
 #[derive(Clone, Copy, Debug)]
 pub struct Config {
@@ -141,12 +112,6 @@
     char_set: CharacterSet,
     /// True to pad output with `=` characters
     pad: bool,
-    /// Remove whitespace before decoding, at the cost of an allocation. Whitespace is defined
-    /// according to POSIX-locale `isspace`, meaning \n \r \f \t \v and space.
-    strip_whitespace: bool,
-    /// ADT signifying whether to linewrap output, and if so by how many characters and with what
-    /// ending
-    line_wrap: LineWrap,
 }
 
 impl Config {
@@ -154,19 +119,10 @@
     pub fn new(
         char_set: CharacterSet,
         pad: bool,
-        strip_whitespace: bool,
-        input_line_wrap: LineWrap,
     ) -> Config {
-        let line_wrap = match input_line_wrap {
-            LineWrap::Wrap(0, _) => LineWrap::NoWrap,
-            _ => input_line_wrap,
-        };
-
         Config {
             char_set,
             pad,
-            strip_whitespace,
-            line_wrap,
         }
     }
 }
@@ -175,46 +131,28 @@
 pub const STANDARD: Config = Config {
     char_set: CharacterSet::Standard,
     pad: true,
-    strip_whitespace: false,
-    line_wrap: LineWrap::NoWrap,
 };
 
 /// Standard character set without padding.
 pub const STANDARD_NO_PAD: Config = Config {
     char_set: CharacterSet::Standard,
     pad: false,
-    strip_whitespace: false,
-    line_wrap: LineWrap::NoWrap,
-};
-
-/// As per standards for MIME encoded messages
-pub const MIME: Config = Config {
-    char_set: CharacterSet::Standard,
-    pad: true,
-    strip_whitespace: true,
-    line_wrap: LineWrap::Wrap(76, LineEnding::CRLF),
 };
 
 /// URL-safe character set with padding
 pub const URL_SAFE: Config = Config {
     char_set: CharacterSet::UrlSafe,
     pad: true,
-    strip_whitespace: false,
-    line_wrap: LineWrap::NoWrap,
 };
 
 /// URL-safe character set without padding
 pub const URL_SAFE_NO_PAD: Config = Config {
     char_set: CharacterSet::UrlSafe,
     pad: false,
-    strip_whitespace: false,
-    line_wrap: LineWrap::NoWrap,
 };
 
 /// As per `crypt(3)` requirements
 pub const CRYPT: Config = Config {
     char_set: CharacterSet::Crypt,
     pad: false,
-    strip_whitespace: false,
-    line_wrap: LineWrap::NoWrap,
 };
diff --git a/rustc_deps/vendor/base64/src/tests.rs b/rustc_deps/vendor/base64/src/tests.rs
index ff0f4b6..dcbae9f 100644
--- a/rustc_deps/vendor/base64/src/tests.rs
+++ b/rustc_deps/vendor/base64/src/tests.rs
@@ -1,75 +1,62 @@
 extern crate rand;
 
 use encode::encoded_size;
-use line_wrap::line_wrap_parameters;
 use *;
 
 use std::str;
 
-use self::rand::distributions::{IndependentSample, Range};
-use self::rand::Rng;
+use self::rand::distributions::{Distribution, Range};
+use self::rand::{Rng, FromEntropy};
 
 #[test]
 fn roundtrip_random_config_short() {
     // exercise the slower encode/decode routines that operate on shorter buffers more vigorously
-    roundtrip_random_config(Range::new(0, 50), Range::new(0, 50), 10_000);
+    roundtrip_random_config(Range::new(0, 50), 10_000);
 }
 
 #[test]
 fn roundtrip_random_config_long() {
-    roundtrip_random_config(Range::new(0, 1000), Range::new(0, 1000), 10_000);
+    roundtrip_random_config(Range::new(0, 1000), 10_000);
 }
 
 pub fn assert_encode_sanity(encoded: &str, config: &Config, input_len: usize) {
     let input_rem = input_len % 3;
-    let (expected_padding_len, last_encoded_chunk_len) = if input_rem > 0 {
+    let expected_padding_len = if input_rem > 0 {
         if config.pad {
-            (3 - input_rem, 4)
+            3 - input_rem
         } else {
-            (0, input_rem + 1)
+            0
         }
     } else {
-        (0, 0)
-    };
-
-    let b64_only_len = (input_len / 3) * 4 + last_encoded_chunk_len;
-
-    let expected_line_ending_len = match config.line_wrap {
-        LineWrap::NoWrap => 0,
-        LineWrap::Wrap(line_len, line_ending) => {
-            line_wrap_parameters(b64_only_len, line_len, line_ending).total_line_endings_len
-        }
+        0
     };
 
     let expected_encoded_len = encoded_size(input_len, &config).unwrap();
 
     assert_eq!(expected_encoded_len, encoded.len());
 
-    let line_endings_len = encoded.chars().filter(|&c| c == '\r' || c == '\n').count();
     let padding_len = encoded.chars().filter(|&c| c == '=').count();
 
     assert_eq!(expected_padding_len, padding_len);
-    assert_eq!(expected_line_ending_len, line_endings_len);
 
     let _ = str::from_utf8(encoded.as_bytes()).expect("Base64 should be valid utf8");
 }
 
 fn roundtrip_random_config(
     input_len_range: Range<usize>,
-    line_len_range: Range<usize>,
     iterations: u32,
 ) {
     let mut input_buf: Vec<u8> = Vec::new();
     let mut encoded_buf = String::new();
-    let mut rng = rand::weak_rng();
+    let mut rng = rand::rngs::SmallRng::from_entropy();
 
     for _ in 0..iterations {
         input_buf.clear();
         encoded_buf.clear();
 
-        let input_len = input_len_range.ind_sample(&mut rng);
+        let input_len = input_len_range.sample(&mut rng);
 
-        let config = random_config(&mut rng, &line_len_range);
+        let config = random_config(&mut rng);
 
         for _ in 0..input_len {
             input_buf.push(rng.gen());
@@ -83,21 +70,7 @@
     }
 }
 
-pub fn random_config<R: Rng>(rng: &mut R, line_len_range: &Range<usize>) -> Config {
-    let line_wrap = if rng.gen() {
-        LineWrap::NoWrap
-    } else {
-        let line_len = line_len_range.ind_sample(rng);
-
-        let line_ending = if rng.gen() {
-            LineEnding::LF
-        } else {
-            LineEnding::CRLF
-        };
-
-        LineWrap::Wrap(line_len, line_ending)
-    };
-
+pub fn random_config<R: Rng>(rng: &mut R) -> Config {
     const CHARSETS: &[CharacterSet] = &[
         CharacterSet::UrlSafe,
         CharacterSet::Standard,
@@ -105,10 +78,5 @@
     ];
     let charset = *rng.choose(CHARSETS).unwrap();
 
-    let strip_whitespace = match line_wrap {
-        LineWrap::NoWrap => false,
-        _ => true,
-    };
-
-    Config::new(charset, rng.gen(), strip_whitespace, line_wrap)
+    Config::new(charset, rng.gen())
 }
diff --git a/rustc_deps/vendor/base64/src/write/encoder.rs b/rustc_deps/vendor/base64/src/write/encoder.rs
new file mode 100644
index 0000000..41a9bcb
--- /dev/null
+++ b/rustc_deps/vendor/base64/src/write/encoder.rs
@@ -0,0 +1,252 @@
+use ::encode::encode_to_slice;
+use std::{cmp, fmt};
+use std::io::{Result, Write};
+use {encode_config_slice, Config};
+
+pub(crate) const BUF_SIZE: usize = 1024;
+/// The most bytes whose encoding will fit in `BUF_SIZE`
+const MAX_INPUT_LEN: usize = BUF_SIZE / 4 * 3;
+// 3 bytes of input = 4 bytes of base64, always (because we don't allow line wrapping)
+const MIN_ENCODE_CHUNK_SIZE: usize = 3;
+
+/// A `Write` implementation that base64 encodes data before delegating to the wrapped writer.
+///
+/// Because base64 has special handling for the end of the input data (padding, etc), there's a
+/// `finish()` method on this type that encodes any leftover input bytes and adds padding if
+/// appropriate. It's called automatically when deallocated (see the `Drop` implementation), but
+/// any error that occurs when invoking the underlying writer will be suppressed. If you want to
+/// handle such errors, call `finish()` yourself.
+///
+/// # Examples
+///
+/// ```
+/// use std::io::Write;
+///
+/// // use a vec as the simplest possible `Write` -- in real code this is probably a file, etc.
+/// let mut wrapped_writer = Vec::new();
+/// {
+///     let mut enc = base64::write::EncoderWriter::new(
+///         &mut wrapped_writer, base64::STANDARD);
+///
+///     // handle errors as you normally would
+///     enc.write_all(b"asdf").unwrap();
+///     // could leave this out to be called by Drop, if you don't care
+///     // about handling errors
+///     enc.finish().unwrap();
+///
+/// }
+///
+/// // base64 was written to the writer
+/// assert_eq!(b"YXNkZg==", &wrapped_writer[..]);
+///
+/// ```
+///
+/// # Panics
+///
+/// Calling `write()` after `finish()` is invalid and will panic.
+///
+/// # Errors
+///
+/// Base64 encoding itself does not generate errors, but errors from the wrapped writer will be
+/// returned as per the contract of `Write`.
+///
+/// # Performance
+///
+/// It has some minor performance loss compared to encoding slices (a couple percent).
+/// It does not do any heap allocation.
+pub struct EncoderWriter<'a, W: 'a + Write> {
+    config: Config,
+    /// Where encoded data is written to
+    w: &'a mut W,
+    /// Holds a partial chunk, if any, after the last `write()`, so that we may then fill the chunk
+    /// with the next `write()`, encode it, then proceed with the rest of the input normally.
+    extra: [u8; MIN_ENCODE_CHUNK_SIZE],
+    /// How much of `extra` is occupied, in `[0, MIN_ENCODE_CHUNK_SIZE]`.
+    extra_len: usize,
+    /// Buffer to encode into.
+    output: [u8; BUF_SIZE],
+    /// True iff padding / partial last chunk has been written.
+    finished: bool,
+    /// panic safety: don't write again in destructor if writer panicked while we were writing to it
+    panicked: bool
+}
+
+impl<'a, W: Write> fmt::Debug for EncoderWriter<'a, W> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "extra:{:?} extra_len:{:?} output[..5]: {:?}",
+            self.extra,
+            self.extra_len,
+            &self.output[0..5]
+        )
+    }
+}
+
+impl<'a, W: Write> EncoderWriter<'a, W> {
+    /// Create a new encoder around an existing writer.
+    pub fn new(w: &'a mut W, config: Config) -> EncoderWriter<'a, W> {
+        EncoderWriter {
+            config,
+            w,
+            extra: [0u8; MIN_ENCODE_CHUNK_SIZE],
+            extra_len: 0,
+            output: [0u8; BUF_SIZE],
+            finished: false,
+            panicked: false
+        }
+    }
+
+    /// Encode all remaining buffered data and write it, including any trailing incomplete input
+    /// triples and associated padding.
+    ///
+    /// Once this succeeds, no further writes can be performed, as that would produce invalid
+    /// base64.
+    ///
+    /// # Errors
+    ///
+    /// Assuming the wrapped writer obeys the `Write` contract, if this returns `Err`, no data was
+    /// written, and `finish()` may be retried if appropriate for the type of error, etc.
+    pub fn finish(&mut self) -> Result<()> {
+        if self.finished {
+            return Ok(());
+        };
+
+        if self.extra_len > 0 {
+            let encoded_len = encode_config_slice(
+                &self.extra[..self.extra_len],
+                self.config,
+                &mut self.output[..],
+            );
+            self.panicked = true;
+            let _ = self.w.write(&self.output[..encoded_len])?;
+            self.panicked = false;
+            // write succeeded, do not write the encoding of extra again if finish() is retried
+            self.extra_len = 0;
+        }
+
+        self.finished = true;
+        Ok(())
+    }
+}
+
+impl<'a, W: Write> Write for EncoderWriter<'a, W> {
+    fn write(&mut self, input: &[u8]) -> Result<usize> {
+        if self.finished {
+            panic!("Cannot write more after calling finish()");
+        }
+
+        if input.len() == 0 {
+            return Ok(0);
+        }
+
+        // The contract of `Write::write` places some constraints on this implementation:
+        // - a call to `write()` represents at most one call to a wrapped `Write`, so we can't
+        // iterate over the input and encode multiple chunks.
+        // - Errors mean that "no bytes were written to this writer", so we need to reset the
+        // internal state to what it was before the error occurred
+
+        // how many bytes, if any, were read into `extra` to create a triple to encode
+        let mut extra_input_read_len = 0;
+        let mut input = input;
+
+        let orig_extra_len = self.extra_len;
+
+        let mut encoded_size = 0;
+        // always a multiple of MIN_ENCODE_CHUNK_SIZE
+        let mut max_input_len = MAX_INPUT_LEN;
+
+        // process leftover stuff from last write
+        if self.extra_len > 0 {
+            debug_assert!(self.extra_len < 3);
+            if input.len() + self.extra_len >= MIN_ENCODE_CHUNK_SIZE {
+                // Fill up `extra`, encode that into `output`, and consume as much of the rest of
+                // `input` as possible.
+                // We could write just the encoding of `extra` by itself but then we'd have to
+                // return after writing only 4 bytes, which is inefficient if the underlying writer
+                // would make a syscall.
+                extra_input_read_len = MIN_ENCODE_CHUNK_SIZE - self.extra_len;
+                debug_assert!(extra_input_read_len > 0);
+                // overwrite only bytes that weren't already used. If we need to rollback extra_len
+                // (when the subsequent write errors), the old leading bytes will still be there.
+                self.extra[self.extra_len..MIN_ENCODE_CHUNK_SIZE].copy_from_slice(&input[0..extra_input_read_len]);
+
+                let len = encode_to_slice(&self.extra[0..MIN_ENCODE_CHUNK_SIZE],
+                                          &mut self.output[..],
+                                          self.config.char_set.encode_table());
+                debug_assert_eq!(4, len);
+
+                input = &input[extra_input_read_len..];
+
+                // consider extra to be used up, since we encoded it
+                self.extra_len = 0;
+                // don't clobber where we just encoded to
+                encoded_size = 4;
+                // and don't read more than can be encoded
+                max_input_len = MAX_INPUT_LEN - MIN_ENCODE_CHUNK_SIZE;
+
+                // fall through to normal encoding
+            } else {
+                // `extra` and `input` are non empty, but `|extra| + |input| < 3`, so there must be
+                // 1 byte in each.
+                debug_assert_eq!(1, input.len());
+                debug_assert_eq!(1, self.extra_len);
+
+                self.extra[self.extra_len] = input[0];
+                self.extra_len += 1;
+                return Ok(1);
+            };
+        } else if input.len() < MIN_ENCODE_CHUNK_SIZE {
+            // `extra` is empty, and `input` fits inside it
+            self.extra[0..input.len()].copy_from_slice(input);
+            self.extra_len = input.len();
+            return Ok(input.len());
+        };
+
+        // either 0 or 1 complete chunks encoded from extra
+        debug_assert!(encoded_size == 0 || encoded_size == 4);
+        debug_assert!(MAX_INPUT_LEN - max_input_len == 0
+            || MAX_INPUT_LEN - max_input_len == MIN_ENCODE_CHUNK_SIZE);
+
+        // handle complete triples
+        let input_complete_chunks_len = input.len() - (input.len() % MIN_ENCODE_CHUNK_SIZE);
+        let input_chunks_to_encode_len = cmp::min(input_complete_chunks_len, max_input_len);
+        debug_assert_eq!(0, max_input_len % MIN_ENCODE_CHUNK_SIZE);
+        debug_assert_eq!(0, input_chunks_to_encode_len % MIN_ENCODE_CHUNK_SIZE);
+
+        encoded_size += encode_to_slice(
+            &input[..(input_chunks_to_encode_len)],
+            &mut self.output[encoded_size..],
+            self.config.char_set.encode_table(),
+        );
+        self.panicked = true;
+        let r = self.w.write(&self.output[..encoded_size]);
+        self.panicked = false;
+        match r {
+            Ok(_) => return Ok(extra_input_read_len + input_chunks_to_encode_len),
+            Err(_) => {
+                // in case we filled and encoded `extra`, reset extra_len
+                self.extra_len = orig_extra_len;
+                return r;
+            }
+        }
+
+        // we could hypothetically copy a few more bytes into `extra` but the extra 1-2 bytes
+        // are not worth all the complexity (and branches)
+    }
+
+    /// Because this is usually treated as OK to call multiple times, it will *not* flush any
+    /// incomplete chunks of input or write padding.
+    fn flush(&mut self) -> Result<()> {
+        self.w.flush()
+    }
+}
+
+impl<'a, W: Write> Drop for EncoderWriter<'a, W> {
+    fn drop(&mut self) {
+        if !self.panicked {
+            // like `BufWriter`, ignore errors during drop
+            let _ = self.finish();
+        }
+    }
+}
diff --git a/rustc_deps/vendor/base64/src/write/encoder_tests.rs b/rustc_deps/vendor/base64/src/write/encoder_tests.rs
new file mode 100644
index 0000000..4fbf6e5
--- /dev/null
+++ b/rustc_deps/vendor/base64/src/write/encoder_tests.rs
@@ -0,0 +1,479 @@
+extern crate rand;
+
+use super::EncoderWriter;
+use tests::random_config;
+use {encode_config, encode_config_buf, URL_SAFE, STANDARD_NO_PAD};
+
+use std::io::{Cursor, Write};
+use std::{cmp, str, io};
+
+use self::rand::Rng;
+
+#[test]
+fn encode_three_bytes() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, URL_SAFE);
+
+        let sz = enc.write(b"abc").unwrap();
+        assert_eq!(sz, 3);
+    }
+    assert_eq!(&c.get_ref()[..], encode_config("abc", URL_SAFE).as_bytes());
+}
+
+#[test]
+fn encode_nine_bytes_two_writes() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, URL_SAFE);
+
+        let sz = enc.write(b"abcdef").unwrap();
+        assert_eq!(sz, 6);
+        let sz = enc.write(b"ghi").unwrap();
+        assert_eq!(sz, 3);
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abcdefghi", URL_SAFE).as_bytes()
+    );
+}
+
+#[test]
+fn encode_one_then_two_bytes() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, URL_SAFE);
+
+        let sz = enc.write(b"a").unwrap();
+        assert_eq!(sz, 1);
+        let sz = enc.write(b"bc").unwrap();
+        assert_eq!(sz, 2);
+    }
+    assert_eq!(&c.get_ref()[..], encode_config("abc", URL_SAFE).as_bytes());
+}
+
+#[test]
+fn encode_one_then_five_bytes() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, URL_SAFE);
+
+        let sz = enc.write(b"a").unwrap();
+        assert_eq!(sz, 1);
+        let sz = enc.write(b"bcdef").unwrap();
+        assert_eq!(sz, 5);
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abcdef", URL_SAFE).as_bytes()
+    );
+}
+
+#[test]
+fn encode_1_2_3_bytes() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, URL_SAFE);
+
+        let sz = enc.write(b"a").unwrap();
+        assert_eq!(sz, 1);
+        let sz = enc.write(b"bc").unwrap();
+        assert_eq!(sz, 2);
+        let sz = enc.write(b"def").unwrap();
+        assert_eq!(sz, 3);
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abcdef", URL_SAFE).as_bytes()
+    );
+}
+
+#[test]
+fn encode_with_padding() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, URL_SAFE);
+
+        enc.write_all(b"abcd").unwrap();
+
+        enc.flush().unwrap();
+    }
+    assert_eq!(&c.get_ref()[..], encode_config("abcd", URL_SAFE).as_bytes());
+}
+
+#[test]
+fn encode_with_padding_multiple_writes() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, URL_SAFE);
+
+        assert_eq!(1, enc.write(b"a").unwrap());
+        assert_eq!(2, enc.write(b"bc").unwrap());
+        assert_eq!(3, enc.write(b"def").unwrap());
+        assert_eq!(1, enc.write(b"g").unwrap());
+
+        enc.flush().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abcdefg", URL_SAFE).as_bytes()
+    );
+}
+
+#[test]
+fn finish_writes_extra_byte() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, URL_SAFE);
+
+        assert_eq!(6, enc.write(b"abcdef").unwrap());
+
+        // will be in extra
+        assert_eq!(1, enc.write(b"g").unwrap());
+
+        // 1 trailing byte = 2 encoded chars
+        let _ = enc.finish().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abcdefg", URL_SAFE).as_bytes()
+    );
+}
+
+#[test]
+fn write_partial_chunk_encodes_partial_chunk() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, STANDARD_NO_PAD);
+
+        // nothing encoded yet
+        assert_eq!(2, enc.write(b"ab").unwrap());
+        // encoded here
+        let _ = enc.finish().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("ab", STANDARD_NO_PAD).as_bytes()
+    );
+    assert_eq!(3, c.get_ref().len());
+}
+
+#[test]
+fn write_1_chunk_encodes_complete_chunk() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, STANDARD_NO_PAD);
+
+        assert_eq!(3, enc.write(b"abc").unwrap());
+        let _ = enc.finish().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abc", STANDARD_NO_PAD).as_bytes()
+    );
+    assert_eq!(4, c.get_ref().len());
+}
+
+#[test]
+fn write_1_chunk_and_partial_encodes_only_complete_chunk() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, STANDARD_NO_PAD);
+
+        // "d" not written
+        assert_eq!(3, enc.write(b"abcd").unwrap());
+        let _ = enc.finish().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abc", STANDARD_NO_PAD).as_bytes()
+    );
+    assert_eq!(4, c.get_ref().len());
+}
+
+#[test]
+fn write_2_partials_to_exactly_complete_chunk_encodes_complete_chunk() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, STANDARD_NO_PAD);
+
+        assert_eq!(1, enc.write(b"a").unwrap());
+        assert_eq!(2, enc.write(b"bc").unwrap());
+        let _ = enc.finish().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abc", STANDARD_NO_PAD).as_bytes()
+    );
+    assert_eq!(4, c.get_ref().len());
+}
+
+#[test]
+fn write_partial_then_enough_to_complete_chunk_but_not_complete_another_chunk_encodes_complete_chunk_without_consuming_remaining() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, STANDARD_NO_PAD);
+
+        assert_eq!(1, enc.write(b"a").unwrap());
+        // doesn't consume "d"
+        assert_eq!(2, enc.write(b"bcd").unwrap());
+        let _ = enc.finish().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abc", STANDARD_NO_PAD).as_bytes()
+    );
+    assert_eq!(4, c.get_ref().len());
+}
+
+#[test]
+fn write_partial_then_enough_to_complete_chunk_and_another_chunk_encodes_complete_chunks() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, STANDARD_NO_PAD);
+
+        assert_eq!(1, enc.write(b"a").unwrap());
+        // completes partial chunk, and another chunk
+        assert_eq!(5, enc.write(b"bcdef").unwrap());
+        let _ = enc.finish().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abcdef", STANDARD_NO_PAD).as_bytes()
+    );
+    assert_eq!(8, c.get_ref().len());
+}
+
+#[test]
+fn write_partial_then_enough_to_complete_chunk_and_another_chunk_and_another_partial_chunk_encodes_only_complete_chunks() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, STANDARD_NO_PAD);
+
+        assert_eq!(1, enc.write(b"a").unwrap());
+        // completes partial chunk, and another chunk, with one more partial chunk that's not
+        // consumed
+        assert_eq!(5, enc.write(b"bcdefe").unwrap());
+        let _ = enc.finish().unwrap();
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("abcdef", STANDARD_NO_PAD).as_bytes()
+    );
+    assert_eq!(8, c.get_ref().len());
+}
+
+#[test]
+fn drop_calls_finish_for_you() {
+    let mut c = Cursor::new(Vec::new());
+    {
+        let mut enc = EncoderWriter::new(&mut c, STANDARD_NO_PAD);
+        assert_eq!(1, enc.write(b"a").unwrap());
+    }
+    assert_eq!(
+        &c.get_ref()[..],
+        encode_config("a", STANDARD_NO_PAD).as_bytes()
+    );
+    assert_eq!(2, c.get_ref().len());
+}
+
+#[test]
+fn every_possible_split_of_input() {
+    let mut rng = rand::thread_rng();
+    let mut orig_data = Vec::<u8>::new();
+    let mut stream_encoded = Vec::<u8>::new();
+    let mut normal_encoded = String::new();
+
+    let size = 5_000;
+
+    for i in 0..size {
+        orig_data.clear();
+        stream_encoded.clear();
+        normal_encoded.clear();
+
+        for _ in 0..size {
+            orig_data.push(rng.gen());
+        }
+
+        let config = random_config(&mut rng);
+        encode_config_buf(&orig_data, config, &mut normal_encoded);
+
+        {
+            let mut stream_encoder = EncoderWriter::new(&mut stream_encoded, config);
+            // Write the first i bytes, then the rest
+            stream_encoder.write_all(&orig_data[0..i]).unwrap();
+            stream_encoder.write_all(&orig_data[i..]).unwrap();
+        }
+
+        assert_eq!(normal_encoded, str::from_utf8(&stream_encoded).unwrap());
+    }
+}
+
+#[test]
+fn encode_random_config_matches_normal_encode_reasonable_input_len() {
+    // choose up to 2 * buf size, so ~half the time it'll use a full buffer
+    do_encode_random_config_matches_normal_encode(super::encoder::BUF_SIZE * 2)
+}
+
+#[test]
+fn encode_random_config_matches_normal_encode_tiny_input_len() {
+    do_encode_random_config_matches_normal_encode(10)
+}
+
+#[test]
+fn retrying_writes_that_error_with_interrupted_works() {
+    let mut rng = rand::thread_rng();
+    let mut orig_data = Vec::<u8>::new();
+    let mut stream_encoded = Vec::<u8>::new();
+    let mut normal_encoded = String::new();
+
+    for _ in 0..1_000 {
+        orig_data.clear();
+        stream_encoded.clear();
+        normal_encoded.clear();
+
+        let orig_len: usize = rng.gen_range(100, 20_000);
+        for _ in 0..orig_len {
+            orig_data.push(rng.gen());
+        }
+
+        // encode the normal way
+        let config = random_config(&mut rng);
+        encode_config_buf(&orig_data, config, &mut normal_encoded);
+
+        // encode via the stream encoder
+        {
+            let mut interrupt_rng = rand::thread_rng();
+            let mut interrupting_writer = InterruptingWriter {
+                w: &mut stream_encoded,
+                rng: &mut interrupt_rng,
+                fraction: 0.8,
+            };
+
+            let mut stream_encoder = EncoderWriter::new(&mut interrupting_writer, config);
+            let mut bytes_consumed = 0;
+            while bytes_consumed < orig_len {
+                // use short inputs since we want to use `extra` a lot as that's what needs rollback
+                // when errors occur
+                let input_len: usize = cmp::min(rng.gen_range(0, 10),
+                                                orig_len - bytes_consumed);
+
+                // write a little bit of the data
+                retry_interrupted_write_all(&mut stream_encoder,
+                                            &orig_data[bytes_consumed..bytes_consumed + input_len])
+                    .unwrap();
+
+                bytes_consumed += input_len;
+            }
+
+            loop {
+                let res = stream_encoder.finish();
+                match res {
+                    Ok(_) => break,
+                    Err(e) => match e.kind() {
+                        io::ErrorKind::Interrupted => continue,
+                        _ => Err(e).unwrap() // bail
+                    }
+                }
+            }
+
+            assert_eq!(orig_len, bytes_consumed);
+        }
+
+        assert_eq!(normal_encoded, str::from_utf8(&stream_encoded).unwrap());
+    }
+}
+
+/// Retry writes until all the data is written or an error that isn't Interrupted is returned.
+fn retry_interrupted_write_all<W: Write>(w: &mut W, buf: &[u8]) -> io::Result<()> {
+    let mut written = 0;
+
+    while written < buf.len() {
+        let res = w.write(&buf[written..]);
+
+        match res {
+            Ok(len) => written += len,
+            Err(e) => match e.kind() {
+                io::ErrorKind::Interrupted => continue,
+                _ => {
+                    println!("got kind: {:?}", e.kind());
+                    return Err(e);
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn do_encode_random_config_matches_normal_encode(max_input_len: usize) {
+    let mut rng = rand::thread_rng();
+    let mut orig_data = Vec::<u8>::new();
+    let mut stream_encoded = Vec::<u8>::new();
+    let mut normal_encoded = String::new();
+
+    for _ in 0..1_000 {
+        orig_data.clear();
+        stream_encoded.clear();
+        normal_encoded.clear();
+
+        let orig_len: usize = rng.gen_range(100, 20_000);
+        for _ in 0..orig_len {
+            orig_data.push(rng.gen());
+        }
+
+        // encode the normal way
+        let config = random_config(&mut rng);
+        encode_config_buf(&orig_data, config, &mut normal_encoded);
+
+        // encode via the stream encoder
+        {
+            let mut stream_encoder = EncoderWriter::new(&mut stream_encoded, config);
+            let mut bytes_consumed = 0;
+            while bytes_consumed < orig_len {
+                let input_len: usize = cmp::min(rng.gen_range(0, max_input_len),
+                                                orig_len - bytes_consumed);
+
+                // write a little bit of the data
+                stream_encoder
+                    .write_all(&orig_data[bytes_consumed..bytes_consumed + input_len])
+                    .unwrap();
+
+                bytes_consumed += input_len;
+            }
+
+            stream_encoder.finish().unwrap();
+
+            assert_eq!(orig_len, bytes_consumed);
+        }
+
+        assert_eq!(normal_encoded, str::from_utf8(&stream_encoded).unwrap());
+    }
+}
+
+/// A `Write` implementation that returns Interrupted some fraction of the time, randomly.
+struct InterruptingWriter<'a, W: 'a + Write, R: 'a + Rng> {
+    w: &'a mut W,
+    rng: &'a mut R,
+    /// In [0, 1]. If a random number in [0, 1] is  `<= threshold`, `Write` methods will return
+    /// an `Interrupted` error
+    fraction: f64,
+}
+
+impl<'a, W: Write, R: Rng> Write for InterruptingWriter<'a, W, R> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if self.rng.gen_range(0.0, 1.0) <= self.fraction {
+            return Err(io::Error::new(io::ErrorKind::Interrupted, "interrupted"));
+        }
+
+        self.w.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        if self.rng.gen_range(0.0, 1.0) <= self.fraction {
+            return Err(io::Error::new(io::ErrorKind::Interrupted, "interrupted"));
+        }
+
+        self.w.flush()
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/base64/src/write/mod.rs b/rustc_deps/vendor/base64/src/write/mod.rs
new file mode 100644
index 0000000..f8ed707
--- /dev/null
+++ b/rustc_deps/vendor/base64/src/write/mod.rs
@@ -0,0 +1,6 @@
+//! Implementations of `io::Write` to transparently handle base64.
+mod encoder;
+pub use self::encoder::EncoderWriter;
+
+#[cfg(test)]
+mod encoder_tests;
diff --git a/rustc_deps/vendor/base64/tests/decode.rs b/rustc_deps/vendor/base64/tests/decode.rs
index 1f68a8c..2b9aa60 100644
--- a/rustc_deps/vendor/base64/tests/decode.rs
+++ b/rustc_deps/vendor/base64/tests/decode.rs
@@ -6,13 +6,6 @@
 
 use helpers::*;
 
-fn compare_decode_mime(expected: &str, target: &str) {
-    assert_eq!(
-        expected,
-        String::from_utf8(decode_config(target, MIME).unwrap()).unwrap()
-    );
-}
-
 #[test]
 fn decode_rfc4648_0() {
     compare_decode("", "");
@@ -75,48 +68,10 @@
 }
 
 #[test]
-fn decode_mime_allow_space() {
-    assert!(decode_config("YWx pY2U=", MIME).is_ok());
-}
-
-#[test]
-fn decode_mime_allow_tab() {
-    assert!(decode_config("YWx\tpY2U=", MIME).is_ok());
-}
-
-#[test]
-fn decode_mime_allow_ff() {
-    assert!(decode_config("YWx\x0cpY2U=", MIME).is_ok());
-}
-
-#[test]
-fn decode_mime_allow_vtab() {
-    assert!(decode_config("YWx\x0bpY2U=", MIME).is_ok());
-}
-
-#[test]
-fn decode_mime_allow_nl() {
-    assert!(decode_config("YWx\npY2U=", MIME).is_ok());
-}
-
-#[test]
-fn decode_mime_allow_crnl() {
-    assert!(decode_config("YWx\r\npY2U=", MIME).is_ok());
-}
-
-#[test]
-fn decode_mime_reject_null() {
+fn decode_reject_null() {
     assert_eq!(
         DecodeError::InvalidByte(3, 0x0),
-        decode_config("YWx\0pY2U==", MIME).unwrap_err()
-    );
-}
-
-#[test]
-fn decode_mime_absurd_whitespace() {
-    compare_decode_mime(
-        "how could you let this happen",
-        "\n aG93I\n\nG\x0bNvd\r\nWxkI HlvdSB \tsZXQgdGh\rpcyBo\x0cYXBwZW4 =   ",
+        decode_config("YWx\0pY2U==", config_std_pad()).unwrap_err()
     );
 }
 
@@ -349,3 +304,7 @@
         }
     }
 }
+
+fn config_std_pad() -> Config {
+    Config::new(CharacterSet::Standard, true)
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/base64/tests/encode.rs b/rustc_deps/vendor/base64/tests/encode.rs
index e23f015..0004be0 100644
--- a/rustc_deps/vendor/base64/tests/encode.rs
+++ b/rustc_deps/vendor/base64/tests/encode.rs
@@ -95,50 +95,6 @@
 }
 
 #[test]
-fn encode_line_ending_lf_partial_last_line() {
-    let config = Config::new(
-        CharacterSet::Standard,
-        true,
-        false,
-        LineWrap::Wrap(3, LineEnding::LF),
-    );
-    assert_eq!("Zm9\nvYm\nFy", encode_config(b"foobar", config));
-}
-
-#[test]
-fn encode_line_ending_crlf_partial_last_line() {
-    let config = Config::new(
-        CharacterSet::Standard,
-        true,
-        false,
-        LineWrap::Wrap(3, LineEnding::CRLF),
-    );
-    assert_eq!("Zm9\r\nvYm\r\nFy", encode_config(b"foobar", config));
-}
-
-#[test]
-fn encode_line_ending_lf_full_last_line() {
-    let config = Config::new(
-        CharacterSet::Standard,
-        true,
-        false,
-        LineWrap::Wrap(4, LineEnding::LF),
-    );
-    assert_eq!("Zm9v\nYmFy", encode_config(b"foobar", config));
-}
-
-#[test]
-fn encode_line_ending_crlf_full_last_line() {
-    let config = Config::new(
-        CharacterSet::Standard,
-        true,
-        false,
-        LineWrap::Wrap(4, LineEnding::CRLF),
-    );
-    assert_eq!("Zm9v\r\nYmFy", encode_config(b"foobar", config));
-}
-
-#[test]
 fn encode_url_safe_without_padding() {
     let encoded = encode_config(b"alice", URL_SAFE_NO_PAD);
     assert_eq!(&encoded, "YWxpY2U");
diff --git a/rustc_deps/vendor/base64/tests/tests.rs b/rustc_deps/vendor/base64/tests/tests.rs
index 5ad3ec7..2d3f3ab 100644
--- a/rustc_deps/vendor/base64/tests/tests.rs
+++ b/rustc_deps/vendor/base64/tests/tests.rs
@@ -1,7 +1,7 @@
 extern crate base64;
 extern crate rand;
 
-use rand::Rng;
+use rand::{Rng, FromEntropy};
 
 use base64::*;
 
@@ -19,7 +19,7 @@
 ) {
     // let the short ones be short but don't let it get too crazy large
     let num_rounds = calculate_number_of_rounds(byte_len, approx_values_per_byte, max_rounds);
-    let mut r = rand::weak_rng();
+    let mut r = rand::rngs::SmallRng::from_entropy();
     let mut decode_buf = Vec::new();
 
     for _ in 0..num_rounds {
@@ -53,7 +53,7 @@
 }
 
 fn no_pad_config() -> Config {
-    Config::new(CharacterSet::Standard, false, false, LineWrap::NoWrap)
+    Config::new(CharacterSet::Standard, false)
 }
 
 #[test]
@@ -141,7 +141,7 @@
 
     assert_eq!(
         encode(&bytes),
-        format!("{}", base64::display::Base64Display::standard(&bytes))
+        format!("{}", base64::display::Base64Display::with_config(&bytes, STANDARD))
     );
 }
 
@@ -158,7 +158,7 @@
     let mut larger_buf: [u8; 24] = [0; 24];
     let mut input: [u8; 16] = [0; 16];
 
-    let mut rng = rand::weak_rng();
+    let mut rng = rand::rngs::SmallRng::from_entropy();
     for elt in &mut input {
         *elt = rng.gen();
     }
@@ -182,7 +182,7 @@
     let mut buf: [u8; 22] = [0; 22];
     let mut input: [u8; 16] = [0; 16];
 
-    let mut rng = rand::weak_rng();
+    let mut rng = rand::rngs::SmallRng::from_entropy();
     for elt in &mut input {
         *elt = rng.gen();
     }
diff --git a/rustc_deps/vendor/ring/.cargo-checksum.json b/rustc_deps/vendor/ring/.cargo-checksum.json
index 80e89fc..c844a51 100644
--- a/rustc_deps/vendor/ring/.cargo-checksum.json
+++ b/rustc_deps/vendor/ring/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"fd9b24803d45fe5855ac134e760b868f48ca21564ea86a29e90d2906009efaa1","LICENSE":"76b39f9b371688eac9d8323f96ee80b3aef5ecbc2217f25377bd4e4a615296a9","build.rs":"302d913c2fb91aa000d4ef903273caaed192a74eba277d797c2988397999053b","crypto/chacha/asm/chacha-armv4.pl":"4dabdd766dd25711ee6276f7415c3fd654635687aa536617eceb75a8a3ad1189","crypto/chacha/asm/chacha-armv8.pl":"7ca420290e179dc4b348d5a3bfcf78d27e374fa10c16b2533dd5339245690305","crypto/chacha/asm/chacha-x86.pl":"abbcf8181bd629d8003322dbf2592bf4631abb7895861d7021c451043e39be34","crypto/chacha/asm/chacha-x86_64.pl":"7f38c54bae872a6f6cde85cd13bf061ebcd9372a4d126f66bbe018fb7231d6a4","crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl":"c0ae9169db7e1bd9244074e9d221aea3ef56930b54925a369b66c8782e602e64","crypto/cipher_extra/test/aes_128_gcm_siv_tests.txt":"1a0b201dd8f4aa2106db0de3c26eb0d9623394ec80247867371c20103718b1c0","crypto/cipher_extra/test/aes_256_gcm_siv_tests.txt":"514a978594261e0520b30aac455c8a29c3280cc15701a928a0e8ad7bacfc2c79","crypto/constant_time_test.c":"a9e6346e829c35310fcbf8da8d820da1d66a2d7957704f7c020cd29898079191","crypto/cpu-aarch64-linux.c":"61cb9b03431d543488ca045b9f70d04b6a1d1fc876ab7e3613ec9b3b237baa0b","crypto/cpu-arm-linux.c":"c60eb2cf858814842624cfe7adf9f080cae99dba9decb25e35b91affbfbbe7f3","crypto/cpu-arm.c":"e7b6be5862e1f7f83568991ef2c46f05df9d6517f8ad5ce0a12fe8c8bab788c7","crypto/cpu-intel.c":"bfe154d6fe0670181634d58df0a9810e2482677e795b8780390c341d17b2bd2d","crypto/crypto.c":"bc59868b8d99ab744dda129f2d01c5150e9f0872c6d6f9b992f4a6b6b19f986a","crypto/curve25519/asm/x25519-asm-arm.S":"a6784f13e24bc8db7b3f2088722b04fd6a3382c02eaaa0d652a3ae931a465be9","crypto/fipsmodule/aes/aes.c":"a83349c801cd7145b110fa4ae52db2f3cf8f009f6124a3968c721e7b7bed97a4","crypto/fipsmodule/aes/asm/aes-586.pl":"49ad826191e7f1bda45bbaac10027343cabf56443c5e3bec869c6e1c37e105fa","crypto/fipsmodule/aes/asm/aes-armv4.pl":"4e845e40ef5e1cf7153c9b1d0a6e75b192f9255ddfa53f4aadee3362700d954b","crypto/fipsmodule/aes/asm/aes-x86_64.pl":"52e0ce0725f41ddf9ba4220d5ef3f4c5ef9c835c90d9e998bd5f7e957d7f025b","crypto/fipsmodule/aes/asm/aesni-x86.pl":"5c1ae42c253f05b8d76af696ecced2a6bce6750e66bdd0e4cfa3cc1102dd5c25","crypto/fipsmodule/aes/asm/aesni-x86_64.pl":"97b0a0d9ddac8b972b5fb98e0fd564eb68b3b50dc31180d1af1d6599685d004c","crypto/fipsmodule/aes/asm/aesv8-armx.pl":"6794d9fb90b3fe183e457a425596d7e57600f937d7435d5075894cfb7fc3bd77","crypto/fipsmodule/aes/asm/bsaes-armv7.pl":"8a569dfcc42bc4dd2252de088793a3b55c020d5166459df8f4eb779f1e414db7","crypto/fipsmodule/aes/asm/vpaes-x86.pl":"7672ae209b0eb33d0d6856f46c46066a07db4c6534cb678cc2bf329b040575b9","crypto/fipsmodule/aes/asm/vpaes-x86_64.pl":"383e964a9188bfbbdb5f0b53d74c5493ef234194c1eb1b7e2f63504bb3974c9e","crypto/fipsmodule/aes/internal.h":"5091399344bf1fa3ef1f5c94aa8629e04820070b4fd1713ecfcdc4db63f62a52","crypto/fipsmodule/bn/asm/armv4-mont.pl":"0e6b793c5628ff2d1172969a56a508735150409e4a520bdc7226a0dd1f104240","crypto/fipsmodule/bn/asm/armv8-mont.pl":"a0f9368bcce4d56ec72ebf04a0664c8514a0fa9299aa2d27eec07fc63dcf4d0a","crypto/fipsmodule/bn/asm/x86-mont.pl":"eff867e854ba35bdbe2f884b35e1c6cabb7f4e6b5ffc62d13e3d795285479138","crypto/fipsmodule/bn/asm/x86_64-mont.pl":"240d70d03b632727c71afe0de20478104768290dfbd15023cda2d440de99e3df","crypto/fipsmodule/bn/asm/x86_64-mont5.pl":"acad1c261477c1e028d3d429be6f5c709aac95e8e87eefd6b1ce1057e5e316fe","crypto/fipsmodule/bn/exponentiation.c":"a4db6ae8f9756204656db37ba4d0cd1eb21ec13d27c189eb7808d5c809ae582d","crypto/fipsmodule/bn/generic.c":"3c910c750af5e39fa5fdbe02266a192a8a4a5c6f2058a6da4911dd39a561eb90","crypto/fipsmodule/bn/internal.h":"f71a90792d124fa35531cfd17aa9085c6f7ba60e6dc1361bc151cd4553f61bf2","crypto/fipsmodule/bn/montgomery.c":"c1518fac73f378cd7514cf5a5ab2c3c29d95ef44817141e06cff45a3c9bf9a3b","crypto/fipsmodule/bn/montgomery_inv.c":"189e42169abb7aa166dcd67084e82169c5eb2a9edd22099147c1859f687198d4","crypto/fipsmodule/bn/shift.c":"c440ff1d7164ed3f6acfe169ac4735df5df8a73ea38c9b872ce15471e9b9b2f9","crypto/fipsmodule/cipher/e_aes.c":"380e23cd4673e247811076b21b17bc79a714e05ab8a5c19239d87100244421d5","crypto/fipsmodule/cipher/internal.h":"ddb38c0d1315d6d68a7c8a6d771aab2b8414c514575478ee5315a6a3fd287445","crypto/fipsmodule/ec/asm/ecp_nistz256-armv4.pl":"f92e6f293af43e439cf41f603ca1c016227912e3ea16d221edc56a467c5ab1e5","crypto/fipsmodule/ec/asm/ecp_nistz256-armv8.pl":"2338e60bd7a868850ec681fc66e313c92c90727de8f723e83ad72a0d7c553c3f","crypto/fipsmodule/ec/asm/ecp_nistz256-x86.pl":"51be61331792fc0c971eed9d70f15b89a79a0bcc3211f65401d343f5bf794091","crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl":"ee22f9cc1f108be12dc71d9751330cd8289cf67645a3ab9eb71a217427f4a5d9","crypto/fipsmodule/ec/ecp_nistz.c":"0aa030bae6375beda98471759d367fd43df7a2d8ef7a0bb917a4638cf6f07429","crypto/fipsmodule/ec/ecp_nistz.h":"47640aa28ddde8bcc6ef015cb9f77cfef6b0d9849a106bd1307158b7d7f0773a","crypto/fipsmodule/ec/ecp_nistz256.c":"db52545e6614512de7bb2ce72d4c616526113baf6f093f4f2361164fb7219cde","crypto/fipsmodule/ec/ecp_nistz256.h":"0032b44c8a61c6478f8c2c36c1dbbf9789418f509f428419c7a7f6d148674872","crypto/fipsmodule/ec/ecp_nistz256_table.inl":"ccc4126030480c8898832cc7f0ae6c62bf5e16de51a32d16f667fae016699579","crypto/fipsmodule/ec/ecp_nistz384.h":"9fbd1b8a9fdb0514110b441f47618ee781d531e67fc54c38a89671a5160a44b1","crypto/fipsmodule/ec/ecp_nistz384.inl":"db02c8713824572c6b3b75c8c43b59f8aaa0e91ebc757b183598984b1b3c584f","crypto/fipsmodule/ec/gfp_p256.c":"b2d9d6523d02d0adb2ae8230e70a7618e100e6026a82b1dceebda955d4922d0e","crypto/fipsmodule/ec/gfp_p384.c":"ae7c91d6dfc69dd7c47c80169450abce2c5452b6273fea10864c938bd1bad47e","crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl":"5b0a694058161ef6536d798acfc2bf268a5a9cb0615fa16bdac04e2873f44639","crypto/fipsmodule/modes/asm/ghash-armv4.pl":"77408b681c42324691044d98d4ff7f8160a4193cb286ade366279ebf3c581ac2","crypto/fipsmodule/modes/asm/ghash-x86.pl":"16c8c02399a7513430b8d88fe10a94e19a016acd72801bffd29c1c14705bd367","crypto/fipsmodule/modes/asm/ghash-x86_64.pl":"2ad656e0b03246db0f30b2a8ad5a76d20528a643d36802a633fe8ad87dcf697a","crypto/fipsmodule/modes/asm/ghashv8-armx.pl":"e210dcf14cad06e593481e30db0f06355582f53bb2419eeb78c7bb3bbb393091","crypto/fipsmodule/modes/gcm.c":"8db9fb57ba6a0d83b13b10243051fd05e3b1152bd3190d4a5f83aa97e9d61018","crypto/fipsmodule/modes/internal.h":"799277554a552f83e5cb9f69ed1ac89414b1364c99280b1d7d15e93a2879f36c","crypto/fipsmodule/sha/asm/sha256-586.pl":"7d28f78ef27b17a7ac6a62337ae5a75d2ef1c2bf08c8154189652e4d93e9ab65","crypto/fipsmodule/sha/asm/sha256-armv4.pl":"673523183c7ac34ade7becc78f077e6bbda6a2d1f6d33644207c725be2dc16c8","crypto/fipsmodule/sha/asm/sha512-586.pl":"b536e80fcc7cf77e5945fa7af1c43b18d2e1df438e601262429065b0b622682b","crypto/fipsmodule/sha/asm/sha512-armv4.pl":"7352a2ced5b722e37023e27afdfdcd5eddebbe067ba8f5da4c421a8709ee8955","crypto/fipsmodule/sha/asm/sha512-armv8.pl":"a2dfbb71da796eb45d75776ef65192bfedd70b1a106d2e067c4be9c7af79c761","crypto/fipsmodule/sha/asm/sha512-x86_64.pl":"50393117d19a47dc99387fb0a353cd29cbc3276a339e138d1d7edc4ba273a386","crypto/internal.h":"15db12031a8df201e12bb8dc411268d6cd2fe18188336856bafbbb9fbe46468e","crypto/limbs/limbs.c":"c9a13bbdae2a11a5d3b06b0a37095fb7030ae4104ae2f675dc6f4e30a176f03a","crypto/limbs/limbs.h":"25b3b6a396642ee69e5056c3ce2a4bdc5c83cfa963af7db5924c257081196ca3","crypto/limbs/limbs.inl":"82511bcb44106f579e023adb67c7ae07093c0f36078a2c4bc6ca107773ce5eed","crypto/mem.c":"18e2844c6205fab613031e671dac3b65ceeb18bb5125f2a11e4df7ec0c09ec0f","crypto/perlasm/arm-xlate.pl":"3089f10d2d1dd355b4ccbd4dc39d807c0623ba47f68b0cb4ef7bfdd269194c62","crypto/perlasm/x86_64-xlate.pl":"67d5a38865d5a5b9e00926d867454553afc5c4cf2e4fd5ebe122162996e66bc1","crypto/perlasm/x86asm.pl":"8a25f4ecff890d0f6f9d6f66481f080b7cf80ce722d916351cb0ef19782fbe70","crypto/perlasm/x86gas.pl":"183d2642ab2e4c76b46bcb97a92fd16c539d9c07331c7204b0564d78c9413817","crypto/perlasm/x86nasm.pl":"7d3b50f58cfd1da94a10f17e1129770d744edf03d4029417ea53bf8771a99b97","crypto/poly1305/asm/poly1305-armv4.pl":"2092a6f1b330972fb050da99b7a63d3c70dfd5f99db98ed1f679018d89e839c2","crypto/poly1305/asm/poly1305-armv8.pl":"c717d87739909c95e0dd1e2d95e6a5d9f693677e68ca1bcf2dc619c93c777185","crypto/poly1305/asm/poly1305-x86.pl":"060b3689cac73fb7a32e16daa799573e6c52dda47fa3ddba9cc235763d6834fc","crypto/poly1305/asm/poly1305-x86_64.pl":"ee69a0717f931d7c336898cce017946a56196a90d6fb44a02989b855ce136bf7","include/GFp/aes.h":"e48438db50d49f708d56b55db0f8a783bca20f237c79c7aff7336e08b6c78883","include/GFp/arm_arch.h":"7b2d7945fc47ba8d8534ffb03a62d9b891e727d3a14fe32f1608f07dd0021f5d","include/GFp/base.h":"d35bf7b59e1b3e98e7b9bd5c5a6fc226c63fd95bedf80c5337daf2f89d090640","include/GFp/cpu.h":"fd8bb798fb6ea1b1afa4cd11717c970d7591ad8ef207be5188a552798bf7615f","include/GFp/mem.h":"8cdf71bb6bd7ba1d1625a88c055a57f4e1529884b93498b495efd62cb582d0c7","include/GFp/type_check.h":"0071b1f6a42e5f0185561443600800a02dae4f355db6895b6c3df63aa40a5bc8","pregenerated/aes-586-elf.S":"bace0bf299d6830f564ff1f6b71dfeb08a97142f924ca77b722f66dc74520067","pregenerated/aes-586-macosx.S":"ed1529ea2b001e54e12cfd247b72bd1f68c7c915b8d5bf0846e00e2b24239043","pregenerated/aes-586-win32n.obj":"08ee97af66fdca8902776e3b8c9acf3c6d2a3ddfd79da9942f2b6b5dd2954162","pregenerated/aes-armv4-ios32.S":"bd592c0302d9ac88f96af8c29fa9c28d76470c19d25b52f1dfc4ed8a9278ddb4","pregenerated/aes-armv4-linux32.S":"7434ac4faf6e4c6fb166aa1393d20fc5b5814f18a44180d7a5a5bf159810f747","pregenerated/aes-x86_64-elf.S":"4670fa16e3ebbec6332e6f906a1aba2bd60cb07c6d7775c4a802bf37e127bf52","pregenerated/aes-x86_64-macosx.S":"fc8d58ed35da1be37294c895979bfacf697e518cfc2d2d6cb983d89780bcccdf","pregenerated/aes-x86_64-nasm.obj":"4e4945c594e09f3264921a163a1d16b5c800b508687e1a995db37f7a31cfd25a","pregenerated/aesni-gcm-x86_64-elf.S":"53dfea5b51c8236904fcab378ecf198b852056ff6a3b98716c75acc5af32d1db","pregenerated/aesni-gcm-x86_64-macosx.S":"29c5de7f4f0682036331551206d32df8f1df0f872dae2c341bf883f526931e00","pregenerated/aesni-gcm-x86_64-nasm.obj":"61f5ddb2f07bea9b1655a1d1d450361a7c4006ab2efa80f8ebbe95976d22e1a0","pregenerated/aesni-x86-elf.S":"3e17c6dea1430e75740e885731d422f70cba21f3699cb753ac7aa157224da886","pregenerated/aesni-x86-macosx.S":"36633ebff6c930b5d827073257e0c9fad745356ac3aeb607d516946e12466b75","pregenerated/aesni-x86-win32n.obj":"873a3c82e91b3e327487da22d451e18509932bfae82064eb258ae1509200349a","pregenerated/aesni-x86_64-elf.S":"3094c086f75504128e8fd130c8ab70666329f422107e209564b4ceab3724143a","pregenerated/aesni-x86_64-macosx.S":"5c00ba24973a34cd6b2155882b3ca987d66d81a1c9a70cb64e48dc18cdd6c96e","pregenerated/aesni-x86_64-nasm.obj":"e44ce85e7955f9dc17ea6ba9ca847138c6382d9df77d17a452b035bad9f65cb5","pregenerated/aesv8-armx-ios32.S":"e211ab361d174af69fac02d0fb8d5985ba642ddae45d0eafb74dee7a5aafaeb1","pregenerated/aesv8-armx-ios64.S":"b6f27a22653e31497788de7c4c936dde0c727280dba39064144a6f1a7ae84539","pregenerated/aesv8-armx-linux32.S":"5e9c84abdedd92d8977414b537f3939ae1dc9e9506900bac169be35fbe7708f7","pregenerated/aesv8-armx-linux64.S":"e70652666e535c57ff5871ea84b1acef339cbf9b1231e87c28ba7d2834e7b1a0","pregenerated/armv4-mont-ios32.S":"2f9926339db35652ce582d131bcb2de6981cd23fed979f0b35252bab03fb38bc","pregenerated/armv4-mont-linux32.S":"93bf9b6db03f63f1c3e013d9590ac7b7f6bad34188584f15d800b0e28e8c3f51","pregenerated/armv8-mont-ios64.S":"10a193c3eb405f93fa3d714a9c31b835f2c156625a2ab8ac22b6fc45b9724e80","pregenerated/armv8-mont-linux64.S":"a4f643237edd317afd3c70cf2c0e5b8c9c3fc55f5c16ba6175d66991ca81bf77","pregenerated/bsaes-armv7-ios32.S":"5d79110f25c887c61c973489c28cb539414b884ed3f5ab75f80ef9c56ccc49c3","pregenerated/bsaes-armv7-linux32.S":"965c4c95239527b33c4c53a7135b39471548e30c42fc469a2e0cac918edcbd27","pregenerated/chacha-armv4-ios32.S":"d5097696c4e08359a4c707c1a219adc359f03754ea2427de02abf892165336dc","pregenerated/chacha-armv4-linux32.S":"1b1afa5bbd819683bd96ed60b6d329a1dbe79aaa90ecd5ea83e52fd2934b957c","pregenerated/chacha-armv8-ios64.S":"209e0b2874a69bedf6aa92c8793eba323b0b44894804f916f7050c67b6f0540f","pregenerated/chacha-armv8-linux64.S":"b6c8b24c11fba499cfd4905e33526e19592240a1e35bb673d568ff9b55067156","pregenerated/chacha-x86-elf.S":"4c2add447dadec5c1531fa77e63de71f5c07bd11db0eb36adfcfa26664f2813d","pregenerated/chacha-x86-macosx.S":"5f75f029943ce4752307c3fcd8fd3f409d0d2bfc8e6e182dc6855d1fc4ff28f9","pregenerated/chacha-x86-win32n.obj":"567f434cf1dd6713340f7cc04fa214db7cb8f78e94c7271ca2374bfa8edd516b","pregenerated/chacha-x86_64-elf.S":"ef6b6948c031e112678758670f51eb5a077fcfcd3d1ca5229a1cfd62749892eb","pregenerated/chacha-x86_64-macosx.S":"4ec99e102952ea66a3f6bb3ff4fea2302df01c2b13fd87b2a0916ff9c698d062","pregenerated/chacha-x86_64-nasm.obj":"cd5eaf1ca437fc8ae049479632ab384a9ce178d312fac45f01440215d7e9ae33","pregenerated/ecp_nistz256-armv4-ios32.S":"094232c4428647397123c507662cf2610b42e5e368ac845fe62fdccfd8a54e62","pregenerated/ecp_nistz256-armv4-linux32.S":"24f74c3114acc6a40172fae0ac3143dd81cd150680cdf0add76203ed19a3d0f8","pregenerated/ecp_nistz256-armv8-ios64.S":"16409f691fe1adfd30d0bc11d4918e336f77e86618be2489f64a3b14f7cfa9d4","pregenerated/ecp_nistz256-armv8-linux64.S":"9d14df832a8c41b0569fc1374b944b72076f031d14f937eb976474ce97203b49","pregenerated/ecp_nistz256-x86-elf.S":"ae3770aee96b96226c96b07a9ff9bcdf5b411dff83adef5a970952c3d8bb7ad5","pregenerated/ecp_nistz256-x86-macosx.S":"0ac9c2c1ac8e0ce2d44559b18c215cee8ce308d1570636f19aa980afb94cdfdd","pregenerated/ecp_nistz256-x86-win32n.obj":"d6a6693840a6c7478775e2ca67c513653856503b42dc1cdf7921773296753988","pregenerated/ghash-armv4-ios32.S":"2aa696368c007d065a227d46f2c760d26141dc326543d6fd92d084eeed63ff18","pregenerated/ghash-armv4-linux32.S":"6679d36bd2a8c482085f33abed0b5ff77157a011d054932b53d3a0938ea6d686","pregenerated/ghash-x86-elf.S":"22ea8f199210f5dea6afee4a58f6a04fbb977a1cbd5a7819e2421833cd5182d5","pregenerated/ghash-x86-macosx.S":"a484fe8deafd7e216a3c7924209882f2c67fa7e56ae8843c094acad9868ccc88","pregenerated/ghash-x86-win32n.obj":"3e4474492360d7d4970ab92cce237cba95ef3af251e1359c0ddc635f3982563b","pregenerated/ghash-x86_64-elf.S":"127e5996c745d8f221a58f5da1af94347ff97ca578640c07e9ee4dcb538e8d29","pregenerated/ghash-x86_64-macosx.S":"1183022494af6d13fa77fa30752977f19152f4aa28931ca3c0951f8503eea000","pregenerated/ghash-x86_64-nasm.obj":"4fde8c6b1c3274df3543f08aa032defb7cb06722f325b5740a37f1ff7b5d9876","pregenerated/ghashv8-armx-ios32.S":"72cb523ff6176952ebcfac359a47f037405ed3911169c48ef0176ab2917a1088","pregenerated/ghashv8-armx-ios64.S":"f3f66f47d0daa285098c1485991c8599416904b7107fe68e5c6b1ff1dcd76a96","pregenerated/ghashv8-armx-linux32.S":"26e10ec3e2480bb4266cca7008de4bbc1b434250b45224cc2d6807daa9bd54ea","pregenerated/ghashv8-armx-linux64.S":"6c82cec3c0d2147a0b9a251e1c870caa311158171acfd21dd5b428fd9a28e37b","pregenerated/p256-x86_64-asm-elf.S":"d65eb4365b9470247d3d7e48b2b71e814dfc2ca9c29b2319df013b5723585007","pregenerated/p256-x86_64-asm-macosx.S":"251984dfb1620b19fb470f9cf6dc30c681f12ef8aafb34d1db50f10d1d103c6f","pregenerated/p256-x86_64-asm-nasm.obj":"67bcc411568b43b73399b02b7610645575633d81e5a24a4900fda4eb4c9296e0","pregenerated/poly1305-armv4-ios32.S":"05e1002ce1eafba66534856b2d0904294a04197185ad26c4002c0ae336f6d321","pregenerated/poly1305-armv4-linux32.S":"e750ff85fddee95ac48289c47158cb9019912bf2d93710f541b3be4e6bcbc6e1","pregenerated/poly1305-armv8-ios64.S":"0a260a41312bba9a823ec0f6036c01713fd04f7cdf91970c979862fc5b16aa75","pregenerated/poly1305-armv8-linux64.S":"7033faf43fe02ee9bb37f58c87c74852ddefe296d5b5d3d26589a3acd628e371","pregenerated/poly1305-x86-elf.S":"77e2b31e6dce365adebbdc4e9efd1e74381d24c1bf17c8edacd64a842dc0895d","pregenerated/poly1305-x86-macosx.S":"c8db55e562fb5b067d130badacd90b4e2b47522a03851e7cc59c2c5b281a22be","pregenerated/poly1305-x86-win32n.obj":"3eb2b419b3ddc0408ad98143855aa21b30e33b9350bb971aa62bbd2027c8779b","pregenerated/poly1305-x86_64-elf.S":"950d09f0dc5c333c2efd72f252eccbc5f3f392bff503ef11c0c32560ac565d02","pregenerated/poly1305-x86_64-macosx.S":"89cc9c0ad2e6421cd89fb341cfc1422d842ac7a3d0555218fb549dfad14dddd1","pregenerated/poly1305-x86_64-nasm.obj":"a4f72316097966f37409e60f3d1ec1a62a11913ad4d0c1515b9bf63248549849","pregenerated/sha256-586-elf.S":"c2666a6fe1ebcaf8e906b16fbcbda35941df5cfb28c9d5afbba2b31d32120e33","pregenerated/sha256-586-macosx.S":"0cd5007b8ad2fdd07f2f97c857ddd8bd066098aed3ac7060cc3b6e0db2b3cb43","pregenerated/sha256-586-win32n.obj":"42e65c791d92225e54de4d5acdf5d9c91a64f8b1fd4eb90e8f7bb486935e4aae","pregenerated/sha256-armv4-ios32.S":"8c8b07fe80ea742de1b113c8fe820293a8e584c935bb17efbce74221fb6865a4","pregenerated/sha256-armv4-linux32.S":"512f3fcc9bab4988e3f36f8bde6018c957f15e526d26b63770fb00533560f7d7","pregenerated/sha256-armv8-ios64.S":"df7f441e8687e5f2e05b27327c19f1d76e2f67817886d464d729c976572dd80f","pregenerated/sha256-armv8-linux64.S":"2d9fb077b296ee97c5a7738def3ac093d6173945861419ab4c640a1696d78e10","pregenerated/sha256-x86_64-elf.S":"8e475f6c5f3787c10c71513b0d611c24684ac4277dd29810d7a271a0230e4071","pregenerated/sha256-x86_64-macosx.S":"b352aa748664533d595b30030e03dd07ee04300d8f7dedb7a962e95428582830","pregenerated/sha256-x86_64-nasm.obj":"15dea95dedb29855669dc8a7b426b07e1291e4750bc14e9530b1406d7c7d2e5d","pregenerated/sha512-586-elf.S":"e785f2903296490ebd77a58cac011b86e27bd08006b41dbba7d8d25617a031ee","pregenerated/sha512-586-macosx.S":"8507b01795ce1b6db3683a609fdbf82673bc83170a3aea6f09d41c148419aed4","pregenerated/sha512-586-win32n.obj":"977174b643357d5fa5d9f350b61c67f435d329bcaa5a77ad692af4566726b12b","pregenerated/sha512-armv4-ios32.S":"588ba52839ac62a67e671bcd46dbd038eae49039e29a691bb219f5b21b84f9ed","pregenerated/sha512-armv4-linux32.S":"01432363bdb1de88f551b021c4a3f8f95e2e164b7a474360a5609df61ac1210e","pregenerated/sha512-armv8-ios64.S":"85a754750ae044677650fb5e888194f7c655040dc8bf6229c868bd72b6dae9d8","pregenerated/sha512-armv8-linux64.S":"d0542bf1e2e7aa4535404932d5f10afecd16df7b0b40606fdea6ea09a09a6d4c","pregenerated/sha512-x86_64-elf.S":"cfa50a0164c2b722610898680d0c1fd2b0a1c298697d96563158ddf92859d95f","pregenerated/sha512-x86_64-macosx.S":"8264ca5e2c717d6e65d53f80c715c54b5debd78ce4701b4b055b729973dfbf31","pregenerated/sha512-x86_64-nasm.obj":"a81977f62ebf5b07e0aa20d8083d185ba45a7cac01b6ca3c4d117abdb6d8b7ea","pregenerated/tmp/aes-586-win32n.asm":"da525d7cb54408984e806c6c33a9064d363b70e81d9b29c1d6b66069dc072f0e","pregenerated/tmp/aes-x86_64-nasm.asm":"4a0ed0baaa2cef67a862ae5cc77e5cb41a22a339e692a6d3df7f9157b1918d6a","pregenerated/tmp/aesni-gcm-x86_64-nasm.asm":"8eb7d4f4608392545156d187ebff40778fb88eed4191ae1e86d92d71025ae4f7","pregenerated/tmp/aesni-x86-win32n.asm":"1146ea29b0189531e25715320e3a35f6c6c07bfb940649cc4d7efedd07ca49d2","pregenerated/tmp/aesni-x86_64-nasm.asm":"8f80e63b42c61dd6a65fe0952558fcc22153995cd87a7409882380b39781a368","pregenerated/tmp/chacha-x86-win32n.asm":"4249a0825b7c75bc31005f49e78c3c4aeb50cece4b27abbbbf40cdc6ba3e2106","pregenerated/tmp/chacha-x86_64-nasm.asm":"1556daf278153ba33ba8eb5b1271dd663562b22f44794cd126ad9be73eb200e5","pregenerated/tmp/ecp_nistz256-x86-win32n.asm":"77c2a6d166912a2aa84f0e14290e9560add3cd40287e575636f78c09185cb214","pregenerated/tmp/ghash-x86-win32n.asm":"9fdc5bc9524240cf62a58f95a357106082fb1ef5e00677877519cc728df74d28","pregenerated/tmp/ghash-x86_64-nasm.asm":"494576f0ff30589cb66eeb5f45a8c552f03bab4ec2517934e79a929b2f37e06d","pregenerated/tmp/p256-x86_64-asm-nasm.asm":"71060ebfe9e47b4458d1240dd038b3f9341ce83a229d63d3cfb763524b9806f6","pregenerated/tmp/poly1305-x86-win32n.asm":"eadefc208a7f260fb44e38577ab584479e2d289dbdbe524cabef996f81b78de2","pregenerated/tmp/poly1305-x86_64-nasm.asm":"66b27a9152114f1a0a614318b645a9cfc22a00c0bd2c9ffdb8774a74effb36a2","pregenerated/tmp/sha256-586-win32n.asm":"71a5f45df90f6ce35d3657ca83b5b80b3864de6f63ba045594785fb21cdf8e59","pregenerated/tmp/sha256-x86_64-nasm.asm":"498b2471bfacc12df4aa9233c81f5b86d6e56773e60e28f24088cde6454a11cb","pregenerated/tmp/sha512-586-win32n.asm":"fa32423c613e30cb6dbd8fad6e2ffe2e450da321a960381498609b1ebb5d8e1a","pregenerated/tmp/sha512-x86_64-nasm.asm":"233604a1bb54a541585a711d430f7e99623069bcc61e674eee76590268afb1fb","pregenerated/tmp/vpaes-x86-win32n.asm":"e4d9f5c86c207b67fc6a246fcb07e3a192ed6c929cdec18d60a384fb33b7f9b0","pregenerated/tmp/vpaes-x86_64-nasm.asm":"4cd63141bdf1e3b80768a9c532f65094e4fd800409f3901cfdb1a97bd9ae9c36","pregenerated/tmp/x86-mont-win32n.asm":"0cf31818e21a33d865f3a24ab9d38292e059338d28b295009fc3013dc45046fb","pregenerated/tmp/x86_64-mont-nasm.asm":"6f6544745dd9d181472ff0f0a53a9651794b7835ddfbc1f382976767a78712b3","pregenerated/tmp/x86_64-mont5-nasm.asm":"cd7a8e378e8c430e9f3b755f690f61a800332f830ad34b667cfde63c30c6d8b7","pregenerated/vpaes-x86-elf.S":"f0730662912db49c4f500c7074070f0d1d9b423e4b9e4e8ee0abdcfd6f097b3d","pregenerated/vpaes-x86-macosx.S":"f4e1f9846776ed68a83513e44cc3aca4da6124d71f87ddc5e4b4de5bd8bf75fa","pregenerated/vpaes-x86-win32n.obj":"46ed84d51fc35618dc394124ec715e6e593dd8e67f25c973f63d06cf10c518ef","pregenerated/vpaes-x86_64-elf.S":"ebaf462c4dbb7d79899aba8b50752af8466febae32d1ac9f9325464e41b733eb","pregenerated/vpaes-x86_64-macosx.S":"19392ab0203adea52781382df124e874c5c95dbbdd024e970af2589f0378b865","pregenerated/vpaes-x86_64-nasm.obj":"2b2b41b75eeaab47310c3ed24a570b0b74208b54639f78c7177b633b691b70f7","pregenerated/x86-mont-elf.S":"7f71ebc9188f3ae1bd366f5ba0e97c3ff97d204d84f774cc0c4b57907223d825","pregenerated/x86-mont-macosx.S":"7382660774ac0cee55c33e816200efcacca726d9b8744f07a0cd655b20764e36","pregenerated/x86-mont-win32n.obj":"5fc0e1b6e21d4f877cd53164717d983cb0f1f4c3c59cd80c5310bc6519d10e7f","pregenerated/x86_64-mont-elf.S":"1170f36b95b463f0e168ae48d37ee2df7c904331b1d2be5004f65a818d1653ab","pregenerated/x86_64-mont-macosx.S":"79a8d422fe0dc5826c440b74149ab241430b2d0ea025dc5de6474dc5b40069ff","pregenerated/x86_64-mont-nasm.obj":"6a89cf1056351aaf42546ebe63cfa3c75567585d7da2f3767fca974c6d86feba","pregenerated/x86_64-mont5-elf.S":"05420ae9e406e229a6cdefb38b398ea836bc64c61ce75840ecef75dee2252796","pregenerated/x86_64-mont5-macosx.S":"ef81d6d9d221b5ccd493e0540e85fa1cf1db065249bd34dfa19a6398f8200460","pregenerated/x86_64-mont5-nasm.obj":"22ce3087c8c06791a5999aa48d48af71431069078a9fb3dd14d4addc3267086a","src/aead/aes_gcm.rs":"c3c8aa005c9d1c04cb3ac066fd091e7cf355e2e9964013edd96966cf952127cd","src/aead/aes_tests.txt":"4ae334ed8c34c0cef24c22b73568faec906a39e26a428e4cd6fe4f810cc51fb0","src/aead/chacha20_poly1305.rs":"fc2abd81f9e5d60bfe9baf31613990530713b24860e2d317162aabe2a4f97d24","src/aead/chacha20_poly1305_openssh.rs":"3226b02291d257768a5f38d5a264268167ca94d418fcb5616913e21ee59f7670","src/aead/mod.rs":"bbeb66d0711010cde30aa9252ffd417556804fe1dd47f041c1c8f3995c3a228d","src/agreement.rs":"3f84faa61b3f7463584fa00b8f559cf9879631504972629bb6d75ec5268c6d64","src/arithmetic/mod.rs":"4154c5a049a6bc602985170a292f6f16c1728abffcbaf0cf461da228022f1f2d","src/arithmetic/montgomery.rs":"adb7d8e3bb058fcbab6911967d62cf2e2b2ffc9fa165cc8da0de984fe6eab5d2","src/bits.rs":"16c7640e8e7c093883050c44b704d29c772bffb612bf501d1962e0f4eb7a86bd","src/bssl.rs":"b94eda108e6e8bc53e1635e0dd46c21ad208dedb2331fe5cc91eb5ccc788d3af","src/c.rs":"37b7038f9c7f04f44670678ea2ff5a115b3b24f699d0e3480e1de121478e1cd2","src/chacha.rs":"74946cf5dbf1a074667c74d7b7680e2c4a8b677b54251096470a9343394534cf","src/chacha_tests.txt":"6ed1303cef7a0ffa30cc76f9933509a2d952a334b80c731d52d32c6ef3b37042","src/constant_time.rs":"2d76e72ad06e65de8ae060607759b7b618ccdd0b4b1a94c227c9af2b402008ff","src/data/alg-rsa-encryption.der":"7bc023427767a2f2e156f8ae030d06d19f862e326b952116649b423c3ff7110e","src/debug.rs":"692fc36bd8bb6f416fcc3aed93c4fc8809a2ec6614ddf825bc6974a954347b22","src/der.rs":"98afa28694de2b56a3198d23932b2538326b512f97401c86c5fa5b6ba04fc90f","src/digest/mod.rs":"d17f80d215b0e725034bd21160b8524497b3015caf59028611f59b96b731a232","src/digest/sha1.rs":"d744a71eeb1edce3e37d22c571c0c5cc492b98ec09a53066e64e770c11cac467","src/ec/curve25519/ed25519/digest.rs":"6bf6c446b145d0caaf45398c4fe8574df7e974e89a9155d87d4a0798716f79a2","src/ec/curve25519/ed25519/ed25519_pkcs8_v2_template.der":"1bd2db034b5160de343688ff570db3da6a5bbfc66f9f2dd015f0902e2d2b7e34","src/ec/curve25519/ed25519/mod.rs":"5dcee3ebc59b65d444b162b6832a51f501c37bef8f16945c220ec7e0e157b8d5","src/ec/curve25519/ed25519/signing.rs":"324eba85aad558260360dd8c3af883b5a7c07fba9e75e72394770517057161d2","src/ec/curve25519/ed25519/verification.rs":"7fd0d0e7264e1aea1ad9319f62ef8aff7c4fc1fe09b488c37a05dd10100bf124","src/ec/curve25519/mod.rs":"9758e50247f0f325332ccf70245ce7745cbc21a01de39590e2babd6dd185451c","src/ec/curve25519/ops.rs":"71c04dbd2788a59abdcf6d17d1ef5ec0f97de32a94a1345da07f698eb0ebc0ed","src/ec/curve25519/x25519.rs":"d275c9fae49c86c42d5671e9118c84aa8d34f5f7e67d286c189358b4fc49b055","src/ec/mod.rs":"e0724f2b55aee8c68dc4338da6a8f1491dffbd54a5a30ba1b763e5d4e98316ab","src/ec/suite_b/curve.rs":"278b9b54fbe56ce092e441bebaca60cbc8d2f327e84c551b857c2b80562ed896","src/ec/suite_b/ecdh.rs":"d02b0753708246dd2cb03199865f778417cfa87d8c9eb40c0a4feb97f51bc019","src/ec/suite_b/ecdsa/digest_scalar.rs":"d08e48bb1bb7ba694021f11972f9c0a66acec4f2cea746796298dccf1df1c05f","src/ec/suite_b/ecdsa/ecPublicKey_p256_pkcs8_v1_template.der":"5a2207da0199ebe3e2a80e15e7692b21f215f855ed3bd2c51f466c7969e11990","src/ec/suite_b/ecdsa/ecPublicKey_p384_pkcs8_v1_template.der":"5ec14cd6aac17cec849382ee5e2077497f98ce435d7aee2116cd092bf84f5556","src/ec/suite_b/ecdsa/ecdsa_digest_scalar_tests.txt":"7f38872c3acbd5d156783de92f3671062101af3cc496c1b261165971b3eea2ee","src/ec/suite_b/ecdsa/ecdsa_sign_asn1_tests.txt":"ab92cd110846b42d7738374d25734cff6459467f40121c4e7fda5b31bee651e2","src/ec/suite_b/ecdsa/ecdsa_sign_fixed_tests.txt":"c471d314f18270c79141062d5964d84fbe38c1bb9559ca217f3511d34fc4af25","src/ec/suite_b/ecdsa/mod.rs":"013e0d2d2a21eb437253b03a1f6a1a4ba8c45eb1c2ea1396696bdd04a8ed2932","src/ec/suite_b/ecdsa/signing.rs":"481b5cab7364a84e73e60aa778403ea6ef8a800b2afe76fc604b68f4cd991e89","src/ec/suite_b/ecdsa/verification.rs":"5df172396718db719ff3e618ec6e326c14d67bcf08b978b684a272c2600e74bb","src/ec/suite_b/mod.rs":"5c16c4a4f722a5fe85233a5b4877752373ba7623cdd610f0ad6db9dff78371d0","src/ec/suite_b/ops/elem.rs":"7f81e636ed526dcb9fb12f4e4fd642d3a848b5da10ddff6f97b873d6016d52fb","src/ec/suite_b/ops/mod.rs":"90e88ed071e8fa3578ddf9d1635cc3dd7e049fbf00de95f9fd4a98451f11a3b2","src/ec/suite_b/ops/p256.rs":"99bc56042b70278a1e5e3bab43afa15183d48313a569140c1a9f74ab921e3dcb","src/ec/suite_b/ops/p256_elem_mul_tests.txt":"02e7a991d6643a81229f462d21ea72f0503c038d783583c83ad7f118952ecf0b","src/ec/suite_b/ops/p256_elem_neg_tests.txt":"b61eb959dd473bd8edbc4566f18be0ac9f483be9e7d0900f48eb764454475807","src/ec/suite_b/ops/p256_elem_sum_tests.txt":"2fbbc13100065539bce71e83d642878a90103b5ca3d9b8d3c321db15a0c05c9e","src/ec/suite_b/ops/p256_point_double_tests.txt":"34a5968bb40320c6cc0f7d248951376823d46c0aab1fc7ba59311bc1cfd34417","src/ec/suite_b/ops/p256_point_mul_base_tests.txt":"f207084da07de3f63b7563b07994915dc770e2b7d5dfe41881b2ffe875ad69d7","src/ec/suite_b/ops/p256_point_mul_serialized_tests.txt":"f3c8061e0f891441de35e80869c253c65fea2ed1dd4f9be7a444c956211d32ae","src/ec/suite_b/ops/p256_point_mul_tests.txt":"894e02359b562f3d74757f4d8fdd20c5fc5528634f5922ce01d9546910e0b0b9","src/ec/suite_b/ops/p256_point_sum_mixed_tests.txt":"c2a178ad0371ff7dcf15364edbbb5cd0e82478d7e1037a6d3b2243204465f918","src/ec/suite_b/ops/p256_point_sum_tests.txt":"1ede1f508c673890e2f48ba53309397a17a02f13370aac114f34ea0c3c4f4617","src/ec/suite_b/ops/p256_scalar_mul_tests.txt":"6fa09fc69c9962c31f090ffc747d4cafe184429b8e0acad3adda7b14ac26a4ef","src/ec/suite_b/ops/p256_scalar_square_tests.txt":"19633fcefdf8af6685fa9750a96c17478e282972ee7ffbf4c4303229f7938db3","src/ec/suite_b/ops/p384.rs":"6e1237710c247c7097687549d9b2e9db6f38d9bb64d620a81de2cad3c0bdf33d","src/ec/suite_b/ops/p384_elem_div_by_2_tests.txt":"8c4d02994577c8b6ec3a83158fe20ce92366052ddff349b02bad4595847be8cc","src/ec/suite_b/ops/p384_elem_mul_tests.txt":"acf37680470a3574acfe64cb3629186d1f29bc8e905c5d9c1e40a2c2bde2701d","src/ec/suite_b/ops/p384_elem_neg_tests.txt":"08986c5fb0b8adfd3be6ba217ee68308c5e452dba086d92793e0ce3383c1acaa","src/ec/suite_b/ops/p384_elem_sum_tests.txt":"48850b24fca0487a875379b6de77879f97578f50111c11a12e8d789f6c8f0ab4","src/ec/suite_b/ops/p384_point_double_tests.txt":"6d25547058f40d98ef3c2a1957fb72a57f4fb19623c28dda92b42b7adc93bc9a","src/ec/suite_b/ops/p384_point_mul_base_tests.txt":"4995baf7080a6a4d72de1d262300c4ee49d0449034e1250f87bb15fadb78408f","src/ec/suite_b/ops/p384_point_mul_tests.txt":"2fa85969ab080e6f977ed92abbe29f6f5f0658e5ee126834769673ff557efbd0","src/ec/suite_b/ops/p384_point_sum_tests.txt":"5cbdf15ce4a56a952b85046e49cd0fc4ee22d516d914ab48c19b7801864bd352","src/ec/suite_b/ops/p384_scalar_mul_tests.txt":"f88e82363d7a1eb4fd687bd54dec6cb05e2796e751f39b5c774c11af0569bea5","src/ec/suite_b/private_key.rs":"a2c63d29a99b635848a693399c06e25f4ff6f35832377a2c69a55b4f5f05fc92","src/ec/suite_b/public_key.rs":"20997859ba83ce8b9fd0d0d6934b3d48d036c944962bb102fd1dac8e2b019ac3","src/ec/suite_b/suite_b_public_key_tests.txt":"392bcb543cf69cbab5252792a8dfe09ffa3421cb27d65cdafe9771bd68d49a5d","src/error.rs":"ce9845ba2da202dac97d2c4a9539d3b8483cecdac589984a65449cb4c5efe02a","src/hkdf.rs":"4f15ecd47d2031225e5f14b02245b3635489516a82ff13be8bf9959ab8c77c60","src/hmac.rs":"ee8555f302e0bfc7bb1f2b905ba1dcc78c12cd13592e1a680e68733e8c58ff24","src/hmac_generate_serializable_tests.txt":"d9fad4aa957496eb05dd67d97699631bd428de8a5be6e29aeb82b732eae97a59","src/init.rs":"fb8b2031e0341387b2583c39a0be48922a1292dc6bbd9a80de40e283c5249db6","src/lib.rs":"ab2ce04b421460116baffb6c9fd4d05b263ace73d570e46c0f36728d856c97b8","src/limb.rs":"068e271eb91b3b701db7bd6ae23089dd7c436243918fd4f17a4b208c2bf0018b","src/pbkdf2.rs":"190713bfe17a273442b737dad836f5020c377bc800eba7d6866a4f4c848ce8d0","src/pkcs8.rs":"cda6d79cb18dc83a4e3ce9ef087df7eece0fbb935a02029b7584441c2eac6b35","src/poly1305.rs":"23af607e1c79812139bd25b26e641d747310a65b2b34a9d2557f0787fc1d4786","src/poly1305_test.txt":"89be1be8e403e5a17845f0603e19337604f1f278c7b283de2c7227ef6041491f","src/polyfill.rs":"797682ba9f781abecc6efc11477802a058148f3822557750a74df6db303113c7","src/rand.rs":"19e1807425d7bde230df350fe30aa7c680f0ba3b191b756a1b754464895978a3","src/rsa/bigint.rs":"ecc414a276c4d777af2b199d62ce8c8f2917c81f9207d78db2226ca4ca88e264","src/rsa/bigint_elem_exp_consttime_tests.txt":"5f84de732433df1e0db3b3eb690bdb0cc1a735bdc7e60a8218d5910e9d9ac436","src/rsa/bigint_elem_exp_vartime_tests.txt":"6501c58fa66083ceb7dffe14a0191cd6a2d74a96aafeb72d828841844a37f409","src/rsa/bigint_elem_mul_tests.txt":"0de8d667f4bae0648607cff2c53df81a6b2ccddb8ee620593350255b36de0e91","src/rsa/bigint_elem_reduced_once_tests.txt":"7b4aea41259ffa329d669843d6dbf29a5ba56d845210bbf4b0a2ccafbe8d8c01","src/rsa/bigint_elem_reduced_tests.txt":"7c5dd25b495b89bab09e8f09cbbecf34aa28ee7eb2ed592bad50ab63e5b17ebe","src/rsa/bigint_elem_squared_tests.txt":"0517a5446667fd49d198a89fd93f19d9870fd3fddad3371ad9aa8075b6020e22","src/rsa/convert_nist_rsa_test_vectors.py":"c670a7d9761667c46a9b204848c74ed8cb5ba723e3f5b92b081e94e4601c55fa","src/rsa/mod.rs":"0edd512f8636bd0f50927ed7bbcf4b90adf067511f0acb8617540e8933b7c44d","src/rsa/padding.rs":"6c7fc38bc021a3c2ede033e83e8ee45b476b4730f937ab5271bcd89ec15b2e7b","src/rsa/rsa_pss_padding_tests.txt":"1b68a294521e983a4a35fd7ad4e5823d6173641ad63d736b3b8e6e867f748ea8","src/rsa/signature_rsa_example_private_key.der":"5344d57f719a98c4464aed1d1c2fa569f0a9de8621c6fdec7d28923a0e1c662c","src/rsa/signature_rsa_example_public_key.der":"28b0a357936485bd2a7776321cccfe17c2347f2bb75751ddf9dfc6429cacb6f1","src/rsa/signing.rs":"ca953aa66b43367d94059c2a5fd61d4ae404866e223bf60dbed57694c0ef5d02","src/rsa/verification.rs":"65b382531d6af89c841a33778d313737b81ad42a7b9a4670f76dc44df17e20ef","src/signature.rs":"8c76db30b50e9b342c402cd54390d4e2cda522a4b0e7de670ca846140e07142e","src/signature_impl.rs":"15c07c7d916c19f1e6cc8afc89c0c9ba602bbd6186888f2210254ecd8268b594","src/test.rs":"befd5a72ec39b58208ec081248e22a6f57c28864ea41c45474dc65d5a6c7977d","src/test_1_syntax_error_tests.txt":"c6e72aaee3817e145fea114020193c5b3acbbd2f3a97614f1c2670822f1ac6f1","src/test_1_tests.txt":"1014aec056f9a06eb23983e61eb6dae8384ee982f4eb0c5be002fb5d6ce10f99","src/test_3_tests.txt":"e489a2da5f486e75cd6e2cf7089f09d6ddf61a8765fd58c47bc79ad32be77e13","tests/aead_aes_128_gcm_tests.txt":"2e88612cf3d767626f62d59d81652fef5611f4418bf56016c12ac0bc26a12a20","tests/aead_aes_256_gcm_tests.txt":"c21fab30c0098cddef658908ca2820d656c4717d24d79ef3dd68251695972040","tests/aead_chacha20_poly1305_tests.txt":"3688abbd7b1d87c9200b627c289a2bebf763f512baadf536cd72cc8f3ce80fe5","tests/aead_tests.rs":"791b311be75d72a2e302443345d994179c219ba1963c84b188fb423fa39c52a3","tests/agreement_tests.rs":"4693499fa201cad7709030818dcd59d6738d31a342781f21516437d22e818038","tests/agreement_tests.txt":"4b784d203e87f9de0678df00ac1b2a28db169f680a3333e9d773656fcebceea9","tests/digest_tests.rs":"6ac88c9673b3c03fa772c4493a9aeb226e7fa548097439591151dcdb746b9fec","tests/digest_tests.txt":"dd817794e2ba72ed637805e225240a295ae7b4cbea956dcd23c4752da67a394c","tests/ecdsa_from_pkcs8_tests.txt":"c277b11b3efd6598269257a5aab14896214c611bf22b89fef9a2e6ddf1ed913c","tests/ecdsa_tests.rs":"5866e997da7642e45c75aec507a7db0bdd50a5983a4c0af971b94dc70e14fa3d","tests/ecdsa_verify_asn1_tests.txt":"4ae6325e0a1fdf4cd6fd2f299a7fb7a60927d0775b63aa9b027676fa76f3ee6d","tests/ecdsa_verify_fixed_tests.txt":"837f116fca066cb181677e389cf92b684d15ed883189b4544538cb5387e6b742","tests/ed25519_from_pkcs8_tests.txt":"0eac04f0e0ef3bab0e3ce2f2005d230e173333ac85fa363d560dc351dbcb09b7","tests/ed25519_from_pkcs8_unchecked_tests.txt":"dcb114c04bedcf720da313f93b79ce81ec805e5291b366a770010568f405ae08","tests/ed25519_test_private_key.bin":"644d50ab64864c20a12b3c4656d46b4a48f69ef7c47ecdc8415cd28316b22ef5","tests/ed25519_test_public_key.bin":"21fe31dfa154a261626bf854046fd2271b7bed4b6abe45aa58877ef47f9721b9","tests/ed25519_tests.rs":"ad473116a57c61fce3a71844a1710b283a34afd5198e9e5bf64f1276372fbeac","tests/ed25519_tests.txt":"f99c7e7bf7cbbd7df936ca883ca0cb293c31ad37c03597890fdb07dc1c923d36","tests/hkdf_tests.rs":"7d57171a547d5e0e87235426aed97f258603d645629eba8590101823fbfbdfee","tests/hkdf_tests.txt":"516a19799fa940c72dca68d8cc92ec605b46aa71590cf1b827468a58a01da574","tests/hmac_tests.rs":"44757854526929bb7643cebc00d424e6dcf596db23f38053854e2e7ed569efd7","tests/hmac_tests.txt":"272c143921789a66d39396843c2fa0aadbdfe26d061bd2b7836ec40dfc76e09e","tests/pbkdf2_tests.rs":"f5b23675a2335961919b5b75d4626fddd4df5322ff597306a8d74ead9121cefe","tests/pbkdf2_tests.txt":"db65f42fb72cec9ca89c8c071d11c341f67c4df5e0c66a70735da5d1d370cee3","tests/rsa_from_pkcs8_tests.txt":"3140defc47180e283e59d4fb457061f041c9e724491849d3ff8eca3af3fcc387","tests/rsa_pkcs1_sign_tests.txt":"cb202666f2ed100a0ba8ebf818dab1bece055bd9ac9d5533d3f20fdad7b4c509","tests/rsa_pkcs1_verify_tests.txt":"ed8a330181e8a47cc707238e80377a8bd4002f6f8f6d06106c78aa9b59da98cb","tests/rsa_primitive_verify_tests.txt":"68c90857490543bcfb836f3b8644445acfe90a2e4c5189310914ce5484927418","tests/rsa_pss_sign_tests.txt":"aca70cfc877b055c0a29da2a457563cd1b5afe6e932b011e8b9a15d57dbe10d0","tests/rsa_pss_verify_tests.txt":"afcde20cea975ea235d9828bbb9b083f77584a7cb8c5c955e40c4bd305573f4a","tests/rsa_tests.rs":"57f43dbe11ce75285a92f0cbdce0df593210c4ea6bd28abe4917adbd8177aa17","tests/signature_tests.rs":"b71d9ba0580a27e1f3c7da01de19cb3a8b12c07e417b6951b74db63abcbb0143","third_party/NIST/SHAVS/SHA1LongMsg.rsp":"c765dbc1609e9046b12f60a5285a88128dab4315080c94ce9f2a57a7b0b980be","third_party/NIST/SHAVS/SHA1Monte.rsp":"d458fa7e39095b4e292a75b0cd224f90b72dc801a63ad2c0d75b8f10d745ab6d","third_party/NIST/SHAVS/SHA1ShortMsg.rsp":"be0991ddc5372932d55804b11713c9140d10435ef4b316a0773e3506eec79cda","third_party/NIST/SHAVS/SHA224LongMsg.rsp":"d37115e5d2286dde969c5e1b2275cd83ecb066366d7a38bb6b2b3adb4a88de89","third_party/NIST/SHAVS/SHA224Monte.rsp":"7854d388666ea3eb01bdaca37dc8ae0bc39d30f8731d9a5487cbd61de47d1d59","third_party/NIST/SHAVS/SHA224ShortMsg.rsp":"0dad6656c08f77252f6ccb789e42284fd61fc53bba30e83162800aa3d2aa939f","third_party/NIST/SHAVS/SHA256LongMsg.rsp":"6fac36f37360bcf74ffcf4465c18e30d6d5a04cc90885b901fc3130c16060974","third_party/NIST/SHAVS/SHA256Monte.rsp":"29ea30c6bb4b84e425fb8c1d731c6bb852dac935825f2bd1143e5d3c4f10bfb9","third_party/NIST/SHAVS/SHA256ShortMsg.rsp":"75e1cb83994638481808e225b9eb0c1ebd0c232d952ac42b61abce6363be283c","third_party/NIST/SHAVS/SHA384LongMsg.rsp":"536171765a4278c000ac3c9913edb2eed0ca7ccd5a10b72ed79fdfe7901a6d6a","third_party/NIST/SHAVS/SHA384Monte.rsp":"4270099431ff52ee1686dc472351e681c26c507433df8f107c7de203b771424e","third_party/NIST/SHAVS/SHA384ShortMsg.rsp":"7ea7bcf00fadc20949fae63703e40681ddf288fea808471cb3cbc95f3ec16811","third_party/NIST/SHAVS/SHA512LongMsg.rsp":"b1f3f05d5c209777954d49521d7ea1349447c36a0c52849e044bc397a27dd410","third_party/NIST/SHAVS/SHA512Monte.rsp":"8ca78659286c2f01667a98fc7accd32fc171ae7b24ac00f1a8ce6b77770247fa","third_party/NIST/SHAVS/SHA512ShortMsg.rsp":"e53a36c03609e5a3e3cc4b6e117a499db7864c23ec825c6cec99503a45f40764","third_party/fiat/LICENSE":"0c125a4dab5ab869473e6491db22f6c0a7f8a4de58588d03bb2b16c0c8ebd7de","third_party/fiat/curve25519.c":"7564f75438fa896278f17c249261030b4c2ebee0304678c01ca8a16a0932f1aa","third_party/fiat/curve25519_tables.h":"668f3615a9cac425b96619b46de44631976e167f0cfc842ab87844dcd8a5c529","third_party/fiat/internal.h":"cfe41b40e51ca477eda94d07dd521fbb5d3389e77d94a55b058bf60efa0d2aa8","third_party/fiat/make_curve25519_tables.py":"c499f166e8df31f23cf00296b46f7634aaacbb0f48f5bfa0277c27bdf89a619d"},"package":"2c4db68a2e35f3497146b7e4563df7d4773a2433230c5e4b448328e31740458a"}
\ No newline at end of file
+{"files":{"Cargo.toml":"719d043b0b046cb53890a6bbd35b261993f2a4136994d7f4d68361c561fea8a3","LICENSE":"76b39f9b371688eac9d8323f96ee80b3aef5ecbc2217f25377bd4e4a615296a9","build.rs":"315db4ca6a3b00a00139fb8525e875706a288074d752eae6f50350ea50502670","crypto/block.c":"f78b50b1482f00f1ed030fc2e0b325eac5be387a1af6150cb6c8bf359038f54e","crypto/block.h":"ca5fc0e831d6f053811c6c96254d303ea58c48ea875af6d2c6862d3f07971f02","crypto/chacha/asm/chacha-armv4.pl":"4dabdd766dd25711ee6276f7415c3fd654635687aa536617eceb75a8a3ad1189","crypto/chacha/asm/chacha-armv8.pl":"60f4d3a7904fbd2d7c5c98a369c9a540fe4c44b62165032d01574326d5b6f46e","crypto/chacha/asm/chacha-x86.pl":"abbcf8181bd629d8003322dbf2592bf4631abb7895861d7021c451043e39be34","crypto/chacha/asm/chacha-x86_64.pl":"7f38c54bae872a6f6cde85cd13bf061ebcd9372a4d126f66bbe018fb7231d6a4","crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl":"82d31709de6b5e7c633b44eb54f8c92206a44f28fcaa130b6a7f794acd99c11d","crypto/cipher_extra/test/aes_128_gcm_siv_tests.txt":"1a0b201dd8f4aa2106db0de3c26eb0d9623394ec80247867371c20103718b1c0","crypto/cipher_extra/test/aes_256_gcm_siv_tests.txt":"514a978594261e0520b30aac455c8a29c3280cc15701a928a0e8ad7bacfc2c79","crypto/constant_time_test.c":"f753a77612182705f4405a450fe762731f9ea23bf557d739fc9fe55ef56a4be2","crypto/cpu-aarch64-linux.c":"61cb9b03431d543488ca045b9f70d04b6a1d1fc876ab7e3613ec9b3b237baa0b","crypto/cpu-arm-linux.c":"a420ad717fd85c22bfb33c51735dd4ac4ca63fbdb54eda0dd451aa0550d565a2","crypto/cpu-arm.c":"e7b6be5862e1f7f83568991ef2c46f05df9d6517f8ad5ce0a12fe8c8bab788c7","crypto/cpu-intel.c":"abc91c05aa072d2966fdb0a61a7da14e1bb2dff8ecbecf3a697d2b138ccceaac","crypto/crypto.c":"b1bc80bf90aa1f1691ee6f27d3d3f4c491c7590cf83fb39ab2702a166072ba38","crypto/curve25519/asm/x25519-asm-arm.S":"a6784f13e24bc8db7b3f2088722b04fd6a3382c02eaaa0d652a3ae931a465be9","crypto/fipsmodule/aes/aes.c":"b0b56a8f6282b4c149dab5403fe0fccbfcb2a946d0d39ee00ca32a8900a5e2d5","crypto/fipsmodule/aes/asm/aes-586.pl":"c4b671435008c6747c755060900f14f65eb007a16448bc7aa91a3133ce064e8d","crypto/fipsmodule/aes/asm/aes-armv4.pl":"f2aea5fdebbdb093a90d7b42e925ffcfb48509479d0157bdd88f46f33b690ff5","crypto/fipsmodule/aes/asm/aes-x86_64.pl":"d8088bdf4a3c28b0cdf0284bf829bae6dcbe70637c9e79ded33a61572302fa93","crypto/fipsmodule/aes/asm/aesni-x86.pl":"8625210b9588ddb994a53c3babc6f68aa1b7615e572934b2bbf8e5c284e1de4e","crypto/fipsmodule/aes/asm/aesni-x86_64.pl":"97b0a0d9ddac8b972b5fb98e0fd564eb68b3b50dc31180d1af1d6599685d004c","crypto/fipsmodule/aes/asm/aesv8-armx.pl":"eb5b5e4fe4447767b7b95a53c697885f4c20c5a2c82b2f56b48240f7b5a3bcb8","crypto/fipsmodule/aes/asm/bsaes-armv7.pl":"07d795e03b6463ef5ac2d92e554de52bfc32af6f2585b2ed8ea60b61abceb0d3","crypto/fipsmodule/aes/asm/vpaes-x86.pl":"7672ae209b0eb33d0d6856f46c46066a07db4c6534cb678cc2bf329b040575b9","crypto/fipsmodule/aes/asm/vpaes-x86_64.pl":"383e964a9188bfbbdb5f0b53d74c5493ef234194c1eb1b7e2f63504bb3974c9e","crypto/fipsmodule/aes/internal.h":"b9cd4c26b7d87be155776ba553336ded881f9a8deeac08a9a053c383a0d657e8","crypto/fipsmodule/bn/asm/armv4-mont.pl":"0e6b793c5628ff2d1172969a56a508735150409e4a520bdc7226a0dd1f104240","crypto/fipsmodule/bn/asm/armv8-mont.pl":"a0f9368bcce4d56ec72ebf04a0664c8514a0fa9299aa2d27eec07fc63dcf4d0a","crypto/fipsmodule/bn/asm/x86-mont.pl":"eff867e854ba35bdbe2f884b35e1c6cabb7f4e6b5ffc62d13e3d795285479138","crypto/fipsmodule/bn/asm/x86_64-mont.pl":"240d70d03b632727c71afe0de20478104768290dfbd15023cda2d440de99e3df","crypto/fipsmodule/bn/asm/x86_64-mont5.pl":"729634aecab869465b6f3fba71406bf34603c3fa4a371749cc7228ccb4a728be","crypto/fipsmodule/bn/generic.c":"8427b35e188177a3669a5763d4cd639457391f285b9fa501b788cb21706ff565","crypto/fipsmodule/bn/internal.h":"49c3cb55c4523b8b418dad6c19ad44709833bab6e82cde1fd7295f9d1491efd0","crypto/fipsmodule/bn/montgomery.c":"312cb830ac61d83d02e7afcd46c9a2b4367c46f30792ffb13f9f826aef869ff3","crypto/fipsmodule/bn/montgomery_inv.c":"0781fbab3065777572720df6a8c3ce3e2dd2b731e7c71c35635f94c881eecc82","crypto/fipsmodule/cipher/e_aes.c":"935b389d3fed3627b56aca91010c073173a6e5e02357c1e50aa0b074a08971ed","crypto/fipsmodule/ec/asm/ecp_nistz256-armv4.pl":"f92e6f293af43e439cf41f603ca1c016227912e3ea16d221edc56a467c5ab1e5","crypto/fipsmodule/ec/asm/ecp_nistz256-armv8.pl":"2338e60bd7a868850ec681fc66e313c92c90727de8f723e83ad72a0d7c553c3f","crypto/fipsmodule/ec/asm/ecp_nistz256-x86.pl":"51be61331792fc0c971eed9d70f15b89a79a0bcc3211f65401d343f5bf794091","crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl":"add0f387e8bb2f40f591eb42da0534f44b771a47a301d8f93a448fdc9d52be83","crypto/fipsmodule/ec/ecp_nistz.c":"f138a4baced1595ea06911bc425f0766b897afb3007437dd7f8c68e9e493e73c","crypto/fipsmodule/ec/ecp_nistz.h":"f9b3176c9a9883721529665583b118a8e859e2b6bbf06077d0d1f7339dce8c65","crypto/fipsmodule/ec/ecp_nistz256.c":"6810068be6b2d28c17bc634349eb1d70cb7be578d9f3aaab7849be179fa9f877","crypto/fipsmodule/ec/ecp_nistz256.h":"0032b44c8a61c6478f8c2c36c1dbbf9789418f509f428419c7a7f6d148674872","crypto/fipsmodule/ec/ecp_nistz256_table.inl":"ccc4126030480c8898832cc7f0ae6c62bf5e16de51a32d16f667fae016699579","crypto/fipsmodule/ec/ecp_nistz384.h":"9fbd1b8a9fdb0514110b441f47618ee781d531e67fc54c38a89671a5160a44b1","crypto/fipsmodule/ec/ecp_nistz384.inl":"f0e4f7f8415f057556da8d3f40e651706bc074ed393e1442f6dbba5232a2ee00","crypto/fipsmodule/ec/gfp_p256.c":"b2d9d6523d02d0adb2ae8230e70a7618e100e6026a82b1dceebda955d4922d0e","crypto/fipsmodule/ec/gfp_p384.c":"ae7c91d6dfc69dd7c47c80169450abce2c5452b6273fea10864c938bd1bad47e","crypto/fipsmodule/ecdsa/ecdsa_verify_tests.txt":"a607b74542c3833ab907e74e341c988ed16ee1e4b02c4323887e82c881a6b990","crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl":"b63b0a1c3e9484661a1c1a55a0275cedb8a1148227e4ea60c6aeb4cc6f195d07","crypto/fipsmodule/modes/asm/ghash-armv4.pl":"77408b681c42324691044d98d4ff7f8160a4193cb286ade366279ebf3c581ac2","crypto/fipsmodule/modes/asm/ghash-x86.pl":"16c8c02399a7513430b8d88fe10a94e19a016acd72801bffd29c1c14705bd367","crypto/fipsmodule/modes/asm/ghash-x86_64.pl":"6b9f719b33d7d6fc45b833aad6f5e8c51096628a377c7d0b9836f7cff4f36581","crypto/fipsmodule/modes/asm/ghashv8-armx.pl":"e210dcf14cad06e593481e30db0f06355582f53bb2419eeb78c7bb3bbb393091","crypto/fipsmodule/modes/gcm.c":"b4ed85e413798e1ab8a56ce8d91423e3cca277e9dbe4c4ab3bcdda90f6ff25c7","crypto/fipsmodule/modes/internal.h":"3d837589c477fe666a2e314dfd457f386e3acaee306c3bab3e2d155fe4c643cb","crypto/fipsmodule/sha/asm/sha256-586.pl":"7d28f78ef27b17a7ac6a62337ae5a75d2ef1c2bf08c8154189652e4d93e9ab65","crypto/fipsmodule/sha/asm/sha256-armv4.pl":"673523183c7ac34ade7becc78f077e6bbda6a2d1f6d33644207c725be2dc16c8","crypto/fipsmodule/sha/asm/sha512-586.pl":"b536e80fcc7cf77e5945fa7af1c43b18d2e1df438e601262429065b0b622682b","crypto/fipsmodule/sha/asm/sha512-armv4.pl":"7352a2ced5b722e37023e27afdfdcd5eddebbe067ba8f5da4c421a8709ee8955","crypto/fipsmodule/sha/asm/sha512-armv8.pl":"c79a028ee366e6a3dc234787c1ab4696be29aef08b3af6877a0dfffede1dfd09","crypto/fipsmodule/sha/asm/sha512-x86_64.pl":"ad914a24a3d903018261499d930871d696af24e379fc9249ce372180d586ca92","crypto/internal.h":"81d55fe0d255f6d7edb7b58a6cf2ee9cbfdc7b07f5b27d17df856d38cda01fbd","crypto/limbs/limbs.c":"195d4c147d460b2af0505d649b7db0f6958fd06eabf4e896747f4e6d86382af1","crypto/limbs/limbs.h":"5736985c56532a9e51a858f83c5ad0c19c22e293deb44346a57c9862bbad707e","crypto/limbs/limbs.inl":"34ebb0d77672cb538ddcaa69c16c781daf5a241ae853fdb3f787b2fe1ad1cba1","crypto/mem.c":"18e2844c6205fab613031e671dac3b65ceeb18bb5125f2a11e4df7ec0c09ec0f","crypto/perlasm/arm-xlate.pl":"54998c82dcf99ca2328ad28ed0ef0b06e95b64f5407e66ff8f1b4e106ed31f9a","crypto/perlasm/x86_64-xlate.pl":"be38cb5a80c8a89e209bf46cea424ada94f9e1e7920f80aa211dd691d81c481a","crypto/perlasm/x86asm.pl":"c437421fe9cfe8fea96f9f38f35fec0d1086d6d1b7b6349180b2163ce8cc9e63","crypto/perlasm/x86gas.pl":"183d2642ab2e4c76b46bcb97a92fd16c539d9c07331c7204b0564d78c9413817","crypto/perlasm/x86nasm.pl":"7d3b50f58cfd1da94a10f17e1129770d744edf03d4029417ea53bf8771a99b97","crypto/poly1305/asm/poly1305-armv4.pl":"2092a6f1b330972fb050da99b7a63d3c70dfd5f99db98ed1f679018d89e839c2","crypto/poly1305/asm/poly1305-armv8.pl":"c717d87739909c95e0dd1e2d95e6a5d9f693677e68ca1bcf2dc619c93c777185","crypto/poly1305/asm/poly1305-x86.pl":"060b3689cac73fb7a32e16daa799573e6c52dda47fa3ddba9cc235763d6834fc","crypto/poly1305/asm/poly1305-x86_64.pl":"ee69a0717f931d7c336898cce017946a56196a90d6fb44a02989b855ce136bf7","include/GFp/aes.h":"fe399abed5f51e4f87efb740db962bfbba8ee3da0895ff87a0adac01b84cec98","include/GFp/arm_arch.h":"7b2d7945fc47ba8d8534ffb03a62d9b891e727d3a14fe32f1608f07dd0021f5d","include/GFp/base.h":"f4dc1f800fb305f3ea06dc2fcfe52bcb3ee42a621d54a470077c44a8f4c620b9","include/GFp/cpu.h":"89adbd17d00d648c77cb9a39f7ff0b974287088803bfb16aabb1c342943626a3","include/GFp/mem.h":"f60b987b803b79b149aa140195ed9c1108b90b01123aca367a599da6174d082d","include/GFp/type_check.h":"6311bbc55de60641683e0380014588dfc5fe8545d62a430f73289f6194bc9f81","pregenerated/aes-586-elf.S":"f7f20706ef759b5c57754d4d76ee02a52720823e690a7d8622706ed519314443","pregenerated/aes-586-macosx.S":"192f02221d5c29435fff77278881d84ebb27317d5193d30f5a16d003b7fe7fd1","pregenerated/aes-586-win32n.obj":"2525a34657d7f6b0662ffd52cf1927179794090f7b2e393b8346bb66d603f920","pregenerated/aes-armv4-ios32.S":"05e3aa1606492acf27005eaf7da9d8d395a46891685ad5a4ab119ce9399fc318","pregenerated/aes-armv4-linux32.S":"a566fa70cea01f894e310ac223bbddae6bd06085ec5abe9f01bb949176c7d04f","pregenerated/aes-x86_64-elf.S":"52f2903cee5b295afd045c8e2c643599607243721f4a29c2c3450d7ee2c05d0a","pregenerated/aes-x86_64-macosx.S":"d9816ae3dd046d168cbed5c81bd8523d8ad0d7cfd23e249ca649dc8bf200a5ed","pregenerated/aes-x86_64-nasm.obj":"73d295c44db097b6a73beb46284a686e0f0cb92752e1638cf1f50b60511aaf13","pregenerated/aesni-gcm-x86_64-elf.S":"ef5d9c077556e5797a3a077822db69c0ee910612a2c5a0ab78d7d7c6c38715e4","pregenerated/aesni-gcm-x86_64-macosx.S":"416356efcc64fa2d8562e4cdfd5450d24dc7fc7b0b75a34c477aa1d6c72797b4","pregenerated/aesni-gcm-x86_64-nasm.obj":"03e0225286522a4eb58afd6af0af9b08205db9ae95013a1baad5abdb96af40d7","pregenerated/aesni-x86-elf.S":"bc47724289b8686a53182ddebde870dec87fd9f475764eccccce2ab7b2afded8","pregenerated/aesni-x86-macosx.S":"daec8c6e24442e087c0f9d966de30c5e65ce54965d5e4d3807b32b86b831ea32","pregenerated/aesni-x86-win32n.obj":"fdcb0d03bd5d48595fa4c252e6baa8926ba5640b8507f8ff88637ce3d9a2bd84","pregenerated/aesni-x86_64-elf.S":"a157857e74365447651edcf52a1c22d025148d0ec4591a2a171bb3961b4c5f3f","pregenerated/aesni-x86_64-macosx.S":"429b63c941b4b097f0535e1e4e7ecf581aca5fa0f28aa01826f86e61dcd19bb7","pregenerated/aesni-x86_64-nasm.obj":"d143c53d8f90e311f6c3cca1793ebb262197739237edb40e41340dc7d9da80ce","pregenerated/aesv8-armx-ios32.S":"b584a245f583c5476b580624f4a008cdd61a3222ac95c2d7e28dd3582d207a24","pregenerated/aesv8-armx-ios64.S":"f8c03d0da11439e3728a10b4ae8070ff0857bd954a601720c4b34dcad72cbb48","pregenerated/aesv8-armx-linux32.S":"cec32d89aeaa2441663dbc3f8a930b1704edb633c312e24d2409a14b1a574d45","pregenerated/aesv8-armx-linux64.S":"b5cb8d4f1a97d3ed999998c2792a67e769c70985a8b1a45bd86aae5383a52db0","pregenerated/armv4-mont-ios32.S":"3b0de93587df778e89c19a8def5f9ac3600b731dd2f44bee85f9df9af5350428","pregenerated/armv4-mont-linux32.S":"1753245efba56ffb87abe9cc8971d55c850c017ea18ab182c275cae746331494","pregenerated/armv8-mont-ios64.S":"046966e4b03a96dfbee84eb87606010141e966860d1515cdd22dae9e413f85e3","pregenerated/armv8-mont-linux64.S":"0ef399c278a521892ea032e4acfc141c8938182cb49f6dc6014da3ecd5e245d7","pregenerated/bsaes-armv7-ios32.S":"404abf267dbe5a7c5654af6073bb2644535e4280d18bb3934665d47033c41848","pregenerated/bsaes-armv7-linux32.S":"829fc5a382da5a48deb4067fa91ebe94a34bc626f88db80b03f8a9cbf7109bff","pregenerated/chacha-armv4-ios32.S":"ba4c729adc67d7a2299ecd4c47cce27d451bc41c6c4207d31deadbbd10fb6ff3","pregenerated/chacha-armv4-linux32.S":"a3e1a500630d115cfc90146085264e52a4d353a5219bd2e5ddf29629d6e54a79","pregenerated/chacha-armv8-ios64.S":"772f02153068af213a9e62d8c8899ce3ccd42db29a660d20532fd2e12de5213c","pregenerated/chacha-armv8-linux64.S":"861c6bc4c98ee87ff878a4ddd275ffa1f813bba2aa877155b7b50af666bda509","pregenerated/chacha-x86-elf.S":"967c527546a8286b8cfc707992db8208c473835d446f98070b7c0ea78f2929d0","pregenerated/chacha-x86-macosx.S":"5e2f5071e7dcc62ab2e1ef3ccc4b2bf3d5c3645a08a31045007a0c52bc45a11a","pregenerated/chacha-x86-win32n.obj":"41da22f4f48c94402bf0b919dab7f3a09c10561c18a8ede761a8686d98e6c080","pregenerated/chacha-x86_64-elf.S":"02ae07f9de15a0cb603f22cd6c28e807bd91187aff8c74984afc33dcb45258c1","pregenerated/chacha-x86_64-macosx.S":"8267602ae4564e5748b285ba6aee2add9300c2d6cbebe498c06222634913f632","pregenerated/chacha-x86_64-nasm.obj":"69da72aeb5ff364dc8b8158dfe8e74146a4ab7f854781e073fed076f03e763fa","pregenerated/ecp_nistz256-armv4-ios32.S":"7ae6270a92c6db9a2903cc170e5ef1fa6caef3c5e714425ad4787b08acdb6956","pregenerated/ecp_nistz256-armv4-linux32.S":"3cc2210827b822d93e53f21b0c0320f7e1995fa850608d0080b406a1a3ecd901","pregenerated/ecp_nistz256-armv8-ios64.S":"a1eba8b2cb8329bb1460920ad8c11a4d39c46730cd82b8d885f2d136adb92954","pregenerated/ecp_nistz256-armv8-linux64.S":"366b8a55b901e0d994b669a8a7dd6ab83b1d13fcaa5421252a5a76597c201121","pregenerated/ecp_nistz256-x86-elf.S":"0637df02d673aa92e4edd38c46839ed6c7821cd4fc89bc02e1c508c087cd9ba2","pregenerated/ecp_nistz256-x86-macosx.S":"c38c2396d228c952e30ebb9b7251405e7880ae16440fccdaa86efc26cdb2a1dd","pregenerated/ecp_nistz256-x86-win32n.obj":"234b3df4dcf9a655641f15690be9ab15174919b558be3b6a8cd60d221335147e","pregenerated/ghash-armv4-ios32.S":"014bf7d418bb7b7e030885b32cd61877e4106928ccb6f0fd33de88ed2e465429","pregenerated/ghash-armv4-linux32.S":"2067ea82a959f0765555486421f1dc9b870f87ff63affa00a0b40155d194106c","pregenerated/ghash-x86-elf.S":"07f69a40972df42e35dbfe264cf888bdeddf12b3d67e46fcc1a0912e647fe32a","pregenerated/ghash-x86-macosx.S":"0e1bd58308d6561393e5afb73a6f60c3aeebdb65286567fcc1056f15871b4861","pregenerated/ghash-x86-win32n.obj":"a5244ea28f7e8e55eb50489599228c3e11201540d3f3ebe11e0742b8c83baff6","pregenerated/ghash-x86_64-elf.S":"35cf055b04ea70c2a1d3a2b7a317f53a24d7e0f3adbb4300b97007b3251e1b92","pregenerated/ghash-x86_64-macosx.S":"d981a50bce4855f6d75d65727c67edbfaa750c1159fda566aeb2848e5b1b55ff","pregenerated/ghash-x86_64-nasm.obj":"e1243e64e022e49d30d55ed4a0f64c1f69e9e4396267659082f2752115bcce1e","pregenerated/ghashv8-armx-ios32.S":"ec3fc65980bf87da05810ded052dda0c8e618a1f701d4e395d1e8c3bb8fd5889","pregenerated/ghashv8-armx-ios64.S":"f35ef78af951e00eb58149f76196b5adcdd43281475eba53453507456b36fc84","pregenerated/ghashv8-armx-linux32.S":"115a80523da63d40118c2b1cb5b90923e4c728a6f47a2349225c5bf5d31f077d","pregenerated/ghashv8-armx-linux64.S":"5af1f0b5ad4b2fa90513af464253ae4e085068dbc6af946a3a7f64fdbe307db8","pregenerated/p256-x86_64-asm-elf.S":"dbb349dfeb60bd7c031b5e2d3ab82a94ca8fcfeab6db0170025beff1a2ac7d67","pregenerated/p256-x86_64-asm-macosx.S":"1bed415a3f002f1fb9e0704416b317a43554e427286f92fedfd431fdd6b484c4","pregenerated/p256-x86_64-asm-nasm.obj":"3404abd25bafae4ce825f323b8b14fa768e13f35d910be5367cfe49bc7c62aa5","pregenerated/poly1305-armv4-ios32.S":"4288cd6a682a62ca6bc6fd4fa21ab2c7373c32c9005e2c7203806c29ff13586b","pregenerated/poly1305-armv4-linux32.S":"677a4a6dbc997d62e88d6951ab2a0efc9a2b253fe2c4418541cad5b347f75f5a","pregenerated/poly1305-armv8-ios64.S":"580102422eb14f37128d772150d28b4dc2d0751e5f3d250b250cac46e99dd662","pregenerated/poly1305-armv8-linux64.S":"58f0d37ecec9bbbd467f3086a318173b426155ae68a64f644b759938c956a2c9","pregenerated/poly1305-x86-elf.S":"93450ce7acb252e01414bb3b722765cdba57a9ece9414e8c89d882d339a7521e","pregenerated/poly1305-x86-macosx.S":"e80d43e8f4970e3b29f98e673d4144391a82dc480187c70effd78407b3d2fc34","pregenerated/poly1305-x86-win32n.obj":"410359eecb69de832dd49f279cb1049b13ca6cf901054fa8dab1c176a28014d5","pregenerated/poly1305-x86_64-elf.S":"6bddae35d68af8e79f7808b0120f4da4ee0925937f62f9e5f6410c32598fa464","pregenerated/poly1305-x86_64-macosx.S":"38d507b81739912a0d48c60de7023a089dad43eb86dcced6a0b87a12d1cb9c92","pregenerated/poly1305-x86_64-nasm.obj":"7e279f04063e082a97f6368cfe312ff2144366cefa84da8bfe6eeb10d80b25be","pregenerated/sha256-586-elf.S":"6597654ea92ba427e36f29c83fd3d3fbb382a404abb3e3bef71b14a3555ac137","pregenerated/sha256-586-macosx.S":"85eab88fe377adc470d04c2b0528d5f26b821788f1929008e6ac250526940c7a","pregenerated/sha256-586-win32n.obj":"097fc3ee037a72b9487f97c76e9f642497da923e83bf47f3e35706cf7b785600","pregenerated/sha256-armv4-ios32.S":"fc6c163ebaa9e4d38e1b08c41b601a92d798cff4736edac606fba9bf49e38b87","pregenerated/sha256-armv4-linux32.S":"dd793ff66f2dae5b390e3cd34893d178e0bb7f6ef18353911601f284bd1c868d","pregenerated/sha256-armv8-ios64.S":"e6cbd98d0266a53bf4858694c549efeeefcf545388d2bd342f34c24a470ea9cd","pregenerated/sha256-armv8-linux64.S":"19a5751954bd142f1d45c1773c9e61505025414829f5f0c1109cc86f3df924e8","pregenerated/sha256-x86_64-elf.S":"0c21b7659537a0fffa684f460c92c2117304b097e20701725b0309b9ed8b575a","pregenerated/sha256-x86_64-macosx.S":"f08bc11e30b778ed0ef065b60b8d0e2871fcf08fabfec375eecaf653f9e4d03a","pregenerated/sha256-x86_64-nasm.obj":"292d7bd7119a7455c13138bd7410f2ac0db58eefbf71323dad985ed85b7bdad0","pregenerated/sha512-586-elf.S":"97c5b9ac0596c58e76e6a72e4549fe00c10ba1f607103b91edd81a43016c1746","pregenerated/sha512-586-macosx.S":"ea4a8a89a4d68e5bc7e026a653b67c6e0c3539176f90705458e85e3894497aa3","pregenerated/sha512-586-win32n.obj":"0d52f08c4c88ec72b66bcd9a32403e8d5c0a73788ed3abefbff033d23e16ea51","pregenerated/sha512-armv4-ios32.S":"ef8af43bb96db4c3900c844ae3c30efa2144d8d01ceb7c9c551cc17063a4f37f","pregenerated/sha512-armv4-linux32.S":"100f3450012b3011b4f76aaf5c0c9d329d461f990e50fbefb36325da27f426c4","pregenerated/sha512-armv8-ios64.S":"727d125b1b7c6d7d9ca9022f8e22d5a81f5c5c29231cbdc8429b9e9c79f84612","pregenerated/sha512-armv8-linux64.S":"a3b012b53884f36a6a98fda1485cbbc10a4eef3815aa2fef2db48ca1ef33fb20","pregenerated/sha512-x86_64-elf.S":"6d4fc6c7ac0953fb0d5bcb8d35443e360c5333c26951c204743b80a711c50f5b","pregenerated/sha512-x86_64-macosx.S":"26694e275333099f32d854488473ca91d4eae0d7a4abb6fbe34579b4a3a8d1f8","pregenerated/sha512-x86_64-nasm.obj":"a044272b6f422f0b883acbf0b5024a18212fe375558cf900dea138f669b00942","pregenerated/tmp/aes-586-win32n.asm":"1af1558e639f10fffbacb7fe3ff9ececa365d58c310a33ed6eca26fcfc1a1f22","pregenerated/tmp/aes-x86_64-nasm.asm":"eb481cbf35144dcfda3a1ff0ec1397464480188ca676d7dfd896386b41d6fba6","pregenerated/tmp/aesni-gcm-x86_64-nasm.asm":"cbb0552dc5c461b55e188554bbfc65cc617352e412437f1b82a2cfb272ee64c9","pregenerated/tmp/aesni-x86-win32n.asm":"5f79203b4670ddf4c780960dac8854085f4aacdd2315928840ba24def950ca3e","pregenerated/tmp/aesni-x86_64-nasm.asm":"ad0b5749b28081687532dc64936c991d21b61681c418aa9069838d558a0a023a","pregenerated/tmp/chacha-x86-win32n.asm":"7518ec6d94d27670f8f0ae40842776db7b97251996ea5a15936f389191cc8a63","pregenerated/tmp/chacha-x86_64-nasm.asm":"6dd69849887d8244563b51138be45d64e96126d346191859ee0c07b50ecf3a1c","pregenerated/tmp/ecp_nistz256-x86-win32n.asm":"58d048d40696999d4be9e9423107bfca7ba32e72a8d4d688512e1206760dac85","pregenerated/tmp/ghash-x86-win32n.asm":"a05e4e986d1c13418d10e1ba58f5dfd8e2863503aac199a991981293a8e8dc08","pregenerated/tmp/ghash-x86_64-nasm.asm":"6303a2dd25cacac88f6e8bdd4ab257bdda98627419e8cbb78d7bd7450ab224fa","pregenerated/tmp/p256-x86_64-asm-nasm.asm":"e5879444025354d636b73f4bde92949e99ed451766fcc91a8d5c399d4a9de016","pregenerated/tmp/poly1305-x86-win32n.asm":"dd0a2397d15873b5f12dce1aa54205c7a0edb3aaa0be2b0f0676aa6aac6be87b","pregenerated/tmp/poly1305-x86_64-nasm.asm":"36e27b7690d658ca2977eeb5a4522766b2100410b8fad1818c94c5b2080ed956","pregenerated/tmp/sha256-586-win32n.asm":"bc24c8123100377d1141ba246f808764ab6702ab8b81e7d39776e09183b0ee2a","pregenerated/tmp/sha256-x86_64-nasm.asm":"593fb0095950fcd900c81506c75007f215ce7a6f42ecc6c0c406f0ca72567130","pregenerated/tmp/sha512-586-win32n.asm":"11ae55b1507b0f6bab9c02469b5b0fa3c28e2f0b344713042d7301bbe21e8e19","pregenerated/tmp/sha512-x86_64-nasm.asm":"2c1193ead520148b2b3daccdcf8f2eed5fca2c61f3d0816c8b3255960b065739","pregenerated/tmp/vpaes-x86-win32n.asm":"a1795a27e3549fdd69fb970ac30b9f414f6a9eac666de5995d48f7d3ac2351f8","pregenerated/tmp/vpaes-x86_64-nasm.asm":"c2e653835f0a28d99813cf6caeaf030f25fad3b23df7ab257848f33274fa25a1","pregenerated/tmp/x86-mont-win32n.asm":"a8ec86cd7fb43b7a96a817bc54b8885353974c4eca5aceab45cbdf2ad8af4133","pregenerated/tmp/x86_64-mont-nasm.asm":"a1d5a0548380eee1f618a7175821d409901862da7a8ab3adca0291285cede53a","pregenerated/tmp/x86_64-mont5-nasm.asm":"99d1ea3eebfacc3f11beb3787a526658f83735c266def879fdd8ed57022340fe","pregenerated/vpaes-x86-elf.S":"2a6e86db7140e49cbb6abe304554f1ef4383dc48c451d27cbdec96c0015f4609","pregenerated/vpaes-x86-macosx.S":"d3d44014c63249fcf020a88a7463060d033ddb3e1b1c2d08945c45bfbbe05a36","pregenerated/vpaes-x86-win32n.obj":"0cf50973daa1e899b9054f6b9c4bcbf8a548a137fa5134025be179390592f1dd","pregenerated/vpaes-x86_64-elf.S":"592174da3c8d5a79fbbb915968bd44a78701c3c04df5831ff491b3fcd3523c2e","pregenerated/vpaes-x86_64-macosx.S":"dd27dcbd3b689b3d5e5e06a408efe169cbfe6f5554a1a48f79412258b3b779c6","pregenerated/vpaes-x86_64-nasm.obj":"bdb24f9ec8a3bbe432a0edad79c67db2ca6ab81ba7ecb52b58877664c4193298","pregenerated/x86-mont-elf.S":"6d8f2899d07d94e31025af13482983fc7087bde45e3c8a237c2878a28cc54b96","pregenerated/x86-mont-macosx.S":"7d85116fc8a29c64215166fb2c44566dc7c1b31048a635605f4fd8fcbaea3459","pregenerated/x86-mont-win32n.obj":"316263efda24c2549d742354b56a2b23abe02cfa65b0ed14eec710614ec21440","pregenerated/x86_64-mont-elf.S":"67ac57ec1c335cf16580b550826f56fd7e3ccb1bd2e52a845595f9ee44c98f45","pregenerated/x86_64-mont-macosx.S":"191c8e8dc9e8dfd07f3cf9e52e8bd18a8209cf25f648ba0e1c7f724307830377","pregenerated/x86_64-mont-nasm.obj":"522c6fa22c3f7a663337175f0e380ee34e39559b675f484b8761c13e664eb5d6","pregenerated/x86_64-mont5-elf.S":"2b7d8e6f395e6dfd5b85149ebc729674c8f29f2ba82e67693042ea111c0a0c0f","pregenerated/x86_64-mont5-macosx.S":"c79f3e15ab0b1f2ee14ee8dc058031810d20ed497faba1cb10412523e809d483","pregenerated/x86_64-mont5-nasm.obj":"57a235b25afbf0d1c5b37831a326b47c122d0dc87356d4ff00632338c9b9bebf","src/aead.rs":"5664b919c2a9384704d89ac223778682928395403fe189e559350937cccb05af","src/aead/aes.rs":"c489d02902c45c694e01882a8bb7576d9bb7c4a7efcb294b358d32adb458384b","src/aead/aes_gcm.rs":"9d2b62c8a884dc81a36c278e91cddf32cac05712e786557f8e4d0005b02921ff","src/aead/aes_tests.txt":"4ae334ed8c34c0cef24c22b73568faec906a39e26a428e4cd6fe4f810cc51fb0","src/aead/block.rs":"50e29c11dc8a0713ec0705f100f52d02e80a5909c0929be9217409ed692fb994","src/aead/chacha.rs":"61d0b24e9e27551eb05598ddeac0dc979e1c5c1c7b7e888920d7cfaebab4cba1","src/aead/chacha20_poly1305.rs":"3384a06f32395255d47730f2c66a82fff30ff91bdcc7529ca4b8a5b26db590c5","src/aead/chacha20_poly1305_openssh.rs":"538789d0f7367028c9474080db000f473b6f916ab26c02783a6c335accf0a91d","src/aead/chacha_tests.txt":"6ed1303cef7a0ffa30cc76f9933509a2d952a334b80c731d52d32c6ef3b37042","src/aead/gcm.rs":"a1f25af33f8ab42b6a7833f7dcd064ca584297fbe09ac417d6d2a155514b2d0c","src/aead/nonce.rs":"3a72654293072cecceabdc2d9c29d35fe1d3b70aa9c6a9a121f85967326988e2","src/aead/poly1305.rs":"e018f035414edc2dfcaf18d1a9d67f7f3e5e16e3b54840325f8afac5dae5e09d","src/aead/poly1305_test.txt":"89be1be8e403e5a17845f0603e19337604f1f278c7b283de2c7227ef6041491f","src/aead/quic.rs":"a3fbd28960f378d8b453cf266ded1e3b7d901a90e518dfa4fe4b37125b5a33c0","src/aead/shift.rs":"13baa522a61d202f3d398af2ba508f1cdc8c173e7cc1caa725b4e81efc6b2368","src/agreement.rs":"d36109df69b5f33bebb17380ca044fdc523f41b520a8bbf96e678d9899cc922a","src/arithmetic.rs":"4154c5a049a6bc602985170a292f6f16c1728abffcbaf0cf461da228022f1f2d","src/arithmetic/montgomery.rs":"adb7d8e3bb058fcbab6911967d62cf2e2b2ffc9fa165cc8da0de984fe6eab5d2","src/bits.rs":"c59d4f351eef85ea1361c2477c76fae56896a0dd4c54178ad856f4e6b22cc5a2","src/bssl.rs":"e1c8b40f68c91da5f59b81d3d55d26822ef3bf6fc7fa2c3818cc97be0956d1f3","src/c.rs":"4c74177dd9ed4298270bcfd71355d0f41ea3bce74d3deda267c9cbf704184c49","src/constant_time.rs":"2d76e72ad06e65de8ae060607759b7b618ccdd0b4b1a94c227c9af2b402008ff","src/cpu.rs":"9685d194a8187d98ad76113d127f73eb99051088e2705bae439b3f69f78465ad","src/data/alg-rsa-encryption.der":"7bc023427767a2f2e156f8ae030d06d19f862e326b952116649b423c3ff7110e","src/debug.rs":"791483943c68a663f1cb8ca5b22ed0d2dc9af1023f2709efc1c935b830b5a898","src/digest.rs":"acba858d0baaadbcc6995700e6d08f3c98e04af99a5e373f4579e43946b743eb","src/digest/sha1.rs":"5bd500e8b688e1758c24b324985e56f70b5f0a6a7c6917cd13a6d44804884000","src/ec.rs":"c80a72f653eed85fd73cf575d1d9146d99e2b574f18da79e0596dcc4800f53be","src/ec/curve25519.rs":"9758e50247f0f325332ccf70245ce7745cbc21a01de39590e2babd6dd185451c","src/ec/curve25519/ed25519.rs":"5dcee3ebc59b65d444b162b6832a51f501c37bef8f16945c220ec7e0e157b8d5","src/ec/curve25519/ed25519/digest.rs":"6bf6c446b145d0caaf45398c4fe8574df7e974e89a9155d87d4a0798716f79a2","src/ec/curve25519/ed25519/ed25519_pkcs8_v2_template.der":"1bd2db034b5160de343688ff570db3da6a5bbfc66f9f2dd015f0902e2d2b7e34","src/ec/curve25519/ed25519/signing.rs":"3d437cac44a078353b093eab45589e7c48c13287dba647963b23203ba21ac0e2","src/ec/curve25519/ed25519/verification.rs":"457d060b4c97d6ac2442fdbd9fb4ddfe29c3ce8075567bc0e1b5ec5d1c5ac544","src/ec/curve25519/ops.rs":"e8c18066815c98c16569bd15d62d52191262b413c299aefdf2543a4ec45addf8","src/ec/curve25519/x25519.rs":"a2a63b7572e1d61e416716ec47697d77356ed1a8c63a2398b9cea7a398d7f820","src/ec/keys.rs":"8a90171fe14ba36cc1033ca8b61761f61488098e8d0f5c0b810a882859046f65","src/ec/suite_b.rs":"11507c0ddd8b67342c0868b64a723eb06ec5f106194274ac949982bb7a7f2ef5","src/ec/suite_b/curve.rs":"9ee3168fe44e427bb8862c680d9975f207ce3d7aa90dacfac5163dfc8e107ec6","src/ec/suite_b/ecdh.rs":"de9a999cf304ea4b92322eb094d43d5feba99a9167c7c46da1d78be420aa9a9c","src/ec/suite_b/ecdsa.rs":"013e0d2d2a21eb437253b03a1f6a1a4ba8c45eb1c2ea1396696bdd04a8ed2932","src/ec/suite_b/ecdsa/digest_scalar.rs":"d69e86e71b96ee40eda4a3a522b379bff71e6de5b78a24e559b2da900b3917f0","src/ec/suite_b/ecdsa/ecPublicKey_p256_pkcs8_v1_template.der":"5a2207da0199ebe3e2a80e15e7692b21f215f855ed3bd2c51f466c7969e11990","src/ec/suite_b/ecdsa/ecPublicKey_p384_pkcs8_v1_template.der":"5ec14cd6aac17cec849382ee5e2077497f98ce435d7aee2116cd092bf84f5556","src/ec/suite_b/ecdsa/ecdsa_digest_scalar_tests.txt":"7f38872c3acbd5d156783de92f3671062101af3cc496c1b261165971b3eea2ee","src/ec/suite_b/ecdsa/ecdsa_sign_asn1_tests.txt":"ab92cd110846b42d7738374d25734cff6459467f40121c4e7fda5b31bee651e2","src/ec/suite_b/ecdsa/ecdsa_sign_fixed_tests.txt":"c471d314f18270c79141062d5964d84fbe38c1bb9559ca217f3511d34fc4af25","src/ec/suite_b/ecdsa/signing.rs":"b6d566294b7431b8a4c3b4a155e9cbf2b271fd89ccbb1e054dd9959fab73ee33","src/ec/suite_b/ecdsa/verification.rs":"7381235fa8976e8a3b9676bf9a8897174f343c4a6c7a386ac5cd0cbab1a3f43e","src/ec/suite_b/ops.rs":"9cd1dd318b0804310466a5b99dcb36b8099ae49d0d5dbed3bab149cafdea69f7","src/ec/suite_b/ops/elem.rs":"15c18d85f2e8df996604ac24392ac09a27f0530bbe524f8f6a1a7e0933435d28","src/ec/suite_b/ops/p256.rs":"64d76c820bb33e62c5f7e76023f8bc2f920f5559ef17ff590cd251da2a6784ff","src/ec/suite_b/ops/p256_elem_mul_tests.txt":"02e7a991d6643a81229f462d21ea72f0503c038d783583c83ad7f118952ecf0b","src/ec/suite_b/ops/p256_elem_neg_tests.txt":"b61eb959dd473bd8edbc4566f18be0ac9f483be9e7d0900f48eb764454475807","src/ec/suite_b/ops/p256_elem_sum_tests.txt":"2fbbc13100065539bce71e83d642878a90103b5ca3d9b8d3c321db15a0c05c9e","src/ec/suite_b/ops/p256_point_double_tests.txt":"34a5968bb40320c6cc0f7d248951376823d46c0aab1fc7ba59311bc1cfd34417","src/ec/suite_b/ops/p256_point_mul_base_tests.txt":"f207084da07de3f63b7563b07994915dc770e2b7d5dfe41881b2ffe875ad69d7","src/ec/suite_b/ops/p256_point_mul_serialized_tests.txt":"f3c8061e0f891441de35e80869c253c65fea2ed1dd4f9be7a444c956211d32ae","src/ec/suite_b/ops/p256_point_mul_tests.txt":"894e02359b562f3d74757f4d8fdd20c5fc5528634f5922ce01d9546910e0b0b9","src/ec/suite_b/ops/p256_point_sum_mixed_tests.txt":"c2a178ad0371ff7dcf15364edbbb5cd0e82478d7e1037a6d3b2243204465f918","src/ec/suite_b/ops/p256_point_sum_tests.txt":"1ede1f508c673890e2f48ba53309397a17a02f13370aac114f34ea0c3c4f4617","src/ec/suite_b/ops/p256_scalar_mul_tests.txt":"6fa09fc69c9962c31f090ffc747d4cafe184429b8e0acad3adda7b14ac26a4ef","src/ec/suite_b/ops/p256_scalar_square_tests.txt":"19633fcefdf8af6685fa9750a96c17478e282972ee7ffbf4c4303229f7938db3","src/ec/suite_b/ops/p384.rs":"2441cf2a255bf24e0dcbc81ace0baf8b65c23256e57ec98d8bde4279ca031896","src/ec/suite_b/ops/p384_elem_div_by_2_tests.txt":"8c4d02994577c8b6ec3a83158fe20ce92366052ddff349b02bad4595847be8cc","src/ec/suite_b/ops/p384_elem_mul_tests.txt":"acf37680470a3574acfe64cb3629186d1f29bc8e905c5d9c1e40a2c2bde2701d","src/ec/suite_b/ops/p384_elem_neg_tests.txt":"08986c5fb0b8adfd3be6ba217ee68308c5e452dba086d92793e0ce3383c1acaa","src/ec/suite_b/ops/p384_elem_sum_tests.txt":"48850b24fca0487a875379b6de77879f97578f50111c11a12e8d789f6c8f0ab4","src/ec/suite_b/ops/p384_point_double_tests.txt":"6d25547058f40d98ef3c2a1957fb72a57f4fb19623c28dda92b42b7adc93bc9a","src/ec/suite_b/ops/p384_point_mul_base_tests.txt":"4995baf7080a6a4d72de1d262300c4ee49d0449034e1250f87bb15fadb78408f","src/ec/suite_b/ops/p384_point_mul_tests.txt":"2fa85969ab080e6f977ed92abbe29f6f5f0658e5ee126834769673ff557efbd0","src/ec/suite_b/ops/p384_point_sum_tests.txt":"5cbdf15ce4a56a952b85046e49cd0fc4ee22d516d914ab48c19b7801864bd352","src/ec/suite_b/ops/p384_scalar_mul_tests.txt":"f88e82363d7a1eb4fd687bd54dec6cb05e2796e751f39b5c774c11af0569bea5","src/ec/suite_b/private_key.rs":"a8e8d11d9390ed25a2ef9495d6f657adbff662a4c25cbd303a54a09ef632ca4e","src/ec/suite_b/public_key.rs":"9cdcb54a9431dfc04289c9298f47873a53b2ec95f11724d8ba956da009c2b31f","src/ec/suite_b/suite_b_public_key_tests.txt":"392bcb543cf69cbab5252792a8dfe09ffa3421cb27d65cdafe9771bd68d49a5d","src/endian.rs":"2432a71b890cf7d1f1e0f7fcdb418cd398c5d2753d1a85e007bc5cc24c3ab17a","src/error.rs":"8a984e5922f5c24d0b25bce3d7ba34962bedfc0afce3b061ae610fcd4547d75c","src/hkdf.rs":"8585d8cbf0af7209cb39360e0a04d9c785a86b0feb3a1a40e75e70e6e6209ac4","src/hmac.rs":"e769df52776ec61e4b835af327664c2b45aaece69633cd5e06b5f14f0e9806c2","src/hmac_generate_serializable_tests.txt":"d9fad4aa957496eb05dd67d97699631bd428de8a5be6e29aeb82b732eae97a59","src/io.rs":"05efb92ff58e8e5f47195a8b63ce460fac6193be31cd5a2cd8549b528e530e19","src/io/der.rs":"b2044554d24eb12ea386350cbc69380077220504f660aa510f49bcab899ee40f","src/io/der_writer.rs":"af1c41c0eb55266887a657a65bb731a9b04403e2e78d96cd0d376fcd7ff92902","src/io/writer.rs":"184e6954df087ace08061de72bca561ac10f94e420461a5934adf69ce8bf931e","src/lib.rs":"98309a7452a0a6ca571be61ee3709dfb54effd0468b84bd46dcd29aad06b5966","src/limb.rs":"9f6bc7487b5833ed759b6d0191b352a92e5ea66119e6f574649fb2abe20740ff","src/pbkdf2.rs":"67d19dc309626dfbc097ffbfd354203e4411040a8111405460030528ddca4db8","src/pkcs8.rs":"6d201c861ca780dc95958e0da46415389f5c56035e0ac13323b0894ba2c8061b","src/polyfill.rs":"aa9cd611f9d76bc4a66c2783883f50174f2d0898e6614221b51c252fed6dd3d9","src/polyfill/convert.rs":"61cf8e869bf2d87b225b1dc1f9b6b210bcaad5f145003c35f236de639f539e73","src/rand.rs":"3467f5223ebfc255596c5f37dd76d937b4511ad60664a45efce0806cfaccccf3","src/rsa.rs":"1e40518715c1aa20fa2cf36b1de0acecdabe5bd8f2b391ed0aefb5161b4ba95a","src/rsa/bigint.rs":"4b2fb772e31c8515c315a62aca2542285d58a126d44aa42933e3cc50e42292b1","src/rsa/bigint_elem_exp_consttime_tests.txt":"5f84de732433df1e0db3b3eb690bdb0cc1a735bdc7e60a8218d5910e9d9ac436","src/rsa/bigint_elem_exp_vartime_tests.txt":"6501c58fa66083ceb7dffe14a0191cd6a2d74a96aafeb72d828841844a37f409","src/rsa/bigint_elem_mul_tests.txt":"0de8d667f4bae0648607cff2c53df81a6b2ccddb8ee620593350255b36de0e91","src/rsa/bigint_elem_reduced_once_tests.txt":"7b4aea41259ffa329d669843d6dbf29a5ba56d845210bbf4b0a2ccafbe8d8c01","src/rsa/bigint_elem_reduced_tests.txt":"7c5dd25b495b89bab09e8f09cbbecf34aa28ee7eb2ed592bad50ab63e5b17ebe","src/rsa/bigint_elem_squared_tests.txt":"0517a5446667fd49d198a89fd93f19d9870fd3fddad3371ad9aa8075b6020e22","src/rsa/convert_nist_rsa_test_vectors.py":"c670a7d9761667c46a9b204848c74ed8cb5ba723e3f5b92b081e94e4601c55fa","src/rsa/padding.rs":"12121a579eb155b512cca4562dd59420149626b738fadc436f61d3942a23d2b5","src/rsa/rsa_pss_padding_tests.txt":"1b68a294521e983a4a35fd7ad4e5823d6173641ad63d736b3b8e6e867f748ea8","src/rsa/signature_rsa_example_private_key.der":"5344d57f719a98c4464aed1d1c2fa569f0a9de8621c6fdec7d28923a0e1c662c","src/rsa/signature_rsa_example_public_key.der":"28b0a357936485bd2a7776321cccfe17c2347f2bb75751ddf9dfc6429cacb6f1","src/rsa/signing.rs":"4a5237d5f6c9d2d48da89f594a3d325ee086663e67297f5af933589142730161","src/rsa/verification.rs":"aa1bca3691214f67125fa1e01cdf992d563b77dc0acae59bea4abffbf56245df","src/signature.rs":"4d57c953a79b9928602c2c1c0fd148003716a3fdcf77429561e19820dc0a0253","src/test.rs":"45e3503100146029952195a5515314248e5e731015757ab7b5e5400b9eb25ebf","src/test_1_syntax_error_tests.txt":"c6e72aaee3817e145fea114020193c5b3acbbd2f3a97614f1c2670822f1ac6f1","src/test_1_tests.txt":"1014aec056f9a06eb23983e61eb6dae8384ee982f4eb0c5be002fb5d6ce10f99","src/test_3_tests.txt":"e489a2da5f486e75cd6e2cf7089f09d6ddf61a8765fd58c47bc79ad32be77e13","tests/aead_aes_128_gcm_tests.txt":"2e88612cf3d767626f62d59d81652fef5611f4418bf56016c12ac0bc26a12a20","tests/aead_aes_256_gcm_tests.txt":"c21fab30c0098cddef658908ca2820d656c4717d24d79ef3dd68251695972040","tests/aead_chacha20_poly1305_openssh_tests.txt":"85a012f4b6bc9b7ca5af861179ce832ea93e4a175b604be781bd1fdd9accc24e","tests/aead_chacha20_poly1305_tests.txt":"3688abbd7b1d87c9200b627c289a2bebf763f512baadf536cd72cc8f3ce80fe5","tests/aead_tests.rs":"5f7804c81338d50959d2c0f2f2dff647437d18bcd56ec1c7170abe264467d938","tests/agreement_tests.rs":"a7cf8bb3628ee81b978ef074852b0d947dff98afafa8d317777bc7183b563928","tests/agreement_tests.txt":"4b784d203e87f9de0678df00ac1b2a28db169f680a3333e9d773656fcebceea9","tests/digest_tests.rs":"0385f3d62ea368828d6d4f71765e744034de25a651f9c99528d7650e81a40d22","tests/digest_tests.txt":"dd817794e2ba72ed637805e225240a295ae7b4cbea956dcd23c4752da67a394c","tests/ecdsa_from_pkcs8_tests.txt":"8880710ed78fea954b23f7adda6189b599307f22ba5c24b44f8ca9f00e9bbb6c","tests/ecdsa_test_private_key_p256.p8":"d56f99994233d749d03315f5cb9797fad81d3e25f962d2cd543d4dfe7cdd1389","tests/ecdsa_test_public_key_p256.der":"93c930878dc29d802b151bf492a2f00672b2240b740002a650ccb706664d10c9","tests/ecdsa_test_public_key_p256_debug.txt":"ccce94ab37a5e5286f0e5f1934bdeb39539e8f72bc7ccd0a1f666c9a1abc0bdb","tests/ecdsa_tests.rs":"f08d743a6d901c2ebd3005b9d297c267fa308ea678403bcfd23651df87d2e81d","tests/ecdsa_verify_asn1_tests.txt":"4ae6325e0a1fdf4cd6fd2f299a7fb7a60927d0775b63aa9b027676fa76f3ee6d","tests/ecdsa_verify_fixed_tests.txt":"837f116fca066cb181677e389cf92b684d15ed883189b4544538cb5387e6b742","tests/ed25519_from_pkcs8_tests.txt":"4312701b6fbc57992598a4db50b0bf9bcc1df91004901f43e30982ba85d9d466","tests/ed25519_from_pkcs8_unchecked_tests.txt":"e2a7a54c8ea31b87bb5357a002f6f4c11b50ad5050681aaed91a375ef58c239b","tests/ed25519_test_private_key.bin":"644d50ab64864c20a12b3c4656d46b4a48f69ef7c47ecdc8415cd28316b22ef5","tests/ed25519_test_private_key.p8":"13e11da834fecc6aed04d8ff36a0301a5fb8187c86f5ab0f9cde434eda6762fe","tests/ed25519_test_public_key.bin":"21fe31dfa154a261626bf854046fd2271b7bed4b6abe45aa58877ef47f9721b9","tests/ed25519_test_public_key.der":"119e5ed7b8533bdf24897f07fe4dd57671a64f8d10534ba128c9bb016af86484","tests/ed25519_tests.rs":"555756ed48e5f4d6662f89b398d1b97a5b4bddf8e9e5479961e15468d48318b6","tests/ed25519_tests.txt":"f99c7e7bf7cbbd7df936ca883ca0cb293c31ad37c03597890fdb07dc1c923d36","tests/hkdf_tests.rs":"533e99caa17d466ea664f61a5d77fe3cf1e0a0dc2e09633f710686dcf8e66f8a","tests/hkdf_tests.txt":"516a19799fa940c72dca68d8cc92ec605b46aa71590cf1b827468a58a01da574","tests/hmac_tests.rs":"e478ba32daa0a47652515e31fbc37877fcc29c4ce3e78f254684b848c869eec2","tests/hmac_tests.txt":"272c143921789a66d39396843c2fa0aadbdfe26d061bd2b7836ec40dfc76e09e","tests/pbkdf2_tests.rs":"37f10f2121d9e5811b3255e8c7e53fb5f3c09f3f2caa9bf12e7af308f287ae21","tests/pbkdf2_tests.txt":"db65f42fb72cec9ca89c8c071d11c341f67c4df5e0c66a70735da5d1d370cee3","tests/quic_aes_128_tests.txt":"786f989f301ca97b17e3a62e1dd5d9562baf0f3081f59de5e34fcc4d9e8d9580","tests/quic_aes_256_tests.txt":"63540293d9b95e67aa9cdb7effdb5d40f977ec6a527490ce7b32592debac0428","tests/quic_chacha20_tests.txt":"b0c2abc90ecbb0146fa812c33641ad643380189429bb9e7c7db1b32d3363c67a","tests/quic_tests.rs":"e343eb1b8409c0364d3aa3f32f86f4eed7dec54839f179b0561a15dccbd7c39d","tests/rsa_from_pkcs8_tests.txt":"2ccd777cc8014904bb98de0462ee220c0a641f88d67aac489cff0742c9a1bc9f","tests/rsa_pkcs1_sign_tests.txt":"cb202666f2ed100a0ba8ebf818dab1bece055bd9ac9d5533d3f20fdad7b4c509","tests/rsa_pkcs1_verify_tests.txt":"ed8a330181e8a47cc707238e80377a8bd4002f6f8f6d06106c78aa9b59da98cb","tests/rsa_primitive_verify_tests.txt":"68c90857490543bcfb836f3b8644445acfe90a2e4c5189310914ce5484927418","tests/rsa_pss_sign_tests.txt":"aca70cfc877b055c0a29da2a457563cd1b5afe6e932b011e8b9a15d57dbe10d0","tests/rsa_pss_verify_tests.txt":"afcde20cea975ea235d9828bbb9b083f77584a7cb8c5c955e40c4bd305573f4a","tests/rsa_test_private_key_2048.p8":"a0d95a0b133b4c217bc11322b67d62eb13537b8a9f66e20b5c9b5ac31af21859","tests/rsa_test_public_key_2048.der":"7180acb59312d3544c3b36975ae6c4c55f59035ce4de487852cf6c99b33868cd","tests/rsa_test_public_key_2048_debug.txt":"dc471e4ca8c1ef4b57d2ce79c9b9ba25ab9e262ed63a24d2b65cb2d2f3797ffd","tests/rsa_tests.rs":"344675830bf2dbc67e3cbfc335f784d39a7487c2056b3617dfd98a51dc707ba2","tests/signature_tests.rs":"b6e2d33cc5907f2a57397090b749daa3a99157d9568e7153a67c7b9c6ebe1d84","third_party/NIST/SHAVS/SHA1LongMsg.rsp":"c765dbc1609e9046b12f60a5285a88128dab4315080c94ce9f2a57a7b0b980be","third_party/NIST/SHAVS/SHA1Monte.rsp":"d458fa7e39095b4e292a75b0cd224f90b72dc801a63ad2c0d75b8f10d745ab6d","third_party/NIST/SHAVS/SHA1ShortMsg.rsp":"be0991ddc5372932d55804b11713c9140d10435ef4b316a0773e3506eec79cda","third_party/NIST/SHAVS/SHA224LongMsg.rsp":"d37115e5d2286dde969c5e1b2275cd83ecb066366d7a38bb6b2b3adb4a88de89","third_party/NIST/SHAVS/SHA224Monte.rsp":"7854d388666ea3eb01bdaca37dc8ae0bc39d30f8731d9a5487cbd61de47d1d59","third_party/NIST/SHAVS/SHA224ShortMsg.rsp":"0dad6656c08f77252f6ccb789e42284fd61fc53bba30e83162800aa3d2aa939f","third_party/NIST/SHAVS/SHA256LongMsg.rsp":"6fac36f37360bcf74ffcf4465c18e30d6d5a04cc90885b901fc3130c16060974","third_party/NIST/SHAVS/SHA256Monte.rsp":"29ea30c6bb4b84e425fb8c1d731c6bb852dac935825f2bd1143e5d3c4f10bfb9","third_party/NIST/SHAVS/SHA256ShortMsg.rsp":"75e1cb83994638481808e225b9eb0c1ebd0c232d952ac42b61abce6363be283c","third_party/NIST/SHAVS/SHA384LongMsg.rsp":"536171765a4278c000ac3c9913edb2eed0ca7ccd5a10b72ed79fdfe7901a6d6a","third_party/NIST/SHAVS/SHA384Monte.rsp":"4270099431ff52ee1686dc472351e681c26c507433df8f107c7de203b771424e","third_party/NIST/SHAVS/SHA384ShortMsg.rsp":"7ea7bcf00fadc20949fae63703e40681ddf288fea808471cb3cbc95f3ec16811","third_party/NIST/SHAVS/SHA512LongMsg.rsp":"b1f3f05d5c209777954d49521d7ea1349447c36a0c52849e044bc397a27dd410","third_party/NIST/SHAVS/SHA512Monte.rsp":"8ca78659286c2f01667a98fc7accd32fc171ae7b24ac00f1a8ce6b77770247fa","third_party/NIST/SHAVS/SHA512ShortMsg.rsp":"e53a36c03609e5a3e3cc4b6e117a499db7864c23ec825c6cec99503a45f40764","third_party/fiat/LICENSE":"0c125a4dab5ab869473e6491db22f6c0a7f8a4de58588d03bb2b16c0c8ebd7de","third_party/fiat/curve25519.c":"4aa9c3946bc961591a797f44c4d6b62ee8b03998275fbdf075b240773f581ced","third_party/fiat/curve25519_tables.h":"668f3615a9cac425b96619b46de44631976e167f0cfc842ab87844dcd8a5c529","third_party/fiat/internal.h":"cfe41b40e51ca477eda94d07dd521fbb5d3389e77d94a55b058bf60efa0d2aa8","third_party/fiat/make_curve25519_tables.py":"c499f166e8df31f23cf00296b46f7634aaacbb0f48f5bfa0277c27bdf89a619d"},"package":"be5386a5f59e5f5bcaea38b50ad26c09e3918a0abc0610640b3be5cfd85d6894"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/ring/Cargo.toml b/rustc_deps/vendor/ring/Cargo.toml
index 2721b93..60a90ee 100644
--- a/rustc_deps/vendor/ring/Cargo.toml
+++ b/rustc_deps/vendor/ring/Cargo.toml
@@ -11,13 +11,14 @@
 # will likely look very different (and much more reasonable)
 
 [package]
+edition = "2018"
 name = "ring"
-version = "0.13.5"
+version = "0.14.3"
 authors = ["Brian Smith <brian@briansmith.org>"]
 build = "build.rs"
 links = "ring-asm"
 exclude = [".gitignore", "pregenerated/tmp"]
-include = ["LICENSE", "Cargo.toml", "pregenerated/*", "build.rs", "crypto/chacha/asm/chacha-armv4.pl", "crypto/chacha/asm/chacha-armv8.pl", "crypto/chacha/asm/chacha-x86.pl", "crypto/chacha/asm/chacha-x86_64.pl", "crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl", "crypto/cipher_extra/e_aesgcmsiv.c", "crypto/cipher_extra/test/aes_128_gcm_siv_tests.txt", "crypto/cipher_extra/test/aes_256_gcm_siv_tests.txt", "crypto/constant_time_test.c", "crypto/cpu-aarch64-linux.c", "crypto/cpu-arm-linux.c", "crypto/cpu-arm.c", "crypto/cpu-intel.c", "crypto/crypto.c", "crypto/curve25519/asm/x25519-asm-arm.S", "crypto/fipsmodule/aes/aes.c", "crypto/fipsmodule/aes/asm/aes-586.pl", "crypto/fipsmodule/aes/asm/aes-armv4.pl", "crypto/fipsmodule/aes/asm/aes-x86_64.pl", "crypto/fipsmodule/aes/asm/aesni-x86.pl", "crypto/fipsmodule/aes/asm/aesni-x86_64.pl", "crypto/fipsmodule/aes/asm/aesv8-armx.pl", "crypto/fipsmodule/aes/asm/bsaes-armv7.pl", "crypto/fipsmodule/aes/asm/bsaes-x86_64.pl", "crypto/fipsmodule/aes/asm/vpaes-x86.pl", "crypto/fipsmodule/aes/asm/vpaes-x86_64.pl", "crypto/fipsmodule/aes/internal.h", "crypto/fipsmodule/bn/asm/armv4-mont.pl", "crypto/fipsmodule/bn/asm/armv8-mont.pl", "crypto/fipsmodule/bn/asm/x86-mont.pl", "crypto/fipsmodule/bn/asm/x86_64-mont.pl", "crypto/fipsmodule/bn/asm/x86_64-mont5.pl", "crypto/fipsmodule/bn/exponentiation.c", "crypto/fipsmodule/bn/generic.c", "crypto/fipsmodule/bn/internal.h", "crypto/fipsmodule/bn/montgomery.c", "crypto/fipsmodule/bn/montgomery_inv.c", "crypto/fipsmodule/bn/shift.c", "crypto/fipsmodule/cipher/e_aes.c", "crypto/fipsmodule/cipher/internal.h", "crypto/fipsmodule/ec/asm/ecp_nistz256-armv4.pl", "crypto/fipsmodule/ec/asm/ecp_nistz256-armv8.pl", "crypto/fipsmodule/ec/asm/ecp_nistz256-x86.pl", "crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl", "crypto/fipsmodule/ec/ecp_nistz.c", "crypto/fipsmodule/ec/ecp_nistz.h", "crypto/fipsmodule/ec/ecp_nistz256.c", "crypto/fipsmodule/ec/ecp_nistz256.h", "crypto/fipsmodule/ec/ecp_nistz256_table.inl", "crypto/fipsmodule/ec/ecp_nistz384.h", "crypto/fipsmodule/ec/ecp_nistz384.inl", "crypto/fipsmodule/ec/gfp_p256.c", "crypto/fipsmodule/ec/gfp_p384.c", "crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl", "crypto/fipsmodule/modes/asm/ghash-armv4.pl", "crypto/fipsmodule/modes/asm/ghash-x86.pl", "crypto/fipsmodule/modes/asm/ghash-x86_64.pl", "crypto/fipsmodule/modes/asm/ghashv8-armx.pl", "crypto/fipsmodule/modes/gcm.c", "crypto/fipsmodule/modes/internal.h", "crypto/fipsmodule/sha/asm/sha256-586.pl", "crypto/fipsmodule/sha/asm/sha256-armv4.pl", "crypto/fipsmodule/sha/asm/sha512-586.pl", "crypto/fipsmodule/sha/asm/sha512-armv4.pl", "crypto/fipsmodule/sha/asm/sha512-armv8.pl", "crypto/fipsmodule/sha/asm/sha512-x86_64.pl", "crypto/internal.h", "crypto/limbs/limbs.c", "crypto/limbs/limbs.h", "crypto/limbs/limbs.inl", "crypto/mem.c", "crypto/perlasm/arm-xlate.pl", "crypto/perlasm/x86asm.pl", "crypto/perlasm/x86gas.pl", "crypto/perlasm/x86nasm.pl", "crypto/perlasm/x86_64-xlate.pl", "crypto/poly1305/asm/poly1305-armv4.pl", "crypto/poly1305/asm/poly1305-armv8.pl", "crypto/poly1305/asm/poly1305-x86.pl", "crypto/poly1305/asm/poly1305-x86_64.pl", "examples/checkdigest.rs", "include/GFp/aes.h", "include/GFp/arm_arch.h", "include/GFp/base.h", "include/GFp/cpu.h", "include/GFp/mem.h", "include/GFp/type_check.h", "src/aead/aes_gcm.rs", "src/aead/aes_tests.txt", "src/aead/chacha20_poly1305.rs", "src/aead/chacha20_poly1305_openssh.rs", "src/aead/mod.rs", "src/agreement.rs", "src/arithmetic/mod.rs", "src/arithmetic/montgomery.rs", "src/bits.rs", "src/bssl.rs", "src/c.rs", "src/chacha.rs", "src/chacha_tests.txt", "src/constant_time.rs", "src/data/alg-rsa-encryption.der", "src/debug.rs", "src/der.rs", "src/digest/mod.rs", "src/digest/sha1.rs", "src/ec/curve25519/ed25519/digest.rs", "src/ec/curve25519/ed25519/mod.rs", "src/ec/curve25519/ed25519/signing.rs", "src/ec/curve25519/ed25519/verification.rs", "src/ec/curve25519/ed25519/ed25519_pkcs8_v2_template.der", "src/ec/curve25519/mod.rs", "src/ec/curve25519/ops.rs", "src/ec/curve25519/x25519.rs", "src/ec/mod.rs", "src/ec/suite_b/curve.rs", "src/ec/suite_b/ecdh.rs", "src/ec/suite_b/ecdsa/digest_scalar.rs", "src/ec/suite_b/ecdsa/mod.rs", "src/ec/suite_b/ecdsa/signing.rs", "src/ec/suite_b/ecdsa/verification.rs", "src/ec/suite_b/ecdsa/ecdsa_digest_scalar_tests.txt", "src/ec/suite_b/ecdsa/ecPublicKey_p256_pkcs8_v1_template.der", "src/ec/suite_b/ecdsa/ecPublicKey_p384_pkcs8_v1_template.der", "src/ec/suite_b/ecdsa/ecdsa_sign_asn1_tests.txt", "src/ec/suite_b/ecdsa/ecdsa_sign_fixed_tests.txt", "src/ec/suite_b/mod.rs", "src/ec/suite_b/ops/elem.rs", "src/ec/suite_b/ops/mod.rs", "src/ec/suite_b/ops/p256.rs", "src/ec/suite_b/ops/p256_elem_mul_tests.txt", "src/ec/suite_b/ops/p256_elem_neg_tests.txt", "src/ec/suite_b/ops/p256_elem_sum_tests.txt", "src/ec/suite_b/ops/p256_point_double_tests.txt", "src/ec/suite_b/ops/p256_point_mul_base_tests.txt", "src/ec/suite_b/ops/p256_point_mul_serialized_tests.txt", "src/ec/suite_b/ops/p256_point_mul_tests.txt", "src/ec/suite_b/ops/p256_point_sum_mixed_tests.txt", "src/ec/suite_b/ops/p256_point_sum_tests.txt", "src/ec/suite_b/ops/p256_scalar_mul_tests.txt", "src/ec/suite_b/ops/p256_scalar_square_tests.txt", "src/ec/suite_b/ops/p384.rs", "src/ec/suite_b/ops/p384_elem_div_by_2_tests.txt", "src/ec/suite_b/ops/p384_elem_mul_tests.txt", "src/ec/suite_b/ops/p384_elem_neg_tests.txt", "src/ec/suite_b/ops/p384_elem_sum_tests.txt", "src/ec/suite_b/ops/p384_point_double_tests.txt", "src/ec/suite_b/ops/p384_point_mul_base_tests.txt", "src/ec/suite_b/ops/p384_point_mul_tests.txt", "src/ec/suite_b/ops/p384_point_sum_tests.txt", "src/ec/suite_b/ops/p384_scalar_mul_tests.txt", "src/ec/suite_b/private_key.rs", "src/ec/suite_b/public_key.rs", "src/ec/suite_b/suite_b_public_key_tests.txt", "src/error.rs", "src/hkdf.rs", "src/hmac.rs", "src/hmac_generate_serializable_tests.txt", "src/init.rs", "src/lib.rs", "src/limb.rs", "src/pbkdf2.rs", "src/pkcs8.rs", "src/poly1305.rs", "src/poly1305_test.txt", "src/polyfill.rs", "src/rand.rs", "src/rsa/bigint.rs", "src/rsa/bigint_elem_exp_consttime_tests.txt", "src/rsa/bigint_elem_exp_vartime_tests.txt", "src/rsa/bigint_elem_mul_tests.txt", "src/rsa/bigint_elem_reduced_once_tests.txt", "src/rsa/bigint_elem_reduced_tests.txt", "src/rsa/bigint_elem_squared_tests.txt", "src/rsa/convert_nist_rsa_test_vectors.py", "src/rsa/mod.rs", "src/rsa/padding.rs", "src/rsa/random.rs", "src/rsa/rsa_pss_padding_tests.txt", "src/rsa/signature_rsa_example_private_key.der", "src/rsa/signature_rsa_example_public_key.der", "src/rsa/signing.rs", "src/rsa/verification.rs", "src/signature.rs", "src/signature_impl.rs", "src/test.rs", "src/test_1_syntax_error_tests.txt", "src/test_1_tests.txt", "src/test_3_tests.txt", "tests/aead_aes_128_gcm_tests.txt", "tests/aead_aes_256_gcm_tests.txt", "tests/aead_chacha20_poly1305_tests.txt", "tests/aead_tests.rs", "tests/agreement_tests.rs", "tests/agreement_tests.txt", "tests/digest_tests.rs", "tests/digest_tests.txt", "tests/ecdsa_from_pkcs8_tests.txt", "tests/ecdsa_tests.rs", "tests/ecdsa_sign_asn1_tests.txt", "tests/ecdsa_sign_fixed_tests.txt", "tests/ecdsa_verify_asn1_tests.txt", "tests/ecdsa_verify_fixed_tests.txt", "tests/ed25519_from_pkcs8_tests.txt", "tests/ed25519_from_pkcs8_unchecked_tests.txt", "tests/ed25519_tests.rs", "tests/ed25519_tests.txt", "tests/ed25519_test_private_key.bin", "tests/ed25519_test_public_key.bin", "tests/hkdf_tests.rs", "tests/hkdf_tests.txt", "tests/hmac_tests.rs", "tests/hmac_tests.txt", "tests/pbkdf2_tests.rs", "tests/pbkdf2_tests.txt", "tests/rsa_from_pkcs8_tests.txt", "tests/rsa_pkcs1_sign_tests.txt", "tests/rsa_pkcs1_verify_tests.txt", "tests/rsa_primitive_verify_tests.txt", "tests/rsa_pss_sign_tests.txt", "tests/rsa_pss_verify_tests.txt", "tests/rsa_tests.rs", "tests/signature_tests.rs", "third_party/fiat/curve25519.c", "third_party/fiat/curve25519_tables.h", "third_party/fiat/internal.h", "third_party/fiat/LICENSE", "third_party/fiat/make_curve25519_tables.py", "third_party/NIST/SHAVS/SHA1LongMsg.rsp", "third_party/NIST/SHAVS/SHA1Monte.rsp", "third_party/NIST/SHAVS/SHA1ShortMsg.rsp", "third_party/NIST/SHAVS/SHA224LongMsg.rsp", "third_party/NIST/SHAVS/SHA224Monte.rsp", "third_party/NIST/SHAVS/SHA224ShortMsg.rsp", "third_party/NIST/SHAVS/SHA256LongMsg.rsp", "third_party/NIST/SHAVS/SHA256Monte.rsp", "third_party/NIST/SHAVS/SHA256ShortMsg.rsp", "third_party/NIST/SHAVS/SHA384LongMsg.rsp", "third_party/NIST/SHAVS/SHA384Monte.rsp", "third_party/NIST/SHAVS/SHA384ShortMsg.rsp", "third_party/NIST/SHAVS/SHA512LongMsg.rsp", "third_party/NIST/SHAVS/SHA512Monte.rsp", "third_party/NIST/SHAVS/SHA512ShortMsg.rsp"]
+include = ["LICENSE", "Cargo.toml", "pregenerated/*", "build.rs", "crypto/block.c", "crypto/block.h", "crypto/chacha/asm/chacha-armv4.pl", "crypto/chacha/asm/chacha-armv8.pl", "crypto/chacha/asm/chacha-x86.pl", "crypto/chacha/asm/chacha-x86_64.pl", "crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl", "crypto/cipher_extra/test/aes_128_gcm_siv_tests.txt", "crypto/cipher_extra/test/aes_256_gcm_siv_tests.txt", "crypto/constant_time_test.c", "crypto/cpu-aarch64-linux.c", "crypto/cpu-arm-linux.c", "crypto/cpu-arm.c", "crypto/cpu-intel.c", "crypto/crypto.c", "crypto/curve25519/asm/x25519-asm-arm.S", "crypto/fipsmodule/aes/aes.c", "crypto/fipsmodule/aes/asm/aes-586.pl", "crypto/fipsmodule/aes/asm/aes-armv4.pl", "crypto/fipsmodule/aes/asm/aes-x86_64.pl", "crypto/fipsmodule/aes/asm/aesni-x86.pl", "crypto/fipsmodule/aes/asm/aesni-x86_64.pl", "crypto/fipsmodule/aes/asm/aesv8-armx.pl", "crypto/fipsmodule/aes/asm/bsaes-armv7.pl", "crypto/fipsmodule/aes/asm/bsaes-x86_64.pl", "crypto/fipsmodule/aes/asm/vpaes-x86.pl", "crypto/fipsmodule/aes/asm/vpaes-x86_64.pl", "crypto/fipsmodule/aes/internal.h", "crypto/fipsmodule/bn/asm/armv4-mont.pl", "crypto/fipsmodule/bn/asm/armv8-mont.pl", "crypto/fipsmodule/bn/asm/x86-mont.pl", "crypto/fipsmodule/bn/asm/x86_64-mont.pl", "crypto/fipsmodule/bn/asm/x86_64-mont5.pl", "crypto/fipsmodule/bn/generic.c", "crypto/fipsmodule/bn/internal.h", "crypto/fipsmodule/bn/montgomery.c", "crypto/fipsmodule/bn/montgomery_inv.c", "crypto/fipsmodule/cipher/e_aes.c", "crypto/fipsmodule/ec/asm/ecp_nistz256-armv4.pl", "crypto/fipsmodule/ec/asm/ecp_nistz256-armv8.pl", "crypto/fipsmodule/ec/asm/ecp_nistz256-x86.pl", "crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl", "crypto/fipsmodule/ec/ecp_nistz.c", "crypto/fipsmodule/ec/ecp_nistz.h", "crypto/fipsmodule/ec/ecp_nistz256.c", "crypto/fipsmodule/ec/ecp_nistz256.h", "crypto/fipsmodule/ec/ecp_nistz256_table.inl", "crypto/fipsmodule/ec/ecp_nistz384.h", "crypto/fipsmodule/ec/ecp_nistz384.inl", "crypto/fipsmodule/ec/gfp_p256.c", "crypto/fipsmodule/ec/gfp_p384.c", "crypto/fipsmodule/ecdsa/ecdsa_verify_tests.txt", "crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl", "crypto/fipsmodule/modes/asm/ghash-armv4.pl", "crypto/fipsmodule/modes/asm/ghash-x86.pl", "crypto/fipsmodule/modes/asm/ghash-x86_64.pl", "crypto/fipsmodule/modes/asm/ghashv8-armx.pl", "crypto/fipsmodule/modes/gcm.c", "crypto/fipsmodule/modes/internal.h", "crypto/fipsmodule/sha/asm/sha256-586.pl", "crypto/fipsmodule/sha/asm/sha256-armv4.pl", "crypto/fipsmodule/sha/asm/sha512-586.pl", "crypto/fipsmodule/sha/asm/sha512-armv4.pl", "crypto/fipsmodule/sha/asm/sha512-armv8.pl", "crypto/fipsmodule/sha/asm/sha512-x86_64.pl", "crypto/internal.h", "crypto/limbs/limbs.c", "crypto/limbs/limbs.h", "crypto/limbs/limbs.inl", "crypto/mem.c", "crypto/perlasm/arm-xlate.pl", "crypto/perlasm/x86asm.pl", "crypto/perlasm/x86gas.pl", "crypto/perlasm/x86nasm.pl", "crypto/perlasm/x86_64-xlate.pl", "crypto/poly1305/asm/poly1305-armv4.pl", "crypto/poly1305/asm/poly1305-armv8.pl", "crypto/poly1305/asm/poly1305-x86.pl", "crypto/poly1305/asm/poly1305-x86_64.pl", "examples/checkdigest.rs", "include/GFp/aes.h", "include/GFp/arm_arch.h", "include/GFp/base.h", "include/GFp/cpu.h", "include/GFp/mem.h", "include/GFp/type_check.h", "src/aead.rs", "src/aead/aes.rs", "src/aead/aes_gcm.rs", "src/aead/aes_tests.txt", "src/aead/block.rs", "src/aead/chacha.rs", "src/aead/chacha_tests.txt", "src/aead/chacha20_poly1305.rs", "src/aead/chacha20_poly1305_openssh.rs", "src/aead/gcm.rs", "src/aead/nonce.rs", "src/aead/poly1305.rs", "src/aead/poly1305_test.txt", "src/aead/quic.rs", "src/aead/shift.rs", "src/agreement.rs", "src/arithmetic.rs", "src/arithmetic/montgomery.rs", "src/array.rs", "src/bits.rs", "src/bssl.rs", "src/c.rs", "src/constant_time.rs", "src/cpu.rs", "src/data/alg-rsa-encryption.der", "src/debug.rs", "src/digest.rs", "src/digest/sha1.rs", "src/ec/curve25519/ed25519/digest.rs", "src/ec/curve25519/ed25519.rs", "src/ec/curve25519/ed25519/signing.rs", "src/ec/curve25519/ed25519/verification.rs", "src/ec/curve25519/ed25519/ed25519_pkcs8_v2_template.der", "src/ec/curve25519.rs", "src/ec/curve25519/ops.rs", "src/ec/curve25519/x25519.rs", "src/ec.rs", "src/ec/keys.rs", "src/ec/suite_b/curve.rs", "src/ec/suite_b/ecdh.rs", "src/ec/suite_b/ecdsa/digest_scalar.rs", "src/ec/suite_b/ecdsa.rs", "src/ec/suite_b/ecdsa/signing.rs", "src/ec/suite_b/ecdsa/verification.rs", "src/ec/suite_b/ecdsa/ecdsa_digest_scalar_tests.txt", "src/ec/suite_b/ecdsa/ecPublicKey_p256_pkcs8_v1_template.der", "src/ec/suite_b/ecdsa/ecPublicKey_p384_pkcs8_v1_template.der", "src/ec/suite_b/ecdsa/ecdsa_sign_asn1_tests.txt", "src/ec/suite_b/ecdsa/ecdsa_sign_fixed_tests.txt", "src/ec/suite_b.rs", "src/ec/suite_b/ops/elem.rs", "src/ec/suite_b/ops.rs", "src/ec/suite_b/ops/p256.rs", "src/ec/suite_b/ops/p256_elem_mul_tests.txt", "src/ec/suite_b/ops/p256_elem_neg_tests.txt", "src/ec/suite_b/ops/p256_elem_sum_tests.txt", "src/ec/suite_b/ops/p256_point_double_tests.txt", "src/ec/suite_b/ops/p256_point_mul_base_tests.txt", "src/ec/suite_b/ops/p256_point_mul_serialized_tests.txt", "src/ec/suite_b/ops/p256_point_mul_tests.txt", "src/ec/suite_b/ops/p256_point_sum_mixed_tests.txt", "src/ec/suite_b/ops/p256_point_sum_tests.txt", "src/ec/suite_b/ops/p256_scalar_mul_tests.txt", "src/ec/suite_b/ops/p256_scalar_square_tests.txt", "src/ec/suite_b/ops/p384.rs", "src/ec/suite_b/ops/p384_elem_div_by_2_tests.txt", "src/ec/suite_b/ops/p384_elem_mul_tests.txt", "src/ec/suite_b/ops/p384_elem_neg_tests.txt", "src/ec/suite_b/ops/p384_elem_sum_tests.txt", "src/ec/suite_b/ops/p384_point_double_tests.txt", "src/ec/suite_b/ops/p384_point_mul_base_tests.txt", "src/ec/suite_b/ops/p384_point_mul_tests.txt", "src/ec/suite_b/ops/p384_point_sum_tests.txt", "src/ec/suite_b/ops/p384_scalar_mul_tests.txt", "src/ec/suite_b/private_key.rs", "src/ec/suite_b/public_key.rs", "src/ec/suite_b/suite_b_public_key_tests.txt", "src/endian.rs", "src/error.rs", "src/hkdf.rs", "src/hmac.rs", "src/hmac_generate_serializable_tests.txt", "src/io.rs", "src/io/der.rs", "src/io/der_writer.rs", "src/io/writer.rs", "src/lib.rs", "src/limb.rs", "src/endian.rs", "src/pbkdf2.rs", "src/pkcs8.rs", "src/polyfill.rs", "src/polyfill/convert.rs", "src/rand.rs", "src/rsa/bigint.rs", "src/rsa/bigint_elem_exp_consttime_tests.txt", "src/rsa/bigint_elem_exp_vartime_tests.txt", "src/rsa/bigint_elem_mul_tests.txt", "src/rsa/bigint_elem_reduced_once_tests.txt", "src/rsa/bigint_elem_reduced_tests.txt", "src/rsa/bigint_elem_squared_tests.txt", "src/rsa/convert_nist_rsa_test_vectors.py", "src/rsa.rs", "src/rsa/padding.rs", "src/rsa/random.rs", "src/rsa/rsa_pss_padding_tests.txt", "src/rsa/signature_rsa_example_private_key.der", "src/rsa/signature_rsa_example_public_key.der", "src/rsa/signing.rs", "src/rsa/verification.rs", "src/signature.rs", "src/test.rs", "src/test_1_syntax_error_tests.txt", "src/test_1_tests.txt", "src/test_3_tests.txt", "tests/aead_aes_128_gcm_tests.txt", "tests/aead_aes_256_gcm_tests.txt", "tests/aead_chacha20_poly1305_tests.txt", "tests/aead_chacha20_poly1305_openssh_tests.txt", "tests/aead_tests.rs", "tests/agreement_tests.rs", "tests/agreement_tests.txt", "tests/digest_tests.rs", "tests/digest_tests.txt", "tests/ecdsa_from_pkcs8_tests.txt", "tests/ecdsa_tests.rs", "tests/ecdsa_test_private_key_p256.p8", "tests/ecdsa_test_public_key_p256.der", "tests/ecdsa_test_public_key_p256_debug.txt", "tests/ecdsa_sign_asn1_tests.txt", "tests/ecdsa_sign_fixed_tests.txt", "tests/ecdsa_verify_asn1_tests.txt", "tests/ecdsa_verify_fixed_tests.txt", "tests/ed25519_from_pkcs8_tests.txt", "tests/ed25519_from_pkcs8_unchecked_tests.txt", "tests/ed25519_tests.rs", "tests/ed25519_tests.txt", "tests/ed25519_test_private_key.bin", "tests/ed25519_test_private_key.p8", "tests/ed25519_test_public_key.bin", "tests/ed25519_test_public_key.der", "tests/hkdf_tests.rs", "tests/hkdf_tests.txt", "tests/hmac_tests.rs", "tests/hmac_tests.txt", "tests/pbkdf2_tests.rs", "tests/pbkdf2_tests.txt", "tests/quic_aes_128_tests.txt", "tests/quic_aes_256_tests.txt", "tests/quic_chacha20_tests.txt", "tests/quic_tests.rs", "tests/rsa_from_pkcs8_tests.txt", "tests/rsa_pkcs1_sign_tests.txt", "tests/rsa_pkcs1_verify_tests.txt", "tests/rsa_primitive_verify_tests.txt", "tests/rsa_pss_sign_tests.txt", "tests/rsa_pss_verify_tests.txt", "tests/rsa_tests.rs", "tests/rsa_test_private_key_2048.p8", "tests/rsa_test_public_key_2048.der", "tests/rsa_test_public_key_2048_debug.txt", "tests/signature_tests.rs", "third_party/fiat/curve25519.c", "third_party/fiat/curve25519_tables.h", "third_party/fiat/internal.h", "third_party/fiat/LICENSE", "third_party/fiat/make_curve25519_tables.py", "third_party/NIST/SHAVS/SHA1LongMsg.rsp", "third_party/NIST/SHAVS/SHA1Monte.rsp", "third_party/NIST/SHAVS/SHA1ShortMsg.rsp", "third_party/NIST/SHAVS/SHA224LongMsg.rsp", "third_party/NIST/SHAVS/SHA224Monte.rsp", "third_party/NIST/SHAVS/SHA224ShortMsg.rsp", "third_party/NIST/SHAVS/SHA256LongMsg.rsp", "third_party/NIST/SHAVS/SHA256Monte.rsp", "third_party/NIST/SHAVS/SHA256ShortMsg.rsp", "third_party/NIST/SHAVS/SHA384LongMsg.rsp", "third_party/NIST/SHAVS/SHA384Monte.rsp", "third_party/NIST/SHAVS/SHA384ShortMsg.rsp", "third_party/NIST/SHAVS/SHA512LongMsg.rsp", "third_party/NIST/SHAVS/SHA512Monte.rsp", "third_party/NIST/SHAVS/SHA512ShortMsg.rsp"]
 description = "Safe, fast, small crypto using Rust."
 documentation = "https://briansmith.org/rustdoc/ring/"
 readme = "doc/link-to-readme.md"
@@ -25,8 +26,6 @@
 categories = ["cryptography", "no-std"]
 license-file = "LICENSE"
 repository = "https://github.com/briansmith/ring"
-[package.metadata.docs.rs]
-features = ["rsa_signing"]
 [profile.bench]
 opt-level = 3
 lto = true
@@ -48,17 +47,16 @@
 [dependencies.untrusted]
 version = "0.6.2"
 [build-dependencies.cc]
-version = "1.0.9"
+version = "1.0.26"
 
 [features]
 default = ["use_heap", "dev_urandom_fallback"]
 dev_urandom_fallback = []
 internal_benches = []
-rsa_signing = ["use_heap"]
 slow_tests = []
 test_logging = []
 use_heap = []
 [target."cfg(any(target_os = \"redox\", all(unix, not(any(target_os = \"macos\", target_os = \"ios\")))))".dependencies.lazy_static]
 version = "1.2"
 [target."cfg(target_os = \"linux\")".dependencies.libc]
-version = "0.2.34"
+version = "0.2.45"
diff --git a/rustc_deps/vendor/ring/build.rs b/rustc_deps/vendor/ring/build.rs
index 29e6e6f..8a98839 100644
--- a/rustc_deps/vendor/ring/build.rs
+++ b/rustc_deps/vendor/ring/build.rs
@@ -33,8 +33,6 @@
     warnings
 )]
 
-extern crate cc;
-
 // In the `pregenerate_asm_main()` case we don't want to access (Cargo)
 // environment variables at all, so avoid `use std::env` here.
 
@@ -53,14 +51,11 @@
 
 #[cfg_attr(rustfmt, rustfmt_skip)]
 const RING_SRCS: &[(&[&str], &str)] = &[
-    (&[], "crypto/fipsmodule/aes/aes.c"),
-    (&[], "crypto/fipsmodule/bn/exponentiation.c"),
+    (&[], "crypto/block.c"),
     (&[], "crypto/fipsmodule/bn/generic.c"),
     (&[], "crypto/fipsmodule/bn/montgomery.c"),
     (&[], "crypto/fipsmodule/bn/montgomery_inv.c"),
-    (&[], "crypto/fipsmodule/bn/shift.c"),
     (&[], "crypto/fipsmodule/cipher/e_aes.c"),
-    (&[NEVER], "crypto/cipher_extra/e_aesgcmsiv.c"),
     (&[], "crypto/crypto.c"),
     (&[], "crypto/fipsmodule/ec/ecp_nistz.c"),
     (&[], "crypto/fipsmodule/ec/ecp_nistz256.c"),
@@ -92,6 +87,7 @@
     (&[X86_64], "crypto/chacha/asm/chacha-x86_64.pl"),
     (&[NEVER], "crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl"),
     (&[X86_64], "crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl"),
+    (&[NEVER], "crypto/fipsmodule/ec/asm/p256_beeu-x86_64-asm.pl"),
     (&[X86_64], "crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl"),
     (&[X86_64], "crypto/fipsmodule/modes/asm/ghash-x86_64.pl"),
     (&[X86_64], "crypto/poly1305/asm/poly1305-x86_64.pl"),
@@ -113,6 +109,7 @@
     (&[ARM], "crypto/fipsmodule/sha/asm/sha256-armv4.pl"),
     (&[ARM], "crypto/fipsmodule/sha/asm/sha512-armv4.pl"),
 
+    (&[AARCH64], "crypto/fipsmodule/aes/aes.c"),
     (&[AARCH64], "crypto/fipsmodule/bn/asm/armv8-mont.pl"),
     (&[AARCH64], "crypto/cpu-aarch64-linux.c"),
     (&[AARCH64], "crypto/chacha/asm/chacha-armv8.pl"),
@@ -133,12 +130,12 @@
 const RING_INCLUDES: &[&str] =
     &["crypto/fipsmodule/aes/internal.h",
       "crypto/fipsmodule/bn/internal.h",
-      "crypto/fipsmodule/cipher/internal.h",
       "crypto/fipsmodule/ec/ecp_nistz256_table.inl",
       "crypto/fipsmodule/ec/ecp_nistz384.inl",
       "crypto/fipsmodule/ec/ecp_nistz.h",
       "crypto/fipsmodule/ec/ecp_nistz384.h",
       "crypto/fipsmodule/ec/ecp_nistz256.h",
+      "crypto/block.h",
       "crypto/internal.h",
       "crypto/limbs/limbs.h",
       "crypto/limbs/limbs.inl",
@@ -189,6 +186,7 @@
             "-Wextra",
             "-Wcast-align",
             "-Wcast-qual",
+            "-Wconversion",
             "-Wenum-compare",
             "-Wfloat-equal",
             "-Wformat=2",
@@ -200,12 +198,12 @@
             "-Wredundant-decls",
             "-Wshadow",
             "-Wsign-compare",
+            "-Wsign-conversion",
             "-Wundef",
             "-Wuninitialized",
             "-Wwrite-strings",
             "-fno-strict-aliasing",
             "-fvisibility=hidden",
-            "-Wno-cast-align",
         ];
         NON_MSVC_FLAGS
     } else {
diff --git a/rustc_deps/vendor/ring/src/init.rs b/rustc_deps/vendor/ring/crypto/block.c
similarity index 69%
copy from rustc_deps/vendor/ring/src/init.rs
copy to rustc_deps/vendor/ring/crypto/block.c
index 0f70564..9bbed1a 100644
--- a/rustc_deps/vendor/ring/src/init.rs
+++ b/rustc_deps/vendor/ring/crypto/block.c
@@ -1,4 +1,4 @@
-// Copyright 2016 Brian Smith.
+// Copyright 2018 Brian Smith.
 //
 // Permission to use, copy, modify, and/or distribute this software for any
 // purpose with or without fee is hereby granted, provided that the above
@@ -12,15 +12,13 @@
 // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-#[inline(always)]
-pub fn init_once() {
-    #[cfg(not(target_os = "ios"))]
-    {
-        use std;
-        extern "C" {
-            fn GFp_cpuid_setup();
-        }
-        static INIT: std::sync::Once = std::sync::ONCE_INIT;
-        INIT.call_once(|| unsafe { GFp_cpuid_setup() });
-    }
+#include "internal.h"
+#include "block.h"
+
+// Prevent missing prototypes warnings.
+void GFp_block128_xor_assign(Block *r, Block a);
+
+void GFp_block128_xor_assign(Block *r, Block a) {
+  r->subblocks[0] ^= a.subblocks[0];
+  r->subblocks[1] ^= a.subblocks[1];
 }
diff --git a/rustc_deps/vendor/ring/src/init.rs b/rustc_deps/vendor/ring/crypto/block.h
similarity index 69%
copy from rustc_deps/vendor/ring/src/init.rs
copy to rustc_deps/vendor/ring/crypto/block.h
index 0f70564..7163b99 100644
--- a/rustc_deps/vendor/ring/src/init.rs
+++ b/rustc_deps/vendor/ring/crypto/block.h
@@ -1,4 +1,4 @@
-// Copyright 2016 Brian Smith.
+// Copyright 2018 Brian Smith.
 //
 // Permission to use, copy, modify, and/or distribute this software for any
 // purpose with or without fee is hereby granted, provided that the above
@@ -12,15 +12,13 @@
 // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-#[inline(always)]
-pub fn init_once() {
-    #[cfg(not(target_os = "ios"))]
-    {
-        use std;
-        extern "C" {
-            fn GFp_cpuid_setup();
-        }
-        static INIT: std::sync::Once = std::sync::ONCE_INIT;
-        INIT.call_once(|| unsafe { GFp_cpuid_setup() });
-    }
-}
+#include "internal.h"
+
+#ifndef RING_HEADER_CRYPTO_INTERNAL_H
+#define RING_HEADER_CRYPTO_INTERNAL_H
+
+typedef struct Block {
+  uint64_t subblocks[2];
+} Block;
+
+#endif
diff --git a/rustc_deps/vendor/ring/crypto/chacha/asm/chacha-armv8.pl b/rustc_deps/vendor/ring/crypto/chacha/asm/chacha-armv8.pl
index 02c412b..a4fd3c9 100644
--- a/rustc_deps/vendor/ring/crypto/chacha/asm/chacha-armv8.pl
+++ b/rustc_deps/vendor/ring/crypto/chacha/asm/chacha-armv8.pl
@@ -122,10 +122,10 @@
 $code.=<<___;
 #include <GFp/arm_arch.h>
 
-.text
-
 .extern	GFp_armcap_P
 
+.section .rodata
+
 .align	5
 .Lsigma:
 .quad	0x3320646e61707865,0x6b20657479622d32		// endian-neutral
@@ -139,20 +139,18 @@
 #endif
 .asciz	"ChaCha20 for ARMv8, CRYPTOGAMS by <appro\@openssl.org>"
 
+.text
+
 .globl	GFp_ChaCha20_ctr32
 .type	GFp_ChaCha20_ctr32,%function
 .align	5
 GFp_ChaCha20_ctr32:
 	cbz	$len,.Labort
-	adr	@x[0],.LGFp_armcap_P
+	adrp	@x[0],:pg_hi21:GFp_armcap_P
 	cmp	$len,#192
 	b.lo	.Lshort
-#ifdef	__ILP32__
-	ldrsw	@x[1],[@x[0]]
-#else
-	ldr	@x[1],[@x[0]]
-#endif
-	ldr	w17,[@x[1],@x[0]]
+	add	@x[0],@x[0],:lo12:GFp_armcap_P
+	ldr	w17,[@x[0]]
 	tst	w17,#ARMV7_NEON
 	b.ne	ChaCha20_neon
 
@@ -160,7 +158,8 @@
 	stp	x29,x30,[sp,#-96]!
 	add	x29,sp,#0
 
-	adr	@x[0],.Lsigma
+	adrp	@x[0],:pg_hi21:.Lsigma
+	add	@x[0],@x[0],:lo12:.Lsigma
 	stp	x19,x20,[sp,#16]
 	stp	x21,x22,[sp,#32]
 	stp	x23,x24,[sp,#48]
@@ -380,7 +379,8 @@
 	stp	x29,x30,[sp,#-96]!
 	add	x29,sp,#0
 
-	adr	@x[0],.Lsigma
+	adrp	@x[0],:pg_hi21:.Lsigma
+	add	@x[0],@x[0],:lo12:.Lsigma
 	stp	x19,x20,[sp,#16]
 	stp	x21,x22,[sp,#32]
 	stp	x23,x24,[sp,#48]
@@ -699,7 +699,8 @@
 	stp	x29,x30,[sp,#-96]!
 	add	x29,sp,#0
 
-	adr	@x[0],.Lsigma
+	adrp	@x[0],:pg_hi21:.Lsigma
+	add	@x[0],@x[0],:lo12:.Lsigma
 	stp	x19,x20,[sp,#16]
 	stp	x21,x22,[sp,#32]
 	stp	x23,x24,[sp,#48]
diff --git a/rustc_deps/vendor/ring/crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl b/rustc_deps/vendor/ring/crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl
index 1a3d064..5b4d217 100644
--- a/rustc_deps/vendor/ring/crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl
+++ b/rustc_deps/vendor/ring/crypto/cipher_extra/asm/aes128gcmsiv-x86_64.pl
@@ -13,7 +13,7 @@
 # SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 # OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
-# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 use warnings FATAL => 'all';
 
diff --git a/rustc_deps/vendor/ring/crypto/constant_time_test.c b/rustc_deps/vendor/ring/crypto/constant_time_test.c
index 2e80c39..dd618e8 100644
--- a/rustc_deps/vendor/ring/crypto/constant_time_test.c
+++ b/rustc_deps/vendor/ring/crypto/constant_time_test.c
@@ -126,24 +126,6 @@
   return 0;
 }
 
-static int test_eq_int(int a, int b) {
-  crypto_word equal = constant_time_eq_int(a, b);
-  if (a == b && equal != CONSTTIME_TRUE_W) {
-    fprintf(stderr,
-            "Test failed for constant_time_eq_int(%d, %d): expected %zu(TRUE), "
-            "got %zu\n",
-            a, b, (size_t)CONSTTIME_TRUE_W, (size_t)equal);
-    return 1;
-  } else if (a != b && equal != CONSTTIME_FALSE_W) {
-    fprintf(stderr,
-            "Test failed for constant_time_eq_int(%d, %d): expected "
-            "%zu(FALSE), got %zu\n",
-            a, b, (size_t)CONSTTIME_FALSE_W, (size_t)equal);
-    return 1;
-  }
-  return 0;
-}
-
 static crypto_word test_values_s[] = {
   0,
   1,
@@ -164,22 +146,6 @@
   SIZE_MAX
 };
 
-static int signed_test_values[] = {
-  0,
-  1,
-  -1,
-  1024,
-  -1024,
-  12345,
-  -12345,
-  32000,
-  -32000,
-  INT_MAX,
-  INT_MIN,
-  INT_MAX - 1,
-  INT_MIN + 1
-};
-
 int bssl_constant_time_test_main(void) {
   int num_failed = 0;
 
@@ -198,16 +164,6 @@
     }
   }
 
-  for (size_t i = 0;
-       i < sizeof(signed_test_values) / sizeof(signed_test_values[0]); ++i) {
-    int a = signed_test_values[i];
-    for (size_t j = 0;
-         j < sizeof(signed_test_values) / sizeof(signed_test_values[0]); ++j) {
-      int b = signed_test_values[j];
-      num_failed += test_eq_int(a, b);
-    }
-  }
-
   if (!num_failed) {
     return EXIT_SUCCESS;
   }
diff --git a/rustc_deps/vendor/ring/crypto/cpu-arm-linux.c b/rustc_deps/vendor/ring/crypto/cpu-arm-linux.c
index bd6e953..96d48fb 100644
--- a/rustc_deps/vendor/ring/crypto/cpu-arm-linux.c
+++ b/rustc_deps/vendor/ring/crypto/cpu-arm-linux.c
@@ -16,14 +16,8 @@
 
 #if defined(OPENSSL_ARM) && !defined(OPENSSL_STATIC_ARMCAP)
 
-#include <errno.h>
-#include <fcntl.h>
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
-
+#include <sys/auxv.h>
 #include <GFp/arm_arch.h>
-#include <GFp/mem.h>
 
 #include "internal.h"
 
@@ -40,301 +34,20 @@
 #define HWCAP2_SHA1 (1 << 2)
 #define HWCAP2_SHA2 (1 << 3)
 
-// |getauxval| is not available on Android until API level 20. Link it as a weak
-// symbol and use other methods as fallback.
-unsigned long getauxval(unsigned long type) __attribute__((weak));
-
-static int open_eintr(const char *path, int flags) {
-  int ret;
-  do {
-    ret = open(path, flags);
-  } while (ret < 0 && errno == EINTR);
-  return ret;
-}
-
-static ssize_t read_eintr(int fd, void *out, size_t len) {
-  ssize_t ret;
-  do {
-    ret = read(fd, out, len);
-  } while (ret < 0 && errno == EINTR);
-  return ret;
-}
-
-// read_full reads exactly |len| bytes from |fd| to |out|. On error or end of
-// file, it returns zero.
-static int read_full(int fd, void *out, size_t len) {
-  while (len > 0) {
-    ssize_t ret = read_eintr(fd, out, len);
-    if (ret <= 0) {
-      return 0;
-    }
-    out = (aliasing_uint8 *)out + ret;
-    len -= ret;
-  }
-  return 1;
-}
-
-// read_file opens |path| and reads until end-of-file. On success, it returns
-// one and sets |*out_ptr| and |*out_len| to a newly-allocated buffer with the
-// contents. Otherwise, it returns zero.
-static int read_file(char **out_ptr, size_t *out_len, const char *path) {
-  int fd = open_eintr(path, O_RDONLY);
-  if (fd < 0) {
-    return 0;
-  }
-
-  static const size_t kReadSize = 1024;
-  int ret = 0;
-  size_t cap = kReadSize, len = 0;
-  char *buf = OPENSSL_malloc(cap);
-  if (buf == NULL) {
-    goto err;
-  }
-
-  for (;;) {
-    if (cap - len < kReadSize) {
-      size_t new_cap = cap * 2;
-      if (new_cap < cap) {
-        goto err;
-      }
-      char *new_buf = OPENSSL_realloc(buf, new_cap);
-      if (new_buf == NULL) {
-        goto err;
-      }
-      buf = new_buf;
-      cap = new_cap;
-    }
-
-    ssize_t bytes_read = read_eintr(fd, buf + len, kReadSize);
-    if (bytes_read < 0) {
-      goto err;
-    }
-    if (bytes_read == 0) {
-      break;
-    }
-    len += bytes_read;
-  }
-
-  *out_ptr = buf;
-  *out_len = len;
-  ret = 1;
-  buf = NULL;
-
-err:
-  OPENSSL_free(buf);
-  close(fd);
-  return ret;
-}
-
-// getauxval_proc behaves like |getauxval| but reads from /proc/self/auxv.
-static unsigned long getauxval_proc(unsigned long type) {
-  int fd = open_eintr("/proc/self/auxv", O_RDONLY);
-  if (fd < 0) {
-    return 0;
-  }
-
-  struct {
-    unsigned long tag;
-    unsigned long value;
-  } entry;
-
-  for (;;) {
-    if (!read_full(fd, &entry, sizeof(entry)) ||
-        (entry.tag == 0 && entry.value == 0)) {
-      break;
-    }
-    if (entry.tag == type) {
-      close(fd);
-      return entry.value;
-    }
-  }
-  close(fd);
-  return 0;
-}
-
-typedef struct {
-  const char *data;
-  size_t len;
-} STRING_PIECE;
-
-static int STRING_PIECE_equals(const STRING_PIECE *a, const char *b) {
-  size_t b_len = strlen(b);
-  return a->len == b_len && memcmp(a->data, b, b_len) == 0;
-}
-
-// STRING_PIECE_split finds the first occurence of |sep| in |in| and, if found,
-// sets |*out_left| and |*out_right| to |in| split before and after it. It
-// returns one if |sep| was found and zero otherwise.
-static int STRING_PIECE_split(STRING_PIECE *out_left, STRING_PIECE *out_right,
-                              const STRING_PIECE *in, char sep) {
-  const char *p = memchr(in->data, sep, in->len);
-  if (p == NULL) {
-    return 0;
-  }
-  // |out_left| or |out_right| may alias |in|, so make a copy.
-  STRING_PIECE in_copy = *in;
-  out_left->data = in_copy.data;
-  out_left->len = p - in_copy.data;
-  out_right->data = in_copy.data + out_left->len + 1;
-  out_right->len = in_copy.len - out_left->len - 1;
-  return 1;
-}
-
-// STRING_PIECE_trim removes leading and trailing whitespace from |s|.
-static void STRING_PIECE_trim(STRING_PIECE *s) {
-  while (s->len != 0 && (s->data[0] == ' ' || s->data[0] == '\t')) {
-    s->data++;
-    s->len--;
-  }
-  while (s->len != 0 &&
-         (s->data[s->len - 1] == ' ' || s->data[s->len - 1] == '\t')) {
-    s->len--;
-  }
-}
-
-// extract_cpuinfo_field extracts a /proc/cpuinfo field named |field| from
-// |in|.  If found, it sets |*out| to the value and returns one. Otherwise, it
-// returns zero.
-static int extract_cpuinfo_field(STRING_PIECE *out, const STRING_PIECE *in,
-                                 const char *field) {
-  // Process |in| one line at a time.
-  STRING_PIECE remaining = *in, line;
-  while (STRING_PIECE_split(&line, &remaining, &remaining, '\n')) {
-    STRING_PIECE key, value;
-    if (!STRING_PIECE_split(&key, &value, &line, ':')) {
-      continue;
-    }
-    STRING_PIECE_trim(&key);
-    if (STRING_PIECE_equals(&key, field)) {
-      STRING_PIECE_trim(&value);
-      *out = value;
-      return 1;
-    }
-  }
-
-  return 0;
-}
-
-static int cpuinfo_field_equals(const STRING_PIECE *cpuinfo, const char *field,
-                                const char *value) {
-  STRING_PIECE extracted;
-  return extract_cpuinfo_field(&extracted, cpuinfo, field) &&
-         STRING_PIECE_equals(&extracted, value);
-}
-
-// has_list_item treats |list| as a space-separated list of items and returns
-// one if |item| is contained in |list| and zero otherwise.
-static int has_list_item(const STRING_PIECE *list, const char *item) {
-  STRING_PIECE remaining = *list, feature;
-  while (STRING_PIECE_split(&feature, &remaining, &remaining, ' ')) {
-    if (STRING_PIECE_equals(&feature, item)) {
-      return 1;
-    }
-  }
-  return 0;
-}
-
-static unsigned long get_hwcap_cpuinfo(const STRING_PIECE *cpuinfo) {
-  if (cpuinfo_field_equals(cpuinfo, "CPU architecture", "8")) {
-    // This is a 32-bit ARM binary running on a 64-bit kernel. NEON is always
-    // available on ARMv8. Linux omits required features, so reading the
-    // "Features" line does not work. (For simplicity, use strict equality. We
-    // assume everything running on future ARM architectures will have a
-    // working |getauxval|.)
-    return HWCAP_NEON;
-  }
-
-  STRING_PIECE features;
-  if (extract_cpuinfo_field(&features, cpuinfo, "Features") &&
-      has_list_item(&features, "neon")) {
-    return HWCAP_NEON;
-  }
-  return 0;
-}
-
-static unsigned long get_hwcap2_cpuinfo(const STRING_PIECE *cpuinfo) {
-  STRING_PIECE features;
-  if (!extract_cpuinfo_field(&features, cpuinfo, "Features")) {
-    return 0;
-  }
-
-  unsigned long ret = 0;
-  if (has_list_item(&features, "aes")) {
-    ret |= HWCAP2_AES;
-  }
-  if (has_list_item(&features, "pmull")) {
-    ret |= HWCAP2_PMULL;
-  }
-  if (has_list_item(&features, "sha1")) {
-    ret |= HWCAP2_SHA1;
-  }
-  if (has_list_item(&features, "sha2")) {
-    ret |= HWCAP2_SHA2;
-  }
-  return ret;
-}
-
-// has_broken_neon returns one if |in| matches a CPU known to have a broken
-// NEON unit. See https://crbug.com/341598.
-static int has_broken_neon(const STRING_PIECE *cpuinfo) {
-  return cpuinfo_field_equals(cpuinfo, "CPU implementer", "0x51") &&
-         cpuinfo_field_equals(cpuinfo, "CPU architecture", "7") &&
-         cpuinfo_field_equals(cpuinfo, "CPU variant", "0x1") &&
-         cpuinfo_field_equals(cpuinfo, "CPU part", "0x04d") &&
-         cpuinfo_field_equals(cpuinfo, "CPU revision", "0");
-}
-
 extern uint32_t GFp_armcap_P;
 
-static int g_has_broken_neon;
-
 void GFp_cpuid_setup(void) {
-  char *cpuinfo_data;
-  size_t cpuinfo_len;
-  if (!read_file(&cpuinfo_data, &cpuinfo_len, "/proc/cpuinfo")) {
-    return;
-  }
-  STRING_PIECE cpuinfo;
-  cpuinfo.data = cpuinfo_data;
-  cpuinfo.len = cpuinfo_len;
-
-  // |getauxval| is not available on Android until API level 20. If it is
-  // unavailable, read from /proc/self/auxv as a fallback. This is unreadable
-  // on some versions of Android, so further fall back to /proc/cpuinfo.
-  //
-  // See
-  // https://android.googlesource.com/platform/ndk/+/882ac8f3392858991a0e1af33b4b7387ec856bd2
-  // and b/13679666 (Google-internal) for details.
-  unsigned long hwcap = 0;
-  if (getauxval != NULL) {
-    hwcap = getauxval(AT_HWCAP);
-  }
-  if (hwcap == 0) {
-    hwcap = getauxval_proc(AT_HWCAP);
-  }
-  if (hwcap == 0) {
-    hwcap = get_hwcap_cpuinfo(&cpuinfo);
-  }
-
-  // Clear NEON support if known broken.
-  g_has_broken_neon = has_broken_neon(&cpuinfo);
-  if (g_has_broken_neon) {
-    hwcap &= ~HWCAP_NEON;
-  }
+  // |getauxval| is not available on Android until API level 20. Unlike
+  // BoringSSL, require API level 20.
+  unsigned long hwcap = getauxval(AT_HWCAP);
 
   // Matching OpenSSL, only report other features if NEON is present.
   if (hwcap & HWCAP_NEON) {
     GFp_armcap_P |= ARMV7_NEON;
 
-    // Some ARMv8 Android devices don't expose AT_HWCAP2. Fall back to
-    // /proc/cpuinfo. See https://crbug.com/596156.
-    unsigned long hwcap2 = 0;
-    if (getauxval != NULL) {
-      hwcap2 = getauxval(AT_HWCAP2);
-    }
-    if (hwcap2 == 0) {
-      hwcap2 = get_hwcap2_cpuinfo(&cpuinfo);
-    }
+    // Note that some (old?) ARMv8 Android devices don't support |AT_HWCAP2|
+    // even when the instructions are available.
+    unsigned long hwcap2 = getauxval(AT_HWCAP2);
 
     if (hwcap2 & HWCAP2_AES) {
       GFp_armcap_P |= ARMV8_AES;
@@ -349,10 +62,6 @@
       GFp_armcap_P |= ARMV8_SHA256;
     }
   }
-
-  OPENSSL_free(cpuinfo_data);
 }
 
-int GFp_has_broken_NEON(void) { return g_has_broken_neon; }
-
 #endif  // OPENSSL_ARM && !OPENSSL_STATIC_ARMCAP
diff --git a/rustc_deps/vendor/ring/crypto/cpu-intel.c b/rustc_deps/vendor/ring/crypto/cpu-intel.c
index 67e7f0d..2a71421 100644
--- a/rustc_deps/vendor/ring/crypto/cpu-intel.c
+++ b/rustc_deps/vendor/ring/crypto/cpu-intel.c
@@ -128,10 +128,6 @@
   int is_intel = ebx == 0x756e6547 /* Genu */ &&
                  edx == 0x49656e69 /* ineI */ &&
                  ecx == 0x6c65746e /* ntel */;
-  int is_amd = ebx == 0x68747541 /* Auth */ &&
-               edx == 0x69746e65 /* enti */ &&
-               ecx == 0x444d4163 /* cAMD */;
-
 
   uint32_t extended_features[2] = {0};
   if (num_ids >= 7) {
@@ -140,29 +136,11 @@
     extended_features[1] = ecx;
   }
 
-  // Determine the number of cores sharing an L1 data cache to adjust the
-  // hyper-threading bit.
-  uint32_t cores_per_cache = 0;
-  if (is_amd) {
-    // AMD CPUs never share an L1 data cache between threads but do set the HTT
-    // bit on multi-core CPUs.
-    cores_per_cache = 1;
-  } else if (num_ids >= 4) {
-    // TODO(davidben): The Intel manual says this CPUID leaf enumerates all
-    // caches using ECX and doesn't say which is first. Does this matter?
-    OPENSSL_cpuid(&eax, &ebx, &ecx, &edx, 4);
-    cores_per_cache = 1 + ((eax >> 14) & 0xfff);
-  }
-
   OPENSSL_cpuid(&eax, &ebx, &ecx, &edx, 1);
 
-  // Adjust the hyper-threading bit.
-  if (edx & (1u << 28)) {
-    uint32_t num_logical_cores = (ebx >> 16) & 0xff;
-    if (cores_per_cache == 1 || num_logical_cores <= 1) {
-      edx &= ~(1u << 28);
-    }
-  }
+  // Force the hyper-threading bit so that the more conservative path is always
+  // chosen.
+  edx |= 1u << 28;
 
   // Reserved bit #20 was historically repurposed to control the in-memory
   // representation of RC4 state. Always set it to zero.
@@ -183,7 +161,8 @@
     edx &= ~(1u << 30);
   }
 
-  // The SDBG bit is repurposed to denote AMD XOP support.
+  // The SDBG bit is repurposed to denote AMD XOP support. Don't ever use AMD
+  // XOP code paths.
   ecx &= ~(1u << 11);
 
   uint64_t xcr0 = 0;
diff --git a/rustc_deps/vendor/ring/crypto/crypto.c b/rustc_deps/vendor/ring/crypto/crypto.c
index fa81681..84d1446 100644
--- a/rustc_deps/vendor/ring/crypto/crypto.c
+++ b/rustc_deps/vendor/ring/crypto/crypto.c
@@ -65,7 +65,8 @@
 #if defined(OPENSSL_STATIC_ARMCAP)
 
 HIDDEN uint32_t GFp_armcap_P =
-#if defined(OPENSSL_STATIC_ARMCAP_NEON) || defined(__ARM_NEON__)
+#if defined(OPENSSL_STATIC_ARMCAP_NEON) || \
+    (defined(__ARM_NEON__) || defined(__ARM_NEON))
     ARMV7_NEON |
 #endif
 #if defined(OPENSSL_STATIC_ARMCAP_AES) || defined(__ARM_FEATURE_CRYPTO)
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/aes.c b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/aes.c
index dfead5e..5c4f5cb 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/aes.c
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/aes.c
@@ -53,8 +53,9 @@
 #include "internal.h"
 #include "../modes/internal.h"
 
-
-#if defined(GFp_C_AES)
+int GFp_aes_nohw_set_encrypt_key(const uint8_t *key, unsigned bits,
+                                 AES_KEY *aeskey);
+void GFp_aes_nohw_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key);
 
 // Te0[x] = S [x].[02, 01, 01, 03];
 // Te1[x] = S [x].[03, 02, 01, 01];
@@ -284,11 +285,14 @@
 };
 
 // |bits| must be 128 or 256. 192-bit keys are not supported.
-void GFp_aes_c_set_encrypt_key(const uint8_t *key, unsigned bits,
-                               AES_KEY *aeskey) {
+int GFp_aes_nohw_set_encrypt_key(const uint8_t *key, unsigned bits,
+                                 AES_KEY *aeskey) {
   assert(key != NULL);
   assert(aeskey != NULL);
-  assert(bits == 128 || bits == 256);
+
+  if (bits != 128 && bits != 256) {
+    return -2;
+  }
 
   uint32_t *rk;
   int i = 0;
@@ -313,7 +317,7 @@
       rk[6] = rk[2] ^ rk[5];
       rk[7] = rk[3] ^ rk[6];
       if (++i == 10) {
-        return;
+        return 0;
       }
       rk += 4;
     }
@@ -335,7 +339,7 @@
     rk[10] = rk[2] ^ rk[9];
     rk[11] = rk[3] ^ rk[10];
     if (++i == 7) {
-      return;
+      return 0;
     }
     temp = rk[11];
     rk[12] = rk[4] ^ (Te2[(temp >> 24)] & 0xff000000) ^
@@ -350,10 +354,9 @@
   }
 }
 
-void GFp_aes_c_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key) {
+void GFp_aes_nohw_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key) {
   const uint32_t *rk;
   uint32_t s0, s1, s2, s3, t0, t1, t2, t3;
-  int r;
 
   assert(in && out && key);
   rk = key->rd_key;
@@ -366,7 +369,7 @@
   s3 = from_be_u32_ptr(in + 12) ^ rk[3];
 
   // Nr - 1 full rounds:
-  r = key->rounds >> 1;
+  unsigned r = key->rounds >> 1;
   for (;;) {
     t0 = Te0[(s0 >> 24)] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^
          Te3[(s3) & 0xff] ^ rk[4];
@@ -410,6 +413,3 @@
        rk[3];
   to_be_u32_ptr(out + 12, s3);
 }
-
-#endif  // defined(GFp_C_AES)
-
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-586.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-586.pl
index 6b6503f..c420078 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-586.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-586.pl
@@ -1169,8 +1169,8 @@
 	&data_word(0x00000000, 0x00000000, 0x00000000, 0x00000000);
 &function_end_B("_x86_AES_encrypt");
 
-# void GFp_asm_AES_encrypt (const void *inp,void *out,const AES_KEY *key);
-&function_begin("GFp_asm_AES_encrypt");
+# void GFp_aes_nohw_encrypt (const void *inp,void *out,const AES_KEY *key);
+&function_begin("GFp_aes_nohw_encrypt");
 	&mov	($acc,&wparam(0));		# load inp
 	&mov	($key,&wparam(2));		# load key
 
@@ -1226,7 +1226,7 @@
 	&mov	(&DWP(4,$acc),$s1);
 	&mov	(&DWP(8,$acc),$s2);
 	&mov	(&DWP(12,$acc),$s3);
-&function_end("GFp_asm_AES_encrypt");
+&function_end("GFp_aes_nohw_encrypt");
 
 #--------------------------------------------------------------------#
 
@@ -1597,12 +1597,12 @@
     &set_label("exit");
 &function_end("_x86_AES_set_encrypt_key");
 
-# int asm_AES_set_encrypt_key(const unsigned char *userKey, const int bits,
-#                             AES_KEY *key)
-&function_begin_B("GFp_asm_AES_set_encrypt_key");
+# int GFp_aes_nohw_set_encrypt_key(const unsigned char *userKey, const int bits,
+#                                  AES_KEY *key)
+&function_begin_B("GFp_aes_nohw_set_encrypt_key");
 	&call	("_x86_AES_set_encrypt_key");
 	&ret	();
-&function_end_B("GFp_asm_AES_set_encrypt_key");
+&function_end_B("GFp_aes_nohw_set_encrypt_key");
 
 &asciz("AES for x86, CRYPTOGAMS by <appro\@openssl.org>");
 
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-armv4.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-armv4.pl
index a3989fa..157091d 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-armv4.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-armv4.pl
@@ -196,14 +196,14 @@
 .word	0x1B000000, 0x36000000, 0, 0, 0, 0, 0, 0
 .size	AES_Te,.-AES_Te
 
-@ void GFp_asm_AES_encrypt(const unsigned char *in, unsigned char *out,
+@ void GFp_aes_nohw_encrypt(const unsigned char *in, unsigned char *out,
 @ 		                   const AES_KEY *key) {
-.global GFp_asm_AES_encrypt
-.type   GFp_asm_AES_encrypt,%function
+.global GFp_aes_nohw_encrypt
+.type   GFp_aes_nohw_encrypt,%function
 .align	5
-GFp_asm_AES_encrypt:
+GFp_aes_nohw_encrypt:
 #ifndef	__thumb2__
-	sub	r3,pc,#8		@ GFp_asm_AES_encrypt
+	sub	r3,pc,#8		@ GFp_aes_nohw_encrypt
 #else
 	adr	r3,.
 #endif
@@ -211,7 +211,7 @@
 #if defined(__thumb2__) || defined(__APPLE__)
 	adr	$tbl,AES_Te
 #else
-	sub	$tbl,r3,#GFp_asm_AES_encrypt-AES_Te	@ Te
+	sub	$tbl,r3,#GFp_aes_nohw_encrypt-AES_Te	@ Te
 #endif
 	mov	$rounds,r0		@ inp
 	mov	$key,r2
@@ -308,7 +308,7 @@
 	moveq	pc,lr			@ be binary compatible with V4, yet
 	bx	lr			@ interoperable with Thumb ISA:-)
 #endif
-.size	GFp_asm_AES_encrypt,.-GFp_asm_AES_encrypt
+.size	GFp_aes_nohw_encrypt,.-GFp_aes_nohw_encrypt
 
 .type   _armv4_AES_encrypt,%function
 .align	2
@@ -447,13 +447,13 @@
 	ldr	pc,[sp],#4		@ pop and return
 .size	_armv4_AES_encrypt,.-_armv4_AES_encrypt
 
-.global GFp_asm_AES_set_encrypt_key
-.type   GFp_asm_AES_set_encrypt_key,%function
+.global GFp_aes_nohw_set_encrypt_key
+.type   GFp_aes_nohw_set_encrypt_key,%function
 .align	5
-GFp_asm_AES_set_encrypt_key:
+GFp_aes_nohw_set_encrypt_key:
 _armv4_AES_set_encrypt_key:
 #ifndef	__thumb2__
-	sub	r3,pc,#8		@ GFp_asm_AES_set_encrypt_key
+	sub	r3,pc,#8		@ GFp_aes_nohw_set_encrypt_key
 #else
 	adr	r3,.
 #endif
@@ -703,7 +703,7 @@
 	moveq	pc,lr			@ be binary compatible with V4, yet
 	bx	lr			@ interoperable with Thumb ISA:-)
 #endif
-.size	GFp_asm_AES_set_encrypt_key,.-GFp_asm_AES_set_encrypt_key
+.size	GFp_aes_nohw_set_encrypt_key,.-GFp_aes_nohw_set_encrypt_key
 
 .asciz	"AES for ARMv4, CRYPTOGAMS by <appro\@openssl.org>"
 .align	2
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-x86_64.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-x86_64.pl
index f17a93c..09e23ea 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-x86_64.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aes-x86_64.pl
@@ -590,13 +590,13 @@
 .size	_x86_64_AES_encrypt_compact,.-_x86_64_AES_encrypt_compact
 ___
 
-# void GFp_asm_AES_encrypt (const void *inp,void *out,const AES_KEY *key);
+# void GFp_aes_nohw_encrypt (const void *inp,void *out,const AES_KEY *key);
 $code.=<<___;
 .align	16
-.globl	GFp_asm_AES_encrypt
-.type	GFp_asm_AES_encrypt,\@function,3
-.hidden	GFp_asm_AES_encrypt
-GFp_asm_AES_encrypt:
+.globl	GFp_aes_nohw_encrypt
+.type	GFp_aes_nohw_encrypt,\@function,3
+.hidden	GFp_aes_nohw_encrypt
+GFp_aes_nohw_encrypt:
 .cfi_startproc
 	mov	%rsp,%rax
 .cfi_def_cfa_register	%rax
@@ -674,7 +674,7 @@
 .Lenc_epilogue:
 	ret
 .cfi_endproc
-.size	GFp_asm_AES_encrypt,.-GFp_asm_AES_encrypt
+.size	GFp_aes_nohw_encrypt,.-GFp_aes_nohw_encrypt
 ___
 
 #------------------------------------------------------------------#
@@ -706,13 +706,13 @@
 ___
 }
 
-# int GFp_asm_AES_set_encrypt_key(const unsigned char *userKey, const int bits,
+# int GFp_aes_nohw_set_encrypt_key(const unsigned char *userKey, const int bits,
 #                                 AES_KEY *key)
 $code.=<<___;
 .align	16
-.globl GFp_asm_AES_set_encrypt_key
-.type  GFp_asm_AES_set_encrypt_key,\@function,3
-GFp_asm_AES_set_encrypt_key:
+.globl GFp_aes_nohw_set_encrypt_key
+.type  GFp_aes_nohw_set_encrypt_key,\@function,3
+GFp_aes_nohw_set_encrypt_key:
 .cfi_startproc
 	push	%rbx
 .cfi_push	%rbx
@@ -741,7 +741,7 @@
 .Lenc_key_epilogue:
 	ret
 .cfi_endproc
-.size GFp_asm_AES_set_encrypt_key,.-GFp_asm_AES_set_encrypt_key
+.size GFp_aes_nohw_set_encrypt_key,.-GFp_aes_nohw_set_encrypt_key
 
 .type	_x86_64_AES_set_encrypt_key,\@abi-omnipotent
 .align	16
@@ -1256,21 +1256,21 @@
 
 .section	.pdata
 .align	4
-	.rva	.LSEH_begin_GFp_asm_AES_encrypt
-	.rva	.LSEH_end_GFp_asm_AES_encrypt
-	.rva	.LSEH_info_GFp_asm_AES_encrypt
+	.rva	.LSEH_begin_GFp_aes_nohw_encrypt
+	.rva	.LSEH_end_GFp_aes_nohw_encrypt
+	.rva	.LSEH_info_GFp_aes_nohw_encrypt
 
-	.rva	.LSEH_begin_GFp_asm_AES_set_encrypt_key
-	.rva	.LSEH_end_GFp_asm_AES_set_encrypt_key
-	.rva	.LSEH_info_GFp_asm_AES_set_encrypt_key
+	.rva	.LSEH_begin_GFp_aes_nohw_set_encrypt_key
+	.rva	.LSEH_end_GFp_aes_nohw_set_encrypt_key
+	.rva	.LSEH_info_GFp_aes_nohw_set_encrypt_key
 
 .section	.xdata
 .align	8
-.LSEH_info_GFp_asm_AES_encrypt:
+.LSEH_info_GFp_aes_nohw_encrypt:
 	.byte	9,0,0,0
 	.rva	block_se_handler
 	.rva	.Lenc_prologue,.Lenc_epilogue	# HandlerData[]
-.LSEH_info_GFp_asm_AES_set_encrypt_key:
+.LSEH_info_GFp_aes_nohw_set_encrypt_key:
 	.byte	9,0,0,0
 	.rva	key_se_handler
 	.rva	.Lenc_key_prologue,.Lenc_key_epilogue	# HandlerData[]
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aesni-x86.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aesni-x86.pl
index 0964a8c..f1cfddb 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aesni-x86.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aesni-x86.pl
@@ -67,9 +67,10 @@
 # Goldmont	3.84/1.39	1.39	1.63	1.31	1.70
 # Bulldozer	5.80/0.98	1.05	1.24	0.93	1.23
 
-$PREFIX="aesni";	# if $PREFIX is set to "AES", the script
+$PREFIX="GFp_aes_hw";	# if $PREFIX is set to "AES", the script
 			# generates drop-in replacement for
 			# crypto/aes/asm/aes-586.pl:-)
+$AESNI_PREFIX="GFp_aes_hw";
 $inline=1;		# inline _aesni_[en|de]crypt
 
 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
@@ -85,7 +86,7 @@
 &external_label("GFp_ia32cap_P");
 &static_label("key_const");
 
-if ($PREFIX eq "aesni")	{ $movekey=\&movups; }
+if ($PREFIX eq $AESNI_PREFIX)	{ $movekey=\&movups; }
 else			{ $movekey=\&movups; }
 
 $len="eax";
@@ -190,7 +191,7 @@
 
 # void $PREFIX_encrypt (const void *inp,void *out,const AES_KEY *key);
 &aesni_generate1("enc") if (!$inline);
-&function_begin_B("GFp_${PREFIX}_encrypt");
+&function_begin_B("${PREFIX}_encrypt");
 	&mov	("eax",&wparam(0));
 	&mov	($key,&wparam(2));
 	&movups	($inout0,&QWP(0,"eax"));
@@ -205,7 +206,7 @@
 	&movups	(&QWP(0,"eax"),$inout0);
 	&pxor	($inout0,$inout0);
 	&ret	();
-&function_end_B("GFp_${PREFIX}_encrypt");
+&function_end_B("${PREFIX}_encrypt");
 
 # _aesni_[en|de]cryptN are private interfaces, N denotes interleave
 # factor. Why 3x subroutine were originally used in loops? Even though
@@ -394,17 +395,17 @@
     &ret();
     &function_end_B("_aesni_${p}rypt6");
 }
-&aesni_generate2("enc") if ($PREFIX eq "aesni");
-&aesni_generate3("enc") if ($PREFIX eq "aesni");
-&aesni_generate4("enc") if ($PREFIX eq "aesni");
-&aesni_generate6("enc") if ($PREFIX eq "aesni");
+&aesni_generate2("enc") if ($PREFIX eq $AESNI_PREFIX);
+&aesni_generate3("enc") if ($PREFIX eq $AESNI_PREFIX);
+&aesni_generate4("enc") if ($PREFIX eq $AESNI_PREFIX);
+&aesni_generate6("enc") if ($PREFIX eq $AESNI_PREFIX);
 
-if ($PREFIX eq "aesni") {
+if ($PREFIX eq $AESNI_PREFIX) {
 
 ######################################################################
-# void GFp_aesni_ctr32_encrypt_blocks (const void *in, void *out,
-#                                      size_t blocks, const AES_KEY *key,
-#                                      const char *ivec);
+# void aes_hw_ctr32_encrypt_blocks (const void *in, void *out,
+#                         size_t blocks, const AES_KEY *key,
+#                         const char *ivec);
 #
 # Handles only complete blocks, operates on 32-bit counter and
 # does not update *ivec! (see crypto/modes/ctr128.c for details)
@@ -417,7 +418,7 @@
 #	64	2nd triplet of counter vector
 #	80	saved %esp
 
-&function_begin("GFp_aesni_ctr32_encrypt_blocks");
+&function_begin("${PREFIX}_ctr32_encrypt_blocks");
 	&mov	($inp,&wparam(0));
 	&mov	($out,&wparam(1));
 	&mov	($len,&wparam(2));
@@ -659,7 +660,7 @@
 	&movdqa	(&QWP(64,"esp"),"xmm0");
 	&pxor	("xmm7","xmm7");
 	&mov	("esp",&DWP(80,"esp"));
-&function_end("GFp_aesni_ctr32_encrypt_blocks");
+&function_end("${PREFIX}_ctr32_encrypt_blocks");
 }
 
 ######################################################################
@@ -950,13 +951,13 @@
 
 # int $PREFIX_set_encrypt_key (const unsigned char *userKey, int bits,
 #                              AES_KEY *key)
-&function_begin_B("GFp_${PREFIX}_set_encrypt_key");
+&function_begin_B("${PREFIX}_set_encrypt_key");
 	&mov	("eax",&wparam(0));
 	&mov	($rounds,&wparam(1));
 	&mov	($key,&wparam(2));
 	&call	("_aesni_set_encrypt_key");
 	&ret	();
-&function_end_B("GFp_${PREFIX}_set_encrypt_key");
+&function_end_B("${PREFIX}_set_encrypt_key");
 
 &set_label("key_const",64);
 &data_word(0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d);
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aesv8-armx.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aesv8-armx.pl
index 1c372e3..c40c470 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aesv8-armx.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/aesv8-armx.pl
@@ -77,6 +77,9 @@
 	$flavour=~/64/? map("q$_",(0..6)) : map("q$_",(0..3,8..10));
 
 
+# On AArch64, put the data .rodata and use adrp + add for compatibility with
+# execute-only memory. On AArch32, put it in .text and use adr.
+$code.= ".section .rodata\n" if ($flavour =~ /64/);
 $code.=<<___;
 .align	5
 .Lrcon:
@@ -84,6 +87,8 @@
 .long	0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d,0x0c0f0e0d	// rotate-n-splat
 .long	0x1b,0x1b,0x1b,0x1b
 
+.text
+
 .globl	GFp_${prefix}_set_encrypt_key
 .type	GFp_${prefix}_set_encrypt_key,%function
 .align	5
@@ -108,7 +113,15 @@
 	tst	$bits,#0x3f
 	b.ne	.Lenc_key_abort
 
+___
+$code.=<<___	if ($flavour =~ /64/);
+	adrp	$ptr,:pg_hi21:.Lrcon
+	add	$ptr,$ptr,:lo12:.Lrcon
+___
+$code.=<<___	if ($flavour !~ /64/);
 	adr	$ptr,.Lrcon
+___
+$code.=<<___;
 	cmp	$bits,#192
 
 	veor	$zero,$zero,$zero
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/bsaes-armv7.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/bsaes-armv7.pl
index 0fee795..eae3b3f 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/bsaes-armv7.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/asm/bsaes-armv7.pl
@@ -935,7 +935,7 @@
 my $keysched = "sp";
 
 $code.=<<___;
-.extern	GFp_AES_encrypt
+.extern	GFp_aes_nohw_encrypt
 .global	GFp_bsaes_ctr32_encrypt_blocks
 .type	GFp_bsaes_ctr32_encrypt_blocks,%function
 .align	5
@@ -1141,7 +1141,7 @@
 	mov	r1, sp			@ output on the stack
 	mov	r2, r7			@ key
 
-	bl	GFp_AES_encrypt
+	bl	GFp_aes_nohw_encrypt
 
 	vld1.8	{@XMM[0]}, [r4]!	@ load input
 	vld1.8	{@XMM[1]}, [sp]		@ load encrypted counter
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/internal.h b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/internal.h
index bc585c4..36cec2a 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/aes/internal.h
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/aes/internal.h
@@ -15,55 +15,16 @@
 #ifndef OPENSSL_HEADER_AES_INTERNAL_H
 #define OPENSSL_HEADER_AES_INTERNAL_H
 
-#include <stdlib.h>
-
-#include <GFp/cpu.h>
-
-#if defined(OPENSSL_NO_ASM) || \
-    (!defined(OPENSSL_X86) && !defined(OPENSSL_X86_64) && !defined(OPENSSL_ARM))
-#define GFp_C_AES
-void GFp_aes_c_set_encrypt_key(const uint8_t *key, unsigned bits,
-                               AES_KEY *aeskey);
-void GFp_aes_c_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key);
-#endif
-
-#if !defined(OPENSSL_NO_ASM)
-#if defined(OPENSSL_X86_64)
-#define HWAES
+#include "../../internal.h"
 
 static inline int hwaes_capable(void) {
+#if defined(OPENSSL_X86_64) || defined(OPENSSL_X86)
   return (GFp_ia32cap_P[1] & (1 << (57 - 32))) != 0;
-}
 #elif defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)
-#define HWAES
-
-static inline int hwaes_capable(void) {
   return GFp_is_ARMv8_AES_capable();
-}
 #elif defined(OPENSSL_PPC64LE)
-#define HWAES
-
-static inline int hwaes_capable(void) {
   return GFp_is_PPC64LE_vcrypto_capable();
-}
 #endif
-
-#endif  // !NO_ASM
-
-
-#if defined(HWAES)
-
-int aes_hw_set_encrypt_key(const uint8_t *user_key, const int bits,
-                           AES_KEY *key);
-int aes_hw_set_decrypt_key(const uint8_t *user_key, const int bits,
-                           AES_KEY *key);
-void aes_hw_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key);
-void aes_hw_decrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key);
-void aes_hw_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t length,
-                        const AES_KEY *key, uint8_t *ivec, const int enc);
-void aes_hw_ctr32_encrypt_blocks(const uint8_t *in, uint8_t *out, size_t len,
-                                 const AES_KEY *key, const uint8_t ivec[16]);
-
-#endif /* HWAES */
+}
 
 #endif  // OPENSSL_HEADER_AES_INTERNAL_H
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/asm/x86_64-mont5.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/asm/x86_64-mont5.pl
index 5d9340f..35de2d4 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/asm/x86_64-mont5.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/asm/x86_64-mont5.pl
@@ -2897,6 +2897,7 @@
 .align	32
 GFp_bn_sqrx8x_internal:
 __bn_sqrx8x_internal:
+.cfi_startproc
 	##################################################################
 	# Squaring part:
 	#
@@ -3529,6 +3530,7 @@
 	cmp	8+8(%rsp),%r8		# end of t[]?
 	jb	.Lsqrx8x_reduction_loop
 	ret
+.cfi_endproc
 .size	GFp_bn_sqrx8x_internal,.-GFp_bn_sqrx8x_internal
 ___
 }
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/exponentiation.c b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/exponentiation.c
deleted file mode 100644
index 957fb41..0000000
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/exponentiation.c
+++ /dev/null
@@ -1,461 +0,0 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-/* ====================================================================
- * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *
- * 3. All advertising materials mentioning features or use of this
- *    software must display the following acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- *    endorse or promote products derived from this software without
- *    prior written permission. For written permission, please contact
- *    openssl-core@openssl.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- *    nor may "OpenSSL" appear in their names without prior written
- *    permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- *    acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- * ====================================================================
- *
- * This product includes cryptographic software written by Eric Young
- * (eay@cryptsoft.com).  This product includes software written by Tim
- * Hudson (tjh@cryptsoft.com). */
-
-#if defined(_MSC_VER)
-#pragma warning(push, 3)
-#endif
-
-#include <limits.h>
-#include <string.h>
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#include <GFp/mem.h>
-
-#include "internal.h"
-#include "../../internal.h"
-#include "../../limbs/limbs.h"
-
-
-// Prototypes to avoid -Wmissing-prototypes warnings.
-int GFp_BN_mod_exp_mont_consttime(BN_ULONG rr[], const BN_ULONG a_mont[],
-                                  const BN_ULONG p[], const BN_ULONG one_mont[],
-                                  const BN_ULONG n[], size_t num_limbs,
-                                  const BN_ULONG n0[BN_MONT_CTX_N0_LIMBS]);
-
-#if defined(OPENSSL_X86_64)
-#define OPENSSL_BN_ASM_MONT5
-
-void GFp_bn_mul_mont_gather5(BN_ULONG rp[], const BN_ULONG ap[],
-                             const BN_ULONG table[], const BN_ULONG np[],
-                             const BN_ULONG n0[], int num, int power);
-void GFp_bn_scatter5(const BN_ULONG inp[], size_t num, BN_ULONG table[],
-                     size_t power);
-void GFp_bn_gather5(BN_ULONG out[], size_t num, const BN_ULONG table[],
-                    size_t power);
-void GFp_bn_power5(BN_ULONG rp[], const BN_ULONG ap[], const BN_ULONG table[],
-                   const BN_ULONG np[], const BN_ULONG n0[], int num,
-                   int power);
-int GFp_bn_from_montgomery(BN_ULONG rp[], const BN_ULONG ap[],
-                           const BN_ULONG *not_used, const BN_ULONG np[],
-                           const BN_ULONG n0[], int num);
-#else
-
-// GFp_BN_mod_exp_mont_consttime() stores the precomputed powers in a specific
-// layout so that accessing any of these table values shows the same access
-// pattern as far as cache lines are concerned. The following functions are
-// used to transfer a BIGNUM from/to that table.
-
-static void copy_to_prebuf(const BN_ULONG b[], int top, BN_ULONG table[],
-                           int idx, int window) {
-  int i, j;
-  const int width = 1 << window;
-  for (i = 0, j = idx; i < top; i++, j += width)  {
-    table[j] = b[i];
-  }
-}
-
-static void copy_from_prebuf(BN_ULONG b[], int top, const BN_ULONG buf[], int idx,
-                            int window) {
-  int i, j;
-  const int width = 1 << window;
-  volatile const BN_ULONG *table = (volatile const BN_ULONG *)buf;
-
-  if (window <= 3) {
-    for (i = 0; i < top; i++, table += width) {
-      BN_ULONG acc = 0;
-
-      for (j = 0; j < width; j++) {
-        acc |= table[j] & ((BN_ULONG)0 - (constant_time_eq_int(j, idx) & 1));
-      }
-
-      b[i] = acc;
-    }
-  } else {
-    int xstride = 1 << (window - 2);
-    BN_ULONG y0, y1, y2, y3;
-
-    i = idx >> (window - 2);  // equivalent of idx / xstride
-    idx &= xstride - 1;       // equivalent of idx % xstride
-
-    y0 = (BN_ULONG)0 - (constant_time_eq_int(i, 0) & 1);
-    y1 = (BN_ULONG)0 - (constant_time_eq_int(i, 1) & 1);
-    y2 = (BN_ULONG)0 - (constant_time_eq_int(i, 2) & 1);
-    y3 = (BN_ULONG)0 - (constant_time_eq_int(i, 3) & 1);
-
-    for (i = 0; i < top; i++, table += width) {
-      BN_ULONG acc = 0;
-
-      for (j = 0; j < xstride; j++) {
-        acc |= ((table[j + 0 * xstride] & y0) | (table[j + 1 * xstride] & y1) |
-                (table[j + 2 * xstride] & y2) | (table[j + 3 * xstride] & y3)) &
-               ((BN_ULONG)0 - (constant_time_eq_int(j, idx) & 1));
-      }
-
-      b[i] = acc;
-    }
-  }
-}
-#endif
-
-// GFp_BN_mod_exp_mont_consttime is based on the assumption that the L1 data cache
-// line width of the target processor is at least the following value.
-#define MOD_EXP_CTIME_MIN_CACHE_LINE_WIDTH (64)
-#define MOD_EXP_CTIME_MIN_CACHE_LINE_MASK \
-  (MOD_EXP_CTIME_MIN_CACHE_LINE_WIDTH - 1)
-
-#if !defined(OPENSSL_X86_64)
-
-// Window sizes optimized for fixed window size modular exponentiation
-// algorithm (GFp_BN_mod_exp_mont_consttime).
-//
-// To achieve the security goals of GFp_BN_mod_exp_mont_consttime, the maximum
-// size of the window must not exceed
-// log_2(MOD_EXP_CTIME_MIN_CACHE_LINE_WIDTH).
-//
-// Window size thresholds are defined for cache line sizes of 32 and 64, cache
-// line sizes where log_2(32)=5 and log_2(64)=6 respectively. A window size of
-// 7 should only be used on processors that have a 128 byte or greater cache
-// line size.
-#if MOD_EXP_CTIME_MIN_CACHE_LINE_WIDTH == 64
-
-#define BN_MAX_WINDOW_BITS_FOR_CTIME_EXPONENT_SIZE (6)
-
-#elif MOD_EXP_CTIME_MIN_CACHE_LINE_WIDTH == 32
-
-#define BN_MAX_WINDOW_BITS_FOR_CTIME_EXPONENT_SIZE (5)
-
-#endif
-
-#endif // defined(OPENSSL_X86_64)
-
-// Given a pointer value, compute the next address that is a cache line
-// multiple.
-#define MOD_EXP_CTIME_ALIGN(x_)          \
-  ((unsigned char *)(x_) +               \
-   (MOD_EXP_CTIME_MIN_CACHE_LINE_WIDTH - \
-    (((uintptr_t)(x_)) & (MOD_EXP_CTIME_MIN_CACHE_LINE_MASK))))
-
-// This variant of GFp_BN_mod_exp_mont() uses fixed windows and the special
-// precomputation memory layout to limit data-dependency to a minimum
-// to protect secret exponents (cf. the hyper-threading timing attacks
-// pointed out by Colin Percival,
-// http://www.daemonology.net/hyperthreading-considered-harmful/).
-//
-// |p| must be positive. |a_mont| must in [0, m). |one_mont| must be
-// the value 1 Montgomery-encoded and fully reduced (mod m).
-//
-// Assumes 0 < a_mont < n, 0 < p, 0 < p_bits.
-int GFp_BN_mod_exp_mont_consttime(BN_ULONG rr[], const BN_ULONG a_mont[],
-                                  const BN_ULONG p[], const BN_ULONG one_mont[],
-                                  const BN_ULONG n[], size_t num_limbs,
-                                  const BN_ULONG n0[BN_MONT_CTX_N0_LIMBS]) {
-  int i, ret = 0, wvalue;
-
-  int numPowers;
-  unsigned char *powerbufFree = NULL;
-  int powerbufLen = 0;
-
-  const int top = (int)num_limbs;
-  if (!GFp_bn_mul_mont_check_num_limbs(num_limbs)) {
-    goto err;
-  }
-
-  // Use all bits stored in |p|, rather than |BN_num_bits|, so we do not leak
-  // whether the top bits are zero.
-  int max_bits = (int)num_limbs * BN_BITS2;
-  int bits = max_bits;
-  assert(bits > 0);
-
-  // Get the window size to use with size of p.
-#if defined(OPENSSL_BN_ASM_MONT5)
-  static const int window = 5;
-  // reserve space for n copy
-  powerbufLen += top * sizeof(n[0]);
-#else
-  const int window = BN_MAX_WINDOW_BITS_FOR_CTIME_EXPONENT_SIZE;
-#endif
-
-  // Allocate a buffer large enough to hold all of the pre-computed
-  // powers of am, am itself and tmp.
-  numPowers = 1 << window;
-  powerbufLen +=
-      sizeof(n[0]) *
-      (top * numPowers + ((2 * top) > numPowers ? (2 * top) : numPowers));
-  powerbufFree = malloc(powerbufLen + MOD_EXP_CTIME_MIN_CACHE_LINE_WIDTH);
-  if (powerbufFree == NULL) {
-    goto err;
-  }
-  BN_ULONG *powerbuf = (BN_ULONG *)MOD_EXP_CTIME_ALIGN(powerbufFree);
-
-  // Lay down tmp and am right after powers table.
-  BN_ULONG *tmp = powerbuf + (top * numPowers);
-  BN_ULONG *am = tmp + top;
-
-  // Copy a^0 and a^1.
-  LIMBS_copy(tmp, one_mont, num_limbs);
-  LIMBS_copy(am, a_mont, num_limbs);
-
-#if defined(OPENSSL_BN_ASM_MONT5)
-  // This optimization uses ideas from http://eprint.iacr.org/2011/239,
-  // specifically optimization of cache-timing attack countermeasures
-  // and pre-computation optimization.
-  {
-    BN_ULONG *np = am + top;
-
-    // copy n[] to improve cache locality
-    LIMBS_copy(np, n, num_limbs);
-
-    GFp_bn_scatter5(tmp, top, powerbuf, 0);
-    GFp_bn_scatter5(am, top, powerbuf, 1);
-    GFp_bn_mul_mont(tmp, am, am, np, n0, top);
-    GFp_bn_scatter5(tmp, top, powerbuf, 2);
-
-    // same as above, but uses squaring for 1/2 of operations
-    for (i = 4; i < 32; i *= 2) {
-      GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-      GFp_bn_scatter5(tmp, top, powerbuf, i);
-    }
-    for (i = 3; i < 8; i += 2) {
-      int j;
-      GFp_bn_mul_mont_gather5(tmp, am, powerbuf, np, n0, top, i - 1);
-      GFp_bn_scatter5(tmp, top, powerbuf, i);
-      for (j = 2 * i; j < 32; j *= 2) {
-        GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-        GFp_bn_scatter5(tmp, top, powerbuf, j);
-      }
-    }
-    for (; i < 16; i += 2) {
-      GFp_bn_mul_mont_gather5(tmp, am, powerbuf, np, n0, top, i - 1);
-      GFp_bn_scatter5(tmp, top, powerbuf, i);
-      GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-      GFp_bn_scatter5(tmp, top, powerbuf, 2 * i);
-    }
-    for (; i < 32; i += 2) {
-      GFp_bn_mul_mont_gather5(tmp, am, powerbuf, np, n0, top, i - 1);
-      GFp_bn_scatter5(tmp, top, powerbuf, i);
-    }
-
-    bits--;
-    for (wvalue = 0, i = bits % 5; i >= 0; i--, bits--) {
-      wvalue = (wvalue << 1) + GFp_bn_is_bit_set_words(p, num_limbs, bits);
-    }
-    GFp_bn_gather5(tmp, top, powerbuf, wvalue);
-
-    // At this point |bits| is 4 mod 5 and at least -1. (|bits| is the first bit
-    // that has not been read yet.)
-    assert(bits >= -1 && (bits == -1 || bits % 5 == 4));
-
-    // Scan the exponent one window at a time starting from the most
-    // significant bits.
-    if (top & 7) {
-      while (bits >= 0) {
-        for (wvalue = 0, i = 0; i < 5; i++, bits--) {
-          wvalue = (wvalue << 1) + GFp_bn_is_bit_set_words(p, num_limbs, bits);
-        }
-
-        GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-        GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-        GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-        GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-        GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-        GFp_bn_mul_mont_gather5(tmp, tmp, powerbuf, np, n0, top, wvalue);
-      }
-    } else {
-      const aliasing_uint8 *p_bytes = (const aliasing_uint8 *)p;
-      assert(bits < max_bits);
-      // |p = 0| has been handled as a special case, so |max_bits| is at least
-      // one word.
-      assert(max_bits >= 64);
-
-      // If the first bit to be read lands in the last byte, unroll the first
-      // iteration to avoid reading past the bounds of |p|. (After the first
-      // iteration, we are guaranteed to be past the last byte.) Note |bits|
-      // here is the top bit, inclusive.
-      if (bits - 4 >= max_bits - 8) {
-        // Read five bits from |bits-4| through |bits|, inclusive.
-        wvalue = p_bytes[num_limbs * sizeof(Limb) - 1];
-        wvalue >>= (bits - 4) & 7;
-        wvalue &= 0x1f;
-        bits -= 5;
-        GFp_bn_power5(tmp, tmp, powerbuf, np, n0, top, wvalue);
-      }
-      while (bits >= 0) {
-        // Read five bits from |bits-4| through |bits|, inclusive.
-        int first_bit = bits - 4;
-        uint16_t val;
-        // Assumes little-endian.
-        memcpy(&val, p_bytes + (first_bit >> 3), sizeof(val));
-        val >>= first_bit & 7;
-        val &= 0x1f;
-        bits -= 5;
-        GFp_bn_power5(tmp, tmp, powerbuf, np, n0, top, val);
-      }
-    }
-
-    if (!GFp_bn_from_montgomery(tmp, tmp, NULL, np, n0, top)) {
-      goto err;
-    }
-  }
-#else
-  {
-    const BN_ULONG *np = n;
-
-    copy_to_prebuf(tmp, top, powerbuf, 0, window);
-    copy_to_prebuf(am, top, powerbuf, 1, window);
-
-    // If the window size is greater than 1, then calculate
-    // val[i=2..2^winsize-1]. Powers are computed as a*a^(i-1)
-    // (even powers could instead be computed as (a^(i/2))^2
-    // to use the slight performance advantage of sqr over mul).
-    if (window > 1) {
-      GFp_bn_mul_mont(tmp, am, am, np, n0, top);
-      copy_to_prebuf(tmp, top, powerbuf, 2, window);
-
-      for (i = 3; i < numPowers; i++) {
-        // Calculate a^i = a^(i-1) * a
-        GFp_bn_mul_mont(tmp, am, tmp, np, n0, top);
-        copy_to_prebuf(tmp, top, powerbuf, i, window);
-      }
-    }
-
-    bits--;
-    for (wvalue = 0, i = bits % window; i >= 0; i--, bits--) {
-      wvalue = (wvalue << 1) + GFp_bn_is_bit_set_words(p, num_limbs, bits);
-    }
-    copy_from_prebuf(tmp, top, powerbuf, wvalue, window);
-
-    // Scan the exponent one window at a time starting from the most
-    // significant bits.
-    while (bits >= 0) {
-      wvalue = 0;  // The 'value' of the window
-
-      // Scan the window, squaring the result as we go
-      for (i = 0; i < window; i++, bits--) {
-        GFp_bn_mul_mont(tmp, tmp, tmp, np, n0, top);
-        wvalue = (wvalue << 1) + GFp_bn_is_bit_set_words(p, num_limbs, bits);
-      }
-
-      // Fetch the appropriate pre-computed value from the pre-buf */
-      copy_from_prebuf(am, top, powerbuf, wvalue, window);
-
-      // Multiply the result into the intermediate result */
-      GFp_bn_mul_mont(tmp, tmp, am, np, n0, top);
-    }
-  }
-#endif
-  LIMBS_copy(rr, tmp, top);
-
-  ret = 1;
-
-err:
-  OPENSSL_free(powerbufFree);
-  return (ret);
-}
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/generic.c b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/generic.c
index 77703e2..7bcb68e 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/generic.c
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/generic.c
@@ -78,7 +78,7 @@
     return c1;
   }
 
-  while (num & ~3) {
+  while (num >= 4) {
     mul_add(rp[0], ap[0], w, c1);
     mul_add(rp[1], ap[1], w, c1);
     mul_add(rp[2], ap[2], w, c1);
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/internal.h b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/internal.h
index e3b562d..5da22bb 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/internal.h
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/internal.h
@@ -184,12 +184,11 @@
 // implicitly treated as a |size_t|; when |int| is smaller than |size_t|
 // then the |movq 48(%rsp),%r9| done by x86_64-xlate.pl implicitly does the
 // conversion.
-OPENSSL_COMPILE_ASSERT(sizeof(int) == sizeof(size_t) ||
-                       (sizeof(int) == 4 && sizeof(size_t) == 8),
-                       int_and_size_t_abi_mismatch);
+OPENSSL_STATIC_ASSERT(sizeof(int) == sizeof(size_t) ||
+                      (sizeof(int) == 4 && sizeof(size_t) == 8),
+                      "int and size_t ABI mismatch");
 void GFp_bn_mul_mont(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
                      const BN_ULONG *np, const BN_ULONG *n0, size_t num);
-int GFp_bn_mul_mont_check_num_limbs(size_t top);
 
 static inline void bn_umult_lohi(BN_ULONG *low_out, BN_ULONG *high_out,
                                  BN_ULONG a, BN_ULONG b) {
@@ -202,8 +201,4 @@
 #endif
 }
 
-// bn_is_bit_set_words returns one if bit |bit| is set in |a| and zero
-// otherwise.
-int GFp_bn_is_bit_set_words(const BN_ULONG *a, size_t num, unsigned bit);
-
 #endif  // OPENSSL_HEADER_BN_INTERNAL_H
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/montgomery.c b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/montgomery.c
index 0bf3c8a..6bbff80 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/montgomery.c
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/montgomery.c
@@ -117,10 +117,11 @@
                                     size_t num_n,
                                     const BN_ULONG n0_[BN_MONT_CTX_N0_LIMBS]);
 
-OPENSSL_COMPILE_ASSERT(BN_MONT_CTX_N0_LIMBS == 1 || BN_MONT_CTX_N0_LIMBS == 2,
-                       BN_MONT_CTX_N0_LIMBS_VALUE_INVALID);
-OPENSSL_COMPILE_ASSERT(sizeof(BN_ULONG) * BN_MONT_CTX_N0_LIMBS ==
-                       sizeof(uint64_t), BN_MONT_CTX_set_64_bit_mismatch);
+OPENSSL_STATIC_ASSERT(BN_MONT_CTX_N0_LIMBS == 1 || BN_MONT_CTX_N0_LIMBS == 2,
+  "BN_MONT_CTX_N0_LIMBS value is invalid");
+OPENSSL_STATIC_ASSERT(
+  sizeof(BN_ULONG) * BN_MONT_CTX_N0_LIMBS == sizeof(uint64_t),
+  "uint64_t is insufficient precision for n0");
 
 int GFp_bn_from_montgomery_in_place(BN_ULONG r[], size_t num_r, BN_ULONG a[],
                                     size_t num_a, const BN_ULONG n[],
@@ -161,11 +162,3 @@
   }
   return 1;
 }
-
-int GFp_bn_mul_mont_check_num_limbs(size_t num_limbs) {
-  // GFp_bn_mul_mont requires at least four limbs, at least for x86.
-  if (num_limbs < 4) {
-    return 0;
-  }
-  return 1;
-}
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/montgomery_inv.c b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/montgomery_inv.c
index d14582f..95a0712 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/montgomery_inv.c
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/montgomery_inv.c
@@ -19,11 +19,10 @@
 // Avoid -Wmissing-prototypes warnings.
 uint64_t GFp_bn_neg_inv_mod_r_u64(uint64_t n);
 
-OPENSSL_COMPILE_ASSERT(BN_MONT_CTX_N0_LIMBS == 1 || BN_MONT_CTX_N0_LIMBS == 2,
-                       BN_MONT_CTX_N0_LIMBS_VALUE_INVALID);
-OPENSSL_COMPILE_ASSERT(sizeof(uint64_t) ==
-                       BN_MONT_CTX_N0_LIMBS * sizeof(BN_ULONG),
-                       BN_MONT_CTX_N0_LIMBS_DOES_NOT_MATCH_UINT64_T);
+OPENSSL_STATIC_ASSERT(BN_MONT_CTX_N0_LIMBS == 1 || BN_MONT_CTX_N0_LIMBS == 2,
+                      "BN_MONT_CTX_N0_LIMBS value is invalid");
+OPENSSL_STATIC_ASSERT(sizeof(BN_ULONG) * BN_MONT_CTX_N0_LIMBS == sizeof(uint64_t),
+                      "uint64_t is insufficient precision for n0");
 
 // LG_LITTLE_R is log_2(r).
 #define LG_LITTLE_R (BN_MONT_CTX_N0_LIMBS * BN_BITS2)
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/shift.c b/rustc_deps/vendor/ring/crypto/fipsmodule/bn/shift.c
deleted file mode 100644
index 304c43c..0000000
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/bn/shift.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
-
-#include "internal.h"
-
-
-int GFp_bn_is_bit_set_words(const BN_ULONG *a, size_t num, unsigned bit) {
-  unsigned i = bit / BN_BITS2;
-  unsigned j = bit % BN_BITS2;
-  if (i >= num) {
-    return 0;
-  }
-  return (a[i] >> j) & 1;
-}
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/cipher/e_aes.c b/rustc_deps/vendor/ring/crypto/fipsmodule/cipher/e_aes.c
index 79d627d..865e844 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/cipher/e_aes.c
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/cipher/e_aes.c
@@ -46,288 +46,34 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  * ==================================================================== */
 
-#if defined(_MSC_VER)
-#pragma warning(push, 3)
-#endif
-
-#include <string.h>
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#include <GFp/aes.h>
 #include <GFp/cpu.h>
 
-#include "internal.h"
-#include "../../internal.h"
 #include "../aes/internal.h"
-#include "../modes/internal.h"
 
 #if defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)
 #include <GFp/arm_arch.h>
 #endif
 
+int GFp_aes_hw_capable(void);
 
-#define EVP_AEAD_AES_GCM_NONCE_LEN 12
-#define EVP_AEAD_AES_GCM_TAG_LEN 16
-
-// Declarations for extern functions only called by Rust code, to avoid
-// -Wmissing-prototypes warnings.
-int GFp_aes_gcm_init(uint8_t *ctx_buf, size_t ctx_buf_len, const uint8_t *key,
-                     size_t key_len);
-int GFp_aes_gcm_open(const uint8_t *ctx_buf, uint8_t *out, size_t in_out_len,
-                     uint8_t tag_out[EVP_AEAD_AES_GCM_TAG_LEN],
-                     const uint8_t nonce[EVP_AEAD_AES_GCM_NONCE_LEN],
-                     const uint8_t *in, const uint8_t *ad, size_t ad_len);
-int GFp_aes_gcm_seal(const uint8_t *ctx_buf, uint8_t *in_out, size_t in_out_len,
-                     uint8_t tag_out[EVP_AEAD_AES_GCM_TAG_LEN],
-                     const uint8_t nonce[EVP_AEAD_AES_GCM_NONCE_LEN],
-                     const uint8_t *ad, size_t ad_len);
-void GFp_AES_set_encrypt_key(const uint8_t *user_key, unsigned bits,
-                             AES_KEY *key);
-void GFp_AES_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key);
-int GFp_has_aes_hardware(void);
-
-
-#if !defined(GFp_C_AES)
-int GFp_asm_AES_set_encrypt_key(const uint8_t *key, unsigned bits,
-                                AES_KEY *aeskey);
-void GFp_asm_AES_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key);
-#endif
+int GFp_aes_hw_capable(void) {
+  return hwaes_capable();
+}
 
 #if !defined(OPENSSL_NO_ASM) && \
     (defined(OPENSSL_X86_64) || defined(OPENSSL_X86))
-#define VPAES
-static char vpaes_capable(void) {
+int GFp_vpaes_capable(void);
+
+int GFp_vpaes_capable(void) {
   return (GFp_ia32cap_P[1] & (1 << (41 - 32))) != 0;
 }
 #endif
 
 #if !defined(OPENSSL_NO_ASM) && \
     defined(OPENSSL_ARM) && __ARM_MAX_ARCH__ >= 7
-#define BSAES
-static char bsaes_capable(void) {
+int GFp_bsaes_capable(void);
+
+int GFp_bsaes_capable(void) {
   return GFp_is_NEON_capable();
 }
 #endif
-
-#if defined(BSAES)
-// On platforms where BSAES gets defined (just above), then these functions are
-// provided by asm.
-void GFp_bsaes_ctr32_encrypt_blocks(const uint8_t *in, uint8_t *out, size_t len,
-                                    const AES_KEY *key, const uint8_t ivec[16]);
-#endif
-
-#if defined(HWAES)
-int GFp_aes_hw_set_encrypt_key(const uint8_t *user_key, unsigned bits,
-                               AES_KEY *key);
-void GFp_aes_hw_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key);
-void GFp_aes_hw_ctr32_encrypt_blocks(const uint8_t *in, uint8_t *out,
-                                     size_t len, const AES_KEY *key,
-                                     const uint8_t ivec[16]);
-#endif
-
-static void aes_ctr32_encrypt_blocks(const uint8_t *in, uint8_t *out,
-                                     size_t len, const AES_KEY *key,
-                                     const uint8_t ivec[16]);
-
-#if defined(VPAES)
-// On platforms where VPAES gets defined (just above), then these functions are
-// provided by asm.
-int GFp_vpaes_set_encrypt_key(const uint8_t *userKey, unsigned bits,
-                              AES_KEY *key);
-void GFp_vpaes_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key);
-#endif
-
-// |bits| must be 128 or 256. 192-bit keys are not supported.
-void GFp_AES_set_encrypt_key(const uint8_t *user_key, unsigned bits,
-                             AES_KEY *key) {
-  // Keep this in sync with |gcm128_init_gmult_ghash| and |aes_ctr|.
-
-  assert(user_key != NULL);
-  assert(key != NULL);
-  assert(bits == 128 || bits == 256);
-
-#if defined(HWAES)
-  if (hwaes_capable()) {
-    (void) GFp_aes_hw_set_encrypt_key(user_key, bits, key);
-    return;
-  }
-#endif
-
-#if defined(VPAES)
-#if defined(BSAES)
-#error "BSAES and VPAES are enabled at the same time, unexpectedly."
-#endif
-  if (vpaes_capable()) {
-    (void) GFp_vpaes_set_encrypt_key(user_key, bits, key);
-    return;
-  }
-#endif
-
-#if defined(GFp_C_AES)
-  GFp_aes_c_set_encrypt_key(user_key, bits, key);
-#else
-  GFp_asm_AES_set_encrypt_key(user_key, bits, key);
-#endif
-}
-
-static aes_block_f aes_block(void) {
-  // Keep this in sync with |GFp_AES_set_encrypt_key| and |aes_ctr|.
-
-#if defined(HWAES)
-  if (hwaes_capable()) {
-    return GFp_aes_hw_encrypt;
-  }
-#endif
-
-#if defined(VPAES)
-#if defined(BSAES)
-#error "BSAES and VPAES are enabled at the same time, unexpectedly."
-#endif
-  if (vpaes_capable()) {
-    return GFp_vpaes_encrypt;
-  }
-#endif
-
-#if defined(GFp_C_AES)
-  return GFp_aes_c_encrypt;
-#else
-  return GFp_asm_AES_encrypt;
-#endif
-}
-
-void GFp_AES_encrypt(const uint8_t *in, uint8_t *out, const AES_KEY *key) {
-  (aes_block())(in, out, key);
-}
-
-static aes_ctr_f aes_ctr(void) {
-  // Keep this in sync with |set_set_key| and |aes_block|.
-
-#if defined(HWAES)
-  if (hwaes_capable()) {
-    return GFp_aes_hw_ctr32_encrypt_blocks;
-  }
-#endif
-
-#if defined(BSAES)
-  if (bsaes_capable()) {
-    return GFp_bsaes_ctr32_encrypt_blocks;
-  }
-#endif
-
-  return aes_ctr32_encrypt_blocks;
-}
-
-static void aes_ctr32_encrypt_blocks(const uint8_t *in, uint8_t *out,
-                                     size_t blocks, const AES_KEY *key,
-                                     const uint8_t ivec[16]) {
-  alignas(16) uint8_t counter_plaintext[16];
-  memcpy(counter_plaintext, ivec, 16);
-  uint32_t counter = from_be_u32_ptr(&counter_plaintext[12]);
-
-  aes_block_f block = aes_block();
-
-  for (size_t current_block = 0; current_block < blocks; ++current_block) {
-    alignas(16) uint8_t counter_ciphertext[16];
-    block(counter_plaintext, counter_ciphertext, key);
-    for (size_t i = 0; i < 16; ++i) {
-      out[i] = in[i] ^ counter_ciphertext[i];
-    }
-    // The caller must ensure the counter won't wrap around.
-    ++counter;
-    assert(counter != 0);
-    to_be_u32_ptr(&counter_plaintext[12], counter);
-    out += 16;
-    in += 16;
-  }
-}
-
-int GFp_aes_gcm_init(uint8_t *ctx_buf, size_t ctx_buf_len, const uint8_t *key,
-                     size_t key_len) {
-  alignas(16) AES_KEY ks;
-  assert(ctx_buf_len >= sizeof(ks) + GCM128_SERIALIZED_LEN);
-  if (ctx_buf_len < sizeof(ks) + GCM128_SERIALIZED_LEN) {
-    return 0;
-  }
-
-  if (key_len != (128 / 8) && key_len != (256 / 8)) {
-    return 0; // Invalid key length
-  }
-
-  GFp_AES_set_encrypt_key(key, (unsigned)key_len * 8, &ks);
-
-  GFp_gcm128_init_serialized(ctx_buf + sizeof(ks), &ks, aes_block());
-  memcpy(ctx_buf, &ks, sizeof(ks));
-  return 1;
-}
-
-static int gfp_aes_gcm_init_and_aad(GCM128_CONTEXT *gcm, AES_KEY *ks,
-                                    const uint8_t *ctx_buf, const uint8_t nonce[],
-                                    const uint8_t ad[], size_t ad_len) {
-  assert(ad != NULL || ad_len == 0);
-  memcpy(ks, ctx_buf, sizeof(*ks));
-
-  GFp_gcm128_init(gcm, ks, aes_block(), ctx_buf + sizeof(*ks),
-                  nonce);
-  return GFp_gcm128_aad(gcm, ad, ad_len);
-}
-
-int GFp_aes_gcm_seal(const uint8_t *ctx_buf, uint8_t *in_out, size_t in_out_len,
-                     uint8_t tag_out[EVP_AEAD_AES_GCM_TAG_LEN],
-                     const uint8_t nonce[EVP_AEAD_AES_GCM_NONCE_LEN],
-                     const uint8_t *ad, size_t ad_len) {
-  assert(in_out != NULL || in_out_len == 0);
-  assert(ad != NULL || ad_len == 0);
-
-  GCM128_CONTEXT gcm;
-  alignas(16) AES_KEY ks;
-  if (!gfp_aes_gcm_init_and_aad(&gcm, &ks, ctx_buf, nonce, ad, ad_len)) {
-    return 0;
-  }
-  if (in_out_len > 0) {
-    aes_ctr_f ctr = aes_ctr();
-    if (!GFp_gcm128_encrypt_ctr32(&gcm, &ks, in_out, in_out, in_out_len,
-                                  ctr)) {
-      return 0;
-    }
-  }
-  GFp_gcm128_tag(&gcm, tag_out);
-  return 1;
-}
-
-int GFp_aes_gcm_open(const uint8_t *ctx_buf, uint8_t *out, size_t in_out_len,
-                     uint8_t tag_out[EVP_AEAD_AES_GCM_TAG_LEN],
-                     const uint8_t nonce[EVP_AEAD_AES_GCM_NONCE_LEN],
-                     const uint8_t *in, const uint8_t *ad, size_t ad_len) {
-  assert(out != NULL || in_out_len == 0);
-  assert(aead_check_alias(in, in_out_len, out));
-  assert(in != NULL || in_out_len == 0);
-  assert(ad != NULL || ad_len == 0);
-
-  GCM128_CONTEXT gcm;
-  alignas(16) AES_KEY ks;
-  if (!gfp_aes_gcm_init_and_aad(&gcm, &ks, ctx_buf, nonce, ad, ad_len)) {
-    return 0;
-  }
-  if (in_out_len > 0) {
-    aes_ctr_f ctr = aes_ctr();
-    if (!GFp_gcm128_decrypt_ctr32(&gcm, &ks, in, out, in_out_len, ctr)) {
-      return 0;
-    }
-  }
-  GFp_gcm128_tag(&gcm, tag_out);
-  return 1;
-}
-
-
-int GFp_has_aes_hardware(void) {
-#if defined(HWAES) && (defined(OPENSSL_X86) || defined(OPENSSL_X86_64))
-  return hwaes_capable() && GFp_gcm_clmul_enabled();
-#elif defined(HWAES) && (defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64))
-  return hwaes_capable() && GFp_is_ARMv8_PMULL_capable();
-#else
-  return 0;
-#endif
-}
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/cipher/internal.h b/rustc_deps/vendor/ring/crypto/fipsmodule/cipher/internal.h
deleted file mode 100644
index 1e2c637..0000000
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/cipher/internal.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
-
-#ifndef OPENSSL_HEADER_CIPHER_INTERNAL_H
-#define OPENSSL_HEADER_CIPHER_INTERNAL_H
-
-#include <GFp/base.h>
-
-#include <GFp/aes.h>
-
-#include "../../internal.h"
-#include "../modes/internal.h"
-
-// Preconditions for AEAD implementation methods. */
-
-// aead_check_alias returns 0 if |out| points within the buffer determined by
-// |in| and |in_len| and 1 otherwise.
-//
-// When processing, there's only an issue if |out| points within in[:in_len]
-// and isn't equal to |in|. If that's the case then writing the output will
-// stomp input that hasn't been read yet.
-//
-// This function checks for that case. */
-static inline int aead_check_alias(const uint8_t *in, size_t in_len,
-                                   const uint8_t *out) {
-  if (out <= in) {
-    return 1;
-  } else if (in + in_len <= out) {
-    return 1;
-  }
-  return 0;
-}
-
-// TODO: This isn't used yet, but it will probably be used soon, once
-// AES-GCM-SIV is integrated into *ring*.
-//
-#if 0
-
-// aes_ctr_set_key initialises |*aes_key| using |key_bytes| bytes from |key|,
-// where |key_bytes| must either be 16, 24 or 32. If not NULL, |*out_block| is
-// set to a function that encrypts single blocks. If not NULL, |*gcm_ctx| is
-// initialised to do GHASH with the given key. It returns a function for
-// optimised CTR-mode, or NULL if CTR-mode should be built using
-// |*out_block|.
-ctr128_f aes_ctr_set_key(AES_KEY *aes_key, GCM128_CONTEXT *gcm_ctx,
-                         block128_f *out_block, const uint8_t *key,
-                         size_t key_bytes);
-
-#endif
-
-#endif  // OPENSSL_HEADER_CIPHER_INTERNAL_H
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl
index 29843ae..acddaed 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/asm/p256-x86_64-asm.pl
@@ -1366,6 +1366,7 @@
 .type	__ecp_nistz256_mul_montq,\@abi-omnipotent
 .align	32
 __ecp_nistz256_mul_montq:
+.cfi_startproc
 	########################################################################
 	# Multiply a by b[0]
 	mov	%rax, $t1
@@ -1577,6 +1578,7 @@
 	mov	$acc1, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_mul_montq,.-__ecp_nistz256_mul_montq
 
 ################################################################################
@@ -1661,6 +1663,7 @@
 .type	__ecp_nistz256_sqr_montq,\@abi-omnipotent
 .align	32
 __ecp_nistz256_sqr_montq:
+.cfi_startproc
 	mov	%rax, $acc5
 	mulq	$acc6			# a[1]*a[0]
 	mov	%rax, $acc1
@@ -1818,6 +1821,7 @@
 	mov	$acc7, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_sqr_montq,.-__ecp_nistz256_sqr_montq
 ___
 
@@ -1826,6 +1830,7 @@
 .type	__ecp_nistz256_mul_montx,\@abi-omnipotent
 .align	32
 __ecp_nistz256_mul_montx:
+.cfi_startproc
 	########################################################################
 	# Multiply by b[0]
 	mulx	$acc1, $acc0, $acc1
@@ -1988,11 +1993,13 @@
 	mov	$acc1, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_mul_montx,.-__ecp_nistz256_mul_montx
 
 .type	__ecp_nistz256_sqr_montx,\@abi-omnipotent
 .align	32
 __ecp_nistz256_sqr_montx:
+.cfi_startproc
 	mulx	$acc6, $acc1, $acc2	# a[0]*a[1]
 	mulx	$acc7, $t0, $acc3	# a[0]*a[2]
 	xor	%eax, %eax
@@ -2116,6 +2123,7 @@
 	mov	$acc7, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_sqr_montx,.-__ecp_nistz256_sqr_montx
 ___
 }
@@ -2133,6 +2141,7 @@
 .type	GFp_nistz256_select_w5,\@abi-omnipotent
 .align	32
 GFp_nistz256_select_w5:
+.cfi_startproc
 ___
 $code.=<<___	if ($avx>1);
 	leaq	GFp_ia32cap_P(%rip), %rax
@@ -2222,6 +2231,7 @@
 ___
 $code.=<<___;
 	ret
+.cfi_endproc
 .LSEH_end_GFp_nistz256_select_w5:
 .size	GFp_nistz256_select_w5,.-GFp_nistz256_select_w5
 
@@ -2231,6 +2241,7 @@
 .type	GFp_nistz256_select_w7,\@abi-omnipotent
 .align	32
 GFp_nistz256_select_w7:
+.cfi_startproc
 ___
 $code.=<<___	if ($avx>1);
 	leaq	GFp_ia32cap_P(%rip), %rax
@@ -2309,6 +2320,7 @@
 ___
 $code.=<<___;
 	ret
+.cfi_endproc
 .LSEH_end_GFp_nistz256_select_w7:
 .size	GFp_nistz256_select_w7,.-GFp_nistz256_select_w7
 ___
@@ -2325,6 +2337,7 @@
 .type	GFp_nistz256_avx2_select_w5,\@abi-omnipotent
 .align	32
 GFp_nistz256_avx2_select_w5:
+.cfi_startproc
 .Lavx2_select_w5:
 	vzeroupper
 ___
@@ -2412,6 +2425,7 @@
 ___
 $code.=<<___;
 	ret
+.cfi_endproc
 .LSEH_end_GFp_nistz256_avx2_select_w5:
 .size	GFp_nistz256_avx2_select_w5,.-GFp_nistz256_avx2_select_w5
 ___
@@ -2431,6 +2445,7 @@
 .type	GFp_nistz256_avx2_select_w7,\@abi-omnipotent
 .align	32
 GFp_nistz256_avx2_select_w7:
+.cfi_startproc
 .Lavx2_select_w7:
 	vzeroupper
 ___
@@ -2533,6 +2548,7 @@
 ___
 $code.=<<___;
 	ret
+.cfi_endproc
 .LSEH_end_GFp_nistz256_avx2_select_w7:
 .size	GFp_nistz256_avx2_select_w7,.-GFp_nistz256_avx2_select_w7
 ___
@@ -2602,6 +2618,7 @@
 .type	__ecp_nistz256_add_toq,\@abi-omnipotent
 .align	32
 __ecp_nistz256_add_toq:
+.cfi_startproc
 	xor	$t4,$t4
 	add	8*0($b_ptr), $a0
 	adc	8*1($b_ptr), $a1
@@ -2629,11 +2646,13 @@
 	mov	$a3, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_add_toq,.-__ecp_nistz256_add_toq
 
 .type	__ecp_nistz256_sub_fromq,\@abi-omnipotent
 .align	32
 __ecp_nistz256_sub_fromq:
+.cfi_startproc
 	sub	8*0($b_ptr), $a0
 	sbb	8*1($b_ptr), $a1
 	 mov	$a0, $t0
@@ -2660,11 +2679,13 @@
 	mov	$a3, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_sub_fromq,.-__ecp_nistz256_sub_fromq
 
 .type	__ecp_nistz256_subq,\@abi-omnipotent
 .align	32
 __ecp_nistz256_subq:
+.cfi_startproc
 	sub	$a0, $t0
 	sbb	$a1, $t1
 	 mov	$t0, $a0
@@ -2687,11 +2708,13 @@
 	cmovnz	$t3, $a3
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_subq,.-__ecp_nistz256_subq
 
 .type	__ecp_nistz256_mul_by_2q,\@abi-omnipotent
 .align	32
 __ecp_nistz256_mul_by_2q:
+.cfi_startproc
 	xor	$t4, $t4
 	add	$a0, $a0		# a0:a3+a0:a3
 	adc	$a1, $a1
@@ -2719,6 +2742,7 @@
 	mov	$a3, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_mul_by_2q,.-__ecp_nistz256_mul_by_2q
 ___
 									}
@@ -3160,7 +3184,9 @@
 	movq	%xmm1, $a_ptr			# restore $a_ptr
 	movq	%xmm0, $r_ptr			# restore $r_ptr
 	add	\$`32*(18-5)`, %rsp		# difference in frame sizes
+.cfi_adjust_cfa_offset	`-32*(18-5)`
 	jmp	.Lpoint_double_shortcut$x
+.cfi_adjust_cfa_offset	`32*(18-5)`
 
 .align	32
 .Ladd_proceed$x:
@@ -3697,6 +3723,7 @@
 .type	__ecp_nistz256_add_tox,\@abi-omnipotent
 .align	32
 __ecp_nistz256_add_tox:
+.cfi_startproc
 	xor	$t4, $t4
 	adc	8*0($b_ptr), $a0
 	adc	8*1($b_ptr), $a1
@@ -3725,11 +3752,13 @@
 	mov	$a3, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_add_tox,.-__ecp_nistz256_add_tox
 
 .type	__ecp_nistz256_sub_fromx,\@abi-omnipotent
 .align	32
 __ecp_nistz256_sub_fromx:
+.cfi_startproc
 	xor	$t4, $t4
 	sbb	8*0($b_ptr), $a0
 	sbb	8*1($b_ptr), $a1
@@ -3758,11 +3787,13 @@
 	mov	$a3, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_sub_fromx,.-__ecp_nistz256_sub_fromx
 
 .type	__ecp_nistz256_subx,\@abi-omnipotent
 .align	32
 __ecp_nistz256_subx:
+.cfi_startproc
 	xor	$t4, $t4
 	sbb	$a0, $t0
 	sbb	$a1, $t1
@@ -3787,11 +3818,13 @@
 	cmovc	$t3, $a3
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_subx,.-__ecp_nistz256_subx
 
 .type	__ecp_nistz256_mul_by_2x,\@abi-omnipotent
 .align	32
 __ecp_nistz256_mul_by_2x:
+.cfi_startproc
 	xor	$t4, $t4
 	adc	$a0, $a0		# a0:a3+a0:a3
 	adc	$a1, $a1
@@ -3820,6 +3853,7 @@
 	mov	$a3, 8*3($r_ptr)
 
 	ret
+.cfi_endproc
 .size	__ecp_nistz256_mul_by_2x,.-__ecp_nistz256_mul_by_2x
 ___
 									}
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz.c b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz.c
index ded15bc..4ca5996 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz.c
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz.c
@@ -14,6 +14,9 @@
 
 #include "ecp_nistz.h"
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
 
 /* Fills |str| with the bytewise little-endian encoding of |scalar|, where
  * |scalar| has |num_limbs| limbs. |str| is padded with zeros at the end up
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz.h b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz.h
index 1f4ce9c..5bd97a4 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz.h
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz.h
@@ -19,6 +19,11 @@
 
 #include "../../limbs/limbs.h"
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
 
 // This function looks at `w + 1` scalar bits (`w` current, 1 adjacent less
 // significant bit), and recodes them into a signed digit for use in fast point
@@ -108,6 +113,9 @@
   *digit = d;
 }
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
 void gfp_little_endian_bytes_from_scalar(uint8_t str[], size_t str_len,
                                          const Limb scalar[],
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz256.c b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz256.c
index 84750f1..d8199ed 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz256.c
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz256.c
@@ -29,6 +29,10 @@
 #include "../bn/internal.h"
 #include "../../limbs/limbs.inl"
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
 typedef P256_POINT_AFFINE PRECOMP256_ROW[64];
 
 
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz384.inl b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz384.inl
index ae4ccd9..3b723d0 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz384.inl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/ec/ecp_nistz384.inl
@@ -23,6 +23,11 @@
 
 #include "ecp_nistz.h"
 
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
 /* Avoid -Wmissing-prototypes warnings. */
 void GFp_nistz384_point_mul(P384_POINT *r, const BN_ULONG p_scalar[P384_LIMBS],
                             const BN_ULONG p_x[P384_LIMBS],
@@ -259,3 +264,7 @@
   wvalue = (wvalue << 1) & kMask;
   add_precomputed_w5(r, wvalue, table);
 }
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/ecdsa/ecdsa_verify_tests.txt b/rustc_deps/vendor/ring/crypto/fipsmodule/ecdsa/ecdsa_verify_tests.txt
new file mode 100644
index 0000000..c00af6c
--- /dev/null
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/ecdsa/ecdsa_verify_tests.txt
@@ -0,0 +1,1362 @@
+# Tests from NIST CAVP 186-4 ECDSA2VS Test Vectors, Signature Verification Test
+# http://csrc.nist.gov/groups/STM/cavp/documents/dss/186-3ecdsatestvectors.zip
+#
+# NIST's files provide message and digest pairs. Since this is a low-level test,
+# the digests have been extracted. P-521 test vectors were fixed to have the
+# right number of leading zeros.
+
+Curve = P-256
+X = 1198b3c409a8b47edb1347e0982d533cb1813e5cb2a92c824b2881b3cd2f3f4a
+Y = 0bdbac5fa02e41e775f8d602446d58ecb2209b5a3d79ae69eef399016e992e87
+Digest = 01ed0c41d650479c47057f61433d7e8b24492649
+R = 9206d435f148f88c15b2effbf3c506e41b2c620102022b801e371d0767b54bea
+S = cbc4e1674ae1af69873946ccf6275946e59e0107278749b2d0010795833d80fa
+Invalid = Y
+
+Curve = P-256
+X = f7c6280aecd6b936513b0ca84e63346333dc41437a15442e605d46bba93ae101
+Y = 3c834cecc16167b07866a9478f9f2d882de7ef937da447cd837e60cb5ed65d81
+Digest = f91b4dfddd5eb33a875d2e50d1e949211ac819da
+R = f615af212ab030c4bbf9362d9815a1462312df4beb4358a7ce80d820355420bf
+S = d12ed715ef65cfe6fe6bf348364088a0e7f70927bbafe4c12fc4cb65c0cc51bc
+Invalid = Y
+
+Curve = P-256
+X = 0e7632dbc4db879e10d1d80f2789d9fa414c1fe77a6c1e56d6667af43e36e610
+Y = 6f0dd2a5840e5a6f6ff7e23f656f5c945b7a493fbb0cfd5b9b531bf04435b1ef
+Digest = 3905696f8bad8205fa1445df0e91ade3dbc413e6
+R = 2b0b9ab4a575732a168f28494b66a855fc1a757fb1177864bf3e4f0a000c4a86
+S = 54901ce2f92f55ac112afa0f8b62bc00b44c8c10fe0c863675bfd305d6dc0cd8
+Invalid = Y
+
+Curve = P-256
+X = 1613f12bae8e98d09b4bba53f5229596a0d417d2c625f41bb15f923b3c1e4b57
+Y = 411319fa85227997a4cf3b1756161485124d2cedc38c9c30d82f42dc2647d545
+Digest = 580d31ce22700a20c2db81bcdac37330b491c86f
+R = ed058d476a77be99c1b0fc8502abe545541b4c0ff3eed3f558133ae2f02042b0
+S = c571b4895712a4f64f7220b0694cab767379b09f1824fe7874acd127deb2371e
+Invalid = Y
+
+Curve = P-256
+X = 88bb041dcb1733a676a7f4ae8d3e407d72d5396547f07db77078485c1d5db077
+Y = 72cf2b55e596cd140c58228f1b0a19c34fca26ffac043528a417c5abb6fca9c9
+Digest = 7900a02f768b0718a13525c33adace583de15c50
+R = 87208734deb125dca68f0d33f9d369cf1b79cf5a021391b9c6c1727d2efe663a
+S = b984f722de18f1ce407104342948f03f2b55413a096c4b5fca1e032a2c814a4a
+Invalid = Y
+
+Curve = P-256
+X = 811eb5180def7fb60d632f8cb2cba831b88cee778aa2a82ec3a5fc3d80ff7fb6
+Y = db88d65b0fc35d9ba1f1ced0400434979ae895d371d1441d7c7a441a9fb1709b
+Digest = 17b7451ea903125ccb293ffaa9d1a4ca1141a2c5
+R = c329fa28dac0018276c5af0cd770e60be50bc14e2562d5556991971edc7d4916
+S = 2d111d13837a02fa279fe835a7dc59a521864d92b26649ca4e24b36ae93878e8
+Invalid = Y
+
+Curve = P-256
+X = 4a6f1e7f7268174d23993b8b58aa60c2a87b18de79b36a750ec86dd6f9e12227
+Y = 572df22bd6487a863a51ca544b8c5de2b47f801372a881cb996a97d9a98aa825
+Digest = 54e9a048559f370425e9c8e54a460ec91bcc930a
+R = 4a800e24de65e5c57d4cab4dd1ef7b6c38a2f0aa5cfd3a571a4b552fb1993e69
+S = d9c89fb983640a7e65edf632cacd1de0823b7efbc798fc1f7bbfacdda7398955
+Invalid = Y
+
+Curve = P-256
+X = f3033d1e548d245b5e45ff1147db8cd44db8a1f2823c3c164125be88f9a982c2
+Y = 3c078f6cee2f50e95e8916aa9c4e93de3fdf9b045abac6f707cfcb22d065638e
+Digest = e8d38e4c6a905a814b04c2841d898ed6da023c34
+R = d4255db86a416a5a688de4e238071ef16e5f2a20e31b9490c03dee9ae6164c34
+S = 4e0ac1e1a6725bf7c6bd207439b2d370c5f2dea1ff4decf1650ab84c7769efc0
+
+Curve = P-256
+X = 0ea0a6bb6c70966fad1a2307479c12de2322795bdecb70e4b286bd6200ba9c1a
+Y = c40eda3947021348db691ac4086fb6c06b587ce37c155bb0a7d912b93226de81
+Digest = 3b08bf1b67abc03c1cd69b0e24743b5c2d49e506
+R = f5509deff7bfda3f3759800fa4033af6a84466b114ecb48eac37eff48d2ae1b3
+S = 8c4b62dce2082f80caf220cdbb1d02567bbdfab40564b90ef31d86e3e10ce80a
+Invalid = Y
+
+Curve = P-256
+X = e7a57e0f6ec0fa9c7c34978034cf82f039f8fd62804070ad943573fc8efa5775
+Y = 87b2cc85dfff2dae5620fbe3e6256bd728de28fc9dc1b5eb6b5d7bd5d29186ad
+Digest = a8c5dc0344b1442dfdb5f8836251893d6c4ecbe9
+R = 97642038932fdddbe2021ec1af53ae6b9af00ef9c8b9f26aea582892e80e6285
+S = 9cb14918359338041cf795cf6781e4905837fa5ce3b3e50ffafb5f13c73b5bc8
+Invalid = Y
+
+Curve = P-256
+X = be7a651be0c87278569987cf62d7fa1dd1b3d6e1b868d8f4dfb56135a9960eec
+Y = b7a62c588a987760b915edbd7f95506870c60f042471de1d8b2d4cd9d6563391
+Digest = 2f93ee45db133a14c26d418c2ffd3470ae63bf50
+R = aa889fb608b6939f6eeacf2f64c3b2e3a6061f2834058c7e724321720b737a63
+S = 6cd6d0ef2b93a760daa914e11b9b414bd4d72457405f00a62ab63f36d76efb73
+Invalid = Y
+
+Curve = P-256
+X = 76ddc46d8db8d7ce2ce837f60cdabcee92b7c7817ee41c8f066f1ae65f85c318
+Y = bea47191f1c584c87250370ce337a1de1583bcfc20ccc23b7a82e83f19adaa88
+Digest = 2136a5470ff9d45214a0b2c300042efea8ff7266
+R = 84a42efbf7ec04166ad144d19cd98c120aa2e79d483b5eea6fbdfa7f1222e07b
+S = e41531205e691e65668f69f518abc7b60f32c373434872a043b7358462babf83
+Invalid = Y
+
+Curve = P-256
+X = 2f71b932f770ba9daf7c1dd47444ab6cb8881f71a1c597e719845b15cb84ca35
+Y = ab928625b40ec0738d0fc8dbc4df4a1f65d20bc0447b69cfa13bb20b95bb41d4
+Digest = ae6093bb37c1264ca3ead439e4f678721912c8c4
+R = 63fca172bbca6197cd2802a9cb61d74c2b47cf35f6d35203e67ffbaa838be775
+S = e70ec283cd212df6ba3723e26b697501f112d7cf64e4f45185dae76055e09f1e
+
+Curve = P-256
+X = ce775648b928db82ac5edb3b009d32959a73b86c45e96d4b8d5b6e640b7c2790
+Y = 52455caf08ee94d86f0984e9ec9268d74823f2102dd97fced59638055f6af18e
+Digest = 60054807acb29e3091a023c42b9885c4945249e1
+R = 2a64b29146588f3153fee1029a0131ac0a8a25ba2ecc494f697c166c7c91fc08
+S = 7b429bc12a72ca3d76c119eea9f4098633cc31c87831e54d5d93afd6e8d20f4f
+Invalid = Y
+
+Curve = P-256
+X = cd2f29a53f0ce57e0e4a542c3256e65ebbdc30415f4de771d5d706d3aeacc852
+Y = dbbf2c129f30d11fe77d7816a24187764eae3fb2ff70c1ec745e876e26f5232f
+Digest = 5f50e35b134942295c16d003742fd6bce5bdab45
+R = 2454c5ee84e4f77b554acd368dd412389db8c78429590a092f24db2da43cb761
+S = 63e870ce2fa4085d4ff1e360f7a5c101a1f8b288abe71cca56887e613ad034b7
+
+Curve = P-256
+X = 843f6d83d777aac75b758d58c670f417c8deea8d339a440bb626114318c34f29
+Y = 83e0c70008521c8509044b724420463e3478e3c91874d424be44413d1ce555f3
+Digest = cda2c7ad9abb2a858c4981550f78974c69e41cc31fa33509e3e83dc2
+R = d08e9a5db411019d826b20ac889227ed245503a6d839494db1e8d7995a6b245b
+S = 8d46a204054125d0dc776ab1055302ec4eb0f20b90bca6d205f21d3cefd29097
+
+Curve = P-256
+X = f08b56f73f7a0e098444f6f0a02ad81ce0b914a11cafa15893d1c84704e1c564
+Y = bbee9aeb91cdc2d1d1437b4168df73acfd64e8b02962b14c85e67187e1ef80a4
+Digest = 5453c2656550e9b3dc6c40a3f1362a73522396bc35d383dd6451128f
+R = 71b3ec982725a007ac18a5cf60587e1fd1beb57685a1f9df3cddd9df25dcbc18
+S = 407e41217325f92f8a031cfcc4eb64c1a4b17b0a7459c254af754a7ea9eac997
+Invalid = Y
+
+Curve = P-256
+X = 0b688e761e1ddda2305e002809da65bf5916dfe1356a5b99b61f5576a9b90efa
+Y = 90ec958e2e3a676e7bbf8e9394f72742875836125a317b0ae38374953f746a91
+Digest = 7289573d6bb7486e428e086bec9da9d7ff3c5f8bd0db2ec209fed6ae
+R = ef89df3bbf079fb250f7e882c4f85c0023fc3804e862d9ef4d9530a15f1013f0
+S = 4ba985e900e6737b8e07eac638f7b38277ead4faee6d2076a2eee90fd2a6bf0f
+Invalid = Y
+
+Curve = P-256
+X = 0b64480783e260e1e9caef37b4cc9c650d2d57e2c594b1106314843d8d7ab74e
+Y = 29d373d8522deffe40055aef539f53f38937eb799b44f05a8d8c0b381f12907f
+Digest = 497656e780360ec3b4bd1be97570615e4a32467982cd9330bc6aa224
+R = c5c26b0b21eef0f7a0f1cff38d0079d890376759369b01d8d8e959c1c785e203
+S = fecc400bf0deab99d87da168b9d0dd31d2dfa3435b0fe9d38b5fb8efd45195a4
+Invalid = Y
+
+Curve = P-256
+X = 7f78a8fd880c509940e2b83de67c9ab553ab91489bae75cdc1d5b523b06ab7f5
+Y = 7786aee7032c373cdfad7d9ddb6fa09a026f6da30fd477ab014d30a289d542a1
+Digest = 6d88da9e83ae9457e233d7977172c062dfbdd17d365694515251e031
+R = c93ada69db326f76b1362d610cb8bcc6e7ef1dc03d3d11367e153c0e39d5dc86
+S = d0c02c71b14ef7a4af4e23bd207ce98449f5d6e7e5b3ec8cbbca9549e97d379d
+
+Curve = P-256
+X = e58cdc207c56f62e0bb7c0b55b7f7236a6b308f8fc4de3e61cdb3bf20ad2f62c
+Y = 6056c0ee827e85ba284838954d0c6cc096df03b4611b1e0f7f9002bac86856d4
+Digest = 3f9a97b8ea807edc88788df8956c296b1daaed8dd12d50c712344091
+R = 2df3906527ad322000285bccdd11dd09130d633cf43534f5802604639eb847e0
+S = adaaad19b7c66836ef0f4afeff8ac5e898cd2523246a74a1a291a3a1ff583322
+
+Curve = P-256
+X = 70b4bba10b7bbc6d4175ada8d485f3685b13916d0c992301f47e45b629c63d0e
+Y = 257a93be31b09ff4cd22e3375e30b5a79f3bf3c74c80dde93e5d65e88c07c1c4
+Digest = cc3a0d3a5d4f28dc9144a3cdb276eb92265f1157a8d8192cf628673c
+R = 6e714a737b07a4784d26bde0399d8eee81998a13363785e2e4fb527e6a5c9e4e
+S = 94c0220f0f3fa66ff24f96717f464b66ae3a7b0f228ab6a0b5775038da13768a
+Invalid = Y
+
+Curve = P-256
+X = 8b11b48d2397355000a5289d816b9892ae64dffc842abec02a2fb2db2bb34310
+Y = fc1a42528a0473cfc2c2e184b8bc5055096350fe1549d24b526d6536681026e8
+Digest = f340e491fa935be8945b8caa485d0699c66331e0e17c7407da1b018e
+R = 61a91dd1c80049e70dc4aea84bda0efc6ec9c7b9dd16ecbccf687244c51184ce
+S = e381e7b32bab49578c7e7ce7784ce19263e4a7dab4b614df411d20eaebfc391c
+Invalid = Y
+
+Curve = P-256
+X = 7bad1b3d8bad4355a44511d2eb50daeae793af99418ada118327359936aa0e1d
+Y = e7eff40334b7a5455f6b0d0ecdcdc513702857bb5bbb73c910c86746092bcd7d
+Digest = 9cf84546c046b370c372c167ebba39af6aadd60463626453787bb058
+R = fd961b60b21be32b47abafa77e22197dc99af6825dcca46e0e3b1991a90aa202
+S = a0477f97b94a1c26a3b2d186791d7fc9dfa8130bbae79c28fa11ec93a3aeac0b
+Invalid = Y
+
+Curve = P-256
+X = 407d92c9b28723602bf09f20f0de002afdf90e22cb709a8d38e3c51e82cba96c
+Y = 4530659432e1dd74237768133e1f9808e62d0fbe5d1d979d1571baf645dcb84c
+Digest = 0cf5cd48c93f45472d254196bebea4bddb272a2adff23bab8c3adf99
+R = a7dc65293ee3deb0008ae3e2d7ef9e9a4ebb8bf7b10d165f80ab8bed58d6fdef
+S = 3e8300a3ee603a8d8234fe265c628e705015bf1903eb74c943323050626f701f
+Invalid = Y
+
+Curve = P-256
+X = 26aea3dd5c53f984dbdaf415c7f26e1e73048658a548eb3b59dd5f721899919a
+Y = dff15f57bd9b08644d49cbb214403647195725cd4d4511bc8a48b0770466ae9f
+Digest = 75d6b6b575d0a2c89528b83c94ef864c825b66253ab662b36bb0e716
+R = 726af92afe53e8125b0b9f3659745be401a37ae658b7b1aa88c3cb97e9de22c3
+S = 794484c5837a419efe11a4e4293341a6fa36d21230925a0e5e135887302acca9
+Invalid = Y
+
+Curve = P-256
+X = e73418677ce044b331a6d60773cbae199221699d31e1bec4b68b9bc0b87e4cd0
+Y = 37215db4e3d9161f3351b385a61ddb2fcf1cec469d1659e7574610ed27fe879f
+Digest = dcbb92e3be3951d37e37852d508f78da29c8183c5dbe59d6549f78ed
+R = ac469290a8f61a2a8c6adc7533dd5cfe804e2e7bf101cc74e5f624f301bccd23
+S = 4c328c3bc259316641fff44753743afebe89b8627f904df7245e42adcff2dc76
+Invalid = Y
+
+Curve = P-256
+X = b0892b19c508b3543a5ae864ba9194084c8f7ae544760759550cc160972e87ff
+Y = 9208e9b0c86ad6bc833e53026f233db9a42298cdb35d906326008377520b7d98
+Digest = 90333facb4f5068c1d05d1a478fb46d02f367e271a000474c06a5fec
+R = a62dd0d1518c6b9c60de766b952312a8d8c6eaa36a68196d2a30a46fb17dc067
+S = b9ded660e978129277f74c1d436003d1e6d556dc8eed9d505bbaf4c67cb13d21
+Invalid = Y
+
+Curve = P-256
+X = 8c5c41cb07d828a6a86be4533aef791d3a70a95cb285aa2956b21feeac2f8c49
+Y = 84101581cad7a48b7d0596df7ffed47085d22e8a4af685cddbeeb32ea69ae190
+Digest = 8bb52bd045c985167f673c07b613a3402f435a54c122877bc0c5fe34
+R = 9812449df0a51f7a2a8f78aa9a589ca9644dce285f1e69658daaea759fa5bd7e
+S = beb4c27c748a7944e37afe861576f76b5a749a8ccbbd7dec00838ba250ddfe1a
+Invalid = Y
+
+Curve = P-256
+X = 788d7e54ab03020e4954f41259052ee5af68361492b180da31fbbe68d868aa95
+Y = 982a3ababa6d351649e56da3faeb7160b9de74e22fe93a06ead1bd9a8dffdf7e
+Digest = 9870ae25b0f0403eff1079b94669cf95fb250fb098eeb885ff08f117
+R = 3ddea06bf8aa4a1b0c68674a2c4796def0bfb52236f4efb3332204a41fd8ea89
+S = 871237039431a41aeefcdd08f67848b2b09067e3a1344c8ed9b372d1b1c754a6
+Invalid = Y
+
+Curve = P-256
+X = 87f8f2b218f49845f6f10eec3877136269f5c1a54736dbdf69f89940cad41555
+Y = e15f369036f49842fac7a86c8a2b0557609776814448b8f5e84aa9f4395205e9
+Digest = a82c31412f537135d1c418bd7136fb5fde9426e70c70e7c2fb11f02f30fdeae2
+R = d19ff48b324915576416097d2544f7cbdf8768b1454ad20e0baac50e211f23b0
+S = a3e81e59311cdfff2d4784949f7a2cb50ba6c3a91fa54710568e61aca3e847c6
+Invalid = Y
+
+Curve = P-256
+X = 5cf02a00d205bdfee2016f7421807fc38ae69e6b7ccd064ee689fc1a94a9f7d2
+Y = ec530ce3cc5c9d1af463f264d685afe2b4db4b5828d7e61b748930f3ce622a85
+Digest = 5984eab8854d0a9aa5f0c70f96deeb510e5f9ff8c51befcdc3c41bac53577f22
+R = dc23d130c6117fb5751201455e99f36f59aba1a6a21cf2d0e7481a97451d6693
+S = d6ce7708c18dbf35d4f8aa7240922dc6823f2e7058cbc1484fcad1599db5018c
+Invalid = Y
+
+Curve = P-256
+X = 2ddfd145767883ffbb0ac003ab4a44346d08fa2570b3120dcce94562422244cb
+Y = 5f70c7d11ac2b7a435ccfbbae02c3df1ea6b532cc0e9db74f93fffca7c6f9a64
+Digest = 44b02ad3088076f997220a68ff0b27a58ecfa528b604427097cce5ca956274c5
+R = 9913111cff6f20c5bf453a99cd2c2019a4e749a49724a08774d14e4c113edda8
+S = 9467cd4cd21ecb56b0cab0a9a453b43386845459127a952421f5c6382866c5cc
+Invalid = Y
+
+Curve = P-256
+X = e424dc61d4bb3cb7ef4344a7f8957a0c5134e16f7a67c074f82e6e12f49abf3c
+Y = 970eed7aa2bc48651545949de1dddaf0127e5965ac85d1243d6f60e7dfaee927
+Digest = d1b8ef21eb4182ee270638061063a3f3c16c114e33937f69fb232cc833965a94
+R = bf96b99aa49c705c910be33142017c642ff540c76349b9dab72f981fd9347f4f
+S = 17c55095819089c2e03b9cd415abdf12444e323075d98f31920b9e0f57ec871c
+
+Curve = P-256
+X = e0fc6a6f50e1c57475673ee54e3a57f9a49f3328e743bf52f335e3eeaa3d2864
+Y = 7f59d689c91e463607d9194d99faf316e25432870816dde63f5d4b373f12f22a
+Digest = b9336a8d1f3e8ede001d19f41320bc7672d772a3d2cb0e435fff3c27d6804a2c
+R = 1d75830cd36f4c9aa181b2c4221e87f176b7f05b7c87824e82e396c88315c407
+S = cb2acb01dac96efc53a32d4a0d85d0c2e48955214783ecf50a4f0414a319c05a
+
+Curve = P-256
+X = a849bef575cac3c6920fbce675c3b787136209f855de19ffe2e8d29b31a5ad86
+Y = bf5fe4f7858f9b805bd8dcc05ad5e7fb889de2f822f3d8b41694e6c55c16b471
+Digest = 640c13e290147a48c83e0ea75a0f92723cda125ee21a747e34c8d1b36f16cf2d
+R = 25acc3aa9d9e84c7abf08f73fa4195acc506491d6fc37cb9074528a7db87b9d6
+S = 9b21d5b5259ed3f2ef07dfec6cc90d3a37855d1ce122a85ba6a333f307d31537
+Invalid = Y
+
+Curve = P-256
+X = 3dfb6f40f2471b29b77fdccba72d37c21bba019efa40c1c8f91ec405d7dcc5df
+Y = f22f953f1e395a52ead7f3ae3fc47451b438117b1e04d613bc8555b7d6e6d1bb
+Digest = 8a3e7ad7b9b1b0cdc48e58d1e651fe6d710fef1420addeb61582bdd982d2b44c
+R = 548886278e5ec26bed811dbb72db1e154b6f17be70deb1b210107decb1ec2a5a
+S = e93bfebd2f14f3d827ca32b464be6e69187f5edbd52def4f96599c37d58eee75
+Invalid = Y
+
+Curve = P-256
+X = 69b7667056e1e11d6caf6e45643f8b21e7a4bebda463c7fdbc13bc98efbd0214
+Y = d3f9b12eb46c7c6fda0da3fc85bc1fd831557f9abc902a3be3cb3e8be7d1aa2f
+Digest = d80e9933e86769731ec16ff31e6821531bcf07fcbad9e2ac16ec9e6cb343a870
+R = 288f7a1cd391842cce21f00e6f15471c04dc182fe4b14d92dc18910879799790
+S = 247b3c4e89a3bcadfea73c7bfd361def43715fa382b8c3edf4ae15d6e55e9979
+Invalid = Y
+
+Curve = P-256
+X = bf02cbcf6d8cc26e91766d8af0b164fc5968535e84c158eb3bc4e2d79c3cc682
+Y = 069ba6cb06b49d60812066afa16ecf7b51352f2c03bd93ec220822b1f3dfba03
+Digest = 7c1048884558961c7e178b3a9b22583fca0d17f355a9887e2f96d363d2a776a3
+R = f5acb06c59c2b4927fb852faa07faf4b1852bbb5d06840935e849c4d293d1bad
+S = 049dab79c89cc02f1484c437f523e080a75f134917fda752f2d5ca397addfe5d
+Invalid = Y
+
+Curve = P-256
+X = 224a4d65b958f6d6afb2904863efd2a734b31798884801fcab5a590f4d6da9de
+Y = 178d51fddada62806f097aa615d33b8f2404e6b1479f5fd4859d595734d6d2b9
+Digest = 4c8d1afb724ad0c2ec458d866ac1dbb4497e273bbf05f88153102987e376fa75
+R = 87b93ee2fecfda54deb8dff8e426f3c72c8864991f8ec2b3205bb3b416de93d2
+S = 4044a24df85be0cc76f21a4430b75b8e77b932a87f51e4eccbc45c263ebf8f66
+Invalid = Y
+
+Curve = P-256
+X = 43691c7795a57ead8c5c68536fe934538d46f12889680a9cb6d055a066228369
+Y = f8790110b3c3b281aa1eae037d4f1234aff587d903d93ba3af225c27ddc9ccac
+Digest = 8581034ec7d7a6b163d71820923f616b362748f2846042c9896d8e4bf7577960
+R = 8acd62e8c262fa50dd9840480969f4ef70f218ebf8ef9584f199031132c6b1ce
+S = cfca7ed3d4347fb2a29e526b43c348ae1ce6c60d44f3191b6d8ea3a2d9c92154
+Invalid = Y
+
+Curve = P-256
+X = 9157dbfcf8cf385f5bb1568ad5c6e2a8652ba6dfc63bc1753edf5268cb7eb596
+Y = 972570f4313d47fc96f7c02d5594d77d46f91e949808825b3d31f029e8296405
+Digest = e5b30e0041a33281210644938d9aaa15ef2c1247b4178f7ca1ee935ce23daabc
+R = dfaea6f297fa320b707866125c2a7d5d515b51a503bee817de9faa343cc48eeb
+S = 8f780ad713f9c3e5a4f7fa4c519833dfefc6a7432389b1e4af463961f09764f2
+Invalid = Y
+
+Curve = P-256
+X = 072b10c081a4c1713a294f248aef850e297991aca47fa96a7470abe3b8acfdda
+Y = 9581145cca04a0fb94cedce752c8f0370861916d2a94e7c647c5373ce6a4c8f5
+Digest = edd72dc0aa91649e09e2489c37ec27efab3b61953762c6b4532a9b1cd08a500d
+R = 09f5483eccec80f9d104815a1be9cc1a8e5b12b6eb482a65c6907b7480cf4f19
+S = a4f90e560c5e4eb8696cb276e5165b6a9d486345dedfb094a76e8442d026378d
+Invalid = Y
+
+Curve = P-256
+X = 09308ea5bfad6e5adf408634b3d5ce9240d35442f7fe116452aaec0d25be8c24
+Y = f40c93e023ef494b1c3079b2d10ef67f3170740495ce2cc57f8ee4b0618b8ee5
+Digest = 0d06ba42d256062e16b319a0f3099109518a765f26bac3b9f56930d965617726
+R = 5cc8aa7c35743ec0c23dde88dabd5e4fcd0192d2116f6926fef788cddb754e73
+S = 9c9c045ebaa1b828c32f82ace0d18daebf5e156eb7cbfdc1eff4399a8a900ae7
+Invalid = Y
+
+Curve = P-256
+X = 2d98ea01f754d34bbc3003df5050200abf445ec728556d7ed7d5c54c55552b6d
+Y = 9b52672742d637a32add056dfd6d8792f2a33c2e69dafabea09b960bc61e230a
+Digest = 41007876926a20f821d72d9c6f2c9dae6c03954123ea6e6939d7e6e669438891
+R = 06108e525f845d0155bf60193222b3219c98e3d49424c2fb2a0987f825c17959
+S = 62b5cdd591e5b507e560167ba8f6f7cda74673eb315680cb89ccbc4eec477dce
+
+Curve = P-256
+X = 40ded13dbbe72c629c38f07f7f95cf75a50e2a524897604c84fafde5e4cafb9f
+Y = a17202e92d7d6a37c438779349fd79567d75a40ef22b7d09ca21ccf4aec9a66c
+Digest = 5aa8e8a6f0622b841416e1a70d79a54641d2c699a075b6960fe5dcf96301da8ca6f15b0948d4ededac30a42e00d3b310
+R = be34730c31730b4e412e6c52c23edbd36583ace2102b39afa11d24b6848cb77f
+S = 03655202d5fd8c9e3ae971b6f080640c406112fd95e7015874e9b6ee77752b10
+Invalid = Y
+
+Curve = P-256
+X = 1f80e19ffeb51dd74f1c397ac3dfd3415ab16ebd0847ed119e6c3b15a1a884b8
+Y = 9b395787371dbfb55d1347d7bed1c261d2908121fb78de1d1bf2d00666a62aed
+Digest = 244656186c11c2e67be88099d55e60f4b68e61fba0b214aac3399dc559cfccc02f9884e85623426dbdc3243f2b5374f7
+R = 249ca2c3eb6e04ac57334c2f75dc5e658bbb485bf187100774f5099dd13ef707
+S = 97363a05202b602d13166346694e38135bbce025be94950e9233f4c8013bf5bf
+Invalid = Y
+
+Curve = P-256
+X = ce4dcfa7384c83443ace0fb82c4ac1adfa100a9b2c7bf09f093f8b6d084e50c2
+Y = d98ae7b91abee648d0bfde192703741ac21daad7262af418b50e406d825eb0d6
+Digest = adaeadda3f0e941fba1d3e206a84e6d7530d800e0f215b3ddd82022f27c5be44fed27bc73084c6f7ca55555532be2e3b
+R = 597e1e04d93a6b444ccc447a48651f17657ff43fb65fe94461d2bf816b01af40
+S = 359fe3817963548e676d6da34c2d0866aa42499237b682002889eaf8893814d2
+
+Curve = P-256
+X = 1b677f535ac69d1acd4592c0d12fac13c9131e5a6f8ab4f9d0afdcb3a3f327e0
+Y = 5dca2c73ec89e58ef8267cba2bb5eb0f551f412f9dc087c1a6944f0ce475277a
+Digest = e34a541f87ff0eaa0c640f555caec6bf11a1320c74c47a8ff172c4e2ec902e48d499732b12a86189e750bbf4c0424c72
+R = df0b0cd76d2555d4c38b3d70bfdf964884d0beeb9f74385f0893e87d20c9642d
+S = 128299aabf1f5496112be1fe04365f5f8215b08a040abdfeca4626f4d15c005b
+Invalid = Y
+
+Curve = P-256
+X = 7ffc2853f3e17887dda13b0eb43f183ce50a5ac0f8bba75fb1921172484f9b94
+Y = 4cc523d14192f80bd5b27d30b3b41e064da87bfbae15572dd382b9a176c123a2
+Digest = 0689927a38486cccf28fe9454e08e0d74843424b89be4cdee8e48f39a69addec730184da72f914cea67231c765ee2574
+R = 3156176d52eb26f9391229de4251993a41b8172f78970bb70e32a245be4bb653
+S = 62827a29e12d2f29b00fb2d02dd5f2d5412e17a4455f4431a5c996881fdfc0ee
+Invalid = Y
+
+Curve = P-256
+X = 5569f76dc94243cde819fb6fc85144ec67e2b5d49539f62e24d406d1b68f0058
+Y = 1208c38dbe25870deab53c486f793a1e250c9d1b8e7c147ea68b71196c440730
+Digest = 97f8f8cea435282ac746730ac744bf97d85d4e249c0b1d9c7b83c7e59aed172ffc3724d7e6fab7d6ab55ffb3a39c0775
+R = 706f2ba4025e7c06b66d6369a3f93b2fec46c51eceff42a158f7431919506cfb
+S = b4e75ac34a96393237fc4337789e37168d79382705b248051c9c72bcbac5f516
+Invalid = Y
+
+Curve = P-256
+X = e4b470c65b2c04db060d7105ec6911589863d3c7f7ce48726ba3f369ea3467e8
+Y = 44c38d3ae098de05f5915a5868c17fee296a6e150beb1f000df5f3bec8fc4532
+Digest = 5b937a2af46dbf18b4a6fb042ea353a6878e0d4beac016002b3d91a42bcba52856c07a3f35c08dfecb4f03e1c0b9948e
+R = c9c347ee5717e4c759ddaf09e86f4e1db2c8658593177cfda4e6514b5e3ecb87
+S = baae01e9e44a7b04d69c8eaaed77c9e3a36ce8962f95cc50a0db146b4e49eb40
+Invalid = Y
+
+Curve = P-256
+X = 96050c5fa2ddd1b2e5451d89ee74a0b7b54347364ddc0231715a6ef1146fe8dc
+Y = e0888a9e78aeea87f6e1e9002b2651169f36c4ee53013cfc8c9912b7fd504858
+Digest = b123e07744f05ad523790ea5bfa3f848869a3bfdbf936a496c8606b577ed8427eb7ee888e0fe18d4e3cfac73baad883f
+R = 2353d6cd3c21b8ea7dbc1cd940519812dbe365a3b15cd6aebba9d11cf269867a
+S = 85f560273cd9e82e6801e4cb1c8cd29cdac34a020da211d77453756b604b8fa7
+
+Curve = P-256
+X = 0c07bb79f44012299fbfd5a0f31397aaf7d757f8a38437407c1b09271c6551a0
+Y = 84fe7846d5d403dc92c0091fbd39f3c5cbca3f94c10b5cae44e2e96562131b13
+Digest = fb8d12652de59e63ef5297641dfbce084808de146720e9069c2ef814bcd80b6187f7422a6cd9c706f8d64ccf80e8bc54
+R = 49e9425f82d0a8c503009cead24e12adc9d48a08594094ca4f6d13ad1e3c571d
+S = 1f1b70aaa30a8ff639aa0935944e9b88326a213ab8fce5194c1a9dec070eb433
+Invalid = Y
+
+Curve = P-256
+X = 71db1de1a1f38f356c91feaff5cfe395d1a5b9d23cf6aa19f38ae0bcc90a486d
+Y = ecdd6ffb174a50f1cc792985c2f9608c399c98b8a64a69d2b5b7cdd9241f67e2
+Digest = 2d8c6585a3b6319a556e27b53d434f455f73e771c8fc6a115f5c92a8e9a81ce2b4336a5c3edf98910689d11f4c93632a
+R = b0443b33a6f249470d2f943675009d21b9ccbead1525ae57815df86bb20470bf
+S = 316dbee27d998e09128539c269e297ac8f34b9ef8249a0619168c3495c5c1198
+Invalid = Y
+
+Curve = P-256
+X = 8219b225aa15472262c648cac8de9aad4173d17a231ba24352a5a1c4eea70fad
+Y = 0fee2b08ad39fbf0db0016ef2896ca99adc07efc8c415f640f3720498be26037
+Digest = a4cc3b23f54d9d48ba6b0ad3da3b2e3a0806f41348bd7844e9c9b8648753bdeef8a039e1fa4f5172c89148d65b14056f
+R = 134fb689101aaad3954de2819d9fbd12072fe2bc36f496bbf0d13fa72114ab96
+S = e65c232bd915b59e087e7fd5ec90bf636cfa80526345c79a0adfd75003045d6f
+Invalid = Y
+
+Curve = P-256
+X = c934195de33b60cf00461fc3c45dad068e9f5f7af5c7fa78591e95aeb04e2617
+Y = b588dd5f9965fdaa523b475c2812c251bc6973e2df21d9beaace976abf5728cb
+Digest = b962b63a7743ad77f9072f2f08d277f6dda8cc3420ddd37d873746008895902bcce218fbfed1a8cb28406978dd8e5134
+R = 71f302440eb4ed2a939b69e33e905e6fdc545c743458d38f7e1a1d456e35f389
+S = 54eaa0eb9cd7503b19a9658f0a04955d9f0ab20ebc8a0877e33c89ee88ad068f
+Invalid = Y
+
+Curve = P-256
+X = 9e1adcd48e2e3f0e4c213501808228e587c40558f52bb54ddbb6102d4048ea92
+Y = 34eff98704790938e7e0bdf87ae39807a6b77dfdc9ecdfe6dd0f241abae1aeb2
+Digest = 21b883fae159867731b123a2606e9b3320fb53a00e4a5dfe3bc3429dd53b8068197be3c7288c1e0bf28a4fc7b13bd70f
+R = ce4f0d7480522c8dd1b02dd0eb382f22406642f038c1ede9411883d72b3e7ed0
+S = 8546e1ee3b77f9927cdaccbc2f1cf19d6b5576b0f738bb1b86a0c66b39ca56fb
+Invalid = Y
+
+Curve = P-256
+X = 93edbecb0b019c2cc03060f54cb4904b920fdb34eb83badd752be9443036ae13
+Y = b494e9295e080a9080fe7e73249b3a5904aa84e1c028121eecd3e2cf1a55f598
+Digest = fcc17b88077570c053650e1de42ae6bb1522900b38996decc87704aab6a87ab01d52f83f6442875f378a262c22d23ab2
+R = eec2986d47b71995892b0915d3d5becc4dcb2ab55206d772e0189541b2184ddf
+S = 8a6c1edeb6452627ad27c8319599c54ac44cdd831ea66f13f49d90affe6ad45b
+
+Curve = P-256
+X = 3205bae876f9bd50b0713959e72457165e826cbbe3895d67320909daa48b0ebc
+Y = d1592562273e5e0f57bbfb92cedd9af7f133255684ee050af9b6f02019bbcafa
+Digest = 299a6070d32a5557010753d7559dbd8d2bde8a8feae5417616ceb5b167997fd2fac0c2bd44264106d3a9720d5e805a04
+R = 0124f3f1c61ec458561a4eaa6c155bd29e59703d14556324924683db3a4cf43b
+S = 688a5c5fc0c7ba92210c50cce5b512a468a880e05acc21ca56571d89f45f603a
+Invalid = Y
+
+Curve = P-256
+X = 484e31e69ef70bb8527853c22c6b6b4cd2a51311dde66c7b63f097dbb6ab27bf
+Y = e1ff8177f4061d4fbbacbbc70519f0fc8c8b6053d72af0fe4f048d615004f74e
+Digest = f1e9cda2e096ece9a1fc57e55eeeb56b1c635380c0f9a1800a4a1a5f105d1fc0c60e776234daaa8a6f7c0f5286bb420b3f607e7cc0a7d840ad5dcbab26c797b0
+R = 91a303d8fe3ab4176070f6406267f6b79bfe5eb5f62ae6aeb374d90667858518
+S = e152119cefa26826ea07ec40a428869132d70812c5578c5a260e48d6800e046a
+Invalid = Y
+
+Curve = P-256
+X = 8b75fc0129c9a78f8395c63ae9694b05cd6950665cf5da7d66118de451422624
+Y = b394171981d4896d6e1b4ef2336d9befe7d27e1eb87f1c14b8ddda622af379dc
+Digest = 0527199fadea30f9e5e66166a3ebcdf6aedf906984535f48165e591eff36f1c0de6b0fa69aefb6399e8a213cc2ce53268fbe18c3471b7708bc27c426aaa769a4
+R = 17e298e67ad2af76f6892fdcead00a88256573868f79dc74431b55103058f0b0
+S = 881328cd91e43d30133f6e471e0b9b04353b17893fb7614fd7333d812a3df6b4
+Invalid = Y
+
+Curve = P-256
+X = 76e51086e078b2b116fd1e9c6fa3d53f675ae40252fb9f0cc62817bd9ce8831d
+Y = ca7e609a0b1d14b7c9249b53da0b2050450e2a25cb6c8f81c5311974a7efb576
+Digest = c926a5026d8f83ffa2092caf863f2d8a886af391462969b13a11d3c6c5fa66bb4281bc6e60a1e99a2e1ae95d689a66282096a0f27aacc048f32d39297649a014
+R = 23b653faaa7d4552388771931803ce939dd5ee62d3fa72b019be1b2272c85592
+S = a03c6f5c54a10861d6b8922821708e9306fd6d5d10d566845a106539cbf4fadd
+Invalid = Y
+
+Curve = P-256
+X = bc7c8e09bd093468f706740a4130c544374fdc924a535ef02e9d3be6c6d3bbfa
+Y = af3f813ae6646f5b6dbfb0f261fd42537705c800bb1647386343428a9f2e10fc
+Digest = 4d74631eb67fd1a6fa93ecb6e6112b6699e78c1d4c24ae81d0d5842efe5d93c2fd7a7863f8d45d1b2fafecbe41b7dc19c4b2bc208e014ffdc216e7eda0392a70
+R = 6bd7ce95af25abfbf14aef4b17392f1da877ab562eca38d785fe39682e9c9324
+S = 6688bea20c87bab34d420642da9bdd4c69456bdec50835887367bb4fb7cd8650
+Invalid = Y
+
+Curve = P-256
+X = 9cb0cf69303dafc761d4e4687b4ecf039e6d34ab964af80810d8d558a4a8d6f7
+Y = 2d51233a1788920a86ee08a1962c79efa317fb7879e297dad2146db995fa1c78
+Digest = 0250f93e6932887df519921f9a8dcff110be0768dc351ef73a940a579fae2d20061759e892e289c3e4ba5f7fe17d6ebb15c5931d48db55ebc81549f6637292fe
+R = 4b9f91e4285287261a1d1c923cf619cd52c175cfe7f1be60a5258c610348ba3d
+S = 28c45f901d71c41b298638ec0d6a85d7fcb0c33bbfec5a9c810846b639289a84
+
+Curve = P-256
+X = e31096c2d512fbf84f81e9bdb16f33121702897605b43a3db546f8fb695b5f6f
+Y = 6fbec6a04a8c59d61c900a851d8bf8522187d3ec2637b10fa8f377689e086bba
+Digest = f91b09107d10904d3968ec29f85e456ac4e828f32e8da3db6a13f5566bfa625e2ad03f8dad5425a073c0d61d25de63dcafa9f4fcd206f29e9cb6b0fecd74aa57
+R = 1b244c21c08c0c0a10477fb7a21382d405b95c755088292859ca0e71bab68361
+S = 852f4cbfd346e90f404e1dd5c4b2c1debca3ea1abefe8400685d703aea6c5c7f
+Invalid = Y
+
+Curve = P-256
+X = 633c2ee5630b62c9ce839efd4d485a6d35e8b9430d264ffe501d28dbace79123
+Y = 4b668a1a6d1a25b089f75c2bd8d8c6a9a14fe7b729f45a82565da2e866e2c490
+Digest = 575c64df58c8dc517ce65b388fa3ed69470163afecbabc3fa94b497ff7f3fe36ff12fabe2b84cebbf667744195091e4e2335a71d36414e0af0d0260fc8e8ea44
+R = bf2111c93ec055a7eda90c106fce494fd866045634fd2aa28d6e018f9106994e
+S = 86b0341208a0aa55edecfd272f49cb34408ce54b7febc1d0a1c2ce77ab6988f8
+Invalid = Y
+
+Curve = P-256
+X = f78dce40d1cb8c4af2749bf22c6f8a9a470b1e41112796215dd017e57df1b38a
+Y = 61b29b0bc03dff7fa00613b4de1e2317cfbf2badd50dee3376c032a887c5b865
+Digest = 4c097f2f5b2489c94258b34d529675bb5d77d4be083b51b01188dd42b4b5473982728763ee6fbad479375c5eacb5edaaec0b6583a10b19aad81ec88dde2d0e7f
+R = 4a96169a5dea36a2594011537ee0dc19e8f9f74e82c07434079447155a830152
+S = a204eaa4e97d7553a1521d9f6baadc0b6d6183ba0f385d8593d6ca83607c4d82
+Invalid = Y
+
+Curve = P-256
+X = 3fcc3b3e1b103fe435ac214c756bdaad309389e1c803e6d84bbbc27039fcf900
+Y = 7f09edd1ec87a6d36dc81c1528d52a62776e666c274415a9f441d6a8df6b9237
+Digest = 1a3dd21cb6ac1fa7fc196319cf534b7608afb93805420fcb5250dff453564a5b22e22971a3ce6dd222405fea018cd0508d86c561eca15e1ac7d79c14e916b86a
+R = 1cac13f277354456ae67ab09b09e07eb1af2a2bf45108da70f5c8c6a4cbcd538
+S = 5d83752e540525602ba7e6fee4d4263f3eda59e67df20aac79ca67e8899fed0d
+Invalid = Y
+
+Curve = P-256
+X = 5ec702d43a67ada86efbfc136cf16d96078906954a3f1f9e440674cd907e4676
+Y = 05a62044fed8470dd4fca38d89d583ce36d50d28b66ab0b51922b21da92c56d9
+Digest = c5c016f6c9b525987dd835131def77cc72d8360d364eeccdd7af8b95712b6cd487c0b846201f3b64466fd140833514ae8d765da395fbd9d3c03ca410effa9a69
+R = 75f3037298f1457dba55743999976a1c2636b2b8ab2ed3df4736a6d2934acc83
+S = 19d43ad168dda1bb8ac423f8f08876515234b3d841e57faef1b5ab27359b27ef
+Invalid = Y
+
+Curve = P-256
+X = f63afe99e1b5fc652782f86b59926af22e6072be93390fe41f541204f9c935d1
+Y = f6e19ce5935e336183c21becf66596b8f559d2d02ee282aa87a7d6f936f7260c
+Digest = 9eb2f9fa96a1f3ffcef9600522730e86d26d328ec0c1bf2fbfe55a38754610341fda1b894fdcf10c9bc4f48819010fdcf0d24f27ff539e40c6855cafbd306386
+R = cef4831e4515c77ca062282614b54a11b7dc4057e6997685c2fbfa95b392bf72
+S = f20dc01bf38e1344ba675a22239d9893b3a3e33d9a403329a3d21650e9125b75
+
+Curve = P-256
+X = 6d11b09d2767cf8d275faee746c203486259f66dd2bfa3a65c39371a66b23385
+Y = 4eb05c73e05261e979182833f20311e5366f72f4b949665ff294f959375534c6
+Digest = 0e71b28b0a1eac7aa881c09daec616c93d9a9286b5f5fdf2642d211021b125fa884b2595b73c7c3e649e61cd7157ef6660076a3b87ddf830db46533f3aa30afa
+R = 15a697cdb614e11c0810e1e764cd501fcabc70874c957587bc4883d9438e177f
+S = 7bf6244f92bc768063cecb5336c8eaacd23db930b28703560f241c7d93950dfd
+Invalid = Y
+
+Curve = P-256
+X = f3899caba038efb534c4cea0bd276814ffd80194473c903b81af11c8c05cb6e6
+Y = 6ea6b17402fcf2e8e737d11ffc7c2ed3b2d0bc3b8f271a381f4294cff62682c3
+Digest = 104ace16689d785df09a81c5cf47a496db30fbd696aa4df080219487575a23641436e70329dd1c13290582c0d03aae200e51189d43666c86f38a5203c16cd7e4
+R = 57b99380452e1d37b133c49b9ba493dee8630940477ca3351a43d90b99871e6a
+S = df599c3a37105af3ecc159b3b685ccb3e151b7d5cf2d97147974ae71f466b615
+Invalid = Y
+
+Curve = P-256
+X = 1fd6f4b98d0755291e7a230e9f81ecf909e6350aadb08e42a3262ff19200fbd2
+Y = 5578fef79bc477acfb8ed0dc10c4f5809c14dc5492405b3792a7940650b305d7
+Digest = 761a54f3718985b6d7bcfdd57d6c4823f854831bd29305fcb07e34e3f825d451fca28a62ce9582e3957d89ea7c1bc1afe3aa58fd2fa18566974600fc394cf2a8
+R = 97a99e96e407b3ada2c2dcf9ceeeb984d9a4d0aa66ddf0a74ca23cabfb1566cc
+S = 0ecac315dc199cfea3c15348c130924a1f787019fe4cd3ae47ca8b111268754a
+Invalid = Y
+
+Curve = P-256
+X = 2dcbd8790cee552e9f18f2b3149a2252dcd58b99ca7dc9680b92c8c43aa33874
+Y = 5dbc8bb8813c8e019d80e19acdb0792f537980fecde93db621aaf1f6d0e6ee34
+Digest = 45b082e804443b53a82229cdf13e4c5f8f31fe93170cc8a23f63eef506cb7748388e1a971a2f81e3daa324cf2bb69118f7418f40df66a24f50c34a55e1416c3a
+R = 2bdbd8b0d759595662cc10b10236136ef6ce429641f68cf6480f472fcc77bc9f
+S = 7e7df0c8b86f7db06caf1610166f7b9c4c75447f991d5aaf4dea720c25985c8c
+
+Curve = P-384
+X = 6881154cfe3f09affbee04cd387b27b7854326faf8906c4b9c9e6ac2c632e0d59717b3f33f6d747d7b7cbb4e4dc01fb8
+Y = ba295ae0966f06ad9d84b3bb4da7f99b56044c99f88d71082cfea6964ea3c63bb79806a6a41fcc314b55b3f64f82b68a
+Digest = 8a6429d55885146f7aab582a1aa9360fa9591b0a
+R = 2112385a75d4edda89ae2bc3c74524dc792544a3a52fdb588da3f0feaee6a11623db275e2ab8abdd998cc42a29c60856
+S = 8d308a3987b81c595f8cec19898b1a42da8eda97496af280033b0f915283f171fed7e2a221fa9c78927962189333f437
+Invalid = Y
+
+Curve = P-384
+X = 2f2f43f244ae027c3d2ec5c900393f80a8ad0e9b9a12a047195d29a39f2b7026b071688dd9a6764379d02a5ed8035ec1
+Y = e43d45851bc76c37d34dbed996a65ffcfbbaf0e2cbfbc9f62d2116bdf3b330bbef5acdbcd0aa6d949f771daa17cda1e3
+Digest = 5f41322db1a276042ae807f0f0d6f1e04cb5cd26
+R = c011c52e9cb02048957a233704ff9a2c1d4c56e08ebb083aa8ba351f041a23a7d0da19088ac6c60ea2ca117531c7cf35
+S = a66ca9bf06c35d129a8253a0f793acf681e482d9994868b275a230b215286e03a66a0de77c7a53174375137fd4688556
+Invalid = Y
+
+Curve = P-384
+X = 9a5e1932d318bfa7986f0dac4489c6f55775427bb60fb24bac7646b9994bbc3a9b5cd15e818cc4e832afc1c3fca9abae
+Y = 64c89e7c3399c136b2718ab675944207157f0bf23d9e2a807ae7ac3bef81da7ec3c56c2d2c08afc53301af2a3cc71861
+Digest = d36ef9ee70a3b61ba31cdfcd0cac6e49331a407f
+R = 4cf6c63fea6c80efc105cd99afe2b53da05ae16566ddb20b9d40a076575ffac419b6807fa336fc6e7c7416c59775ef09
+S = aec2d96054b4b23c49faaf9903ccf63bc96281fb7c1b9d14daa54bba51bb2b2f4d3a901f3b0b9cb2b62976459219350c
+Invalid = Y
+
+Curve = P-384
+X = b3aeff27b65540c6da10a88008404b1d49239c87fbf47932518fb87a9bb132403d1f310f531d086340bb4a68c3e64b9b
+Y = 567e75f442fcd81017b8adc4cce634f5ffa3cd497d38221d34dc1f43aef99133131ff1b197f7b9f37beecae5c438849a
+Digest = dd0f9c326fb50593fd0a0df31abeeb00a22eb956
+R = 3b94a2514eb915b71e18c867ad7f508a35375c5bcd4b797b86054798569870b2477e2ac14406628017d829400efc63b2
+S = 179a10441a0beea3b375248e697e0d19e24bb68184c373fe4302839b97dd7353a5a25929c2733796b0c0d8211bd67c51
+Invalid = Y
+
+Curve = P-384
+X = 0874a2e0b8ff448f0e54321e27f4f1e64d064cdeb7d26f458c32e930120f4e57dc85c2693f977eed4a8ecc8db981b4d9
+Y = 1f69446df4f4c6f5de19003f45f891d0ebcd2fffdb5c81c040e8d6994c43c7feedb98a4a31edfb35e89a30013c3b9267
+Digest = a871caf9fff9856031a79a55b96753c1a34ccb73
+R = 8d9d3e3d0b2b2871ea2f03f27ba8699f214be8d875c0d770b0fff1c4ce341f0c834ac11f9ec12bfdb8320b1724c8c220
+S = 62150dfba8e65c0c7be7ef81c87241d2c37a83c27eb31ccc2b3c3957670a744c81be6d741340b5189cc0c547df81b0d2
+
+Curve = P-384
+X = b4b92211edbd41c5468d2ba70810bc37b5e7c954c7bd0db80c4fa89ccba10bf07cdab953828a068bc0104d28e4040c14
+Y = 93ed318efce3dff98fc782b788d78658ea5ecde4f716e2d5d0ec2d87a2e761daa1f1658cfb857762caa567baaccf9924
+Digest = 765343d50541bc2c0e20193648048016a95e7588
+R = aa3978eabd196ddf9cab2815cc9cbab0b61cd639deaf70e093a10a58ddf9f410ee1ab965ff8fbb98efbe812421a613d3
+S = 02761a2947e1855806b8a25b9ebb0762be9f5517461a371e5783f34b184f32c4ea684b362119b1a2d8a3ff439f10291f
+
+Curve = P-384
+X = 63b4cc14f9efd3b8f29e65806591d1e9c54f34a3f5231339bcdbfa4109c42d946a59cdd7bbd2591fd1b2383a0819772f
+Y = 55ab3d208109da6ef039c23cddd52a5af619266d8fe066dcabb1af885ad5501401a78c44ed3b5fff2892fdcb2a3ac8b2
+Digest = 4535ef8d7396b4f2af65660ebbb56f356cacefd9
+R = a3f9b840fd7201356f35b5dde39027410aad26ac61919c14fe7b0535bb74e7218cb3312bfa60aac63f14166f32ceff26
+S = 1b1bcbcb0237fad4e406c8d4e3e39b55642d8535afa9ccbc9c601cb4e01891df79f1bc792687cb3a5ee7703565c4a13b
+Invalid = Y
+
+Curve = P-384
+X = f82f82f8f7454ce7a94a040ec0bbb52d49e3b9f8ddd095704973c760ee6067a5c28369656f22d70d8bb1cd70ef9bfea0
+Y = 0e36e256d02870ee5646a17aac4b280c9d1d2e1d4803eb3cb32e7f754cc889522120efd7c4d8a82e509a4d8f266d3ce4
+Digest = 26302c41e6da59e2df2e26c12382738880be94cc
+R = 27a2332f3c59464f5dfe7bb1201a3936248d375bde603724c048eb8f7c0c2be3ed4b56c14b51d7d68bd2554526b36d9e
+S = e1f90367b0cc530c545f95163d9ffb1208c943685d5ae221052b83ee40953397be581e5979c9855b20246e9d26d57acc
+Invalid = Y
+
+Curve = P-384
+X = 7d40b51127cb1642dd8538d4124138a2f49c41b4d12f702c1b0cec8deba50c3712e01c2e1e693e00438af0e86025da33
+Y = e734b5939b673c45dd32baf20d234f01b7124b391d14beea231e9c604e813fc83b3a77b0cb1f2ce4873a69b0165e369d
+Digest = 0b30b209147432207a72177997d28d6f1d03330f
+R = abf16821b6657e0005071f78c679cbbb130bee6e7ca63526eef0f747fb721feefe6258dae1aa02064a700e963bd9dedf
+S = 3f7e61c34a30cc5ff7a8be375fcc9c38a76dbc0c30a4356843421ca37a7bcf24edcd41d8235903bb522fb6e5a8033885
+Invalid = Y
+
+Curve = P-384
+X = a5b59d59599c105e39f61354da99c7c9135c749cf996cc2252eb83b008299cdafbcb44227d2d2c4a5ffa44823922893b
+Y = 0399fb0edcbfd0b76b524f22b7b87ddbb4fa02f510661615312a4492eb3f2001e0fc0e479f77c33a88f9a7e20757373c
+Digest = 44aa3083d111bbce7feb412af74a782cd320becd
+R = a4c9cac2409a9bfea1ebe28fec4e19545f08cd18fdd31048f52a3f2d32b2ed859dcae4dc12fb2fecabe542c4f03191ba
+S = b4d83f927ad1980d96cbb0ccc36aa640f786293b8b19e4dd97a797d192b420f630a5e42ac42d8736e7d42008f445dbc1
+Invalid = Y
+
+Curve = P-384
+X = 29178ce9127e1048ea70c7d435439e9ff9915387e51b7e5ca10bfdafe53565978eb3784d9a4226f443d4834f4d451685
+Y = 5cc2970589a453488649711bdf3cdac9a200519aae65b1c6bd54fed0d965755b36b74d978d674275bd71a03e8f054b0e
+Digest = c679b4a0e61406c4869d721192bd314d77e1cb39
+R = 5d6f5e9a94d9c92a0890c558bc0408b3405cd04e33f663df16701e80520e4394f1c54d3c8225d36f4753a799aaf6ff90
+S = d895b1cc522ceec6a7867867b8f603245c6e4d48945dfc43af721ebae4683d40a3c21b905ca3bd4b974d36806825b2cd
+Invalid = Y
+
+Curve = P-384
+X = 9f03569f8c6ca2c16d707f0ca36a8a8cf214a9d5c14034829d709e283cd675eb4e3090c6b973429efdf476c0782e0a7c
+Y = e1b842536731e91596782787d57af17db85dc92fd2fb95ac65339174aee66775ce0a4721d1faeb29da968ea5eb705e59
+Digest = ae1a63f88a59c7da5d9f512d11bbd5d75dd1f583
+R = 31ccbe22a360b1786dac89394c6ef4ed6604943e50837395f96052821f6182914840096e90f2ad650917bd91d7bd4cfd
+S = d97199a6b952dcaefb1defe23def92bf2ee236ad18046a2ccf8924d42ee10a62e70ffe7f3c909b11112278f160d98b7a
+
+Curve = P-384
+X = b85e78a935d169dd5ba8f558f964b21c07804464816f9231233184675f557463a8b00470ac0ca8278cd008f4642e7962
+Y = 8edf7be8584c5f207939d479e65173e2e69673090a8538fa93efb4432127895d92b4e4cf13b7632a830e9a33b37f75e1
+Digest = 811685f7ff2701e692f6830a33d8712d0432cd5a
+R = fd2876b250a94ced71734aa7a0d32423b2c6f039c926c557e748f38e23bbdb46e17d1204832c6f76c3ea854e1da23979
+S = 76409e381799502c81194ba87540aec0b89fc4680dd683780d49f82a46a7191b40f5f06ccb02e45e704c31fcd59382b9
+Invalid = Y
+
+Curve = P-384
+X = 0c74aaa0527524cb6171ab741896b405a6ac4615e474cdc09c9457b18bed33c6383e1b92f2fa1306e8e5dcd1667e45fe
+Y = 7b00d934dfd876f6e07dc0582b20ed650be104fa603a5a1255c62b6059d2685aa9773f1ba31254d213c815d0efc8ed93
+Digest = 328029316d73d1b8d2b8927d12332036e5671384
+R = 832c62b0f34986eda9d1ace5068a0c5318051b0d0166d3dacf137ac072cc359f109ad6e17059e700bb1958bcf4101246
+S = 6bb56f4eb550688ea66e5dd09aebe7e0b39e2716b4697ebb68f113e080f0ff26fd0fc947a34f3c5a8a2f10e07dc1405e
+Invalid = Y
+
+Curve = P-384
+X = 4104de08b4108ee26ee239e0a5d340c1b1aa48b1b3b40717debd6ed3ff0d777923c106f857a3830ce7f3d08d0d6d7908
+Y = 00498c38393e6393edcf254804558f86e461df1f5a6557bc5144f8d2f3806413d372b6ce417d531c08a52d1e38e8b949
+Digest = a13ebaf4431c43b684d1e18e610a75fd7527200e
+R = 9924a3273248db20db007309560a0e616572ac799d773529a5215786cf4a6e03cc73bea81d4810c1eee4b5e975652eee
+S = 6cc8ea4c4c56da87c25946a198e86917227bcb90da7be1dcde7b6547bc45a98e8175dd54af15bb6ef955b4cb48b7bb0a
+Invalid = Y
+
+Curve = P-384
+X = b6bc9418f3da0cce38a65f1b52bb3a9d22a0368e02f5f12fa1f1303ac67df1cffa55d049a782bf5bddb5e841b125aed6
+Y = 3b578a0560280a2958a14286e10faa7f5dec77fd8d90123aff5780efa8a636cee833fc9f10d7a164f1254a483b613746
+Digest = 7b44de2e448107197558cb071bb5bec9a5849467827d29b2c6625708
+R = 6602090aec001c16e5f6e7e3e488bed5d1702d36b258b6a8a2d8392a5ff30a6af12fbf4308d67eed6aaa8b7be8b831c5
+S = 65d0c3bb1910ba0b7cc108ae1ccaae63405ff01a8df91021e17cd46aa6f8ca8f4eaeac6d6fc26fc816a3ea537fd9576b
+Invalid = Y
+
+Curve = P-384
+X = b4ab83a4ded7d76aa15eaecb1bafe59427d3cfc38564af9123cb707da2405184acd40a6c093ba29e321ba0f67c1e0c6a
+Y = 26e2902499495f8550e798617a44ac9990c4c1cc3527dc0dd003a15aee3cbd3955151f7863de1692a94aafd3730e7665
+Digest = 8f902a34f36d7cd36748d5ddcc8fba6040be223a462842d506f185d1
+R = 61e48d5a100049578e820768ea57f30f27ffd1a1f839fabc55e8f4816c9b95d042619cd3bcc7180fd99834e344f53e7f
+S = 977b81d43216f31d8bedc3ffe873047817de3441df8b80a321aa0a80931f25a15c6628f43cf8e48d5c6aeca7626b0a18
+
+Curve = P-384
+X = f886f36fcf34e8df2a7e09220051b9981a3a6f693ec5999f28864e012c13896d633c9564f0118a95631cea8355b25b20
+Y = 746f9a77835325f18338dee5dc88a9b086b858ce15b4e4462a98844bb01811195f4fae0bee8f457c32823e142210dbb8
+Digest = 6a80377d3c7f0e6a50f6dc1656cef5a0d33cf7934441244f69f0062a
+R = 665390653ed280b8f6bd3718d8423f26cb38d2d7faa10fc0f094295677d9dafad45fc64cfc22ded56afdd86a77cf3c33
+S = 864f0eb3a8d93c388d987cfcb60bba76098039d46bf4ff4be083961f70a29e724c25cf56685802b7b5be048107ad52e3
+Invalid = Y
+
+Curve = P-384
+X = 5fc835a2f5429adb719ed22f11dfcb02731da6759a8ea75c21d1af9631187626c31e191f4dcdc183df01c48e13dbbce6
+Y = 9ed2d03df1cbeaefd4478b8106e90f92e0b6e958145cb81b9648aef0b96b71d1d55918564694b1987d68cc8e7cbd7dd1
+Digest = 807f609592e2ededa12792a7006a6db641904e86a1df3cec477dfd3c
+R = 94d9dedd27f2d014ba84ea58d2e88d68f3e86ba88b93750e50255211effe88b0a0e2f62017f22965726cdc77c55bca4f
+S = 14814bd09d9b7ba81b2485777cc588b5c0a4064df95c63f18a8bfd57494cd0f40c5bda9dc6c01ea72540f57a354360ef
+Invalid = Y
+
+Curve = P-384
+X = 0b86851d7c19f0f04a16e5e2903a36d09bf1863e152d87936fb2d74cf916bcf6dedf3c066d242f7dd327df0fcb42270a
+Y = b0c93480740bb635e6c25fb61630fdfcc462a1418366a51b1265656f721e18ba89ebf754c7dfdad865a252c884a6c4fc
+Digest = c34e896a31fc4de7596679e12bb2416a51e58e8942eabd5cb01f0737
+R = 33fa5fe3e495076e90f4b62753d3cdc7603aa7f5b407dbf89a854b9521d15e6c381d3cf28f103035dc4291ae318c5f82
+S = 30919a2a3fae71e1afe8378aedcaa08fadfab6c6bf954031452d4fe514969ede2acf0347a2f1e81abf1bfb9d8bd55a36
+Invalid = Y
+
+Curve = P-384
+X = 6f8f2fc40d1db28309c8850bf94d77c01c5449b4fc556e6bf50e5ee805209c4489d8ff9bd781699eb0e42f6a962d56fe
+Y = a4c7c77271dbbe7e00d1c6e4287dddc5463c6803a577a18f89a5eea01c6addc12404353abbc128cb9cf2496732312d65
+Digest = c19cabc6141b2adf67fe4bd0a3fead50473dea8cb0276de1fdc467c5
+R = 327c4642019a635d80dab82f7dc22e3102a3c1ba684c2b6de67d3d3009a17d39ae3d58ca2caec9f6f03f5ba3b406178c
+S = 6b1af807cc7265cc6d3049959cd7779ae0de819036647f9510b0e9f7e4c0e3fece5fc3741b68881145a2c944dc5c54d1
+
+Curve = P-384
+X = e98ba8016a976dcc3c50127d2af792969835b1096b1644b37c004d1786f4fb1026233f33ad56cd9444ba0a332c92efb8
+Y = 54bbcb78ffa3c855dd24bf182376ff5d28dd7b7551e4b05a19549c9f59c83dcc12a43092d63c5967fc0256612475b7d4
+Digest = d8d9319d3f705d03dfc992e8e7596586200fb1574f2a918350deb268
+R = 3b76a0c0ece2348085f3554fc92b9e5b0fe84801ab2adf1d239d7c81c9697b62285e8e5667774559d1bbc6e86f2ade64
+S = 91d929e42f8223ccc74d4cb09ee7eb619d3a348886c21091ec55d36164ad3cc04e1da6edd88ad89710a908ca4bc00333
+Invalid = Y
+
+Curve = P-384
+X = b8d7a836715635a8b095d3712817aa9e6ffdd98d24be2db751bb0c1fad42b082542500ea255cde17525ec159afca7002
+Y = 1a526c876d4771157b4f66e3056485c95066d4bd1e73e991ce6d5d3642807efe80015c52ef3cf8c86e57ab9a510ec86a
+Digest = fe23e8ab9dc934144247930a48babb0d8ba57703c2bef60e0e9a1e2b
+R = 9e36f47ec1b7ffdc6e3472f3cbec913494c0bbaa0c073f597e01845b5a3107c0e23a4575de4f2b582e1c2fe3067ec048
+S = b013cf51008a89b379a2a6b519b8d229ff0374401eae21a8da350fe35756b94168e7fafbd81f0f681f21c056941a82eb
+Invalid = Y
+
+Curve = P-384
+X = 4ffdecf5d5f7c1164297a93742c8a685bb425b97fdfe85f630dab2064ab29e52a0df34629c2531048c288216723fc9bf
+Y = 84fcff3e7e478a6932ace6f6b0ab70e61d8a5137b76886c59e721d938e0e252e2f7e57c2ab7dab90493446ad85c3fe4c
+Digest = 28d44c363bfb2e36bc59bb68c56e8b5d2587f149839fd3b8c05d9eb3
+R = 7d909d9aacf064c32d070c3149ace8b8f5d83b2006e8460b84c4bce664fc20e91c61ac8b415965b6155eddbe9238fe3d
+S = 19d909e358e71985179dab9113941ecad21e4f3608cb3a32dd065868af1657df8e06aa86855ac7ad757a7f8fb568a953
+Invalid = Y
+
+Curve = P-384
+X = e805e0733fc156bd582faaf794e58d4630ce73fc383cdc964dd337728f774e4989a697d79665a3282ee6e0ee343d6c7b
+Y = 43821b7b9a6ce1ddf0c59ada552668a0cfc85a87a610b5c36b7a691947116b49a4099340306e53494fc6b496cb8d12b0
+Digest = fd1bb27d666e3d40f5bd19d8c026a3614404b9edc11e582eb80b044c
+R = 3d4fa4ec95b55feac607fddc618d6f4eed71da65dc49d732e64460e5c80c57dc4421c64bacf3ef1e22995fd19c2a3cf5
+S = b11898ba475f2b28402d038afc15f171b99aab93437b35a2f8a3b89f42fdb7f93a0469d9da7652882000dd5bb1e8b9a8
+Invalid = Y
+
+Curve = P-384
+X = e15c7ef9791b9392c3e97389f2597ee161545c267e584b94262870ef25fda348f72349f396c27ac884fa8d776387fdd8
+Y = 107b4a7da8be564a14f9c45e4df5cc9b62f0671b3f2c0573c33fa37f985fefd1ae3ff2640947ebb12dffda72757db6af
+Digest = 3d9611421379fc93226fff23f5fe472a33f6bdc759d5705f7e9a2be3
+R = 9d715fd1a3668283fa83c407242e8d2a4f3fa1bf41919ca4101114bd0e0ac1b16c4379edb11de5210eee8618d42e9ed1
+S = 2dc37f453c8cfe01ea80c56d1865daf0f28847b12970132a1853c3ed80da6693e0da47a2476207947f29da34d68d604a
+Invalid = Y
+
+Curve = P-384
+X = efcb97dd73106b0a2be4f665c496352f6938da9d0fa97690dc0e8d018b06dce2ba8d19b93ddfe889d549a33e64497c31
+Y = 66a0cb7e64f40470b6d09b9e12f217b59e9e6615af52fbdc4ddcb379e77809361eca2093a3e24c7103e971567018400f
+Digest = 5598b06acf834ffbb2e50784fe2bc493fa51967f7ffadf1ece63f9b2
+R = 4ea5d4faf8ee52540db2f4c6283cea5302a3540a56e14c8a7533441c248465be99e10f23bba85be9634efaba7a8b172e
+S = 4c98a2142ecaba7db44c78658efffc1175f810a147306ba2e6498553526adb1507d7a99a372e0f84c8dbd160ef7fd5bf
+
+Curve = P-384
+X = 4e916a3cf2561580b49ecc52321db7103292fd2fcce8dd4d6f86be6035808e0df51c3c4ac1894f0b08ef6ebf953e0d18
+Y = 4e6f28895d024b4c71220b27052ddd4bf6115a260825acade48c043b3e06d2b6b8e4ebdf465980f3b013cb575d475bbb
+Digest = 1668ee6ae19c2d6f23b9184b6895ede8f55549b23095d53ef89487f6
+R = efce00544ebe0d98ba6015c07e3e9d09af808d49a0820c22ef572a3ef9c8a684b377bef1f8b3bbddb734b9b0bd0b1cd4
+S = e80d0e183b3f00098308e20e5b4ae393a07f1d1a8defda9a9d10f19b3e5236e42f593b1dc57f6718dd8d4583f0175ff7
+Invalid = Y
+
+Curve = P-384
+X = 3c6528c82d9d5e8dddf41a211c70f78604d81f49853bdc746270f1340a2a645dca3bc7844c3680268fa5973cd1758313
+Y = 4b9e697f1caf83d3224486bb0a8cd6a7c56e47c91043d8cba3aba51b6e504441d37abcc9b7b2d49b9126463703e514a0
+Digest = 1b39217bcc5dc841b32ddf00245623c581f19cac8a4ecd03eb2c07f0
+R = 848814c01c3d18534f39bcd53a8736db16f0f77a015a0e578cbb2f831739723e83b29cb6d4eee7822c76ff056d0f467d
+S = 05beb19f766bd1d4ec5e65786042258298a2dc617e3f13d8e2f0f4b50d934565f3162c737fa791a81897397f29305943
+Invalid = Y
+
+Curve = P-384
+X = 80c3f6488dcd76f33cdb75e30f8452ab9a3bd6110f14e25179b0aefe4c19c60a07b4af10844b130b0b75a7024e341298
+Y = 6c85a17ad4bbefb33910250e05ac02a17c892c3380712d06dd070843dff0d040e219dae78679b774cd5eff0adb67189a
+Digest = 23cd0066d1d88702c5d4461deff89aa5662b517806a04c4da30e0d82
+R = bc444deb0c7dd9f96f20a7ffd3ddb35a1189316655531860c39b5f87f09992106985e5562e083ee9f538c8e2d5363c52
+S = 91adde5d47eae80a98661f4347fd6e4778478c3d4aff3cff8aa92e2345a8e03cd4ab64adfd38e461bb98b496516439e7
+Invalid = Y
+
+Curve = P-384
+X = 97c3f446803a61a7014f61cb7f8b3f36486c7ea96d90ee1767f5c7e1d896dd5114255abb36c74be218c1f0a4e7ebba3d
+Y = 553ed1fed72c62851e042f0171454f120029adba4ee26855ab881d9470355f1947aa1d2e806a7ff2583660fedbd037a0
+Digest = 647eb206a8477440b4bd048d00f37dca8635b15c2a8e79e2a9d74fb9a5553211
+R = 7b06d6c2b63f1cc3bfdaa897d07dc15a83bdf35d979f70c34578332b3f4920422bb24867c51bde10831324df424e04ec
+S = 4bef715161f400dc98d4b63bd13ff4ad4a6c981ead44bfc662fe9bca4b56cd790698e4deddf9a4bd69327f26bfe801e6
+Invalid = Y
+
+Curve = P-384
+X = 08bd5c6cdc1f8c611df96485090e20e9188df6abb766bff3c1ba341ed209ad5dfd78b628ec60998ddfdd0dd029352fbd
+Y = d9831d75dec760e9f405d1aa5e23aac506dc019fb64d44bd57f6c570d017e6609f8fdbb2dc7b28ca9e00e37cd32a3b73
+Digest = 9a4985f744dd6f2774cb6f20ad6b6969e212abf4ac035b72ad3f8b1955ae1862
+R = 8b372c86ed1eec2163d6f7152e53696b4a10958948d863eb622873b471702ac5b2e75ff852149a499e61510905f98e4c
+S = b2ed728e8b30787a28f2a6d3740872e47348686c7cb426411379411310241d25f08a026b853789b1157f1fc1a7f6ff49
+Invalid = Y
+
+Curve = P-384
+X = 10a784abb3c549444a62c28df1c926b8aabb20c8d9aa4b1f7ca830258857cbe9718dbc9845fa9cbb78587a373baee80d
+Y = a1ad0c10b5ab6780cad49c8cd3eebd27de8f1b382ddd7a604458cef8e76ca632a7e44e1c63141a742426cec598029e2e
+Digest = f5b47101b4ff9baf64aca830b6afbc4f9620035d88a1d84a12cefa6f7f99faf2
+R = d9e52be2a3f7f566899cf6daaa38116d092473066f3a1bf91f3df44d81bca1deb438d9d25ce1632599c1d3576a30f128
+S = 0cad30bce4b3d7f40b3eef762a21bb1a3bad77439838b13024b7b2c70316875a99e80723a74a9e7a404715ca06a5d673
+Invalid = Y
+
+Curve = P-384
+X = 8760182393132d69011edfa127e36f92eeac8272641c27f52f3337ef8af7451e6d14f4e4590c7eb9fafb76e8c92865cf
+Y = ebc2b123ed871ca570ead40ae8f6f32335393c569b21b38f626d09c064a3c8668e9fb10a4667e0f0c68bf25ca98fd6dc
+Digest = 979131ca1d07e0b4ac6f27b20a978e0a230159eec4906db5dbd22b10ec71af87
+R = 1db957e5c2d294035d7f476a0cbc28a4aac2614d8212de5017076cd836bf04ffe237dce8fec91f2fb5ef82449ff1c65d
+S = 3e3b9058d0a9c5b417f9c6f86557b9d50e7a902694a7012a1be6bb70708497e4d39fc1f6d6bc60dfa52d23cab173385f
+Invalid = Y
+
+Curve = P-384
+X = 2b1f98d2acdda8347b9a68c75174408eae7de3d6b9c08c26e73ce9ed2ac147b8d90cd82e30ab43909d63f6b457de2071
+Y = 33f5e6f5f5793201991e014cce0045d04adc352298e32f45f4e374450111c8456b5c2efaec43d157949b5c191b2bc934
+Digest = a1daaf888d93a2a7e52bcd2a66cca3ff2e02916616d1919adefdd7257490e5b8
+R = 23d046402cbce807d232bcf0dc96d53c72992e0ba1ffce0d79050c0f4c5ad9bfbbdc1c96c730d67ff3aa3edaa3845da9
+S = 2cd46a4fe5d120b3af3a6d9ea63cc78f4079e8b5520a8fa96828334a4f182ff4d5e3d79470019e4eb8afc4f598b6becb
+Invalid = Y
+
+Curve = P-384
+X = 86ac12dd0a7fe5b81fdae86b12435d316ef9392a3f50b307ab65d9c6079dd0d2d819dc09e22861459c2ed99fbab66fae
+Y = ac8444077aaed6d6ccacbe67a4caacee0b5a094a3575ca12ea4b4774c030fe1c870c9249023f5dc4d9ad6e333668cc38
+Digest = e3bcded61cbb0bf6ec20d59f91e8e73e532f15b082b89c984c1b51fb0d1db8a9
+R = 798065f1d1cbd3a1897794f4a025ed47565df773843f4fa74c85fe4d30e3a394783ec5723b530fc5f57906f946ce15e8
+S = b57166044c57c7d9582066805b5885abc06e0bfc02433850c2b74973205ca357a2da94a65172086f5a1580baa697400b
+
+Curve = P-384
+X = 9e7553eab8cc7e2e7396128f42ab260c6dbb5457cbff2070ea7c0db21def1537939e3f02699e5dd460eca3798d08bd6d
+Y = 892c0c8e47dddf858e89099a8fc1026e8b8333532b22f561f7647f63f9c79dbf5e8dd18fbfe6ff34902233119c5d5aa3
+Digest = 0f2a9b447ea5cfcfb9e67d661d7f0752befd3b4e3454fe40b9ae1eca47806025
+R = 2452da6a48c3749b66e576e0f1f768d51728be17aea149164c4e1654c5ce27f625a4610c4a2eeddb3a0626d3abc6c37c
+S = 499504fb58c9db24a7ff5f7921e1312f8aa583c08a308e080f5ef1acf5cdae7927c4101573db069ab0b6de7f4f1cab38
+Invalid = Y
+
+Curve = P-384
+X = 0cf4dc51e71185a29c0c6fa3c075d9da5bd7ede085053344dce5dbbe8329e8ac9045f7246c9d0efed393b8e113c71429
+Y = fdb7917b73974b355cf9f3bef6a0a460c2d39fdf1fe32a7744be0a54ddd1cfa8d03914cff4b5ca536b40707ff2629aa4
+Digest = 331aefe2369b9c5ee6dd9f850259b3b8512f5934434e61573f97fe2c1cd2b147
+R = 3812c2dc2881d7ef7f621993b161672329b261ff100bbd19fb5826c9face09aec2017b6843d69336b813b673c5402527
+S = 5dc102fab9d6325131c556ec00309c2959d1031a63fbc1e2d5d04996d3234ed33875c0ab98e5878e9bc72742519ed398
+Invalid = Y
+
+Curve = P-384
+X = 6c590434988155236b43147389c6dbfdd27dcd3387e9b4c2587ece670753a542a13a736579887791cf53d31e5ce99994
+Y = 35a20194ff3f1b55f7ffb2758ddd4b98dd0d9e0cc213e10ed25e8e0430fe861066c1d4423c67f0c93f7ebd87fd3c561e
+Digest = 153475076a003545d3ca3d4a772866f12cc85f6e69f8c486a91a80fd709206b1
+R = 89ff866889245e797926509e563b1746920b78c9370a6cdae52663730d131e558e327d1f5fef8faf9e6c802fa29504ed
+S = 8dd68e2de2f788e598b3e5a60c18d81849a0cc14b3b0e3c931910639f3125e5d6045f00330b1fa989252a80f95419b04
+Invalid = Y
+
+Curve = P-384
+X = 499cbdf18ec4e69b88051543c7da80845fa2de8be2b9d9045fee7f104a8b5b7d04e69142de9955c5ab18c5a34ebff075
+Y = a29cb8d28836b201a389922b6f8f93870f09c80a00242d00d32656a43ac1440fc55bcb123551a73290f603c3469be9ed
+Digest = 5f00b3b48c1ee8287abe6f3fbc3438b91f4268f318ae2aa1e7810369d6716020
+R = 25d4d243da6fd9b439a9242c3656fade7acb7a306e8cf23ea89e3ff4f9330be19c61aaa42d7b426d12c8e0f96b80dae5
+S = e7a99cf4b269bb4a6210d185e9654602523b5cfa1cddc94b1db92018aa557ecb6adda44c816975f5ec1756b6df3c44fd
+Invalid = Y
+
+Curve = P-384
+X = 9a74ea00203c571bd91ae873ce0ed517f8f0a929c1854d68abd3b83a5051c0b686bb37d12958a54940cfa2de23902da7
+Y = 6f20ccf8fa360a9ec03d7bb79ff17ad885f714757ef62995f824908561dc0c3dffc49d873627936a2fff018b82879ced
+Digest = 45c3a1b29a18780234f12f5e4b64e7af9de2acf0029ce55b706cc79a7e4df994
+R = acc1fcac98c593fb0a0765fce35a601c2e9570d63ea1e612fff8bc99ac2d4d877750bb44cfb1014e52e00b9235e350af
+S = 7f53de3afa4146b1447e829ebac8f5645e948cc99e871c07280cc631613cfdaf52ccaeccbe93588a3fd12170a7ec79fa
+
+Curve = P-384
+X = e22f221809fb7a054ac799a70b3d24744eb7c5096c8671770399527c88ccf9ddaea0257a0ae9430d927ff5d9f109c533
+Y = af4101d60df9b306ae92da7592f4faf3df422a3e33f1c2ed2973b2b900eefc346b4cf024de650abf537cecd12ac77618
+Digest = ef1057d83a6e6481be7caf2c12c15f085ff971f02f0db8544352558e2b9fd61c
+R = c39a8e79f0560b9f26504469a470c7b2230c0d25de07c206e87dfbde9aff0a5d85322f56dfb50d4c1fc67c67d615dad7
+S = 2ad94dd13a39cf4f4cb24c2c81d4c1181652363addd856dc9ba7455458e40ed047cd113129bc87f43949d5a98a0d5205
+Invalid = Y
+
+Curve = P-384
+X = fa8ebc3682d90ac7356f0b75b9e3376e76518676e0bedd176cfa7fa57fea4b3a399dbb2bf735ec90b9c1705cf9fa6f57
+Y = 18c3fbca0150ec10696b3851f31fb3ba62c0b6be509d249e0d4b374c7a08e49338e0922e2a8a9319999e6569ab8d292e
+Digest = 0c7152ec620fe9b783625196b41192dd5d49df184ad26965c970ac5e28bb1c4b
+R = fb58ab09b8a7ef7a6ec05b854eae11af9b713f7c7540e25115f609846e636ad4f88dcf4dd61e311273df23ccda474f03
+S = 485be4c21b7c3a9c6b39ffc9f0c39f4050f76d2a6b3fae203d016318c541c1b4ad6cfc0d0950636ff6883895dd49e4e9
+
+Curve = P-384
+X = e5f331536a2940cd67234bedf813c12e15aefa9a1a68429f8754bf2769a47c9c2efb5c42135e7b01a110d7302e097eac
+Y = 63b2398612c863febd482184e834d3acb51408c49aacbbd35d8719746f37cb13e013c9505ce034cd815aacd10d2f7a0d
+Digest = d925955406f6b6dd4df05270a2539a5924830dfbcbf6a5a34f21354db246244b
+R = 96c35f22d036785a392dc6abf9b3cfb0ad37b5c59caefcc0b5212e94e86739a2674020ff79258094d90d7d59f09d47a1
+S = 373cbc865384734c56952f7a35a1fdecd88e8b343ee3aa073d30f5f25b73506f1e5f5857f668b0080dec6edeb5e1be96
+Invalid = Y
+
+Curve = P-384
+X = c53ad865beb1e2b92764065f1a6bb465ee94aacabe43426a93c277d02e00fe36be1c859ba08a031fc518a0d007668979
+Y = 6728d42bae9bc097151748ffa0982964bdd16076fa0e7cc15837c1f773b08d02c3dbc57339091ccc34105b84781150b4
+Digest = 6d5fa5b492406a1e93df6bb6364d7b17a24ef43807a1159acc77486dd7b49b60
+R = d4f0dd94fc3b657dbd234767949207624082ff946de9ce0aeb0d9993b8c7d7935760e1bf9d8b233bc7d6cd34928f5218
+S = 0941df05062aa8849610f4b37d184db77ed1bc19ad2bb42f9a12c123017592bf4086bf424b3caad9a404b260a0f69efb
+Invalid = Y
+
+Curve = P-384
+X = 1f94eb6f439a3806f8054dd79124847d138d14d4f52bac93b042f2ee3cdb7dc9e09925c2a5fee70d4ce08c61e3b19160
+Y = 1c4fd111f6e33303069421deb31e873126be35eeb436fe2034856a3ed1e897f26c846ee3233cd16240989a7990c19d8c
+Digest = 8cf5e81c6858b8395421d8c913f1ac887e282b5818eab525fb79feb9bc64bca7eb98f94b9e48b705e6c28311bb0ca672
+R = 3c15c3cedf2a6fbff2f906e661f5932f2542f0ce68e2a8182e5ed3858f33bd3c5666f17ac39e52cb004b80a0d4ba73cd
+S = 9de879083cbb0a97973c94f1963d84f581e4c6541b7d000f9850deb25154b23a37dd72267bdd72665cc7027f88164fab
+Invalid = Y
+
+Curve = P-384
+X = cb908b1fd516a57b8ee1e14383579b33cb154fece20c5035e2b3765195d1951d75bd78fb23e00fef37d7d064fd9af144
+Y = cd99c46b5857401ddcff2cf7cf822121faf1cbad9a011bed8c551f6f59b2c360f79bfbe32adbcaa09583bdfdf7c374bb
+Digest = 965b83f5d34f7443eb88e78fcc23479156c9cb0080dd68334dac0ad33ba8c774100e440063db28b40b51ac37705d4d70
+R = 33f64fb65cd6a8918523f23aea0bbcf56bba1daca7aff817c8791dc92428d605ac629de2e847d43cee55ba9e4a0e83ba
+S = 4428bb478a43ac73ecd6de51ddf7c28ff3c2441625a081714337dd44fea8011bae71959a10947b6ea33f77e128d3c6ae
+
+Curve = P-384
+X = 9b3c48d924194146eca4172b6d7d618423682686f43e1dbc54ed909053d075ca53b68ae12f0f16a1633d5d9cb17011ec
+Y = 695039f837b68e59330ee95d11d5315a8fb5602a7b60c15142dbba6e93b5e4aba8ae4469eac39fa6436323eccc60dcb6
+Digest = c68382d0641ffad850c41365a8ec68e3d55acba376d1bb941e7dcdf7b71f37b8288b023b942373a40be1dfaaf4aea633
+R = 202da4e4e9632bcb6bf0f6dafb7e348528d0b469d77e46b9f939e2fa946a608dd1f166bcbcde96cfad551701da69f6c2
+S = db595b49983882c48df8a396884cd98893a469c4d590e56c6a59b6150d9a0acdf142cf92151052644702ed857a5b7981
+Invalid = Y
+
+Curve = P-384
+X = 5140108b93b52d9ad572d6129ed6564766f8df3755e49fa53eba41a5a0d6c1d24a483c90070583a66e3cfa52b6fb1f31
+Y = ff52498446a40c61e60c97554256472625633eda0c1a8b4061481fecfbe9c4503e99dfc69e86c9e85c8cc53dca6b8dc4
+Digest = 4b945020c329a61221060e924ec682eceb842c09537fe26265ad084753b89f7650cee4e8df30b38126984d80fd25d246
+R = b2726b2ba9da02de35e9953fc283d1e78700860d4c33dce8db04dd41499d904866c1b8debb377f6c0dfcb0704252174f
+S = 0775b027068d7ad55121a278a819f52099ace750d5e996eaec9dee7be72758736cf769650148fbd5c411beb9b88f979e
+Invalid = Y
+
+Curve = P-384
+X = 31f4fc2fac3a163a5796f5e414af6f8107ab5e4a98c755d81efa9d5a83c10128c16c863190112fc29d3d5f3057a2edf1
+Y = fe208743f3e96c3a34b5fff78c9716c074a1ce3dc01c3f0e471ddfae91cd88e7dda38dd0e5e1f91b00b8539da3cc10bc
+Digest = 2d6affdf541609f649dbe9fd5829059bf42021fcfefee42d8c9cd5c127015c06b4c3c13ef56d08767788955887752e44
+R = 706911812ec9e7370234efd57b2855975eab81e9c2fe783aa8e442dc6e7d681dab2dc0dfc6765f87ab67001108e3facf
+S = 42c89efa22d853d32f619c9fe13e9852889ac98a9fed5d4fa47fed238e1cbe70d7970af9f7bdf84e51176af4885f2490
+Invalid = Y
+
+Curve = P-384
+X = 1f7911dcfe63a6f270cf75b8584d9b1b4a00afc1fa43543c945945b8a821ebeb37fbc705a000f9cc7c35f7d27027b7bb
+Y = f11835ec80c4ac06d99247e73bf72522109ac255e6109262de4dfbf9619244f74fb6c9ee57694537d7e79c248db34dc4
+Digest = f4b0a912331e7fc59a7071e5f47c9dafa6dc09b32c5c3d05301b3833bbe0b9168e2b63f12248849572a322b2f5423b8d
+R = 3587c9c6885adf3be1086825f9a41ccd2edfa0bd95e7fc4dba5a9710f41d539132de7772f14c18e318f8992b66d2a86c
+S = 73a844d729599d4e3e3c1b63e9c4bf5a73d1f69e0160857fe63a56c381c051f5c37ea6b4cc4caacb6ff26ef9699efe30
+Invalid = Y
+
+Curve = P-384
+X = 2039661db813d494a9ecb2c4e0cdd7b54068aae8a5d0597009f67f4f36f32c8ee939abe03716e94970bba69f595fead6
+Y = e2d5236e7e357744514e66a3fb111073336de929598eb79fb4368c5bf80814e7584a3b94118faac9321df37452a846fc
+Digest = cae50a424395e38bde9ba31fa5ea0c107ccceaff06663719162aac2c3e15f2b2cfd376f90d371326e1d29e0392a756ee
+R = 164b8ac2b34c4c499b9d6727e130b5ef37c296bd22c306d1396c6aa54ca661f729aa6353b55d7cf1793b80b5a485115f
+S = 4e7187f8f735b7272f2c0985315b5602bb9b1a09f32233aa10570c82d1ccedef6e725800336511e47f88ddbbbdc08f54
+Invalid = Y
+
+Curve = P-384
+X = 46dcf8ee848c6459fa66d1cae91ccd471401a5782cb2d3b9b9264189f0e9ddf7197b05c694931bde3306240cf9d24b7e
+Y = 79d9508f82c5ead05c3f9392f3b1458f6d6c02f44420b9021d656e59402e2645bf3ba1a6b244ddb12edbb69516d5873b
+Digest = 039fe89dfc54e7f2162545af700a8c49a1216b08854643656b07d74e7032516fd0c9368c5e5ce54655e4d08baa29b6f0
+R = 5ffba3b5bd7c3a89ec40b47884b0b3464e8abb78608c6d61e1e62c2ca98d44fcdf61825d69dffee8408d0849d0623bac
+S = 0d2597b5fc3842ffce1957172253a8c9c0e4dbe770ce54f70f139e0545dc34ec639d609e14175bdb2b812ccfda00c9d4
+Invalid = Y
+
+Curve = P-384
+X = 097cea75f685cf4d54324ad2124ce3f77b1e490bbaa1ffacde40dd988f7591e1c5d158e6f232500d958762831914af7f
+Y = 716d8bc056daf69ca2edd21b89a6ae9923cfcae87bfda5f9a6e514dd4b9d28d164fcc613ca2afb9660adfece59f09b66
+Digest = 02afb35f1df33b3d83df3391ca4184121ca52f520dd12ffc891aee77eab6503f232a5b1231bd997239751f46c4133edb
+R = 1c5d4561d2a3af8835839b543098c101c715c545eb7d00300c5cb05bb08dac29e732ffdc31c50915e691999ad505104c
+S = c3442f2fb1498fd47c2f959edff37a19783e3ccee80dc6955ca64db087fd188e67358e7b9223535bbb858d21ba6a978c
+Invalid = Y
+
+Curve = P-384
+X = d2e2b3d262bb1105d914c32c007ea23d15a98197f0ed90b46a17f3d403e406a76c8f752be1a8cd01a94fd45157f6511a
+Y = e585fba180017b9983b4c853ad3a5dd52e079c5f0ef792d1a0213b6085e390b073de1a4b01749ceab27806e5604980fe
+Digest = e66b11b84f87c38526438e5e3c5b4521248c358eaab80e40526906a05fb29d14d4e5686681f03bc3f0025d45dfb83b5f
+R = 49c001c47bbcee10c81c0cdfdb84c86e5b388510801e9c9dc7f81bf667e43f74b6a6769c4ac0a38863dc4f21c558f286
+S = 1fb4ff67340cc44f212404ba60f39a2cb8dcd3f354c81b7219289d32e849d4915e9d2f91969ba71e3dd4414f1e8f18f7
+Invalid = Y
+
+Curve = P-384
+X = cd887c65c01a1f0880bf58611bf360a8435573bc6704bfb249f1192793f6d3283637cd50f3911e5134b0d6130a1db60e
+Y = f2b3cbf4fe475fd15a7897561e5c898f10caa6d9d73fef10d4345917b527ce30caeaef138e21ac6d0a49ef2fef14bee6
+Digest = f6325d6bcaaaf1aba1197a290b33974f2fe8af200d5d726e78705904e9894ec31988e35dc76b9976834b7cd1c4c67146
+R = addfa475b998f391144156c418561d323bdfd0c4f416a2f71a946712c349bb79ba1334c3de5b86c2567b8657fe4ca1f1
+S = 1c314b1339f73545ff457323470695e0474c4b6860b35d703784fbf66e9c665de6ca3acb60283df61413e0740906f19e
+Invalid = Y
+
+Curve = P-384
+X = a370cdbef95d1df5bf68ec487122514a107db87df3f8852068fd4694abcadb9b14302c72491a76a64442fc07bd99f02c
+Y = d397c25dc1a5781573d039f2520cf329bf65120fdbe964b6b80101160e533d5570e62125b9f3276c49244b8d0f3e44ec
+Digest = 709d1bf45b5817f5a67b859651eb47133ebed2622fda09ab66d3467b5e95da50ecc2c74d8f4d289feebec29729a4bfa3
+R = c6c7bb516cc3f37a304328d136b2f44bb89d3dac78f1f5bcd36b412a8b4d879f6cdb75175292c696b58bfa9c91fe6391
+S = 6b711425e1b14f7224cd4b96717a84d65a60ec9951a30152ea1dd3b6ea66a0088d1fd3e9a1ef069804b7d969148c37a0
+
+Curve = P-384
+X = d1cf635ca04f09b58879d29012f2025479a002bda590020e6a238bccc764478131cac7e6980c67027d92ece947fea5a6
+Y = 21f7675c2be60c0a5b7d6df2bcc89b56212a2849ec0210c59316200c59864fd86b9a19e1641d206fd8b29af7768b61d3
+Digest = 5d54d236db6ab4691b3d50dc81471c5d388e5735ebdd435e9742a5a8a0ad0e841bab57326c8535a680ada57d2b3a70fa
+R = 6101d26e76690634b7294b6b162dcc1a5e6233813ba09edf8567fb57a8f707e024abe0eb3ce948675cd518bb3bfd4383
+S = 4e2a30f71c8f18b74184837f981a90485cd5943c7a184aba9ac787d179f170114a96ddbb8720860a213cc289ae340f1f
+Invalid = Y
+
+Curve = P-384
+X = d15ca4b2d944d5539658a19be8ef85874f0c363b870f1cd1f2dc9cb68b2a43a10d37064697c84543e60982ab62bb32c8
+Y = 062fb7dfc379fc6465302ac5d8d11d3b957b594c9ef445cfe856765dd59e6f10f11809e115ac64969baa23543f2e5661
+Digest = 67cf9e6f9e9558a379ef7361771323a4f3925f2c7a5d94d9156bf2d9d45f9f8fc4d47322da622fbce92fc764a2ccc327
+R = e2cf123ce15ca4edad5f087778d483d9536e4a37d2d55599541c06f878e60354aa31df250b2fc4ed252b80219552c958
+S = 696707a7e3f9a4b918e7c994e7332103d8e816bbe6d0d1cf72877318e087ed0e230b0d1269902f369acb432b9e97a389
+
+Curve = P-384
+X = c83d30de9c4e18167cb41c990781b34b9fceb52793b4627e696796c5803515dbc4d142977d914bc04c153261cc5b537f
+Y = 42318e5c15d65c3f545189781619267d899250d80acc611fe7ed0943a0f5bfc9d4328ff7ccf675ae0aac069ccb4b4d6e
+Digest = e8d6b550271b486e79f6975cff753d49519ed9393b207af7039b4c070cbc2fe7d49dd1bb87f7021e442fadd80ce8a5b0
+R = b567c37f7c84107ef72639e52065486c2e5bf4125b861d37ea3b44fc0b75bcd96dcea3e4dbb9e8f4f45923240b2b9e44
+S = d06266e0f27cfe4be1c6210734a8fa689a6cd1d63240cb19127961365e35890a5f1b464dcb4305f3e8295c6f842ef344
+Invalid = Y
+
+Curve = P-384
+X = d4e93c4bafb54c06814011309e9f3d8e68b76a5452e364ef05ccc3b44b271e576c9028106b1584f09271c886d467f41d
+Y = db730ccfdeb6644362f4fb510d5254bfe6f23e891e936132f90f1913e93baa8b1f8c0613a0f0c61a760ce659f22babc6
+Digest = d5c82ff11f555ce21c3f20a9ecfa6047cb6895e32fa0fb379f49085a59f61b7c8fa05058ef144cf47db5738fa40f4890cb59695998a2358162bbbf6d7f53517b
+R = 8d0fd14a59c24b0c2a34b438e162f1f536fe09a698cacfe0760d026d1593265d02f2668d2a5e49ac0b21e93807aa9c18
+S = 3162ffd2adc9dd5ec1bb1d97d2b0c27b8ae234235ffb374878d0b76382002ea505e885c178d56a2d7809bd1d83117ef1
+Invalid = Y
+
+Curve = P-384
+X = c665feccf51e6bca31593087df60f65b9fe14a12022814615deb892eedb99d86069a82aa91319310b66588185282dad6
+Y = 1e6e25bb8ae7714415b94f89def0f75dcb81d4af6b78d61f277b74b990c11aff51bd12fc88d691c99f2afde7fbd13e51
+Digest = ea056beb112fa9aad69c8dfe51ea947b772bf1c11287edcede43a98089d21492ed581edcb6d1823e2873aabba213b84291db3bffa6eac3ae43a92fc2da276a24
+R = 0e18c4063137468fe864fdc405ad4e120176eb91b4538b28ce43a22ae1a310cc22a2f7a2b3a0f3d15e0f82038b4a4301
+S = 5a1620e42041ce4357daf824befbb2ed65596bcd8214e88726149b26b1f416b9472a8877413f1c3705fc2edf4731943b
+
+Curve = P-384
+X = a6bbf85e8068151482ce855ccf0ed22988fcf4b162c4b811cb7243b849299e3390a083147fbd68683203ba33588b13ae
+Y = 5c837ec9f2eda225c83ab2d5f10b1aa5bfb56387deebf27ecda779f6254a17968260247c75dd813ea0e1926887d46f86
+Digest = 81b1303e10f25d37877b09f9d82dbd894e40264992d86cc74656ebeef505b46fdf9dec312a7f0a26e3f56a7195d5b01d198c378fff9d049e00cbad9586da20c9
+R = 9c11879e59659848274fc1ef5a6a181af813d23708b09a24dc06c089b93b918828dd938a75a34d5a681b0af362dc19a0
+S = 9c362231962ba7579c4a874e87bdc60dc15cb2e0677149c8ea31162963e05a6614616f67a5269616071cf095be7ff44b
+Invalid = Y
+
+Curve = P-384
+X = 9c1eb5cdb1a873e4c275b7ded8712b9058ee0d9ded06c96a2a8d7c652b82e894e2f918dd8e18138e5c34821744b97952
+Y = dd474c93619f02b5d4fe30ea7805c1a13fb80008a81bb5f3eeb95cd11f38841b8e34d64f2c6cc2d6cc2587365eed6b6e
+Digest = c0f9ae90fe8aaf54962e7d47a832e4ca6e60355e4066cd2b08bff78650d4e4a5d1eb1de296f9f0ef92887e09f82e0db4411aa9c3c6b109159bd39feed40419a3
+R = f17b2f2fa3b5c8e9c62a633e5d417139ddf3dafba75b464fa156c99b3948a0aca532c7fd3e14a266eb17e7fa80881da2
+S = 01c246866983fa74d6dff38b1ea091f8afd218b5a42467761b147c19a3bb20cd24be8ed1f95f1e61863a709d2d0148e2
+Invalid = Y
+
+Curve = P-384
+X = 20622a293edc96d83fee77cf1ee8077c61d6f8ed0073d53cfb5ee9c68e764c553fa4fc35fe42dade3a7307179d6fc9c2
+Y = 710fa24383f78cc4568fe0f4ecbbe6b11f0dce5434f4483712a6d2befae975a2efb554907aa46356f29bf7c6c2707c65
+Digest = 5cb8ed471a4001e280a0927faf25183c857b9b2de21c8566e8a1bf04ee085c36db7fab9d8f627898b3bb23c10225305938b56a732659f2cab3fa857d80dfde19
+R = 45a6cf5cef06256139caa709292d1e0f963d176add188572e9c7be29af21a95853a98e23aef0a0850e58d44d60b6d780
+S = df8d71cd5ab22fc718070078103483e5258734872ab935435f21ea199018e49a69c064a63801beb0759fde6e2c4a85b8
+Invalid = Y
+
+Curve = P-384
+X = 83a4fecc0bf0a353b0acf6f54094b822f2b12564e172b296f3461cafa7315d7d31d0089b1b4c18ad3c86bd18f539774a
+Y = e4fd57c5b2937e6fba1e7d72fc3f02352bd79c13611931935f4dfd073b9379f862f2277585137e996e212b5b6533dcba
+Digest = cd7c623c3c3b52f46be0ebb2b353ff97db3cd7dfc1a059a57668fc50101aeeb37b8aee9ddda8ab611546999a120cc9acb0e2c3df48dee66d5c31a46a7be94bc7
+R = fb02804010a570d702ebfbcf3d6cc9d55ddac2bd4b4de56d325e9790571b1737f91d3fa1d4caeec6eea806195aed3187
+S = 1fd20fe383e907e77639c05594642798619b2742090919bedeefb672c5700881baf0df19b9529d64bc7bb02683226103
+
+Curve = P-384
+X = 208a8c5a6b59458160c5b680116c8b23799c54a7ee8954a4869425a717739facfe4fe24540505cdc133fde8c74bfca78
+Y = 22aa7aba797bde1e8389c3c3f8d8d9aa2a914f4d2d7aaf7187ebed9b2761975718ef97660ba0b8a71dee17f2b982e2cf
+Digest = 007b907b90fa60835d45d2f0201a4486d9782fea4f0a235d97d4968336c5369c6c2e82bded56288a10fd6741f4c15d1633bc92e0196308d9f0490fc2077d3b6c
+R = 0b4e835ed83151d2bde96e201c54544ba5f301aca853957d3c538c9858fcce796b60fc50f5600a48dcdf13e5bc029827
+S = 0270adf02d31d5428d523e13d7d315c1929a1d89bbd0f61eec0b1186abe1c307cbba6b1067a68bc3947e6196d49719a0
+Invalid = Y
+
+Curve = P-384
+X = 80ae47e99107d6148b1088c6694df5c1273ff336b66e45b68a7c65fed735129dadcaf2b900e9f8ec50eff70a5ba89ea3
+Y = 47450efb5669bfacd7cbff1f801aafa0812ff88a6ae7b5a1f85e88e19129ed995f509fbf8dec15ce42bbbbd33814c09e
+Digest = 1cacc8f609080e7b8339529f944850a700977ef9107f40956fb35645e15fdd54ef01755f07a2582d0bf2ca0cb84ee8ab154fe0914dfc9ad7ad5fe54b857d0f4e
+R = bae6fba7b1485ecdca48219ead3c39295fa9c196b1f0941445b1ac768e33962f68d37f1f1749eaad7200064aa202fb41
+S = b411a38d02deb42d1015a7837b033c89d2f37d92c70fa8bb1f592223f7750520b950f30277abfb4155a3ab194b3beca0
+Invalid = Y
+
+Curve = P-384
+X = 45cb6dcca8d2e80ac04536a22f9d68ea2313245550108ddcd32799d154c0a55492e49463e826275bd9bf0d5e380205c1
+Y = 6fd124f5a6c745751ccfb3ba4dd9144ea8fd41a4d9a4b34820434da66aa7385e73ffe71e6c11ed1beb6c7af22ce00edf
+Digest = dd7947a5b9a1c988dd7dff537e15335aacafd3e602adc8373765013f338334dd58aed4fb7144de0007c3410d79f5e78bcd4cf0dd63cc33ed3dd564882e299c7b
+R = 2c782c4263eeee63657fbf20fa287a1a81fcd14b1d3bae333928ba4fc31abb20edebc130714380608e38ea74309eca9d
+S = 716113d95bc9dba532bfb470112b0d43d9cd6560ad15e0de2e514994801ff339bcf19ad4ee2b8af573f57c038fbd70f0
+
+Curve = P-384
+X = 36c1459d9e9f7b6c1598778c784cbf94661a2b11370c02ee092f6ea0ca20acf81f1ed5048a28a1466a91689df26bc291
+Y = d1367418c7b216bd32c6dafc8b2be99d02cab68df990758b2ddd543b7eb6ff6e285b649ffe588b1811b549cfb5f0289b
+Digest = 242ff2713c03e3d5277652f8e7fb1e5a1f0422b6652e1bdd696e46c03cdd3aaac329b1d88e7aa345ff7224ce6dc6df05c7e9d7dc2665282c817d15a15b8288fd
+R = 40c338adeb504193444bdb95336177362031aaadc5b7e151e42030df9dd8687f3cb8fe2292fd4f9206989c089d966dae
+S = be4b2ba251094c24de006c89af2b5c77e6937f36d7bb703b4f8edcfe65d45f4b2fd2486222163ae0ed9e215c0a96f488
+Invalid = Y
+
+Curve = P-384
+X = b5eb6670bb0b0d3aef10e533d3660756b7372a2a081d9d920130034f48202cd43b9e2d1e5893d0cfb322db65ab839716
+Y = e28444770396041b489b302786a57fca9a98f19685cb4b455d219151e64645ad30dd3149ec96f3bc90879834b65e58aa
+Digest = 8d2e653807e87962883956ee3705b2167c50370c3af12eb8f6c26f0f15ede56dddc7d0c9642a1c1c2444b06571fa1a4d47e7884acc7ea3884daaa50940f782e2
+R = 0887a13df940907864b425ec0d8f91ac719abcc62b276fa08c5122b38831c8930abd3c8454e98182bb588fc72843717a
+S = a380284eacaa36a34e35f04fbf6e28ffb59176f41ea52d9c9bc1362eccd8e0d699c2e08111d93e9dc2785637b1f4f09e
+Invalid = Y
+
+Curve = P-384
+X = 700e8f65e052e918a63a96fa57f4eda849f9f9faca3302d6ead66ebf85838f8145a6d6718a681b7bef73170d7254958f
+Y = 9e9e10357658913007803859165926cd1e5e92c3a644d834098cb1cbfab466349bf4238a5154cf50ed77c77a78263e81
+Digest = cf885fa7a96db595f825a0ccc56b70b60e0e1c30d0a15af636d1f4957328aecb7eeb734d5874bd72ddaf15c357ca36bd42abf387f7b771ea6160e2e23a08652e
+R = 59be870e0fd684b000cce95c616d9f34674354e9d20db15d204b8a6285ff55258e4eeb49da1573ef1030cd6b2626dcfb
+S = c0bbbf71d87479d82575458be9f4d686921db7ea458d620271f51ec3f4d1afe3bf25ef9c0c400eb7b92cd7058fb17346
+Invalid = Y
+
+Curve = P-384
+X = a9de6f029445fffcf16349b44095cc83b11e3d0d9f08654b158014803b1cc31b8dfe00b1a8167c6f704d69cdd62c6512
+Y = 27336a503a669ba1d1f3619f51dc8aa2a44b2075c682a36f071be486e7dafba9adfac2ce74be0442b7251e99304ffc05
+Digest = b7e73f38767f253790e7fff019b4e0e61562aeb97b2b749afec2a61c87ab0e15916d4286c0a13989912f6bafdf3efc6f64ddc3b944f9041266e5abd4480c1606
+R = f93a4d2eb94d087f28572847e0099ae2ee944efacdad392ec268c9c1e632e6ccd670c36584e58aba52a4c2b07127d55a
+S = 941ee89cea6e7ed20213a95482fae134707ddf4d292ab1952ed5464f1f1138669dedbfc9998b696eaf469be5fb240c80
+Invalid = Y
+
+Curve = P-384
+X = e63500d6d13069c01fafc4518f1d429661c5bb6ad1ff0383037ca6a469a5c20c453dce03bf6e4164f7e26f849016b3d0
+Y = 83b7b731c2531c3ac61b194cf3db6dc02ccdfa16d9eb49f97bc4ec3fe6c8bd865ea27f1538531ad07dc44fc5107af8e6
+Digest = afc0ed355377d0ab0c4f79d420dcf67ad4920c013d5c8afde2287525da4596672927540418a61568b21ae7799d7659f16b85f611bd6e8d2066a55903da0c48b9
+R = eb78733e73fd64a6a1f23eba5311af23d26816fb8847671e01fdbd8dc7d5fce1a0823b080ee99e8d75edb3f100e16077
+S = bcaedfe599f98b51542c0f94ae1010611c6767ac3abb2bd887399d62fd0f1b3a0e97deb24c95a76de44521bf24c8645e
+Invalid = Y
+
+Curve = P-384
+X = 3ebd869be687f82d844416e6816d698d82e1e22a1f451d50b6c146134deb07f05204c0b04e7dc07ebdcfd916531dc7c3
+Y = 6e4d7bde063edb7254a82b9d9249d2a2b9ad8988c37a84ac9f7c09daed42b1fd28f7cca1ea8b4f91a66e878224800bdc
+Digest = 56a61339a35750e95770f28846930e3f594e8d759e07423718734a82b2a80430b0fb3378e40bdcf5c12be135be9a9bec32916b4988a763091a6da7b44631414e
+R = 575f87a8a7980555a198cfdec279cbb2f89551b5271d242397c29f6bc4bf413dc30312a7e626ef7fc77a9124a79bf9be
+S = f0b7d759246ad36ba8240c537b1eeb5d148c38d324f48028c598eaef6e49d79ff3f6cfe3a32fbbf6f3ed3aaaec31d572
+Invalid = Y
+
+# The following tests use digests equal to the order and 2^n - 1, where n is
+# the number of bits in the order. This is to test the truncated digest not
+# being fully reduced.
+
+Curve = P-256
+X = e57231383637c82c1ac801724cf7e03e67198f467a9beb60ac13cb582d13afa8
+Y = 8f190e090155fcf63810b858bc88e259dc49afef8bdef6fd06d93dddb1991aed
+Digest = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551
+R = 05cc6037bb021f4910ea2e489fab2bae6bb6a2769a97f42ba5736994102b7f10
+S = 5db54832ceabf8bccdb8be99b1a49cecff8feee045cb697dec43118e2695b1da
+
+Curve = P-256
+X = 6e0e2897b9a554ee287cdaf43bfbe25ca8404373971575a0e4b61c61aff5a2fe
+Y = 23ea7823a411eb1b39f81bbde24c2cd6ac68be2c7eec3a0671c8676131b8905c
+Digest = ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+R = 16831feeceab2fab1c575e073e944d73ce7e6f3e9b06312088f06159c530ff50
+S = 870cb824692638538b1569c6093fcb693c054e8e3b9a919e3bb26798910f66e9
+
+Curve = P-384
+X = f4a961c19f9cc4ebe4f43081110955f3cede085a08c1415d726e80b2eb774028c5fc96f092ba3ea7d1288dd57fe1db08
+Y = 981398eed0895e09b3b582a0616f3024e51cca7b1ecc347dbf0d24a5f6a222b0c31912f8f5e427d4dde5c6c45212bb10
+Digest = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973
+R = 0b77eaff05bbd922dd80525d2ab301cc119318f5a920a12c71c4b5ff5bb77d25a538983df9bdd5984b0d159daf21f1a2
+S = 73af85ad03a34b6b3993082bf719018d25d1555717b2d2f2535d0601af06a71ad020eff8232d065ab9d7fc4cd0c0ee42
+
+Curve = P-384
+X = 54dd8d7cbf2ccdf1a42f5bbc615a372803b094f6040e3c7b651a61bc6912432c836cf2410ab7d67f543236751d81066f
+Y = 2219d6257b1c80bf327c96786f2b5d0b5a9b9bf7eee9c853bf66a3bf09520494cb1f7823e4c566d79a617b7e201ead96
+Digest = ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+R = 9d923e199d98272e44b8fba382bf3c19660ecb4a9aae3513ff6802a73fef510c15c202807c3f9334b0bce7d6c6a80839
+S = 520784e6290d04d9b61993ee5ebc6fa8ff527fb0777c43cdefc7586701e60edb399005a5648ff852de80208232849fbd
+
+# The following tests are intended to stress the final comparison in ECDSA.
+# ECDSA verification computes some curve point (x, y), picking the fully-reduced
+# representive of x mod p, and checking that x mod n is r. (n is the order of
+# the group and p defines the underlying prime field.)
+#
+# This makes the computation sensitive to values near n and p, and which of n or
+# p is larger. Additionally, there is an optimization that performs the
+# comparison mod p rather than n and compensates for the difference.
+#
+# These tests were generated by picking a target value of r and x, adjusting
+# both until x corresponded to a point on the curve, and then computing the
+# public key by solving for P in ECDSA's (x, y) = u1*G + u2*P. The digest is the
+# hash of "hello, world" with the suitably-sized SHA-2 hash, so the test vectors
+# are suitable for both message- and digest-based APIs.
+#
+# "x" in the comments refer to the x-coordinate of the computed point, not that
+# of the public key.
+
+# r = 5, x = 5 is valid.
+Curve = P-256
+X = 264d796a0dab9b376d34eea6fe297dde1c7b73e53944bc96c8f1e8a6850bb6c9
+Y = cf5308020eed460c649ddae61d4ef8bb79958113f106befaf4f18876d12a5e64
+Digest = 09ca7e4eaa6e8ae9c7d261167129184883644d07dfba7cbfbc4c8a2e08360d5b
+R = 0000000000000000000000000000000000000000000000000000000000000005
+S = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+
+# r = 5 + n, x = 5 is invalid. r must already be reduced.
+Curve = P-256
+X = 264d796a0dab9b376d34eea6fe297dde1c7b73e53944bc96c8f1e8a6850bb6c9
+Y = cf5308020eed460c649ddae61d4ef8bb79958113f106befaf4f18876d12a5e64
+Digest = 09ca7e4eaa6e8ae9c7d261167129184883644d07dfba7cbfbc4c8a2e08360d5b
+R = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632556
+S = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+Invalid = Y
+
+# r = n-2, x = n-2 is the largest x without a reduction.
+Curve = P-256
+X = 50a50c01132bf79e42b31fb278f7317b29515e9e1c973a41266b69048826fb8e
+Y = aac53e7df37b5eb25ce4ddb705fc7135c6b1e00a7f56e30744f62f258afa5537
+Digest = 09ca7e4eaa6e8ae9c7d261167129184883644d07dfba7cbfbc4c8a2e08360d5b
+R = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254f
+S = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+
+# r = n-3, x = n-2 is incorrect.
+Curve = P-256
+X = 50a50c01132bf79e42b31fb278f7317b29515e9e1c973a41266b69048826fb8e
+Y = aac53e7df37b5eb25ce4ddb705fc7135c6b1e00a7f56e30744f62f258afa5537
+Digest = 09ca7e4eaa6e8ae9c7d261167129184883644d07dfba7cbfbc4c8a2e08360d5b
+R = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+S = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+Invalid = Y
+
+# r = 3, x = n+3 is the smallest x with a reduction.
+Curve = P-256
+X = ce24c99032d52ac6ead23c0ae3ec68ef41e51a281fd457808c83136d7dcce90e
+Y = 8f7a154b551e9f39c59279357aa491b2a62bdebc2bb78613883fc72936c057e0
+Digest = 09ca7e4eaa6e8ae9c7d261167129184883644d07dfba7cbfbc4c8a2e08360d5b
+R = 0000000000000000000000000000000000000000000000000000000000000003
+S = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+
+# r = 4, x = n+3 is incorrect.
+Curve = P-256
+X = ce24c99032d52ac6ead23c0ae3ec68ef41e51a281fd457808c83136d7dcce90e
+Y = 8f7a154b551e9f39c59279357aa491b2a62bdebc2bb78613883fc72936c057e0
+Digest = 09ca7e4eaa6e8ae9c7d261167129184883644d07dfba7cbfbc4c8a2e08360d5b
+R = 0000000000000000000000000000000000000000000000000000000000000004
+S = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+Invalid = Y
+
+# r = p-3-n, x = p-3 is the largest valid x.
+Curve = P-256
+X = 768a0d300a595005a520130e50927d403395c8e1e40be997b48fc048410f7cdb
+Y = 16f217d8e1c02bd887e5de388a17783b182e61b5d534152dc2c4be8d75fdd706
+Digest = 09ca7e4eaa6e8ae9c7d261167129184883644d07dfba7cbfbc4c8a2e08360d5b
+R = 000000000000000000000000000000004319055358e8617b0c46353d039cdaab
+S = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+
+# r = p-n+5, x = 5 is incorrect. r is too large to compare r+n with x.
+Curve = P-256
+X = 0ec505bc19b14a43e05678cccf07a443d3e871a2e19b68a4da91859a0650f324
+Y = 77300e4f64e9982d94dff5d294428bb37cc9be66117cae9c389d2d495f68b987
+Digest = 09ca7e4eaa6e8ae9c7d261167129184883644d07dfba7cbfbc4c8a2e08360d5b
+R = 000000000000000000000000000000004319055358e8617b0c46353d039cdab3
+S = ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc63254e
+Invalid = Y
+
+# r = 2, x = 2 is valid.
+Curve = P-384
+X = 016d2db67561bc126ad6c344d6eeb2713a9e2892c649af0f015c6b7617f160c8a3b3a88add669d7155025073c5ac5b4f
+Y = 43bf2ed0088af08645c80aa0a24a567a94ba2d794e9689d3ad4b185bc5d2dd008333e2dd2ebb5069a9b32251a3cac71e
+Digest = 1fcdb6059ce05172a26bbe2a3ccc88ed5a8cd5fc53edfd9053304d429296a6da23b1cd9e5c9ed3bb34f00418a70cdb7e
+R = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002
+S = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52970
+
+# r = 2 + n, x = 2 is invalid. r must already be reduced.
+Curve = P-384
+X = 016d2db67561bc126ad6c344d6eeb2713a9e2892c649af0f015c6b7617f160c8a3b3a88add669d7155025073c5ac5b4f
+Y = 43bf2ed0088af08645c80aa0a24a567a94ba2d794e9689d3ad4b185bc5d2dd008333e2dd2ebb5069a9b32251a3cac71e
+Digest = 1fcdb6059ce05172a26bbe2a3ccc88ed5a8cd5fc53edfd9053304d429296a6da23b1cd9e5c9ed3bb34f00418a70cdb7e
+R = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52975
+S = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52970
+Invalid = Y
+
+# r = n-1, x = n-1 is the largest x without a reduction.
+Curve = P-384
+X = b5b375264c09acf145ca91d12ab10a096092a41ec43f4d718e129ea1c12b2dea62c7785efc52f46f009fb1dba133e811
+Y = bc0b2af172b4b3068d032a798080e76f4d56f72069519e3c19a43682a41794e52cb3ca139348d6bbc923e6a4f7945cb1
+Digest = 1fcdb6059ce05172a26bbe2a3ccc88ed5a8cd5fc53edfd9053304d429296a6da23b1cd9e5c9ed3bb34f00418a70cdb7e
+R = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52972
+S = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52970
+
+# r = n-2, x = n-1 is incorrect.
+Curve = P-384
+X = b5b375264c09acf145ca91d12ab10a096092a41ec43f4d718e129ea1c12b2dea62c7785efc52f46f009fb1dba133e811
+Y = bc0b2af172b4b3068d032a798080e76f4d56f72069519e3c19a43682a41794e52cb3ca139348d6bbc923e6a4f7945cb1
+Digest = 1fcdb6059ce05172a26bbe2a3ccc88ed5a8cd5fc53edfd9053304d429296a6da23b1cd9e5c9ed3bb34f00418a70cdb7e
+R = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52971
+S = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52970
+Invalid = Y
+
+# r = 2, x = n+2 is the smallest x with a reduction.
+Curve = P-384
+X = 01b54a697305092bac2939fb906d7471b411c4eba8654169166a5da3810e1fc96795df921f7abbf519be4a027435176c
+Y = a19012a3518773d508106d4153adee43c3c384fa62ce36a4addea08f593ec9c76b09a6b9c69d29bd7d47eb48e167dd2f
+Digest = 1fcdb6059ce05172a26bbe2a3ccc88ed5a8cd5fc53edfd9053304d429296a6da23b1cd9e5c9ed3bb34f00418a70cdb7e
+R = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002
+S = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52970
+
+# r = 3, x = n+2 is incorrect.
+Curve = P-384
+X = 01b54a697305092bac2939fb906d7471b411c4eba8654169166a5da3810e1fc96795df921f7abbf519be4a027435176c
+Y = a19012a3518773d508106d4153adee43c3c384fa62ce36a4addea08f593ec9c76b09a6b9c69d29bd7d47eb48e167dd2f
+Digest = 1fcdb6059ce05172a26bbe2a3ccc88ed5a8cd5fc53edfd9053304d429296a6da23b1cd9e5c9ed3bb34f00418a70cdb7e
+R = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003
+S = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52970
+Invalid = Y
+
+# r = p-1-n, x = p-1 is the largest valid x.
+Curve = P-384
+X = c4fd8e68006b83f7b7b20b731ae405813aa05f6e57374589b36ae1cecd1d49cae1418c22f398188bcf4ef02e89fe7394
+Y = dd1164b3707f59e05129fa228b8448031db159985f035d93470dc42b3ab4129f0760c46cf201d42e73a7e33ba7402ea6
+Digest = 1fcdb6059ce05172a26bbe2a3ccc88ed5a8cd5fc53edfd9053304d429296a6da23b1cd9e5c9ed3bb34f00418a70cdb7e
+R = 000000000000000000000000000000000000000000000000389cb27e0bc8d21fa7e5f24cb74f58851313e696333ad68b
+S = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52970
+
+# r = p-n+2, x = 2 is incorrect. r is too large to compare r+n with x.
+Curve = P-384
+X = 4e5e4f1a6e97059a6cf2f4e8129e5c7c64cb84f9994a41ff5bf30b29c1bf5ba6898627c91a23c73e05cd1a43c8f908c0
+Y = 06a0aed7f1e63a728f87dbd5360a67571a076ab0b4cde81b10d499959814ddb3a8c7854b0bbfa87cc272f90bca2a2254
+Digest = 1fcdb6059ce05172a26bbe2a3ccc88ed5a8cd5fc53edfd9053304d429296a6da23b1cd9e5c9ed3bb34f00418a70cdb7e
+R = 000000000000000000000000000000000000000000000000389cb27e0bc8d21fa7e5f24cb74f58851313e696333ad68e
+S = ffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52970
+Invalid = Y
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl
index c5ad108..24230c2 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/modes/asm/aesni-gcm-x86_64.pl
@@ -1113,24 +1113,6 @@
 	.rva	.Lgcm_enc_body,.Lgcm_enc_abort
 ___
 }
-}}} else {{{
-$code=<<___;	# assembler is too old
-.text
-
-.globl	GFp_aesni_gcm_encrypt
-.type	GFp_aesni_gcm_encrypt,\@abi-omnipotent
-GFp_aesni_gcm_encrypt:
-	xor	%eax,%eax
-	ret
-.size	GFp_aesni_gcm_encrypt,.-GFp_aesni_gcm_encrypt
-
-.globl	GFp_aesni_gcm_decrypt
-.type	GFp_aesni_gcm_decrypt,\@abi-omnipotent
-GFp_aesni_gcm_decrypt:
-	xor	%eax,%eax
-	ret
-.size	GFp_aesni_gcm_decrypt,.-GFp_aesni_gcm_decrypt
-___
 }}}
 
 $code =~ s/\`([^\`]*)\`/eval($1)/gem;
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/modes/asm/ghash-x86_64.pl b/rustc_deps/vendor/ring/crypto/fipsmodule/modes/asm/ghash-x86_64.pl
index ce71db3..6406386 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/modes/asm/ghash-x86_64.pl
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/modes/asm/ghash-x86_64.pl
@@ -44,9 +44,8 @@
 # See ghash-x86.pl for background information and details about coding
 # techniques.
 #
-# Special thanks to David Woodhouse <dwmw2@infradead.org> for
-# providing access to a Westmere-based system on behalf of Intel
-# Open Source Technology Centre.
+# Special thanks to David Woodhouse for providing access to a
+# Westmere-based system on behalf of Intel Open Source Technology Centre.
 
 # December 2012
 #
@@ -223,191 +222,6 @@
 $code=<<___;
 .text
 .extern	GFp_ia32cap_P
-
-.globl	GFp_gcm_gmult_4bit
-.type	GFp_gcm_gmult_4bit,\@function,2
-.align	16
-GFp_gcm_gmult_4bit:
-	push	%rbx
-	push	%rbp		# %rbp and others are pushed exclusively in
-	push	%r12		# order to reuse Win64 exception handler...
-	push	%r13
-	push	%r14
-	push	%r15
-	sub	\$280,%rsp
-.Lgmult_prologue:
-
-	movzb	15($Xi),$Zlo
-	lea	.Lrem_4bit(%rip),$rem_4bit
-___
-	&loop	($Xi);
-$code.=<<___;
-	mov	$Zlo,8($Xi)
-	mov	$Zhi,($Xi)
-
-	lea	280+48(%rsp),%rsi
-	mov	-8(%rsi),%rbx
-	lea	(%rsi),%rsp
-.Lgmult_epilogue:
-	ret
-.size	GFp_gcm_gmult_4bit,.-GFp_gcm_gmult_4bit
-___
-
-# per-function register layout
-$inp="%rdx";
-$len="%rcx";
-$rem_8bit=$rem_4bit;
-
-$code.=<<___;
-.globl	GFp_gcm_ghash_4bit
-.type	GFp_gcm_ghash_4bit,\@function,4
-.align	16
-GFp_gcm_ghash_4bit:
-	push	%rbx
-	push	%rbp
-	push	%r12
-	push	%r13
-	push	%r14
-	push	%r15
-	sub	\$280,%rsp
-.Lghash_prologue:
-	mov	$inp,%r14		# reassign couple of args
-	mov	$len,%r15
-___
-{ my $inp="%r14";
-  my $dat="%edx";
-  my $len="%r15";
-  my @nhi=("%ebx","%ecx");
-  my @rem=("%r12","%r13");
-  my $Hshr4="%rbp";
-
-	&sub	($Htbl,-128);		# size optimization
-	&lea	($Hshr4,"16+128(%rsp)");
-	{ my @lo =($nlo,$nhi);
-          my @hi =($Zlo,$Zhi);
-
-	  &xor	($dat,$dat);
-	  for ($i=0,$j=-2;$i<18;$i++,$j++) {
-	    &mov	("$j(%rsp)",&LB($dat))		if ($i>1);
-	    &or		($lo[0],$tmp)			if ($i>1);
-	    &mov	(&LB($dat),&LB($lo[1]))		if ($i>0 && $i<17);
-	    &shr	($lo[1],4)			if ($i>0 && $i<17);
-	    &mov	($tmp,$hi[1])			if ($i>0 && $i<17);
-	    &shr	($hi[1],4)			if ($i>0 && $i<17);
-	    &mov	("8*$j($Hshr4)",$hi[0])		if ($i>1);
-	    &mov	($hi[0],"16*$i+0-128($Htbl)")	if ($i<16);
-	    &shl	(&LB($dat),4)			if ($i>0 && $i<17);
-	    &mov	("8*$j-128($Hshr4)",$lo[0])	if ($i>1);
-	    &mov	($lo[0],"16*$i+8-128($Htbl)")	if ($i<16);
-	    &shl	($tmp,60)			if ($i>0 && $i<17);
-
-	    push	(@lo,shift(@lo));
-	    push	(@hi,shift(@hi));
-	  }
-	}
-	&add	($Htbl,-128);
-	&mov	($Zlo,"8($Xi)");
-	&mov	($Zhi,"0($Xi)");
-	&add	($len,$inp);		# pointer to the end of data
-	&lea	($rem_8bit,".Lrem_8bit(%rip)");
-	&jmp	(".Louter_loop");
-
-$code.=".align	16\n.Louter_loop:\n";
-	&xor	($Zhi,"($inp)");
-	&mov	("%rdx","8($inp)");
-	&lea	($inp,"16($inp)");
-	&xor	("%rdx",$Zlo);
-	&mov	("($Xi)",$Zhi);
-	&mov	("8($Xi)","%rdx");
-	&shr	("%rdx",32);
-
-	&xor	($nlo,$nlo);
-	&rol	($dat,8);
-	&mov	(&LB($nlo),&LB($dat));
-	&movz	($nhi[0],&LB($dat));
-	&shl	(&LB($nlo),4);
-	&shr	($nhi[0],4);
-
-	for ($j=11,$i=0;$i<15;$i++) {
-	    &rol	($dat,8);
-	    &xor	($Zlo,"8($Htbl,$nlo)")			if ($i>0);
-	    &xor	($Zhi,"($Htbl,$nlo)")			if ($i>0);
-	    &mov	($Zlo,"8($Htbl,$nlo)")			if ($i==0);
-	    &mov	($Zhi,"($Htbl,$nlo)")			if ($i==0);
-
-	    &mov	(&LB($nlo),&LB($dat));
-	    &xor	($Zlo,$tmp)				if ($i>0);
-	    &movzw	($rem[1],"($rem_8bit,$rem[1],2)")	if ($i>0);
-
-	    &movz	($nhi[1],&LB($dat));
-	    &shl	(&LB($nlo),4);
-	    &movzb	($rem[0],"(%rsp,$nhi[0])");
-
-	    &shr	($nhi[1],4)				if ($i<14);
-	    &and	($nhi[1],0xf0)				if ($i==14);
-	    &shl	($rem[1],48)				if ($i>0);
-	    &xor	($rem[0],$Zlo);
-
-	    &mov	($tmp,$Zhi);
-	    &xor	($Zhi,$rem[1])				if ($i>0);
-	    &shr	($Zlo,8);
-
-	    &movz	($rem[0],&LB($rem[0]));
-	    &mov	($dat,"$j($Xi)")			if (--$j%4==0);
-	    &shr	($Zhi,8);
-
-	    &xor	($Zlo,"-128($Hshr4,$nhi[0],8)");
-	    &shl	($tmp,56);
-	    &xor	($Zhi,"($Hshr4,$nhi[0],8)");
-
-	    unshift	(@nhi,pop(@nhi));		# "rotate" registers
-	    unshift	(@rem,pop(@rem));
-	}
-	&movzw	($rem[1],"($rem_8bit,$rem[1],2)");
-	&xor	($Zlo,"8($Htbl,$nlo)");
-	&xor	($Zhi,"($Htbl,$nlo)");
-
-	&shl	($rem[1],48);
-	&xor	($Zlo,$tmp);
-
-	&xor	($Zhi,$rem[1]);
-	&movz	($rem[0],&LB($Zlo));
-	&shr	($Zlo,4);
-
-	&mov	($tmp,$Zhi);
-	&shl	(&LB($rem[0]),4);
-	&shr	($Zhi,4);
-
-	&xor	($Zlo,"8($Htbl,$nhi[0])");
-	&movzw	($rem[0],"($rem_8bit,$rem[0],2)");
-	&shl	($tmp,60);
-
-	&xor	($Zhi,"($Htbl,$nhi[0])");
-	&xor	($Zlo,$tmp);
-	&shl	($rem[0],48);
-
-	&bswap	($Zlo);
-	&xor	($Zhi,$rem[0]);
-
-	&bswap	($Zhi);
-	&cmp	($inp,$len);
-	&jb	(".Louter_loop");
-}
-$code.=<<___;
-	mov	$Zlo,8($Xi)
-	mov	$Zhi,($Xi)
-
-	lea	280+48(%rsp),%rsi
-	mov	-48(%rsi),%r15
-	mov	-40(%rsi),%r14
-	mov	-32(%rsi),%r13
-	mov	-24(%rsi),%r12
-	mov	-16(%rsi),%rbp
-	mov	-8(%rsi),%rbx
-	lea	0(%rsi),%rsp
-.Lghash_epilogue:
-	ret
-.size	GFp_gcm_ghash_4bit,.-GFp_gcm_ghash_4bit
 ___
 
 ######################################################################
@@ -653,7 +467,8 @@
 my ($Xl,$Xm,$Xh,$Hkey3,$Hkey4)=map("%xmm$_",(11..15));
 
 $code.=<<___;
-	mov		GFp_ia32cap_P+4(%rip),%eax
+	leaq		GFp_ia32cap_P(%rip),%rax
+	mov		4(%rax),%eax
 	cmp		\$0x30,$len
 	jb		.Lskip4x
 
@@ -1692,14 +1507,6 @@
 
 .section	.pdata
 .align	4
-	.rva	.LSEH_begin_GFp_gcm_gmult_4bit
-	.rva	.LSEH_end_GFp_gcm_gmult_4bit
-	.rva	.LSEH_info_GFp_gcm_gmult_4bit
-
-	.rva	.LSEH_begin_GFp_gcm_ghash_4bit
-	.rva	.LSEH_end_GFp_gcm_ghash_4bit
-	.rva	.LSEH_info_GFp_gcm_ghash_4bit
-
 	.rva	.LSEH_begin_GFp_gcm_init_clmul
 	.rva	.LSEH_end_GFp_gcm_init_clmul
 	.rva	.LSEH_info_GFp_gcm_init_clmul
@@ -1720,14 +1527,6 @@
 $code.=<<___;
 .section	.xdata
 .align	8
-.LSEH_info_GFp_gcm_gmult_4bit:
-	.byte	9,0,0,0
-	.rva	se_handler
-	.rva	.Lgmult_prologue,.Lgmult_epilogue	# HandlerData
-.LSEH_info_GFp_gcm_ghash_4bit:
-	.byte	9,0,0,0
-	.rva	se_handler
-	.rva	.Lghash_prologue,.Lghash_epilogue	# HandlerData
 .LSEH_info_GFp_gcm_init_clmul:
 	.byte	0x01,0x08,0x03,0x00
 	.byte	0x08,0x68,0x00,0x00	#movaps	0x00(rsp),xmm6
diff --git a/rustc_deps/vendor/ring/crypto/fipsmodule/modes/gcm.c b/rustc_deps/vendor/ring/crypto/fipsmodule/modes/gcm.c
index 3461c51..7555e4a 100644
--- a/rustc_deps/vendor/ring/crypto/fipsmodule/modes/gcm.c
+++ b/rustc_deps/vendor/ring/crypto/fipsmodule/modes/gcm.c
@@ -54,14 +54,11 @@
 
 #include "internal.h"
 #include "../../internal.h"
-#include "../aes/internal.h"
+#include "../../block.h"
 
-#if !defined(OPENSSL_NO_ASM) &&                         \
-    (defined(OPENSSL_X86) || defined(OPENSSL_X86_64) || \
-     defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64) || \
-     defined(OPENSSL_PPC64LE))
-#define GHASH_ASM
-#endif
+void GFp_gcm128_ghash(GCM128_CONTEXT *ctx, const uint8_t input[], size_t input_len);
+void GFp_gcm128_gmult(GCM128_CONTEXT *ctx);
+int GFp_gcm_clmul_enabled(void);
 
 #define PACK(s) ((size_t)(s) << (sizeof(size_t) * 8 - 16))
 #define REDUCE1BIT(V)                                                 \
@@ -77,10 +74,6 @@
     }                                                                 \
   } while (0)
 
-// kSizeTWithoutLower4Bits is a mask that can be used to zero the lower four
-// bits of a |size_t|.
-static const size_t kSizeTWithoutLower4Bits = (size_t) -16;
-
 static void gcm_init_4bit(u128 Htable[16], const uint64_t H[2]) {
   u128 V;
 
@@ -110,7 +103,7 @@
   Htable[14].hi = V.hi ^ Htable[6].hi, Htable[14].lo = V.lo ^ Htable[6].lo;
   Htable[15].hi = V.hi ^ Htable[7].hi, Htable[15].lo = V.lo ^ Htable[7].lo;
 
-#if defined(GHASH_ASM) && defined(OPENSSL_ARM)
+#if defined(OPENSSL_ARM)
   // ARM assembler expects specific dword order in Htable.
   {
     int j;
@@ -131,7 +124,7 @@
 #endif
 }
 
-#if !defined(GHASH_ASM) || defined(OPENSSL_AARCH64) || defined(OPENSSL_PPC64LE)
+#if defined(OPENSSL_AARCH64) || defined(OPENSSL_PPC64LE) || defined(OPENSSL_X86_64)
 static const size_t rem_4bit[16] = {
     PACK(0x0000), PACK(0x1C20), PACK(0x3840), PACK(0x2460),
     PACK(0x7080), PACK(0x6CA0), PACK(0x48C0), PACK(0x54E0),
@@ -244,30 +237,17 @@
       Z.lo ^= Htable[nlo].lo;
     }
 
-    Xi[0] = from_be_u64(Z.hi);
-    Xi[1] = from_be_u64(Z.lo);
+    to_be_u64_ptr(Xi, Z.hi);
+    to_be_u64_ptr(Xi + 8, Z.lo);
   } while (inp += 16, len -= 16);
 }
-#else // GHASH_ASM
+#else
 void GFp_gcm_gmult_4bit(uint8_t Xi[16], const u128 Htable[16]);
 void GFp_gcm_ghash_4bit(uint8_t Xi[16], const u128 Htable[16],
                         const uint8_t *inp, size_t len);
 #endif
 
-#define GCM_MUL(ctx, Xi) GFp_gcm_gmult_4bit((ctx)->Xi, (ctx)->Htable)
-#if defined(GHASH_ASM)
-#define GHASH(ctx, in, len) GFp_gcm_ghash_4bit((ctx)->Xi, (ctx)->Htable, in, len)
-// GHASH_CHUNK is "stride parameter" missioned to mitigate cache
-// trashing effect. In other words idea is to hash data while it's
-// still in L1 cache after encryption pass...
-#define GHASH_CHUNK (3 * 1024)
-#endif
-
-
-#if defined(GHASH_ASM)
-
 #if defined(OPENSSL_X86) || defined(OPENSSL_X86_64)
-#define GCM_FUNCREF_4BIT
 void GFp_gcm_init_clmul(u128 Htable[16], const uint64_t Xi[2]);
 void GFp_gcm_gmult_clmul(uint8_t Xi[16], const u128 Htable[16]);
 void GFp_gcm_ghash_clmul(uint8_t Xi[16], const u128 Htable[16],
@@ -278,11 +258,11 @@
 void GFp_gcm_init_avx(u128 Htable[16], const uint64_t Xi[2]);
 void GFp_gcm_ghash_avx(uint8_t Xi[16], const u128 Htable[16], const uint8_t *in,
                        size_t len);
-#define AESNI_GCM
-size_t GFp_aesni_gcm_encrypt(const uint8_t *in, uint8_t *out, size_t len,
-                             const void *key, uint8_t ivec[16], uint8_t Xi[16]);
-size_t GFp_aesni_gcm_decrypt(const uint8_t *in, uint8_t *out, size_t len,
-                             const void *key, uint8_t ivec[16], uint8_t Xi[16]);
+int GFp_aesni_gcm_capable(void);
+
+int GFp_aesni_gcm_capable(void) {
+  return ((GFp_ia32cap_P[1] >> 22) & 0x41) == 0x41; // AVX+MOVBE
+}
 #endif
 
 #if defined(OPENSSL_X86)
@@ -298,7 +278,6 @@
 
 #if __ARM_MAX_ARCH__ >= 8
 #define ARM_PMULL_ASM
-#define GCM_FUNCREF_4BIT
 void GFp_gcm_init_v8(u128 Htable[16], const uint64_t Xi[2]);
 void GFp_gcm_gmult_v8(uint8_t Xi[16], const u128 Htable[16]);
 void GFp_gcm_ghash_v8(uint8_t Xi[16], const u128 Htable[16], const uint8_t *inp,
@@ -306,7 +285,6 @@
 #endif
 
 #if defined(OPENSSL_ARM) && __ARM_MAX_ARCH__ >= 7
-#define GCM_FUNCREF_4BIT
 // 32-bit ARM also has support for doing GCM with NEON instructions.
 void GFp_gcm_init_neon(u128 Htable[16], const uint64_t Xi[2]);
 void GFp_gcm_gmult_neon(uint8_t Xi[16], const u128 Htable[16]);
@@ -316,56 +294,29 @@
 
 #elif defined(OPENSSL_PPC64LE)
 #define GHASH_ASM_PPC64LE
-#define GCM_FUNCREF_4BIT
 void GFp_gcm_init_p8(u128 Htable[16], const uint64_t Xi[2]);
 void GFp_gcm_gmult_p8(uint64_t Xi[2], const u128 Htable[16]);
 void GFp_gcm_ghash_p8(uint64_t Xi[2], const u128 Htable[16], const uint8_t *inp,
                       size_t len);
 #endif // Platform
 
-#endif // GHASH_ASM
+void GFp_gcm128_init_htable(GCM128_KEY *r, Block h_block);
 
-#ifdef GCM_FUNCREF_4BIT
-#undef GCM_MUL
-#define GCM_MUL(ctx, Xi) (*gcm_gmult_p)((ctx)->Xi, (ctx)->Htable)
-#ifdef GHASH
-#undef GHASH
-#define GHASH(ctx, in, len) (*gcm_ghash_p)((ctx)->Xi, (ctx)->Htable, in, len)
-#endif
-#endif
-
-static void gcm128_init_htable(u128 Htable[GCM128_HTABLE_LEN],
-                               const uint64_t H[2]);
-
-void GFp_gcm128_init_serialized(
-    uint8_t serialized_ctx[GCM128_SERIALIZED_LEN], const AES_KEY *key,
-    aes_block_f block) {
-  static const alignas(16) uint8_t ZEROS[16] = { 0 };
-  uint8_t H_be[16];
-  (*block)(ZEROS, H_be, key);
+void GFp_gcm128_init_htable(GCM128_KEY *r, Block h_block) {
 
   // H is stored in host byte order
   alignas(16) uint64_t H[2];
-  H[0] = from_be_u64_ptr(H_be);
-  H[1] = from_be_u64_ptr(H_be + 8);
+  H[0] = from_be_u64(h_block.subblocks[0]);
+  H[1] = from_be_u64(h_block.subblocks[1]);
 
-  alignas(16) u128 Htable[GCM128_HTABLE_LEN];
-  gcm128_init_htable(Htable, H);
+  u128 *Htable = r->Htable;
 
-  OPENSSL_COMPILE_ASSERT(sizeof(Htable) == GCM128_SERIALIZED_LEN,
-                         GCM128_SERIALIZED_LEN_is_wrong);
-
-  memcpy(serialized_ctx, Htable, GCM128_SERIALIZED_LEN);
-}
-
-static void gcm128_init_htable(u128 Htable[GCM128_HTABLE_LEN],
-                               const uint64_t H[2]) {
   // Keep in sync with |gcm128_init_gmult_ghash|.
 
 #if defined(GHASH_ASM_X86_64) || defined(GHASH_ASM_X86)
   if (GFp_gcm_clmul_enabled()) {
 #if defined(GHASH_ASM_X86_64)
-    if (((GFp_ia32cap_P[1] >> 22) & 0x41) == 0x41) { // AVX+MOVBE
+    if (GFp_aesni_gcm_capable()) {
       GFp_gcm_init_avx(Htable, H);
       return;
     }
@@ -396,296 +347,89 @@
   gcm_init_4bit(Htable, H);
 }
 
-static void gcm128_init_gmult_ghash(GCM128_CONTEXT *ctx) {
+void GFp_gcm128_gmult(GCM128_CONTEXT *ctx) {
+  // Keep in sync with |gcm128_ghash|, gcm128_init_htable| and |GFp_AES_set_encrypt_key|.
+
+#if defined(GHASH_ASM_X86_64) || defined(GHASH_ASM_X86)
+  if (GFp_gcm_clmul_enabled()) {
+    // GFp_gcm_gmult_avx2 was an alias for GFp_gcm_gmult_clmul so there's no need
+    // for x86-64 MOVEBE+AVX2 stuff here. Apparently GFp_gcm_gmult_clmul doesn't need
+    // that stuff.
+    GFp_gcm_gmult_clmul(ctx->Xi, ctx->key.Htable);
+    return;
+  }
+#endif
+#if defined(ARM_PMULL_ASM)
+  if (GFp_is_ARMv8_PMULL_capable()) {
+    GFp_gcm_gmult_v8(ctx->Xi, ctx->key.Htable);
+    return;
+  }
+#endif
+#if defined(OPENSSL_ARM)
+  if (GFp_is_NEON_capable()) {
+    GFp_gcm_gmult_neon(ctx->Xi, ctx->key.Htable);
+    return;
+  }
+#endif
+#if defined(GHASH_ASM_PPC64LE)
+  if (GFp_is_PPC64LE_vcrypto_capable()) {
+    GFp_gcm_gmult_p8(ctx->Xi, ctx->key.Htable);
+    return;
+  }
+#endif
+
+#if defined(GHASH_ASM_X86)
+  GFp_gcm_gmult_4bit_mmx(ctx->Xi, ctx->key.Htable);
+#else
+  GFp_gcm_gmult_4bit(ctx->Xi, ctx->key.Htable);
+#endif
+}
+
+void GFp_gcm128_ghash(GCM128_CONTEXT *ctx, const uint8_t input[], size_t input_len) {
+  assert(input_len % 16 == 0);
   // Keep in sync with |gcm128_init_htable| and |GFp_AES_set_encrypt_key|.
 
 #if defined(GHASH_ASM_X86_64) || defined(GHASH_ASM_X86)
   if (GFp_gcm_clmul_enabled()) {
 #if defined(GHASH_ASM_X86_64)
     if (((GFp_ia32cap_P[1] >> 22) & 0x41) == 0x41) { // AVX+MOVBE
-      ctx->gmult = GFp_gcm_gmult_clmul;
-      ctx->ghash = GFp_gcm_ghash_avx;
-      ctx->use_aesni_gcm_crypt = hwaes_capable() ? 1 : 0;
+      GFp_gcm_ghash_avx(ctx->Xi, ctx->key.Htable, input, input_len);
       return;
     }
 #endif
-    ctx->gmult = GFp_gcm_gmult_clmul;
-    ctx->ghash = GFp_gcm_ghash_clmul;
+    GFp_gcm_ghash_clmul(ctx->Xi, ctx->key.Htable, input, input_len);
     return;
   }
 #endif
 #if defined(ARM_PMULL_ASM)
   if (GFp_is_ARMv8_PMULL_capable()) {
-    ctx->gmult = GFp_gcm_gmult_v8;
-    ctx->ghash = GFp_gcm_ghash_v8;
+    GFp_gcm_ghash_v8(ctx->Xi, ctx->key.Htable, input, input_len);
     return;
   }
 #endif
 #if defined(OPENSSL_ARM)
   if (GFp_is_NEON_capable()) {
-    ctx->gmult = GFp_gcm_gmult_neon;
-    ctx->ghash = GFp_gcm_ghash_neon;
+    GFp_gcm_ghash_neon(ctx->Xi, ctx->key.Htable, input, input_len);
     return;
   }
 #endif
 #if defined(GHASH_ASM_PPC64LE)
   if (GFp_is_PPC64LE_vcrypto_capable()) {
-    ctx->gmult = GFp_gcm_gmult_p8;
-    ctx->ghash = GFp_gcm_ghash_p8;
+    GFp_gcm_ghash_p8(ctx->Xi, ctx->key.Htable, input, input_len);
     return;
   }
 #endif
 
 #if defined(GHASH_ASM_X86)
-  ctx->gmult = GFp_gcm_gmult_4bit_mmx;
-  ctx->ghash = GFp_gcm_ghash_4bit_mmx;
+  GFp_gcm_ghash_4bit_mmx(ctx->Xi, ctx->key.Htable, input, input_len);
 #else
-  ctx->gmult = GFp_gcm_gmult_4bit;
-  ctx->ghash = GFp_gcm_ghash_4bit;
+  GFp_gcm_ghash_4bit(ctx->Xi, ctx->key.Htable, input, input_len);
 #endif
 }
 
-void GFp_gcm128_init(GCM128_CONTEXT *ctx, const AES_KEY *key,
-                        aes_block_f block,
-                        const uint8_t serialized_ctx[GCM128_SERIALIZED_LEN],
-                        const uint8_t *iv) {
-  uint32_t ctr = 1;
-
-  memset(ctx, 0, sizeof(*ctx));
-  memcpy(ctx->Yi, iv, 12);
-  to_be_u32_ptr(ctx->Yi + 12, ct