Bug 1396821 - Update vendored Rust crates. r=ato
☠☠ backed out by d8a7212c51a4 ☠ ☠
authorHenrik Skupin <mail@hskupin.info>
Mon, 20 Aug 2018 17:49:11 +0200
changeset 490358 2fa2975f97e3e81f501aa982ab224ac470683f51
parent 490357 c5895db52483b9fd5d2e0df6498f5aa601573d37
child 490359 03537843fab253117d5df0a1a3f45cd1e5fa4d52
push id1815
push userffxbld-merge
push dateMon, 15 Oct 2018 10:40:45 +0000
treeherdermozilla-release@18d4c09e9378 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersato
bugs1396821
milestone63.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1396821 - Update vendored Rust crates. r=ato MozReview-Commit-ID: D8W2mtdAmpb
Cargo.lock
third_party/rust/rustc-serialize/.cargo-checksum.json
third_party/rust/rustc-serialize/.travis.yml
third_party/rust/rustc-serialize/Cargo.toml
third_party/rust/rustc-serialize/LICENSE-APACHE
third_party/rust/rustc-serialize/LICENSE-MIT
third_party/rust/rustc-serialize/README.md
third_party/rust/rustc-serialize/appveyor.yml
third_party/rust/rustc-serialize/benches/base64.rs
third_party/rust/rustc-serialize/benches/hex.rs
third_party/rust/rustc-serialize/benches/json.rs
third_party/rust/rustc-serialize/src/base64.rs
third_party/rust/rustc-serialize/src/collection_impls.rs
third_party/rust/rustc-serialize/src/hex.rs
third_party/rust/rustc-serialize/src/json.rs
third_party/rust/rustc-serialize/src/lib.rs
third_party/rust/rustc-serialize/src/serialize.rs
third_party/rust/ryu/.cargo-checksum.json
third_party/rust/ryu/.travis.yml
third_party/rust/ryu/Cargo.toml
third_party/rust/ryu/LICENSE-APACHE
third_party/rust/ryu/README.md
third_party/rust/ryu/benchmark/benchmark.rs
third_party/rust/ryu/build.rs
third_party/rust/ryu/src/buffer/mod.rs
third_party/rust/ryu/src/common.rs
third_party/rust/ryu/src/d2s.rs
third_party/rust/ryu/src/d2s_full_table.rs
third_party/rust/ryu/src/d2s_small_table.rs
third_party/rust/ryu/src/digit_table.rs
third_party/rust/ryu/src/f2s.rs
third_party/rust/ryu/src/lib.rs
third_party/rust/ryu/src/mulshift128.rs
third_party/rust/ryu/src/pretty/exponent.rs
third_party/rust/ryu/src/pretty/mantissa.rs
third_party/rust/ryu/src/pretty/mod.rs
third_party/rust/ryu/tests/d2s_table_test.rs
third_party/rust/ryu/tests/d2s_test.rs
third_party/rust/ryu/tests/exhaustive.rs
third_party/rust/ryu/tests/f2s_test.rs
third_party/rust/ryu/tests/macros/mod.rs
third_party/rust/serde_json/.cargo-checksum.json
third_party/rust/serde_json/Cargo.toml
third_party/rust/serde_json/LICENSE-APACHE
third_party/rust/serde_json/LICENSE-MIT
third_party/rust/serde_json/README.md
third_party/rust/serde_json/src/de.rs
third_party/rust/serde_json/src/error.rs
third_party/rust/serde_json/src/iter.rs
third_party/rust/serde_json/src/lib.rs
third_party/rust/serde_json/src/macros.rs
third_party/rust/serde_json/src/map.rs
third_party/rust/serde_json/src/number.rs
third_party/rust/serde_json/src/read.rs
third_party/rust/serde_json/src/ser.rs
third_party/rust/serde_json/src/value/de.rs
third_party/rust/serde_json/src/value/from.rs
third_party/rust/serde_json/src/value/index.rs
third_party/rust/serde_json/src/value/mod.rs
third_party/rust/serde_json/src/value/partial_eq.rs
third_party/rust/serde_json/src/value/ser.rs
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -801,26 +801,29 @@ dependencies = [
  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "geckodriver"
 version = "0.21.0"
 dependencies = [
+ "base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "chrono 0.2.25 (registry+https://github.com/rust-lang/crates.io-index)",
  "clap 2.31.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "hyper 0.10.13 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "mozprofile 0.3.0",
  "mozrunner 0.7.0",
  "mozversion 0.1.3",
  "regex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.66 (git+https://github.com/servo/serde?branch=deserialize_from_enums8)",
+ "serde_json 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)",
  "uuid 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "webdriver 0.36.0",
  "zip 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "geckoservo"
 version = "0.0.1"
@@ -1832,29 +1835,29 @@ version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "rustc-demangle"
 version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
-name = "rustc-serialize"
-version = "0.3.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
 name = "rustc_version"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
+name = "ryu"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
 name = "safemem"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "same-file"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1924,16 +1927,26 @@ version = "1.0.66"
 source = "git+https://github.com/servo/serde?branch=deserialize_from_enums8#c4457d804b38b14e699b45c01d1909f93f25ab5e"
 dependencies = [
  "proc-macro2 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "syn 0.14.6 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
+name = "serde_json"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "itoa 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ryu 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
 name = "servo_arc"
 version = "0.1.1"
 dependencies = [
  "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
  "stable_deref_trait 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -2407,21 +2420,25 @@ dependencies = [
  "same-file 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "webdriver"
 version = "0.36.0"
 dependencies = [
+ "base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "cookie 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "hyper 0.10.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.66 (git+https://github.com/servo/serde?branch=deserialize_from_enums8)",
+ "serde_json 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-segmentation 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "url 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "webidl"
 version = "0.6.0"
@@ -2790,27 +2807,28 @@ dependencies = [
 "checksum regex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "75ecf88252dce580404a22444fc7d626c01815debba56a7f4f536772a5ff19d3"
 "checksum regex-syntax 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad890a5eef7953f55427c50575c680c42841653abd2b028b68cd223d157f62db"
 "checksum regex-syntax 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8f1ac0f60d675cc6cf13a20ec076568254472551051ad5dd050364d70671bf6b"
 "checksum rkv 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "21983ae9330b1e1cb1d01868229618a3c7cc5134955f0dc1a86a0a1886f3acb7"
 "checksum ron 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "da06feaa07f69125ab9ddc769b11de29090122170b402547f64b86fe16ebc399"
 "checksum runloop 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5d79b4b604167921892e84afbbaad9d5ad74e091bf6c511d9dbfb0593f09fabd"
 "checksum rust-ini 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8a654c5bda722c699be6b0fe4c0d90de218928da5b724c3e467fc48865c37263"
 "checksum rustc-demangle 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "76d7ba1feafada44f2d38eed812bd2489a03c0f5abb975799251518b68848649"
-"checksum rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)" = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
 "checksum rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b9743a7670d88d5d52950408ecdb7c71d8986251ab604d4689dd2ca25c9bca69"
+"checksum ryu 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fd0568787116e13c652377b6846f5931454a363a8fdf8ae50463ee40935b278b"
 "checksum safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e27a8b19b835f7aea908818e871f5cc3a5a186550c30773be987e155e8163d8f"
 "checksum same-file 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "cfb6eded0b06a0b512c8ddbcf04089138c9b4362c2f696f3c3d76039d68f3637"
 "checksum scoped-tls 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f417c22df063e9450888a7561788e9bd46d3bb3c1466435b4eccb903807f147d"
 "checksum scopeguard 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c79eb2c3ac4bc2507cda80e7f3ac5b88bd8eae4c0914d5663e6a8933994be918"
 "checksum semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a3186ec9e65071a2095434b1f5bb24838d4e8e130f584c790f6033c79943537"
 "checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 "checksum serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)" = "e9a2d9a9ac5120e0f768801ca2b58ad6eec929dc9d1d616c162f208869c2ce95"
 "checksum serde_bytes 0.10.4 (registry+https://github.com/rust-lang/crates.io-index)" = "adb6e51a6b3696b301bc221d785f898b4457c619b51d7ce195a6d20baecb37b3"
 "checksum serde_derive 1.0.66 (git+https://github.com/servo/serde?branch=deserialize_from_enums8)" = "<none>"
+"checksum serde_json 1.0.26 (registry+https://github.com/rust-lang/crates.io-index)" = "44dd2cfde475037451fa99b7e5df77aa3cfd1536575fa8e7a538ab36dcde49ae"
 "checksum simd 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "ed3686dd9418ebcc3a26a0c0ae56deab0681e53fe899af91f5bbcee667ebffb1"
 "checksum siphasher 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2ffc669b726f2bc9a3bcff66e5e23b56ba6bf70e22a34c3d7b6d0b3450b65b84"
 "checksum slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "17b4fcaed89ab08ef143da37bc52adbcc04d4a69014f4c1208d6b51f0c47bc23"
 "checksum smallbitvec 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5c63726029f0069f88467873e47f392575f28f9f16b72ac65465263db4b3a13c"
 "checksum smallvec 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "26df3bb03ca5eac2e64192b723d51f56c1b1e0860e7c766281f4598f181acdc8"
 "checksum stable_deref_trait 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "15132e0e364248108c5e2c02e3ab539be8d6f5d52a01ca9bbf27ed657316f02b"
 "checksum string_cache 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "25d70109977172b127fe834e5449e5ab1740b9ba49fa18a2020f509174f25423"
 "checksum string_cache_codegen 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "479cde50c3539481f33906a387f2bd17c8e87cb848c35b6021d41fb81ff9b4d7"
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"03dcea6dcd54625b42d91176e86718626dfd911744a343dee3edefa001e87dc5","Cargo.toml":"01199fa6ca6337a7513e9ef8951268b8882347e5affaa50e710ac4960d9c65e0","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"0aebc3beb6fc32d6073582d5fea170761689a2c83cddb5436aa26e57b7d04e7b","appveyor.yml":"da991211b72fa6f231af7adb84c9fb72f5a9131d1c0a3d47b8ceffe5a82c8542","benches/base64.rs":"96f7d0c7d260362e41b8cefb4839f1e1b3c18c2f10344f6ccafac7c434f99ca9","benches/hex.rs":"057821307b4b7de02f2c267f9248457386035382916c5afe4b72d6f2e905062c","benches/json.rs":"659f2ae2e1ad5ed022fafce6418d17dfe09c3dcb3f054857dce0effc907da850","src/base64.rs":"57649c590c1fba643ff955910f1d4427feda43414bb0863cd279bea56c3ff178","src/collection_impls.rs":"8ae6bc0d61a4777d834c2b24fa987550cb13c570e1564f87ee32eceff3cb2d5b","src/hex.rs":"a2ba86cf47035b5d9cbf4adf8dc3e941d4e0a6ce1a61a29cbb14ea1fdabac6bb","src/json.rs":"75a788a46612c73bfd14af20fb48855dc8c930747c5255a288d2d09de25ea960","src/lib.rs":"a0e4a368a609f019434e7584f54448cf33ebf3e37e3fb1dd5537d300088184b1","src/serialize.rs":"7ddcc3c32843850e30d05b82a8cda8ae63ec0016e2b0bfbcc46a03ea3ea986e8"},"package":"dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/.travis.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-language: rust
-rust:
-  - 1.0.0
-  - stable
-  - beta
-  - nightly
-sudo: false
-before_script:
-  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-script:
-  - cargo build --verbose
-  - cargo test --verbose
-  - cargo doc --no-deps
-after_success:
-  - travis-cargo --only nightly doc-upload
-env:
-  global:
-    secure: "kJnqqAXRl0C7Afx0c8Y3vA6TAEZsxlasu7eIZMdCbNS4N1+Rwh0jNTa2jy2D3CQCrzW5OCefnkpkPTu8mADrAjedM4p/9X5UXZi0sgg2lzCgfGwrRzitTnyPDkdYidiu4QeC/r0WPC8lYZKHkJXYhF8bZgchB9ypnZ6LAHCcDkA="
-
-
-
-notifications:
-  email:
-    on_success: never
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-
-name = "rustc-serialize"
-version = "0.3.24"
-authors = ["The Rust Project Developers"]
-license = "MIT/Apache-2.0"
-readme = "README.md"
-repository = "https://github.com/rust-lang/rustc-serialize"
-homepage = "https://github.com/rust-lang/rustc-serialize"
-documentation = "https://doc.rust-lang.org/rustc-serialize"
-description = """
-Generic serialization/deserialization support corresponding to the
-`derive(RustcEncodable, RustcDecodable)` mode in the compiler. Also includes
-support for hex, base64, and json encoding and decoding.
-"""
-
-[dev-dependencies]
-rand = "0.3"
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# rustc-serialize
-
-> **NOTE**: This crate is deprecated in favor of [`serde`]. No new feature
-> development will happen in this crate, although bug fixes proposed through PRs
-> will still be merged. It is very highly recommended by the Rust Library Team
-> that you use [`serde`], not this crate.
-
-[`serde`]: https://serde.rs
-
-Serialization and deserialization support provided by the compiler in the form
-of `derive(RustcEncodable, RustcDecodable)`.
-
-[![Linux Build Status](https://travis-ci.org/rust-lang-nursery/rustc-serialize.svg?branch=master)](https://travis-ci.org/rust-lang-nursery/rustc-serialize)
-[![Windows Build Status](https://ci.appveyor.com/api/projects/status/ka194de75aapwpft?svg=true)](https://ci.appveyor.com/project/alexcrichton/rustc-serialize)
-
-[Documentation](https://doc.rust-lang.org/rustc-serialize)
-
-## Usage
-
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-rustc-serialize = "0.3"
-```
-
-and this to your crate root:
-
-```rust
-extern crate rustc_serialize;
-```
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/appveyor.yml
+++ /dev/null
@@ -1,17 +0,0 @@
-environment:
-  matrix:
-  - TARGET: x86_64-pc-windows-msvc
-  - TARGET: i686-pc-windows-msvc
-  - TARGET: i686-pc-windows-gnu
-install:
-  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe"
-  - rust-nightly-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
-  - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin
-  - SET PATH=%PATH%;C:\MinGW\bin
-  - rustc -V
-  - cargo -V
-
-build: false
-
-test_script:
-  - cargo test --verbose
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/base64.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use rustc_serialize::base64::{FromBase64, ToBase64, STANDARD};
-use test::Bencher;
-
-#[bench]
-fn bench_to_base64(b: &mut Bencher) {
-    let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-             ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-    b.iter(|| {
-        s.as_bytes().to_base64(STANDARD);
-    });
-    b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_base64(b: &mut Bencher) {
-    let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-             ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-    let sb = s.as_bytes().to_base64(STANDARD);
-    b.iter(|| {
-        sb.from_base64().unwrap();
-    });
-    b.bytes = sb.len() as u64;
-}
-
-
-#[bench]
-fn bench_to_base64_large(b: &mut Bencher) {
-    let s: Vec<_> = (0..10000).map(|i| ((i as u32 * 12345) % 256) as u8).collect();
-    b.iter(|| {
-        s.to_base64(STANDARD);
-    });
-    b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_base64_large(b: &mut Bencher) {
-    let s: Vec<_> = (0..10000).map(|i| ((i as u32 * 12345) % 256) as u8).collect();
-    let sb = s.to_base64(STANDARD);
-    b.iter(|| {
-        sb.from_base64().unwrap();
-    });
-    b.bytes = sb.len() as u64;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/hex.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use test::Bencher;
-use rustc_serialize::hex::{FromHex, ToHex};
-
-#[bench]
-fn bench_to_hex(b: &mut Bencher) {
-    let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-             ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-    b.iter(|| {
-        s.as_bytes().to_hex();
-    });
-    b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_hex(b: &mut Bencher) {
-    let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-             ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-    let sb = s.as_bytes().to_hex();
-    b.iter(|| {
-        sb.from_hex().unwrap();
-    });
-    b.bytes = sb.len() as u64;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/json.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use std::string;
-use rustc_serialize::json::{Json, Parser};
-use test::Bencher;
-
-#[bench]
-fn bench_streaming_small(b: &mut Bencher) {
-    b.iter( || {
-        let mut parser = Parser::new(
-            r#"{
-                "a": 1.0,
-                "b": [
-                    true,
-                    "foo\nbar",
-                    { "c": {"d": null} }
-                ]
-            }"#.chars()
-        );
-        loop {
-            match parser.next() {
-                None => return,
-                _ => {}
-            }
-        }
-    });
-}
-#[bench]
-fn bench_small(b: &mut Bencher) {
-    b.iter( || {
-        let _ = Json::from_str(r#"{
-            "a": 1.0,
-            "b": [
-                true,
-                "foo\nbar",
-                { "c": {"d": null} }
-            ]
-        }"#);
-    });
-}
-
-#[bench]
-fn bench_decode_hex_escape(b: &mut Bencher) {
-    let mut src = "\"".to_string();
-    for _ in 0..10 {
-        src.push_str("\\uF975\\uf9bc\\uF9A0\\uF9C4\\uF975\\uf9bc\\uF9A0\\uF9C4");
-    }
-    src.push_str("\"");
-    b.iter( || {
-        let _ = Json::from_str(&src);
-    });
-}
-
-fn big_json() -> string::String {
-    let mut src = "[\n".to_string();
-    for _ in 0..500 {
-        src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
-                        [1,2,3]},"#);
-    }
-    src.push_str("{}]");
-    return src;
-}
-
-#[bench]
-fn bench_streaming_large(b: &mut Bencher) {
-    let src = big_json();
-    b.iter( || {
-        let mut parser = Parser::new(src.chars());
-        loop {
-            match parser.next() {
-                None => return,
-                _ => {}
-            }
-        }
-    });
-}
-#[bench]
-fn bench_large(b: &mut Bencher) {
-    let src = big_json();
-    b.iter( || { let _ = Json::from_str(&src); });
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/base64.rs
+++ /dev/null
@@ -1,489 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-//
-// ignore-lexer-test FIXME #15679
-
-//! Base64 binary-to-text encoding
-
-pub use self::FromBase64Error::*;
-pub use self::CharacterSet::*;
-
-use std::fmt;
-use std::error;
-
-/// 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
-}
-
-/// Available newline types
-#[derive(Clone, Copy, Debug)]
-pub enum Newline {
-    /// A linefeed (i.e. Unix-style newline)
-    LF,
-    /// A carriage return and a linefeed (i.e. Windows-style newline)
-    CRLF
-}
-
-/// Contains configuration parameters for `to_base64`.
-#[derive(Clone, Copy, Debug)]
-pub struct Config {
-    /// Character set to use
-    pub char_set: CharacterSet,
-    /// Newline to use
-    pub newline: Newline,
-    /// True to pad output with `=` characters
-    pub pad: bool,
-    /// `Some(len)` to wrap lines at `len`, `None` to disable line wrapping
-    pub line_length: Option<usize>
-}
-
-/// Configuration for RFC 4648 standard base64 encoding
-pub static STANDARD: Config =
-    Config {char_set: Standard, newline: Newline::CRLF, pad: true, line_length: None};
-
-/// Configuration for RFC 4648 base64url encoding
-pub static URL_SAFE: Config =
-    Config {char_set: UrlSafe, newline: Newline::CRLF, pad: false, line_length: None};
-
-/// Configuration for RFC 2045 MIME base64 encoding
-pub static MIME: Config =
-    Config {char_set: Standard, newline: Newline::CRLF, pad: true, line_length: Some(76)};
-
-static STANDARD_CHARS: &'static[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
-                                        abcdefghijklmnopqrstuvwxyz\
-                                        0123456789+/";
-
-static URLSAFE_CHARS: &'static[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
-                                       abcdefghijklmnopqrstuvwxyz\
-                                       0123456789-_";
-
-/// A trait for converting a value to base64 encoding.
-pub trait ToBase64 {
-    /// Converts the value of `self` to a base64 value following the specified
-    /// format configuration, returning the owned string.
-    fn to_base64(&self, config: Config) -> String;
-}
-
-impl ToBase64 for [u8] {
-    /// Turn a vector of `u8` bytes into a base64 string.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// extern crate rustc_serialize;
-    /// use rustc_serialize::base64::{ToBase64, STANDARD};
-    ///
-    /// fn main () {
-    ///     let str = [52,32].to_base64(STANDARD);
-    ///     println!("base 64 output: {:?}", str);
-    /// }
-    /// ```
-    fn to_base64(&self, config: Config) -> String {
-        let bytes = match config.char_set {
-            Standard => STANDARD_CHARS,
-            UrlSafe => URLSAFE_CHARS
-        };
-
-        let len = self.len();
-        let newline = match config.newline {
-            Newline::LF => "\n",
-            Newline::CRLF => "\r\n",
-        };
-
-        // Preallocate memory.
-        let mut prealloc_len = (len + 2) / 3 * 4;
-        if let Some(line_length) = config.line_length {
-            let num_lines = match prealloc_len {
-                0 => 0,
-                n => (n - 1) / line_length
-            };
-            prealloc_len += num_lines * newline.bytes().count();
-        }
-
-        let mut out_bytes = vec![b'='; prealloc_len];
-
-        // Deal with padding bytes
-        let mod_len = len % 3;
-
-        // Use iterators to reduce branching
-        {
-            let mut cur_length = 0;
-
-            let mut s_in = self[..len - mod_len].iter().map(|&x| x as u32);
-            let mut s_out = out_bytes.iter_mut();
-
-            // Convenient shorthand
-            let enc = |val| bytes[val as usize];
-            let mut write = |val| *s_out.next().unwrap() = val;
-
-            // Iterate though blocks of 4
-            while let (Some(first), Some(second), Some(third)) =
-                        (s_in.next(), s_in.next(), s_in.next()) {
-
-                // Line break if needed
-                if let Some(line_length) = config.line_length {
-                    if cur_length >= line_length {
-                        for b in newline.bytes() { write(b) };
-                        cur_length = 0;
-                    }
-                }
-
-                let n = first << 16 | second << 8 | third;
-
-                // This 24-bit number gets separated into four 6-bit numbers.
-                write(enc((n >> 18) & 63));
-                write(enc((n >> 12) & 63));
-                write(enc((n >> 6 ) & 63));
-                write(enc((n >> 0 ) & 63));
-
-                cur_length += 4;
-            }
-
-            // Line break only needed if padding is required
-            if mod_len != 0 {
-                if let Some(line_length) = config.line_length {
-                    if cur_length >= line_length {
-                        for b in newline.bytes() { write(b) };
-                    }
-                }
-            }
-
-            // Heh, would be cool if we knew this was exhaustive
-            // (the dream of bounded integer types)
-            match mod_len {
-                0 => (),
-                1 => {
-                    let n = (self[len-1] as u32) << 16;
-                    write(enc((n >> 18) & 63));
-                    write(enc((n >> 12) & 63));
-                }
-                2 => {
-                    let n = (self[len-2] as u32) << 16 |
-                            (self[len-1] as u32) << 8;
-                    write(enc((n >> 18) & 63));
-                    write(enc((n >> 12) & 63));
-                    write(enc((n >> 6 ) & 63));
-                }
-                _ => panic!("Algebra is broken, please alert the math police")
-            }
-        }
-
-        // We get padding for "free", so only have to drop it if unwanted.
-        if !config.pad {
-            while let Some(&b'=') = out_bytes.last() {
-                out_bytes.pop();
-            }
-        }
-
-        unsafe { String::from_utf8_unchecked(out_bytes) }
-    }
-}
-
-impl<'a, T: ?Sized + ToBase64> ToBase64 for &'a T {
-    fn to_base64(&self, config: Config) -> String {
-        (**self).to_base64(config)
-    }
-}
-
-/// A trait for converting from base64 encoded values.
-pub trait FromBase64 {
-    /// Converts the value of `self`, interpreted as base64 encoded data, into
-    /// an owned vector of bytes, returning the vector.
-    fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error>;
-}
-
-/// Errors that can occur when decoding a base64 encoded string
-#[derive(Clone, Copy)]
-pub enum FromBase64Error {
-    /// The input contained a character not part of the base64 format
-    InvalidBase64Byte(u8, usize),
-    /// The input had an invalid length
-    InvalidBase64Length,
-}
-
-impl fmt::Debug for FromBase64Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            InvalidBase64Byte(ch, idx) =>
-                write!(f, "Invalid character '{}' at position {}", ch, idx),
-            InvalidBase64Length => write!(f, "Invalid length"),
-        }
-    }
-}
-
-impl error::Error for FromBase64Error {
-    fn description(&self) -> &str {
-        match *self {
-            InvalidBase64Byte(_, _) => "invalid character",
-            InvalidBase64Length => "invalid length",
-        }
-    }
-}
-
-impl fmt::Display for FromBase64Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl FromBase64 for str {
-    /// Convert any base64 encoded string (literal, `@`, `&`, or `~`)
-    /// to the byte values it encodes.
-    ///
-    /// You can use the `String::from_utf8` function to turn a `Vec<u8>` into a
-    /// string with characters corresponding to those values.
-    ///
-    /// # Example
-    ///
-    /// This converts a string literal to base64 and back.
-    ///
-    /// ```rust
-    /// extern crate rustc_serialize;
-    /// use rustc_serialize::base64::{ToBase64, FromBase64, STANDARD};
-    ///
-    /// fn main () {
-    ///     let hello_str = b"Hello, World".to_base64(STANDARD);
-    ///     println!("base64 output: {}", hello_str);
-    ///     let res = hello_str.from_base64();
-    ///     if res.is_ok() {
-    ///       let opt_bytes = String::from_utf8(res.unwrap());
-    ///       if opt_bytes.is_ok() {
-    ///         println!("decoded from base64: {:?}", opt_bytes.unwrap());
-    ///       }
-    ///     }
-    /// }
-    /// ```
-    #[inline]
-    fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
-        self.as_bytes().from_base64()
-    }
-}
-
-impl FromBase64 for [u8] {
-    fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
-        let mut r = Vec::with_capacity(self.len());
-        let mut buf: u32 = 0;
-        let mut modulus = 0;
-
-        let mut it = self.iter();
-        for byte in it.by_ref() {
-            let code = DECODE_TABLE[*byte as usize];
-            if code >= SPECIAL_CODES_START {
-                match code {
-                    NEWLINE_CODE => continue,
-                    EQUALS_CODE => break,
-                    INVALID_CODE => return Err(InvalidBase64Byte(
-                            *byte, (byte as *const _ as usize) - self.as_ptr() as usize)),
-                    _ => unreachable!(),
-                }
-            }
-            buf = (buf | code as u32) << 6;
-            modulus += 1;
-            if modulus == 4 {
-                modulus = 0;
-                r.push((buf >> 22) as u8);
-                r.push((buf >> 14) as u8);
-                r.push((buf >> 6 ) as u8);
-            }
-        }
-
-        for byte in it {
-            match *byte {
-                b'=' | b'\r' | b'\n' => continue,
-                _ => return Err(InvalidBase64Byte(
-                        *byte, (byte as *const _ as usize) - self.as_ptr() as usize)),
-            }
-        }
-
-        match modulus {
-            2 => {
-                r.push((buf >> 10) as u8);
-            }
-            3 => {
-                r.push((buf >> 16) as u8);
-                r.push((buf >> 8 ) as u8);
-            }
-            0 => (),
-            _ => return Err(InvalidBase64Length),
-        }
-
-        Ok(r)
-    }
-}
-
-impl<'a, T: ?Sized + FromBase64> FromBase64 for &'a T {
-    fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
-        (**self).from_base64()
-    }
-}
-
-/// Base64 decoding lookup table, generated using:
-///
-/// ```
-/// let mut ch = 0u8;
-/// for ch in 0..255 {
-///     let mut ch = ch as u8;
-///     let code = match ch {
-///         b'A'...b'Z' => ch - 0x41,
-///         b'a'...b'z' => ch - 0x47,
-///         b'0'...b'9' => ch + 0x04,
-///         b'+' | b'-' => 0x3E,
-///         b'/' | b'_' => 0x3F,
-///         b'=' => 0xFE,
-///         b'\r' | b'\n' => 0xFD,
-///         _ => 0xFF,
-///     };
-///     print!("0x{:02X}, ", code);
-///     if ch % 16  == 15 { println!(""); }
-///     else if ch == 0xFF { break; }
-///     ch += 1;
-/// }
-/// println!("");
-/// ```
-const DECODE_TABLE: [u8; 256] = [
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0x3E, 0xFF, 0x3F,
-    0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF,
-    0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
-    0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F,
-    0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
-    0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-];
-const INVALID_CODE: u8 = 0xFF;
-const EQUALS_CODE: u8 = 0xFE;
-const NEWLINE_CODE: u8 = 0xFD;
-const SPECIAL_CODES_START: u8 = NEWLINE_CODE;
-
-#[cfg(test)]
-mod tests {
-    use base64::{Config, Newline, FromBase64, ToBase64, STANDARD, URL_SAFE};
-
-    #[test]
-    fn test_to_base64_basic() {
-        assert_eq!("".as_bytes().to_base64(STANDARD), "");
-        assert_eq!("f".as_bytes().to_base64(STANDARD), "Zg==");
-        assert_eq!("fo".as_bytes().to_base64(STANDARD), "Zm8=");
-        assert_eq!("foo".as_bytes().to_base64(STANDARD), "Zm9v");
-        assert_eq!("foob".as_bytes().to_base64(STANDARD), "Zm9vYg==");
-        assert_eq!("fooba".as_bytes().to_base64(STANDARD), "Zm9vYmE=");
-        assert_eq!("foobar".as_bytes().to_base64(STANDARD), "Zm9vYmFy");
-    }
-
-    #[test]
-    fn test_to_base64_crlf_line_break() {
-        assert!(![0; 1000].to_base64(Config {line_length: None, ..STANDARD})
-                              .contains("\r\n"));
-        assert_eq!(b"foobar".to_base64(Config {line_length: Some(4),
-                                               ..STANDARD}),
-                   "Zm9v\r\nYmFy");
-    }
-
-    #[test]
-    fn test_to_base64_lf_line_break() {
-        assert!(![0; 1000].to_base64(Config {line_length: None,
-                                                 newline: Newline::LF,
-                                                 ..STANDARD})
-                              .contains("\n"));
-        assert_eq!(b"foobar".to_base64(Config {line_length: Some(4),
-                                               newline: Newline::LF,
-                                               ..STANDARD}),
-                   "Zm9v\nYmFy");
-    }
-
-    #[test]
-    fn test_to_base64_padding() {
-        assert_eq!("f".as_bytes().to_base64(Config {pad: false, ..STANDARD}), "Zg");
-        assert_eq!("fo".as_bytes().to_base64(Config {pad: false, ..STANDARD}), "Zm8");
-    }
-
-    #[test]
-    fn test_to_base64_url_safe() {
-        assert_eq!([251, 255].to_base64(URL_SAFE), "-_8");
-        assert_eq!([251, 255].to_base64(STANDARD), "+/8=");
-    }
-
-    #[test]
-    fn test_to_base64_empty_line_length() {
-        [].to_base64(Config {line_length: Some(72), ..STANDARD});
-    }
-
-    #[test]
-    fn test_from_base64_basic() {
-        assert_eq!("".from_base64().unwrap(), b"");
-        assert_eq!("Zg==".from_base64().unwrap(), b"f");
-        assert_eq!("Zm8=".from_base64().unwrap(), b"fo");
-        assert_eq!("Zm9v".from_base64().unwrap(), b"foo");
-        assert_eq!("Zm9vYg==".from_base64().unwrap(), b"foob");
-        assert_eq!("Zm9vYmE=".from_base64().unwrap(), b"fooba");
-        assert_eq!("Zm9vYmFy".from_base64().unwrap(), b"foobar");
-    }
-
-    #[test]
-    fn test_from_base64_bytes() {
-        assert_eq!(b"Zm9vYmFy".from_base64().unwrap(), b"foobar");
-    }
-
-    #[test]
-    fn test_from_base64_newlines() {
-        assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
-                   b"foobar");
-        assert_eq!("Zm9vYg==\r\n".from_base64().unwrap(),
-                   b"foob");
-        assert_eq!("Zm9v\nYmFy".from_base64().unwrap(),
-                   b"foobar");
-        assert_eq!("Zm9vYg==\n".from_base64().unwrap(),
-                   b"foob");
-    }
-
-    #[test]
-    fn test_from_base64_urlsafe() {
-        assert_eq!("-_8".from_base64().unwrap(), "+/8=".from_base64().unwrap());
-    }
-
-    #[test]
-    fn test_from_base64_invalid_char() {
-        assert!("Zm$=".from_base64().is_err());
-        assert!("Zg==$".from_base64().is_err());
-    }
-
-    #[test]
-    fn test_from_base64_invalid_padding() {
-        assert!("Z===".from_base64().is_err());
-    }
-
-    #[test]
-    fn test_base64_random() {
-        use rand::{thread_rng, Rng};
-
-        for _ in 0..1000 {
-            let times = thread_rng().gen_range(1, 100);
-            let v = thread_rng().gen_iter::<u8>().take(times)
-                                .collect::<Vec<_>>();
-            assert_eq!(v.to_base64(STANDARD)
-                        .from_base64()
-                        .unwrap(),
-                       v);
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/collection_impls.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Implementations of serialization for structures found in libcollections
-
-use std::hash::Hash;
-
-use {Decodable, Encodable, Decoder, Encoder, cap_capacity};
-use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet};
-
-impl<
-    T: Encodable
-> Encodable for LinkedList<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)));
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T:Decodable> Decodable for LinkedList<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut list = LinkedList::new();
-            for i in 0..len {
-                list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(list)
-        })
-    }
-}
-
-impl<T: Encodable> Encodable for VecDeque<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)));
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T:Decodable> Decodable for VecDeque<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut deque: VecDeque<T> = VecDeque::new();
-            for i in 0..len {
-                deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(deque)
-        })
-    }
-}
-
-impl<
-    K: Encodable + Ord,
-    V: Encodable
-> Encodable for BTreeMap<K, V> {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        e.emit_map(self.len(), |e| {
-            let mut i = 0;
-            for (key, val) in self.iter() {
-                try!(e.emit_map_elt_key(i, |e| key.encode(e)));
-                try!(e.emit_map_elt_val(i, |e| val.encode(e)));
-                i += 1;
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<
-    K: Decodable + Ord,
-    V: Decodable
-> Decodable for BTreeMap<K, V> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
-        d.read_map(|d, len| {
-            let mut map = BTreeMap::new();
-            for i in 0..len {
-                let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
-                let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
-                map.insert(key, val);
-            }
-            Ok(map)
-        })
-    }
-}
-
-impl<
-    T: Encodable + Ord
-> Encodable for BTreeSet<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            let mut i = 0;
-            for e in self.iter() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)));
-                i += 1;
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<
-    T: Decodable + Ord
-> Decodable for BTreeSet<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut set = BTreeSet::new();
-            for i in 0..len {
-                set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(set)
-        })
-    }
-}
-
-impl<K, V> Encodable for HashMap<K, V>
-    where K: Encodable + Hash + Eq,
-          V: Encodable,
-{
-    fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
-        e.emit_map(self.len(), |e| {
-            let mut i = 0;
-            for (key, val) in self.iter() {
-                try!(e.emit_map_elt_key(i, |e| key.encode(e)));
-                try!(e.emit_map_elt_val(i, |e| val.encode(e)));
-                i += 1;
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<K, V> Decodable for HashMap<K, V>
-    where K: Decodable + Hash + Eq,
-          V: Decodable,
-{
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V>, D::Error> {
-        d.read_map(|d, len| {
-            let mut map = HashMap::with_capacity(cap_capacity::<(K, V)>(len));
-            for i in 0..len {
-                let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
-                let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
-                map.insert(key, val);
-            }
-            Ok(map)
-        })
-    }
-}
-
-impl<T> Encodable for HashSet<T> where T: Encodable + Hash + Eq {
-    fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
-        s.emit_seq(self.len(), |s| {
-            let mut i = 0;
-            for e in self.iter() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)));
-                i += 1;
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T> Decodable for HashSet<T> where T: Decodable + Hash + Eq, {
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut set = HashSet::with_capacity(cap_capacity::<T>(len));
-            for i in 0..len {
-                set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(set)
-        })
-    }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/hex.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-//
-// ignore-lexer-test FIXME #15679
-
-//! Hex binary-to-text encoding
-
-pub use self::FromHexError::*;
-
-use std::fmt;
-use std::error;
-
-/// A trait for converting a value to hexadecimal encoding
-pub trait ToHex {
-    /// Converts the value of `self` to a hex value, returning the owned
-    /// string.
-    fn to_hex(&self) -> String;
-}
-
-static CHARS: &'static[u8] = b"0123456789abcdef";
-
-impl ToHex for [u8] {
-    /// Turn a vector of `u8` bytes into a hexadecimal string.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// extern crate rustc_serialize;
-    /// use rustc_serialize::hex::ToHex;
-    ///
-    /// fn main () {
-    ///     let str = [52,32].to_hex();
-    ///     println!("{}", str);
-    /// }
-    /// ```
-    fn to_hex(&self) -> String {
-        let mut v = Vec::with_capacity(self.len() * 2);
-        for &byte in self.iter() {
-            v.push(CHARS[(byte >> 4) as usize]);
-            v.push(CHARS[(byte & 0xf) as usize]);
-        }
-
-        unsafe {
-            String::from_utf8_unchecked(v)
-        }
-    }
-}
-
-impl<'a, T: ?Sized + ToHex> ToHex for &'a T {
-    fn to_hex(&self) -> String {
-        (**self).to_hex()
-    }
-}
-
-/// A trait for converting hexadecimal encoded values
-pub trait FromHex {
-    /// Converts the value of `self`, interpreted as hexadecimal encoded data,
-    /// into an owned vector of bytes, returning the vector.
-    fn from_hex(&self) -> Result<Vec<u8>, FromHexError>;
-}
-
-/// Errors that can occur when decoding a hex encoded string
-#[derive(Clone, Copy)]
-pub enum FromHexError {
-    /// The input contained a character not part of the hex format
-    InvalidHexCharacter(char, usize),
-    /// The input had an invalid length
-    InvalidHexLength,
-}
-
-impl fmt::Debug for FromHexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            InvalidHexCharacter(ch, idx) =>
-                write!(f, "Invalid character '{}' at position {}", ch, idx),
-            InvalidHexLength => write!(f, "Invalid input length"),
-        }
-    }
-}
-
-impl error::Error for FromHexError {
-    fn description(&self) -> &str {
-        match *self {
-            InvalidHexCharacter(_, _) => "invalid character",
-            InvalidHexLength => "invalid length",
-        }
-    }
-}
-
-impl fmt::Display for FromHexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl FromHex for str {
-    /// Convert any hexadecimal encoded string (literal, `@`, `&`, or `~`)
-    /// to the byte values it encodes.
-    ///
-    /// You can use the `String::from_utf8` function to turn a
-    /// `Vec<u8>` into a string with characters corresponding to those values.
-    ///
-    /// # Example
-    ///
-    /// This converts a string literal to hexadecimal and back.
-    ///
-    /// ```rust
-    /// extern crate rustc_serialize;
-    /// use rustc_serialize::hex::{FromHex, ToHex};
-    ///
-    /// fn main () {
-    ///     let hello_str = "Hello, World".as_bytes().to_hex();
-    ///     println!("{}", hello_str);
-    ///     let bytes = hello_str.from_hex().unwrap();
-    ///     println!("{:?}", bytes);
-    ///     let result_str = String::from_utf8(bytes).unwrap();
-    ///     println!("{}", result_str);
-    /// }
-    /// ```
-    fn from_hex(&self) -> Result<Vec<u8>, FromHexError> {
-        // This may be an overestimate if there is any whitespace
-        let mut b = Vec::with_capacity(self.len() / 2);
-        let mut modulus = 0;
-        let mut buf = 0;
-
-        for (idx, byte) in self.bytes().enumerate() {
-            buf <<= 4;
-
-            match byte {
-                b'A'...b'F' => buf |= byte - b'A' + 10,
-                b'a'...b'f' => buf |= byte - b'a' + 10,
-                b'0'...b'9' => buf |= byte - b'0',
-                b' '|b'\r'|b'\n'|b'\t' => {
-                    buf >>= 4;
-                    continue
-                }
-                _ => {
-                    let ch = self[idx..].chars().next().unwrap();
-                    return Err(InvalidHexCharacter(ch, idx))
-                }
-            }
-
-            modulus += 1;
-            if modulus == 2 {
-                modulus = 0;
-                b.push(buf);
-            }
-        }
-
-        match modulus {
-            0 => Ok(b.into_iter().collect()),
-            _ => Err(InvalidHexLength),
-        }
-    }
-}
-
-impl<'a, T: ?Sized + FromHex> FromHex for &'a T {
-    fn from_hex(&self) -> Result<Vec<u8>, FromHexError> {
-        (**self).from_hex()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use hex::{FromHex, ToHex};
-
-    #[test]
-    pub fn test_to_hex() {
-        assert_eq!("foobar".as_bytes().to_hex(), "666f6f626172");
-    }
-
-    #[test]
-    pub fn test_from_hex_okay() {
-        assert_eq!("666f6f626172".from_hex().unwrap(),
-                   b"foobar");
-        assert_eq!("666F6F626172".from_hex().unwrap(),
-                   b"foobar");
-    }
-
-    #[test]
-    pub fn test_from_hex_odd_len() {
-        assert!("666".from_hex().is_err());
-        assert!("66 6".from_hex().is_err());
-    }
-
-    #[test]
-    pub fn test_from_hex_invalid_char() {
-        assert!("66y6".from_hex().is_err());
-    }
-
-    #[test]
-    pub fn test_from_hex_ignores_whitespace() {
-        assert_eq!("666f 6f6\r\n26172 ".from_hex().unwrap(),
-                   b"foobar");
-    }
-
-    #[test]
-    pub fn test_to_hex_all_bytes() {
-        for i in 0..256 {
-            assert_eq!([i as u8].to_hex(), format!("{:02x}", i));
-        }
-    }
-
-    #[test]
-    pub fn test_from_hex_all_bytes() {
-        for i in 0..256 {
-            let ii: &[u8] = &[i as u8];
-            assert_eq!(format!("{:02x}", i).from_hex().unwrap(),
-                       ii);
-            assert_eq!(format!("{:02X}", i).from_hex().unwrap(),
-                       ii);
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/json.rs
+++ /dev/null
@@ -1,3999 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Rust JSON serialization library
-// Copyright (c) 2011 Google Inc.
-
-//! JSON parsing and serialization
-//!
-//! # What is JSON?
-//!
-//! JSON (JavaScript Object Notation) is a way to write data in Javascript.
-//! Like XML, it allows encoding structured data in a text format that can be
-//! easily read by humans. Its simple syntax and native compatibility with
-//! JavaScript have made it a widely used format.
-//!
-//! Data types that can be encoded are JavaScript types (see the `Json` enum
-//! for more details):
-//!
-//! * `I64`: equivalent to rust's `i64`
-//! * `U64`: equivalent to rust's `u64`
-//! * `F64`: equivalent to rust's `f64`
-//! * `Boolean`: equivalent to rust's `bool`
-//! * `String`: equivalent to rust's `String`
-//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of
-//!   different types in the
-//!   same array
-//! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>`
-//! * `Null`
-//!
-//! An object is a series of string keys mapping to values, in `"key": value`
-//! format.  Arrays are enclosed in square brackets ([ ... ]) and objects in
-//! curly brackets ({ ... }).  A simple JSON document encoding a person,
-//! their age, address and phone numbers could look like
-//!
-//! ```ignore
-//! {
-//!     "FirstName": "John",
-//!     "LastName": "Doe",
-//!     "Age": 43,
-//!     "Address": {
-//!         "Street": "Downing Street 10",
-//!         "City": "London",
-//!         "Country": "Great Britain"
-//!     },
-//!     "PhoneNumbers": [
-//!         "+44 1234567",
-//!         "+44 2345678"
-//!     ]
-//! }
-//! ```
-//!
-//! # Rust Type-based Encoding and Decoding
-//!
-//! Rust provides a mechanism for low boilerplate encoding & decoding of values
-//! to and from JSON via the serialization API.  To be able to encode a piece
-//! of data, it must implement the `rustc_serialize::Encodable` trait.  To be
-//! able to decode a piece of data, it must implement the
-//! `rustc_serialize::Decodable` trait.  The Rust compiler provides an
-//! annotation to automatically generate the code for these traits:
-//! `#[derive(RustcDecodable, RustcEncodable)]`
-//!
-//! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode
-//! objects.  The `ToJson` trait provides a `to_json` method to convert an
-//! object into a `json::Json` value.  A `json::Json` value can be encoded as a
-//! string or buffer using the functions described above.  You can also use the
-//! `json::Encoder` object, which implements the `Encoder` trait.
-//!
-//! When using `ToJson`, the `Encodable` trait implementation is not
-//! mandatory.
-//!
-//! # Examples of use
-//!
-//! ## Using Autoserialization
-//!
-//! Create a struct called `TestStruct` and serialize and deserialize it to and
-//! from JSON using the serialization API, using the derived serialization code.
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json;
-//!
-//! // Automatically generate `RustcDecodable` and `RustcEncodable` trait
-//! // implementations
-//! #[derive(RustcDecodable, RustcEncodable)]
-//! pub struct TestStruct  {
-//!     data_int: u8,
-//!     data_str: String,
-//!     data_vector: Vec<u8>,
-//! }
-//!
-//! fn main() {
-//!     let object = TestStruct {
-//!         data_int: 1,
-//!         data_str: "homura".to_string(),
-//!         data_vector: vec![2,3,4,5],
-//!     };
-//!
-//!     // Serialize using `json::encode`
-//!     let encoded = json::encode(&object).unwrap();
-//!
-//!     // Deserialize using `json::decode`
-//!     let decoded: TestStruct = json::decode(&encoded).unwrap();
-//! }
-//! ```
-//!
-//! ## Using the `ToJson` trait
-//!
-//! The examples below use the `ToJson` trait to generate the JSON string,
-//! which is required for custom mappings.
-//!
-//! ### Simple example of `ToJson` usage
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json::{self, ToJson, Json};
-//!
-//! // A custom data structure
-//! struct ComplexNum {
-//!     a: f64,
-//!     b: f64,
-//! }
-//!
-//! // JSON value representation
-//! impl ToJson for ComplexNum {
-//!     fn to_json(&self) -> Json {
-//!         Json::String(format!("{}+{}i", self.a, self.b))
-//!     }
-//! }
-//!
-//! // Only generate `RustcEncodable` trait implementation
-//! #[derive(RustcEncodable)]
-//! pub struct ComplexNumRecord {
-//!     uid: u8,
-//!     dsc: String,
-//!     val: Json,
-//! }
-//!
-//! fn main() {
-//!     let num = ComplexNum { a: 0.0001, b: 12.539 };
-//!     let data: String = json::encode(&ComplexNumRecord{
-//!         uid: 1,
-//!         dsc: "test".to_string(),
-//!         val: num.to_json(),
-//!     }).unwrap();
-//!     println!("data: {}", data);
-//!     // data: {"uid":1,"dsc":"test","val":"0.0001+12.539i"};
-//! }
-//! ```
-//!
-//! ### Verbose example of `ToJson` usage
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use std::collections::BTreeMap;
-//! use rustc_serialize::json::{self, Json, ToJson};
-//!
-//! // Only generate `Decodable` trait implementation
-//! #[derive(RustcDecodable)]
-//! pub struct TestStruct {
-//!     data_int: u8,
-//!     data_str: String,
-//!     data_vector: Vec<u8>,
-//! }
-//!
-//! // Specify encoding method manually
-//! impl ToJson for TestStruct {
-//!     fn to_json(&self) -> Json {
-//!         let mut d = BTreeMap::new();
-//!         // All standard types implement `to_json()`, so use it
-//!         d.insert("data_int".to_string(), self.data_int.to_json());
-//!         d.insert("data_str".to_string(), self.data_str.to_json());
-//!         d.insert("data_vector".to_string(), self.data_vector.to_json());
-//!         Json::Object(d)
-//!     }
-//! }
-//!
-//! fn main() {
-//!     // Serialize using `ToJson`
-//!     let input_data = TestStruct {
-//!         data_int: 1,
-//!         data_str: "madoka".to_string(),
-//!         data_vector: vec![2,3,4,5],
-//!     };
-//!     let json_obj: Json = input_data.to_json();
-//!     let json_str: String = json_obj.to_string();
-//!
-//!     // Deserialize like before
-//!     let decoded: TestStruct = json::decode(&json_str).unwrap();
-//! }
-//! ```
-//!
-//! ## Parsing a `str` to `Json` and reading the result
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json::Json;
-//!
-//! fn main() {
-//!     let data = Json::from_str("{\"foo\": 13, \"bar\": \"baz\"}").unwrap();
-//!     println!("data: {}", data);
-//!     // data: {"bar":"baz","foo":13}
-//!     println!("object? {}", data.is_object());
-//!     // object? true
-//!
-//!     let obj = data.as_object().unwrap();
-//!     let foo = obj.get("foo").unwrap();
-//!
-//!     println!("array? {:?}", foo.as_array());
-//!     // array? None
-//!     println!("u64? {:?}", foo.as_u64());
-//!     // u64? Some(13u64)
-//!
-//!     for (key, value) in obj.iter() {
-//!         println!("{}: {}", key, match *value {
-//!             Json::U64(v) => format!("{} (u64)", v),
-//!             Json::String(ref v) => format!("{} (string)", v),
-//!             _ => format!("other")
-//!         });
-//!     }
-//!     // bar: baz (string)
-//!     // foo: 13 (u64)
-//! }
-//! ```
-//!
-//! # The status of this library
-//!
-//! While this library is the standard way of working with JSON in Rust,
-//! there is a next-generation library called Serde that's in the works (it's
-//! faster, overcomes some design limitations of rustc-serialize and has more
-//! features). You might consider using it when starting a new project or
-//! evaluating Rust JSON performance.
-
-use self::JsonEvent::*;
-use self::ErrorCode::*;
-use self::ParserError::*;
-use self::DecoderError::*;
-use self::ParserState::*;
-use self::InternalStackElement::*;
-
-use std::collections::{HashMap, BTreeMap};
-use std::error::Error as StdError;
-use std::i64;
-use std::io::prelude::*;
-use std::mem::swap;
-use std::ops::Index;
-use std::str::FromStr;
-use std::string;
-use std::{char, f64, fmt, io, str};
-
-use Encodable;
-
-/// Represents a json value
-#[derive(Clone, PartialEq, PartialOrd, Debug)]
-pub enum Json {
-    I64(i64),
-    U64(u64),
-    F64(f64),
-    String(string::String),
-    Boolean(bool),
-    Array(self::Array),
-    Object(self::Object),
-    Null,
-}
-
-pub type Array = Vec<Json>;
-pub type Object = BTreeMap<string::String, Json>;
-
-pub struct PrettyJson<'a> { inner: &'a Json }
-
-pub struct AsJson<'a, T: 'a> { inner: &'a T }
-pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<u32> }
-
-/// The errors that can arise while parsing a JSON stream.
-#[derive(Clone, Copy, PartialEq)]
-pub enum ErrorCode {
-    InvalidSyntax,
-    InvalidNumber,
-    EOFWhileParsingObject,
-    EOFWhileParsingArray,
-    EOFWhileParsingValue,
-    EOFWhileParsingString,
-    KeyMustBeAString,
-    ExpectedColon,
-    TrailingCharacters,
-    TrailingComma,
-    InvalidEscape,
-    InvalidUnicodeCodePoint,
-    LoneLeadingSurrogateInHexEscape,
-    UnexpectedEndOfHexEscape,
-    UnrecognizedHex,
-    NotFourDigit,
-    ControlCharacterInString,
-    NotUtf8,
-}
-
-#[derive(Debug)]
-pub enum ParserError {
-    /// msg, line, col
-    SyntaxError(ErrorCode, usize, usize),
-    IoError(io::Error),
-}
-
-impl PartialEq for ParserError {
-    fn eq(&self, other: &ParserError) -> bool {
-        match (self, other) {
-            (&SyntaxError(msg0, line0, col0), &SyntaxError(msg1, line1, col1)) =>
-                msg0 == msg1 && line0 == line1 && col0 == col1,
-            (&IoError(_), _) => false,
-            (_, &IoError(_)) => false,
-        }
-    }
-}
-
-// Builder and Parser have the same errors.
-pub type BuilderError = ParserError;
-
-#[derive(PartialEq, Debug)]
-pub enum DecoderError {
-    ParseError(ParserError),
-    ExpectedError(string::String, string::String),
-    MissingFieldError(string::String),
-    UnknownVariantError(string::String),
-    ApplicationError(string::String),
-    EOF,
-}
-
-#[derive(Copy, Debug)]
-pub enum EncoderError {
-    FmtError(fmt::Error),
-    BadHashmapKey,
-}
-
-impl PartialEq for EncoderError {
-    fn eq(&self, other: &EncoderError) -> bool {
-        match (*self, *other) {
-            (EncoderError::FmtError(_), EncoderError::FmtError(_)) => true,
-            (EncoderError::BadHashmapKey, EncoderError::BadHashmapKey) => true,
-            _ => false,
-        }
-    }
-}
-
-impl Clone for EncoderError {
-    fn clone(&self) -> Self { *self }
-}
-
-/// Returns a readable error string for a given error code.
-pub fn error_str(error: ErrorCode) -> &'static str {
-    match error {
-        InvalidSyntax => "invalid syntax",
-        InvalidNumber => "invalid number",
-        EOFWhileParsingObject => "EOF While parsing object",
-        EOFWhileParsingArray => "EOF While parsing array",
-        EOFWhileParsingValue => "EOF While parsing value",
-        EOFWhileParsingString => "EOF While parsing string",
-        KeyMustBeAString => "key must be a string",
-        ExpectedColon => "expected `:`",
-        TrailingCharacters => "trailing characters",
-        TrailingComma => "trailing comma",
-        InvalidEscape => "invalid escape",
-        UnrecognizedHex => "invalid \\u{ esc}ape (unrecognized hex)",
-        NotFourDigit => "invalid \\u{ esc}ape (not four digits)",
-        ControlCharacterInString => "unescaped control character in string",
-        NotUtf8 => "contents not utf-8",
-        InvalidUnicodeCodePoint => "invalid Unicode code point",
-        LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape",
-        UnexpectedEndOfHexEscape => "unexpected end of hex escape",
-    }
-}
-
-/// Shortcut function to decode a JSON `&str` into an object
-pub fn decode<T: ::Decodable>(s: &str) -> DecodeResult<T> {
-    let json = match Json::from_str(s) {
-        Ok(x) => x,
-        Err(e) => return Err(ParseError(e))
-    };
-
-    let mut decoder = Decoder::new(json);
-    ::Decodable::decode(&mut decoder)
-}
-
-/// Shortcut function to encode a `T` into a JSON `String`
-pub fn encode<T: ::Encodable>(object: &T) -> EncodeResult<string::String> {
-    let mut s = String::new();
-    {
-        let mut encoder = Encoder::new(&mut s);
-        try!(object.encode(&mut encoder));
-    }
-    Ok(s)
-}
-
-impl fmt::Debug for ErrorCode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        error_str(*self).fmt(f)
-    }
-}
-
-impl StdError for DecoderError {
-    fn description(&self) -> &str { "decoder error" }
-    fn cause(&self) -> Option<&StdError> {
-        match *self {
-            DecoderError::ParseError(ref e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
-impl fmt::Display for DecoderError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl From<ParserError> for DecoderError {
-    fn from(err: ParserError) -> DecoderError {
-        ParseError(From::from(err))
-    }
-}
-
-impl StdError for ParserError {
-    fn description(&self) -> &str { "failed to parse json" }
-}
-
-impl fmt::Display for ParserError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl From<io::Error> for ParserError {
-    fn from(err: io::Error) -> ParserError {
-        IoError(err)
-    }
-}
-
-impl StdError for EncoderError {
-    fn description(&self) -> &str { "encoder error" }
-}
-
-impl fmt::Display for EncoderError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl From<fmt::Error> for EncoderError {
-    fn from(err: fmt::Error) -> EncoderError { EncoderError::FmtError(err) }
-}
-
-pub type EncodeResult<T> = Result<T, EncoderError>;
-pub type DecodeResult<T> = Result<T, DecoderError>;
-
-fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult<()> {
-    try!(wr.write_str("\""));
-
-    let mut start = 0;
-
-    for (i, byte) in v.bytes().enumerate() {
-        let escaped = match byte {
-            b'"' => "\\\"",
-            b'\\' => "\\\\",
-            b'\x00' => "\\u0000",
-            b'\x01' => "\\u0001",
-            b'\x02' => "\\u0002",
-            b'\x03' => "\\u0003",
-            b'\x04' => "\\u0004",
-            b'\x05' => "\\u0005",
-            b'\x06' => "\\u0006",
-            b'\x07' => "\\u0007",
-            b'\x08' => "\\b",
-            b'\t' => "\\t",
-            b'\n' => "\\n",
-            b'\x0b' => "\\u000b",
-            b'\x0c' => "\\f",
-            b'\r' => "\\r",
-            b'\x0e' => "\\u000e",
-            b'\x0f' => "\\u000f",
-            b'\x10' => "\\u0010",
-            b'\x11' => "\\u0011",
-            b'\x12' => "\\u0012",
-            b'\x13' => "\\u0013",
-            b'\x14' => "\\u0014",
-            b'\x15' => "\\u0015",
-            b'\x16' => "\\u0016",
-            b'\x17' => "\\u0017",
-            b'\x18' => "\\u0018",
-            b'\x19' => "\\u0019",
-            b'\x1a' => "\\u001a",
-            b'\x1b' => "\\u001b",
-            b'\x1c' => "\\u001c",
-            b'\x1d' => "\\u001d",
-            b'\x1e' => "\\u001e",
-            b'\x1f' => "\\u001f",
-            b'\x7f' => "\\u007f",
-            _ => { continue; }
-        };
-
-        if start < i {
-            try!(wr.write_str(&v[start..i]));
-        }
-
-        try!(wr.write_str(escaped));
-
-        start = i + 1;
-    }
-
-    if start != v.len() {
-        try!(wr.write_str(&v[start..]));
-    }
-
-    try!(wr.write_str("\""));
-    Ok(())
-}
-
-fn escape_char(writer: &mut fmt::Write, v: char) -> EncodeResult<()> {
-    let mut buf = [0; 4];
-    let _ = write!(&mut &mut buf[..], "{}", v);
-    let buf = unsafe { str::from_utf8_unchecked(&buf[..v.len_utf8()]) };
-    escape_str(writer, buf)
-}
-
-fn spaces(wr: &mut fmt::Write, n: u32) -> EncodeResult<()> {
-    let mut n = n as usize;
-    const BUF: &'static str = "                ";
-
-    while n >= BUF.len() {
-        try!(wr.write_str(BUF));
-        n -= BUF.len();
-    }
-
-    if n > 0 {
-        try!(wr.write_str(&BUF[..n]));
-    }
-    Ok(())
-}
-
-fn fmt_number_or_null(v: f64) -> string::String {
-    use std::num::FpCategory::{Nan, Infinite};
-
-    match v.classify() {
-        Nan | Infinite => "null".to_string(),
-        _ => {
-            let s = v.to_string();
-            if s.contains(".") {s} else {s + ".0"}
-        }
-    }
-}
-
-macro_rules! emit_enquoted_if_mapkey {
-    ($enc:ident,$e:expr) => {
-        if $enc.is_emitting_map_key {
-            try!(write!($enc.writer, "\"{}\"", $e));
-            Ok(())
-        } else {
-            try!(write!($enc.writer, "{}", $e));
-            Ok(())
-        }
-    }
-}
-
-enum EncodingFormat {
-    Compact,
-    Pretty {
-        curr_indent: u32,
-        indent: u32
-    }
-}
-
-/// A structure for implementing serialization to JSON.
-pub struct Encoder<'a> {
-    writer: &'a mut (fmt::Write+'a),
-    format : EncodingFormat,
-    is_emitting_map_key: bool,
-}
-
-impl<'a> Encoder<'a> {
-    /// Creates a new encoder whose output will be written in human-readable
-    /// JSON to the specified writer
-    pub fn new_pretty(writer: &'a mut fmt::Write) -> Encoder<'a> {
-        Encoder {
-            writer: writer,
-            format: EncodingFormat::Pretty {
-                curr_indent: 0,
-                indent: 2,
-            },
-            is_emitting_map_key: false,
-        }
-    }
-
-    /// Creates a new encoder whose output will be written in compact
-    /// JSON to the specified writer
-    pub fn new(writer: &'a mut fmt::Write) -> Encoder<'a> {
-        Encoder {
-            writer: writer,
-            format: EncodingFormat::Compact,
-            is_emitting_map_key: false,
-        }
-    }
-
-    /// Set the number of spaces to indent for each level.
-    /// This is safe to set during encoding.
-    pub fn set_indent(&mut self, new_indent: u32) -> Result<(), ()> {
-        if let EncodingFormat::Pretty{ref mut curr_indent, ref mut indent} = self.format {
-            // self.indent very well could be 0 so we need to use checked division.
-            let level = curr_indent.checked_div(*indent).unwrap_or(0);
-            *indent = new_indent;
-            *curr_indent = level * *indent;
-            Ok(())
-        } else {
-            Err(())
-        }
-    }
-}
-
-impl<'a> ::Encoder for Encoder<'a> {
-    type Error = EncoderError;
-
-    fn emit_nil(&mut self) -> EncodeResult<()> {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        try!(write!(self.writer, "null"));
-        Ok(())
-    }
-
-    fn emit_usize(&mut self, v: usize) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_u64(&mut self, v: u64) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_u32(&mut self, v: u32) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_u16(&mut self, v: u16) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_u8(&mut self, v: u8) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-
-    fn emit_isize(&mut self, v: isize) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_i64(&mut self, v: i64) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_i32(&mut self, v: i32) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_i16(&mut self, v: i16) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_i8(&mut self, v: i8) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-
-    fn emit_bool(&mut self, v: bool) -> EncodeResult<()> {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if v {
-            try!(write!(self.writer, "true"));
-        } else {
-            try!(write!(self.writer, "false"));
-        }
-        Ok(())
-    }
-
-    fn emit_f64(&mut self, v: f64) -> EncodeResult<()> {
-        emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
-    }
-    fn emit_f32(&mut self, v: f32) -> EncodeResult<()> {
-        self.emit_f64(v as f64)
-    }
-
-    fn emit_char(&mut self, v: char) -> EncodeResult<()> {
-        escape_char(self.writer, v)
-    }
-    fn emit_str(&mut self, v: &str) -> EncodeResult<()> {
-        escape_str(self.writer, v)
-    }
-
-    fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        f(self)
-    }
-
-    fn emit_enum_variant<F>(&mut self,
-                            name: &str,
-                            _id: usize,
-                            cnt: usize,
-                            f: F)
-                            -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        // enums are encoded as strings or objects
-        // Bunny => "Bunny"
-        // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
-        if cnt == 0 {
-            escape_str(self.writer, name)
-        } else {
-            if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                try!(write!(self.writer, "{{\n"));
-                *curr_indent += indent;
-                try!(spaces(self.writer, *curr_indent));
-                try!(write!(self.writer, "\"variant\": "));
-                try!(escape_str(self.writer, name));
-                try!(write!(self.writer, ",\n"));
-                try!(spaces(self.writer, *curr_indent));
-                try!(write!(self.writer, "\"fields\": [\n"));
-                *curr_indent += indent;
-            } else {
-                try!(write!(self.writer, "{{\"variant\":"));
-                try!(escape_str(self.writer, name));
-                try!(write!(self.writer, ",\"fields\":["));
-            }
-            try!(f(self));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent -= indent;
-                try!(write!(self.writer, "\n"));
-                try!(spaces(self.writer, *curr_indent));
-                *curr_indent -= indent;
-                try!(write!(self.writer, "]\n"));
-                try!(spaces(self.writer, *curr_indent));
-                try!(write!(self.writer, "}}"));
-            } else {
-                try!(write!(self.writer, "]}}"));
-            }
-            Ok(())
-        }
-    }
-
-    fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if idx != 0 {
-            try!(write!(self.writer, ","));
-            if let EncodingFormat::Pretty{..} = self.format {
-                try!(write!(self.writer, "\n"));
-            }
-        }
-        if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
-            try!(spaces(self.writer, curr_indent));
-        }
-        f(self)
-    }
-
-    fn emit_enum_struct_variant<F>(&mut self,
-                                   name: &str,
-                                   id: usize,
-                                   cnt: usize,
-                                   f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_enum_variant(name, id, cnt, f)
-    }
-
-    fn emit_enum_struct_variant_field<F>(&mut self,
-                                         _: &str,
-                                         idx: usize,
-                                         f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_enum_variant_arg(idx, f)
-    }
-
-
-    fn emit_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if len == 0 {
-            try!(write!(self.writer, "{{}}"));
-        } else {
-            try!(write!(self.writer, "{{"));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent += indent;
-            }
-            try!(f(self));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent -= indent;
-                try!(write!(self.writer, "\n"));
-                try!(spaces(self.writer, *curr_indent));
-            }
-            try!(write!(self.writer, "}}"));
-        }
-        Ok(())
-    }
-
-    fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if idx != 0 {
-            try!(write!(self.writer, ","));
-        }
-        if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
-            try!(write!(self.writer, "\n"));
-            try!(spaces(self.writer, curr_indent));
-        }
-        try!(escape_str(self.writer, name));
-        if let EncodingFormat::Pretty{..} = self.format {
-            try!(write!(self.writer, ": "));
-        } else {
-            try!(write!(self.writer, ":"));
-        }
-        f(self)
-    }
-
-    fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_seq(len, f)
-    }
-    fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_seq_elt(idx, f)
-    }
-
-    fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_seq(len, f)
-    }
-    fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_seq_elt(idx, f)
-    }
-
-    fn emit_option<F>(&mut self, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        f(self)
-    }
-    fn emit_option_none(&mut self) -> EncodeResult<()> {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_nil()
-    }
-    fn emit_option_some<F>(&mut self, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        f(self)
-    }
-
-    fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if len == 0 {
-            try!(write!(self.writer, "[]"));
-        } else {
-            try!(write!(self.writer, "["));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent += indent;
-            }
-            try!(f(self));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent -= indent;
-                try!(write!(self.writer, "\n"));
-                try!(spaces(self.writer, *curr_indent));
-            }
-            try!(write!(self.writer, "]"));
-        }
-        Ok(())
-    }
-
-    fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if idx != 0 {
-            try!(write!(self.writer, ","));
-        }
-        if let EncodingFormat::Pretty{ref mut curr_indent, ..} = self.format {
-            try!(write!(self.writer, "\n"));
-            try!(spaces(self.writer, *curr_indent));
-        }
-        f(self)
-    }
-
-    fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if len == 0 {
-            try!(write!(self.writer, "{{}}"));
-        } else {
-            try!(write!(self.writer, "{{"));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent += indent;
-            }
-            try!(f(self));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent -= indent;
-                try!(write!(self.writer, "\n"));
-                try!(spaces(self.writer, *curr_indent));
-            }
-            try!(write!(self.writer, "}}"));
-        }
-        Ok(())
-    }
-
-    fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if idx != 0 {
-            try!(write!(self.writer, ","));
-        }
-        if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
-            try!(write!(self.writer, "\n"));
-            try!(spaces(self.writer, curr_indent));
-        }
-        self.is_emitting_map_key = true;
-        try!(f(self));
-        self.is_emitting_map_key = false;
-        Ok(())
-    }
-
-    fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if let EncodingFormat::Pretty{..} = self.format {
-            try!(write!(self.writer, ": "));
-        } else {
-            try!(write!(self.writer, ":"));
-        }
-        f(self)
-    }
-}
-
-impl Encodable for Json {
-    fn encode<S: ::Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        match *self {
-            Json::I64(v) => v.encode(e),
-            Json::U64(v) => v.encode(e),
-            Json::F64(v) => v.encode(e),
-            Json::String(ref v) => v.encode(e),
-            Json::Boolean(v) => v.encode(e),
-            Json::Array(ref v) => v.encode(e),
-            Json::Object(ref v) => v.encode(e),
-            Json::Null => e.emit_nil(),
-        }
-    }
-}
-
-/// Create an `AsJson` wrapper which can be used to print a value as JSON
-/// on-the-fly via `write!`
-pub fn as_json<T: Encodable>(t: &T) -> AsJson<T> {
-    AsJson { inner: t }
-}
-
-/// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
-/// on-the-fly via `write!`
-pub fn as_pretty_json<T: Encodable>(t: &T) -> AsPrettyJson<T> {
-    AsPrettyJson { inner: t, indent: None }
-}
-
-impl Json {
-    /// Decodes a json value from an `&mut io::Read`
-    pub fn from_reader(rdr: &mut io::Read) -> Result<Self, BuilderError> {
-        let contents = {
-            let mut c = Vec::new();
-            try!(rdr.read_to_end(&mut c));
-            c
-        };
-        let s = match str::from_utf8(&contents).ok() {
-            Some(s) => s,
-            _       => return Err(SyntaxError(NotUtf8, 0, 0))
-        };
-        let mut builder = Builder::new(s.chars());
-        builder.build()
-    }
-
-    /// Decodes a json value from a string
-    pub fn from_str(s: &str) -> Result<Self, BuilderError> {
-        let mut builder = Builder::new(s.chars());
-        builder.build()
-    }
-
-    /// Borrow this json object as a pretty object to generate a pretty
-    /// representation for it via `Display`.
-    pub fn pretty(&self) -> PrettyJson {
-        PrettyJson { inner: self }
-    }
-
-     /// If the Json value is an Object, returns the value associated with the provided key.
-    /// Otherwise, returns None.
-    pub fn find<'a>(&'a self, key: &str) -> Option<&'a Json>{
-        match self {
-            &Json::Object(ref map) => map.get(key),
-            _ => None
-        }
-    }
-
-    /// Attempts to get a nested Json Object for each key in `keys`.
-    /// If any key is found not to exist, find_path will return None.
-    /// Otherwise, it will return the Json value associated with the final key.
-    pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
-        let mut target = self;
-        for key in keys.iter() {
-            match target.find(*key) {
-                Some(t) => { target = t; },
-                None => return None
-            }
-        }
-        Some(target)
-    }
-
-    /// If the Json value is an Object, performs a depth-first search until
-    /// a value associated with the provided key is found. If no value is found
-    /// or the Json value is not an Object, returns None.
-    pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
-        match self {
-            &Json::Object(ref map) => {
-                match map.get(key) {
-                    Some(json_value) => Some(json_value),
-                    None => {
-                        for (_, v) in map.iter() {
-                            match v.search(key) {
-                                x if x.is_some() => return x,
-                                _ => ()
-                            }
-                        }
-                        None
-                    }
-                }
-            },
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is an Object. Returns false otherwise.
-    pub fn is_object<'a>(&'a self) -> bool {
-        self.as_object().is_some()
-    }
-
-    /// If the Json value is an Object, returns a reference to the associated BTreeMap.
-    /// Returns None otherwise.
-    pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
-        match self {
-            &Json::Object(ref map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// If the Json value is an Object, returns a mutable reference to the associated BTreeMap.
-    /// Returns None otherwise.
-    pub fn as_object_mut<'a>(&'a mut self) -> Option<&'a mut Object> {
-        match self {
-            &mut Json::Object(ref mut map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// If the Json value is an Object, returns the associated BTreeMap.
-    /// Returns None otherwise.
-    pub fn into_object(self) -> Option<Object> {
-        match self {
-            Json::Object(map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is an Array. Returns false otherwise.
-    pub fn is_array<'a>(&'a self) -> bool {
-        self.as_array().is_some()
-    }
-
-    /// If the Json value is an Array, returns a reference to the associated vector.
-    /// Returns None otherwise.
-    pub fn as_array<'a>(&'a self) -> Option<&'a Array> {
-        match self {
-            &Json::Array(ref array) => Some(&*array),
-            _ => None
-        }
-    }
-
-    /// If the Json value is an Array, returns a mutable reference to the associated vector.
-    /// Returns None otherwise.
-    pub fn as_array_mut<'a>(&'a mut self) -> Option<&'a mut Array> {
-        match self {
-            &mut Json::Array(ref mut list) => Some(list),
-            _ => None
-        }
-    }
-
-    /// If the Json value is an Array, returns the associated vector.
-    /// Returns None otherwise.
-    pub fn into_array(self) -> Option<Array> {
-        match self {
-            Json::Array(array) => Some(array),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is a String. Returns false otherwise.
-    pub fn is_string<'a>(&'a self) -> bool {
-        self.as_string().is_some()
-    }
-
-    /// If the Json value is a String, returns the associated str.
-    /// Returns None otherwise.
-    pub fn as_string<'a>(&'a self) -> Option<&'a str> {
-        match *self {
-            Json::String(ref s) => Some(&s),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is a Number. Returns false otherwise.
-    pub fn is_number(&self) -> bool {
-        match *self {
-            Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the Json value is a i64. Returns false otherwise.
-    pub fn is_i64(&self) -> bool {
-        match *self {
-            Json::I64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the Json value is a u64. Returns false otherwise.
-    pub fn is_u64(&self) -> bool {
-        match *self {
-            Json::U64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the Json value is a f64. Returns false otherwise.
-    pub fn is_f64(&self) -> bool {
-        match *self {
-            Json::F64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// If the Json value is a number, return or cast it to a i64.
-    /// Returns None otherwise.
-    pub fn as_i64(&self) -> Option<i64> {
-        match *self {
-            Json::I64(n) => Some(n),
-            Json::U64(n) if n >= i64::MAX as u64 => None,
-            Json::U64(n) => Some(n as i64),
-            _ => None
-        }
-    }
-
-    /// If the Json value is a number, return or cast it to a u64.
-    /// Returns None otherwise.
-    pub fn as_u64(&self) -> Option<u64> {
-        match *self {
-            Json::I64(n) if n >= 0 => Some(n as u64),
-            Json::U64(n) => Some(n),
-            _ => None
-        }
-    }
-
-    /// If the Json value is a number, return or cast it to a f64.
-    /// Returns None otherwise.
-    pub fn as_f64(&self) -> Option<f64> {
-        match *self {
-            Json::I64(n) => Some(n as f64),
-            Json::U64(n) => Some(n as f64),
-            Json::F64(n) => Some(n),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is a Boolean. Returns false otherwise.
-    pub fn is_boolean(&self) -> bool {
-        self.as_boolean().is_some()
-    }
-
-    /// If the Json value is a Boolean, returns the associated bool.
-    /// Returns None otherwise.
-    pub fn as_boolean(&self) -> Option<bool> {
-        match self {
-            &Json::Boolean(b) => Some(b),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is a Null. Returns false otherwise.
-    pub fn is_null(&self) -> bool {
-        self.as_null().is_some()
-    }
-
-    /// If the Json value is a Null, returns ().
-    /// Returns None otherwise.
-    pub fn as_null(&self) -> Option<()> {
-        match self {
-            &Json::Null => Some(()),
-            _ => None
-        }
-    }
-}
-
-impl<'a> Index<&'a str>  for Json {
-    type Output = Json;
-
-    fn index(&self, idx: &str) -> &Json {
-        self.find(idx).unwrap()
-    }
-}
-
-impl Index<usize> for Json {
-    type Output = Json;
-
-    fn index<'a>(&'a self, idx: usize) -> &'a Json {
-        match self {
-            &Json::Array(ref v) => &v[idx],
-            _ => panic!("can only index Json with usize if it is an array")
-        }
-    }
-}
-
-/// The output of the streaming parser.
-#[derive(PartialEq, Debug)]
-pub enum JsonEvent {
-    ObjectStart,
-    ObjectEnd,
-    ArrayStart,
-    ArrayEnd,
-    BooleanValue(bool),
-    I64Value(i64),
-    U64Value(u64),
-    F64Value(f64),
-    StringValue(string::String),
-    NullValue,
-    Error(ParserError),
-}
-
-#[derive(PartialEq, Debug)]
-enum ParserState {
-    // Parse a value in an array, true means first element.
-    ParseArray(bool),
-    // Parse ',' or ']' after an element in an array.
-    ParseArrayComma,
-    // Parse a key:value in an object, true means first element.
-    ParseObject(bool),
-    // Parse ',' or ']' after an element in an object.
-    ParseObjectComma,
-    // Initial state.
-    ParseStart,
-    // Expecting the stream to end.
-    ParseBeforeFinish,
-    // Parsing can't continue.
-    ParseFinished,
-}
-
-/// A Stack represents the current position of the parser in the logical
-/// structure of the JSON stream.
-/// For example foo.bar[3].x
-pub struct Stack {
-    stack: Vec<InternalStackElement>,
-    str_buffer: Vec<u8>,
-}
-
-/// StackElements compose a Stack.
-/// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the
-/// StackElements compositing the stack that represents foo.bar[3].x
-#[derive(PartialEq, Clone, Debug)]
-pub enum StackElement<'l> {
-    Index(u32),
-    Key(&'l str),
-}
-
-// Internally, Key elements are stored as indices in a buffer to avoid
-// allocating a string for every member of an object.
-#[derive(PartialEq, Clone, Debug)]
-enum InternalStackElement {
-    InternalIndex(u32),
-    InternalKey(u16, u16), // start, size
-}
-
-impl Stack {
-    pub fn new() -> Stack {
-        Stack { stack: Vec::new(), str_buffer: Vec::new() }
-    }
-
-    /// Returns The number of elements in the Stack.
-    pub fn len(&self) -> usize { self.stack.len() }
-
-    /// Returns true if the stack is empty.
-    pub fn is_empty(&self) -> bool { self.stack.is_empty() }
-
-    /// Provides access to the StackElement at a given index.
-    /// lower indices are at the bottom of the stack while higher indices are
-    /// at the top.
-    pub fn get<'l>(&'l self, idx: usize) -> StackElement<'l> {
-        match self.stack[idx] {
-            InternalIndex(i) => StackElement::Index(i),
-            InternalKey(start, size) => {
-                StackElement::Key(str::from_utf8(
-                    &self.str_buffer[start as usize .. start as usize + size as usize]).unwrap())
-            }
-        }
-    }
-
-    /// Compares this stack with an array of StackElements.
-    pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
-        if self.stack.len() != rhs.len() { return false; }
-        for i in 0..rhs.len() {
-            if self.get(i) != rhs[i] { return false; }
-        }
-        return true;
-    }
-
-    /// Returns true if the bottom-most elements of this stack are the same as
-    /// the ones passed as parameter.
-    pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
-        if self.stack.len() < rhs.len() { return false; }
-        for i in 0..rhs.len() {
-            if self.get(i) != rhs[i] { return false; }
-        }
-        return true;
-    }
-
-    /// Returns true if the top-most elements of this stack are the same as
-    /// the ones passed as parameter.
-    pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
-        if self.stack.len() < rhs.len() { return false; }
-        let offset = self.stack.len() - rhs.len();
-        for i in 0..rhs.len() {
-            if self.get(i + offset) != rhs[i] { return false; }
-        }
-        return true;
-    }
-
-    /// Returns the top-most element (if any).
-    pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
-        return match self.stack.last() {
-            None => None,
-            Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
-            Some(&InternalKey(start, size)) => {
-                Some(StackElement::Key(str::from_utf8(
-                    &self.str_buffer[start as usize .. (start+size) as usize]
-                ).unwrap()))
-            }
-        }
-    }
-
-    // Used by Parser to insert Key elements at the top of the stack.
-    fn push_key(&mut self, key: string::String) {
-        self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
-        for c in key.as_bytes().iter() {
-            self.str_buffer.push(*c);
-        }
-    }
-
-    // Used by Parser to insert Index elements at the top of the stack.
-    fn push_index(&mut self, index: u32) {
-        self.stack.push(InternalIndex(index));
-    }
-
-    // Used by Parser to remove the top-most element of the stack.
-    fn pop(&mut self) {
-        assert!(!self.is_empty());
-        match *self.stack.last().unwrap() {
-            InternalKey(_, sz) => {
-                let new_size = self.str_buffer.len() - sz as usize;
-                self.str_buffer.truncate(new_size);
-            }
-            InternalIndex(_) => {}
-        }
-        self.stack.pop();
-    }
-
-    // Used by Parser to test whether the top-most element is an index.
-    fn last_is_index(&self) -> bool {
-        if self.is_empty() { return false; }
-        return match *self.stack.last().unwrap() {
-            InternalIndex(_) => true,
-            _ => false,
-        }
-    }
-
-    // Used by Parser to increment the index of the top-most element.
-    fn bump_index(&mut self) {
-        let len = self.stack.len();
-        let idx = match *self.stack.last().unwrap() {
-            InternalIndex(i) => { i + 1 }
-            _ => { panic!(); }
-        };
-        self.stack[len - 1] = InternalIndex(idx);
-    }
-}
-
-/// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
-/// an iterator of char.
-pub struct Parser<T> {
-    rdr: T,
-    ch: Option<char>,
-    line: usize,
-    col: usize,
-    // We maintain a stack representing where we are in the logical structure
-    // of the JSON stream.
-    stack: Stack,
-    // A state machine is kept to make it possible to interrupt and resume parsing.
-    state: ParserState,
-}
-
-impl<T: Iterator<Item = char>> Iterator for Parser<T> {
-    type Item = JsonEvent;
-
-    fn next(&mut self) -> Option<JsonEvent> {
-        if self.state == ParseFinished {
-            return None;
-        }
-
-        if self.state == ParseBeforeFinish {
-            self.parse_whitespace();
-            // Make sure there is no trailing characters.
-            if self.eof() {
-                self.state = ParseFinished;
-                return None;
-            } else {
-                return Some(self.error_event(TrailingCharacters));
-            }
-        }
-
-        return Some(self.parse());
-    }
-}
-
-impl<T: Iterator<Item = char>> Parser<T> {
-    /// Creates the JSON parser.
-    pub fn new(rdr: T) -> Parser<T> {
-        let mut p = Parser {
-            rdr: rdr,
-            ch: Some('\x00'),
-            line: 1,
-            col: 0,
-            stack: Stack::new(),
-            state: ParseStart,
-        };
-        p.bump();
-        return p;
-    }
-
-    /// Provides access to the current position in the logical structure of the
-    /// JSON stream.
-    pub fn stack<'l>(&'l self) -> &'l Stack {
-        return &self.stack;
-    }
-
-    fn eof(&self) -> bool { self.ch.is_none() }
-    fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
-    fn bump(&mut self) {
-        self.ch = self.rdr.next();
-
-        if self.ch_is('\n') {
-            self.line += 1;
-            self.col = 1;
-        } else {
-            self.col += 1;
-        }
-    }
-
-    fn next_char(&mut self) -> Option<char> {
-        self.bump();
-        self.ch
-    }
-    fn ch_is(&self, c: char) -> bool {
-        self.ch == Some(c)
-    }
-
-    fn error<E>(&self, reason: ErrorCode) -> Result<E, ParserError> {
-        Err(SyntaxError(reason, self.line, self.col))
-    }
-
-    fn parse_whitespace(&mut self) {
-        while self.ch_is(' ') ||
-              self.ch_is('\n') ||
-              self.ch_is('\t') ||
-              self.ch_is('\r') { self.bump(); }
-    }
-
-    fn parse_number(&mut self) -> JsonEvent {
-        let mut neg = false;
-
-        if self.ch_is('-') {
-            self.bump();
-            neg = true;
-        }
-
-        let res = match self.parse_u64() {
-            Ok(res) => res,
-            Err(e) => { return Error(e); }
-        };
-
-        if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
-            let mut res = res as f64;
-
-            if self.ch_is('.') {
-                res = match self.parse_decimal(res) {
-                    Ok(res) => res,
-                    Err(e) => { return Error(e); }
-                };
-            }
-
-            if self.ch_is('e') || self.ch_is('E') {
-                res = match self.parse_exponent(res) {
-                    Ok(res) => res,
-                    Err(e) => { return Error(e); }
-                };
-            }
-
-            if neg {
-                res *= -1.0;
-            }
-
-            F64Value(res)
-        } else {
-            if neg {
-                // Make sure we don't underflow.
-                if res > (i64::MAX as u64) + 1 {
-                    Error(SyntaxError(InvalidNumber, self.line, self.col))
-                } else if res == 0 {
-                    I64Value(res as i64)
-                } else {
-                    I64Value((!res + 1) as i64)
-                }
-            } else {
-                U64Value(res)
-            }
-        }
-    }
-
-    fn parse_u64(&mut self) -> Result<u64, ParserError> {
-        let mut accum: u64 = 0;
-
-        match self.ch_or_null() {
-            '0' => {
-                self.bump();
-
-                // A leading '0' must be the only digit before the decimal point.
-                match self.ch_or_null() {
-                    '0' ... '9' => return self.error(InvalidNumber),
-                    _ => ()
-                }
-            },
-            '1' ... '9' => {
-                while !self.eof() {
-                    match self.ch_or_null() {
-                        c @ '0' ... '9' => {
-                            macro_rules! try_or_invalid {
-                                ($e: expr) => {
-                                    match $e {
-                                        Some(v) => v,
-                                        None => return self.error(InvalidNumber)
-                                    }
-                                }
-                            }
-                            accum = try_or_invalid!(accum.checked_mul(10));
-                            accum = try_or_invalid!(accum.checked_add((c as u64) - ('0' as u64)));
-
-                            self.bump();
-                        }
-                        _ => break,
-                    }
-                }
-            }
-            _ => return self.error(InvalidNumber),
-        }
-
-        Ok(accum)
-    }
-
-    fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
-        self.bump();
-
-        // Make sure a digit follows the decimal place.
-        match self.ch_or_null() {
-            '0' ... '9' => (),
-             _ => return self.error(InvalidNumber)
-        }
-
-        let mut dec = 1.0;
-        let mut frac = 0.0;
-        while !self.eof() {
-            match self.ch_or_null() {
-                c @ '0' ... '9' => {
-                    dec /= 10.0;
-                    frac += (((c as isize) - ('0' as isize)) as f64) * dec;
-                    self.bump();
-                }
-                _ => break,
-            }
-        }
-
-        res += frac;
-
-        Ok(res)
-    }
-
-    fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
-        self.bump();
-
-        let mut exp = 0;
-        let mut neg_exp = false;
-
-        if self.ch_is('+') {
-            self.bump();
-        } else if self.ch_is('-') {
-            self.bump();
-            neg_exp = true;
-        }
-
-        // Make sure a digit follows the exponent place.
-        match self.ch_or_null() {
-            '0' ... '9' => (),
-            _ => return self.error(InvalidNumber)
-        }
-        while !self.eof() {
-            match self.ch_or_null() {
-                c @ '0' ... '9' => {
-                    exp *= 10;
-                    exp += (c as usize) - ('0' as usize);
-
-                    self.bump();
-                }
-                _ => break
-            }
-        }
-
-        let exp = 10_f64.powi(exp as i32);
-        if neg_exp {
-            res /= exp;
-        } else {
-            res *= exp;
-        }
-
-        Ok(res)
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
-        let mut i = 0;
-        let mut n = 0;
-        while i < 4 {
-            self.bump();
-            n = match self.ch_or_null() {
-                c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)),
-                c @ 'a' ... 'f' => n * 16 + (10 + (c as u16) - ('a' as u16)),
-                c @ 'A' ... 'F' => n * 16 + (10 + (c as u16) - ('A' as u16)),
-                _ => return self.error(InvalidEscape)
-            };
-
-            i += 1;
-        }
-
-        Ok(n)
-    }
-
-    fn parse_str(&mut self) -> Result<string::String, ParserError> {
-        let mut escape = false;
-        let mut res = string::String::new();
-
-        loop {
-            self.bump();
-            if self.eof() {
-                return self.error(EOFWhileParsingString);
-            }
-
-            if escape {
-                match self.ch_or_null() {
-                    '"' => res.push('"'),
-                    '\\' => res.push('\\'),
-                    '/' => res.push('/'),
-                    'b' => res.push('\x08'),
-                    'f' => res.push('\x0c'),
-                    'n' => res.push('\n'),
-                    'r' => res.push('\r'),
-                    't' => res.push('\t'),
-                    'u' => match try!(self.decode_hex_escape()) {
-                        0xDC00 ... 0xDFFF => {
-                            return self.error(LoneLeadingSurrogateInHexEscape)
-                        }
-
-                        // Non-BMP characters are encoded as a sequence of
-                        // two hex escapes, representing UTF-16 surrogates.
-                        n1 @ 0xD800 ... 0xDBFF => {
-                            match (self.next_char(), self.next_char()) {
-                                (Some('\\'), Some('u')) => (),
-                                _ => return self.error(UnexpectedEndOfHexEscape),
-                            }
-
-                            let n2 = try!(self.decode_hex_escape());
-                            if n2 < 0xDC00 || n2 > 0xDFFF {
-                                return self.error(LoneLeadingSurrogateInHexEscape)
-                            }
-                            let c = (((n1 - 0xD800) as u32) << 10 |
-                                     (n2 - 0xDC00) as u32) + 0x1_0000;
-                            res.push(char::from_u32(c).unwrap());
-                        }
-
-                        n => match char::from_u32(n as u32) {
-                            Some(c) => res.push(c),
-                            None => return self.error(InvalidUnicodeCodePoint),
-                        },
-                    },
-                    _ => return self.error(InvalidEscape),
-                }
-                escape = false;
-            } else if self.ch_is('\\') {
-                escape = true;
-            } else {
-                match self.ch {
-                    Some('"') => {
-                        self.bump();
-                        return Ok(res);
-                    },
-                    Some(c) if c <= '\u{1F}' =>
-                        return self.error(ControlCharacterInString),
-                    Some(c) => res.push(c),
-                    None => unreachable!()
-                }
-            }
-        }
-    }
-
-    // Invoked at each iteration, consumes the stream until it has enough
-    // information to return a JsonEvent.
-    // Manages an internal state so that parsing can be interrupted and resumed.
-    // Also keeps track of the position in the logical structure of the json
-    // stream int the form of a stack that can be queried by the user using the
-    // stack() method.
-    fn parse(&mut self) -> JsonEvent {
-        loop {
-            // The only paths where the loop can spin a new iteration
-            // are in the cases ParseArrayComma and ParseObjectComma if ','
-            // is parsed. In these cases the state is set to (respectively)
-            // ParseArray(false) and ParseObject(false), which always return,
-            // so there is no risk of getting stuck in an infinite loop.
-            // All other paths return before the end of the loop's iteration.
-            self.parse_whitespace();
-
-            match self.state {
-                ParseStart => {
-                    return self.parse_start();
-                }
-                ParseArray(first) => {
-                    return self.parse_array(first);
-                }
-                ParseArrayComma => {
-                    match self.parse_array_comma_or_end() {
-                        Some(evt) => { return evt; }
-                        None => {}
-                    }
-                }
-                ParseObject(first) => {
-                    return self.parse_object(first);
-                }
-                ParseObjectComma => {
-                    self.stack.pop();
-                    if self.ch_is(',') {
-                        self.state = ParseObject(false);
-                        self.bump();
-                    } else {
-                        return self.parse_object_end();
-                    }
-                }
-                _ => {
-                    return self.error_event(InvalidSyntax);
-                }
-            }
-        }
-    }
-
-    fn parse_start(&mut self) -> JsonEvent {
-        let val = self.parse_value();
-        self.state = match val {
-            Error(_) => ParseFinished,
-            ArrayStart => ParseArray(true),
-            ObjectStart => ParseObject(true),
-            _ => ParseBeforeFinish,
-        };
-        return val;
-    }
-
-    fn parse_array(&mut self, first: bool) -> JsonEvent {
-        if self.ch_is(']') {
-            if !first {
-                self.error_event(InvalidSyntax)
-            } else {
-                self.state = if self.stack.is_empty() {
-                    ParseBeforeFinish
-                } else if self.stack.last_is_index() {
-                    ParseArrayComma
-                } else {
-                    ParseObjectComma
-                };
-                self.bump();
-                ArrayEnd
-            }
-        } else {
-            if first {
-                self.stack.push_index(0);
-            }
-            let val = self.parse_value();
-            self.state = match val {
-                Error(_) => ParseFinished,
-                ArrayStart => ParseArray(true),
-                ObjectStart => ParseObject(true),
-                _ => ParseArrayComma,
-            };
-            val
-        }
-    }
-
-    fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
-        if self.ch_is(',') {
-            self.stack.bump_index();
-            self.state = ParseArray(false);
-            self.bump();
-            None
-        } else if self.ch_is(']') {
-            self.stack.pop();
-            self.state = if self.stack.is_empty() {
-                ParseBeforeFinish
-            } else if self.stack.last_is_index() {
-                ParseArrayComma
-            } else {
-                ParseObjectComma
-            };
-            self.bump();
-            Some(ArrayEnd)
-        } else if self.eof() {
-            Some(self.error_event(EOFWhileParsingArray))
-        } else {
-            Some(self.error_event(InvalidSyntax))
-        }
-    }
-
-    fn parse_object(&mut self, first: bool) -> JsonEvent {
-        if self.ch_is('}') {
-            if !first {
-                if self.stack.is_empty() {
-                    return self.error_event(TrailingComma);
-                } else {
-                    self.stack.pop();
-                }
-            }
-            self.state = if self.stack.is_empty() {
-                ParseBeforeFinish
-            } else if self.stack.last_is_index() {
-                ParseArrayComma
-            } else {
-                ParseObjectComma
-            };
-            self.bump();
-            return ObjectEnd;
-        }
-        if self.eof() {
-            return self.error_event(EOFWhileParsingObject);
-        }
-        if !self.ch_is('"') {
-            return self.error_event(KeyMustBeAString);
-        }
-        let s = match self.parse_str() {
-            Ok(s) => s,
-            Err(e) => {
-                self.state = ParseFinished;
-                return Error(e);
-            }
-        };
-        self.parse_whitespace();
-        if self.eof() {
-            return self.error_event(EOFWhileParsingObject);
-        } else if self.ch_or_null() != ':' {
-            return self.error_event(ExpectedColon);
-        }
-        self.stack.push_key(s);
-        self.bump();
-        self.parse_whitespace();
-
-        let val = self.parse_value();
-
-        self.state = match val {
-            Error(_) => ParseFinished,
-            ArrayStart => ParseArray(true),
-            ObjectStart => ParseObject(true),
-            _ => ParseObjectComma,
-        };
-        return val;
-    }
-
-    fn parse_object_end(&mut self) -> JsonEvent {
-        if self.ch_is('}') {
-            self.state = if self.stack.is_empty() {
-                ParseBeforeFinish
-            } else if self.stack.last_is_index() {
-                ParseArrayComma
-            } else {
-                ParseObjectComma
-            };
-            self.bump();
-            ObjectEnd
-        } else if self.eof() {
-            self.error_event(EOFWhileParsingObject)
-        } else {
-            self.error_event(InvalidSyntax)
-        }
-    }
-
-    fn parse_value(&mut self) -> JsonEvent {
-        if self.eof() { return self.error_event(EOFWhileParsingValue); }
-        match self.ch_or_null() {
-            'n' => { self.parse_ident("ull", NullValue) }
-            't' => { self.parse_ident("rue", BooleanValue(true)) }
-            'f' => { self.parse_ident("alse", BooleanValue(false)) }
-            '0' ... '9' | '-' => self.parse_number(),
-            '"' => match self.parse_str() {
-                Ok(s) => StringValue(s),
-                Err(e) => Error(e),
-            },
-            '[' => {
-                self.bump();
-                ArrayStart
-            }
-            '{' => {
-                self.bump();
-                ObjectStart
-            }
-            _ => { self.error_event(InvalidSyntax) }
-        }
-    }
-
-    fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent {
-        if ident.chars().all(|c| Some(c) == self.next_char()) {
-            self.bump();
-            value
-        } else {
-            Error(SyntaxError(InvalidSyntax, self.line, self.col))
-        }
-    }
-
-    fn error_event(&mut self, reason: ErrorCode) -> JsonEvent {
-        self.state = ParseFinished;
-        Error(SyntaxError(reason, self.line, self.col))
-    }
-}
-
-/// A Builder consumes a json::Parser to create a generic Json structure.
-pub struct Builder<T> {
-    parser: Parser<T>,
-    token: Option<JsonEvent>,
-}
-
-impl<T: Iterator<Item = char>> Builder<T> {
-    /// Create a JSON Builder.
-    pub fn new(src: T) -> Builder<T> {
-        Builder { parser: Parser::new(src), token: None, }
-    }
-
-    // Decode a Json value from a Parser.
-    pub fn build(&mut self) -> Result<Json, BuilderError> {
-        self.bump();
-        let result = self.build_value();
-        self.bump();
-        match self.token.take() {
-            None => {}
-            Some(Error(e)) => { return Err(e); }
-            _ => { return Err(SyntaxError(InvalidSyntax, self.parser.line, self.parser.col)); }
-        }
-        result
-    }
-
-    fn bump(&mut self) {
-        self.token = self.parser.next();
-    }
-
-    fn build_value(&mut self) -> Result<Json, BuilderError> {
-        return match self.token.take() {
-            Some(NullValue) => Ok(Json::Null),
-            Some(I64Value(n)) => Ok(Json::I64(n)),
-            Some(U64Value(n)) => Ok(Json::U64(n)),
-            Some(F64Value(n)) => Ok(Json::F64(n)),
-            Some(BooleanValue(b)) => Ok(Json::Boolean(b)),
-            Some(StringValue(ref mut s)) => {
-                let mut temp = string::String::new();
-                swap(s, &mut temp);
-                Ok(Json::String(temp))
-            }
-            Some(Error(e)) => Err(e),
-            Some(ArrayStart) => self.build_array(),
-            Some(ObjectStart) => self.build_object(),
-            Some(ObjectEnd) => self.parser.error(InvalidSyntax),
-            Some(ArrayEnd) => self.parser.error(InvalidSyntax),
-            None => self.parser.error(EOFWhileParsingValue),
-        }
-    }
-
-    fn build_array(&mut self) -> Result<Json, BuilderError> {
-        self.bump();
-        let mut values = Vec::new();
-
-        loop {
-            if let Some(ArrayEnd) = self.token {
-                return Ok(Json::Array(values.into_iter().collect()));
-            }
-            match self.build_value() {
-                Ok(v) => values.push(v),
-                Err(e) => { return Err(e) }
-            }
-            self.bump();
-        }
-    }
-
-    fn build_object(&mut self) -> Result<Json, BuilderError> {
-        self.bump();
-
-        let mut values = BTreeMap::new();
-
-        loop {
-            match self.token.take() {
-                Some(ObjectEnd) => { return Ok(Json::Object(values)); }
-                Some(Error(e)) => { return Err(e); }
-                None => { break; }
-                token => { self.token = token; }
-            }
-            let key = match self.parser.stack().top() {
-                Some(StackElement::Key(k)) => { k.to_string() }
-                _ => { panic!("invalid state"); }
-            };
-            match self.build_value() {
-                Ok(value) => { values.insert(key, value); }
-                Err(e) => { return Err(e); }
-            }
-            self.bump();
-        }
-        return self.parser.error(EOFWhileParsingObject);
-    }
-}
-
-/// A structure to decode JSON to values in rust.
-pub struct Decoder {
-    stack: Vec<Json>,
-}
-
-impl Decoder {
-    /// Creates a new decoder instance for decoding the specified JSON value.
-    pub fn new(json: Json) -> Decoder {
-        Decoder { stack: vec![json] }
-    }
-}
-
-impl Decoder {
-    fn pop(&mut self) -> DecodeResult<Json> {
-        match self.stack.pop() {
-            Some(s) => Ok(s),
-            None => Err(EOF),
-        }
-    }
-}
-
-macro_rules! expect {
-    ($e:expr, Null) => ({
-        match try!($e) {
-            Json::Null => Ok(()),
-            other => Err(ExpectedError("Null".to_string(),
-                                       format!("{}", other)))
-        }
-    });
-    ($e:expr, $t:ident) => ({
-        match try!($e) {
-            Json::$t(v) => Ok(v),
-            other => {
-                Err(ExpectedError(stringify!($t).to_string(),
-                                  format!("{}", other)))
-            }
-        }
-    })
-}
-
-macro_rules! read_primitive {
-    ($name:ident, $ty:ident) => {
-        #[allow(unused_comparisons)]
-        fn $name(&mut self) -> DecodeResult<$ty> {
-            match try!(self.pop()) {
-                Json::I64(i) => {
-                    let other = i as $ty;
-                    if i == other as i64 && (other > 0) == (i > 0) {
-                        Ok(other)
-                    } else {
-                        Err(ExpectedError("Number".to_string(), i.to_string()))
-                    }
-                }
-                Json::U64(u) => {
-                    let other = u as $ty;
-                    if u == other as u64 && other >= 0 {
-                        Ok(other)
-                    } else {
-                        Err(ExpectedError("Number".to_string(), u.to_string()))
-                    }
-                }
-                Json::F64(f) => {
-                    Err(ExpectedError("Integer".to_string(), f.to_string()))
-                }
-                // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
-                // is going to have a string here, as per JSON spec.
-                Json::String(s) => match s.parse() {
-                    Ok(f)  => Ok(f),
-                    Err(_) => Err(ExpectedError("Number".to_string(), s)),
-                },
-                value => {
-                    Err(ExpectedError("Number".to_string(), value.to_string()))
-                }
-            }
-        }
-    }
-}
-
-impl ::Decoder for Decoder {
-    type Error = DecoderError;
-
-    fn read_nil(&mut self) -> DecodeResult<()> {
-        expect!(self.pop(), Null)
-    }
-
-    read_primitive! { read_usize, usize }
-    read_primitive! { read_u8, u8 }
-    read_primitive! { read_u16, u16 }
-    read_primitive! { read_u32, u32 }
-    read_primitive! { read_u64, u64 }
-    read_primitive! { read_isize, isize }
-    read_primitive! { read_i8, i8 }
-    read_primitive! { read_i16, i16 }
-    read_primitive! { read_i32, i32 }
-    read_primitive! { read_i64, i64 }
-
-    fn read_f32(&mut self) -> DecodeResult<f32> {
-        self.read_f64().map(|x| x as f32)
-    }
-
-    fn read_f64(&mut self) -> DecodeResult<f64> {
-        match try!(self.pop()) {
-            Json::I64(f) => Ok(f as f64),
-            Json::U64(f) => Ok(f as f64),
-            Json::F64(f) => Ok(f),
-            Json::String(s) => {
-                // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
-                // is going to have a string here, as per JSON spec.
-                match s.parse() {
-                    Ok(f)  => Ok(f),
-                    Err(_) => Err(ExpectedError("Number".to_string(), s)),
-                }
-            },
-            Json::Null => Ok(f64::NAN),
-            value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
-        }
-    }
-
-    fn read_bool(&mut self) -> DecodeResult<bool> {
-        expect!(self.pop(), Boolean)
-    }
-
-    fn read_char(&mut self) -> DecodeResult<char> {
-        let s = try!(self.read_str());
-        {
-            let mut it = s.chars();
-            match (it.next(), it.next()) {
-                // exactly one character
-                (Some(c), None) => return Ok(c),
-                _ => ()
-            }
-        }
-        Err(ExpectedError("single character string".to_string(), format!("{}", s)))
-    }
-
-    fn read_str(&mut self) -> DecodeResult<string::String> {
-        expect!(self.pop(), String)
-    }
-
-    fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn read_enum_variant<T, F>(&mut self, names: &[&str],
-                               mut f: F) -> DecodeResult<T>
-        where F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
-    {
-        let name = match try!(self.pop()) {
-            Json::String(s) => s,
-            Json::Object(mut o) => {
-                let n = match o.remove(&"variant".to_string()) {
-                    Some(Json::String(s)) => s,
-                    Some(val) => {
-                        return Err(ExpectedError("String".to_string(), format!("{}", val)))
-                    }
-                    None => {
-                        return Err(MissingFieldError("variant".to_string()))
-                    }
-                };
-                match o.remove(&"fields".to_string()) {
-                    Some(Json::Array(l)) => {
-                        for field in l.into_iter().rev() {
-                            self.stack.push(field);
-                        }
-                    },
-                    Some(val) => {
-                        return Err(ExpectedError("Array".to_string(), format!("{}", val)))
-                    }
-                    None => {
-                        return Err(MissingFieldError("fields".to_string()))
-                    }
-                }
-                n
-            }
-            json => {
-                return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
-            }
-        };
-        let idx = match names.iter().position(|n| *n == name) {
-            Some(idx) => idx,
-            None => return Err(UnknownVariantError(name))
-        };
-        f(self, idx)
-    }
-
-    fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
-        F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
-    {
-        self.read_enum_variant(names, f)
-    }
-
-
-    fn read_enum_struct_variant_field<T, F>(&mut self,
-                                         _name: &str,
-                                         idx: usize,
-                                         f: F)
-                                         -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_enum_variant_arg(idx, f)
-    }
-
-    fn read_struct<T, F>(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        let value = try!(f(self));
-        try!(self.pop());
-        Ok(value)
-    }
-
-    fn read_struct_field<T, F>(&mut self,
-                               name: &str,
-                               _idx: usize,
-                               f: F)
-                               -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        let mut obj = try!(expect!(self.pop(), Object));
-
-        let value = match obj.remove(&name.to_string()) {
-            None => {
-                // Add a Null and try to parse it as an Option<_>
-                // to get None as a default value.
-                self.stack.push(Json::Null);
-                match f(self) {
-                    Ok(x) => x,
-                    Err(_) => return Err(MissingFieldError(name.to_string())),
-                }
-            },
-            Some(json) => {
-                self.stack.push(json);
-                try!(f(self))
-            }
-        };
-        self.stack.push(Json::Object(obj));
-        Ok(value)
-    }
-
-    fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_seq(move |d, len| {
-            if len == tuple_len {
-                f(d)
-            } else {
-                Err(ExpectedError(format!("Tuple{}", tuple_len), format!("Tuple{}", len)))
-            }
-        })
-    }
-
-    fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_seq_elt(idx, f)
-    }
-
-    fn read_tuple_struct<T, F>(&mut self,
-                               _name: &str,
-                               len: usize,
-                               f: F)
-                               -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_tuple(len, f)
-    }
-
-    fn read_tuple_struct_arg<T, F>(&mut self,
-                                   idx: usize,
-                                   f: F)
-                                   -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_tuple_arg(idx, f)
-    }
-
-    fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
-        F: FnMut(&mut Decoder, bool) -> DecodeResult<T>,
-    {
-        match try!(self.pop()) {
-            Json::Null => f(self, false),
-            value => { self.stack.push(value); f(self, true) }
-        }
-    }
-
-    fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
-    {
-        let array = try!(expect!(self.pop(), Array));
-        let len = array.len();
-        for v in array.into_iter().rev() {
-            self.stack.push(v);
-        }
-        f(self, len)
-    }
-
-    fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
-    {
-        let obj = try!(expect!(self.pop(), Object));
-        let len = obj.len();
-        for (key, value) in obj.into_iter() {
-            self.stack.push(value);
-            self.stack.push(Json::String(key));
-        }
-        f(self, len)
-    }
-
-    fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
-       F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
-       F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn error(&mut self, err: &str) -> DecoderError {
-        ApplicationError(err.to_string())
-    }
-}
-
-/// A trait for converting values to JSON
-pub trait ToJson {
-    /// Converts the value of `self` to an instance of JSON
-    fn to_json(&self) -> Json;
-}
-
-macro_rules! to_json_impl_i64 {
-    ($($t:ty), +) => (
-        $(impl ToJson for $t {
-            fn to_json(&self) -> Json { Json::I64(*self as i64) }
-        })+
-    )
-}
-
-to_json_impl_i64! { isize, i8, i16, i32, i64 }
-
-macro_rules! to_json_impl_u64 {
-    ($($t:ty), +) => (
-        $(impl ToJson for $t {
-            fn to_json(&self) -> Json { Json::U64(*self as u64) }
-        })+
-    )
-}
-
-to_json_impl_u64! { usize, u8, u16, u32, u64 }
-
-impl ToJson for Json {
-    fn to_json(&self) -> Json { self.clone() }
-}
-
-impl ToJson for f32 {
-    fn to_json(&self) -> Json { (*self as f64).to_json() }
-}
-
-impl ToJson for f64 {
-    fn to_json(&self) -> Json {
-        use std::num::FpCategory::{Nan, Infinite};
-
-        match self.classify() {
-            Nan | Infinite => Json::Null,
-            _                  => Json::F64(*self)
-        }
-    }
-}
-
-impl ToJson for () {
-    fn to_json(&self) -> Json { Json::Null }
-}
-
-impl ToJson for bool {
-    fn to_json(&self) -> Json { Json::Boolean(*self) }
-}
-
-impl ToJson for str {
-    fn to_json(&self) -> Json { Json::String(self.to_string()) }
-}
-
-impl ToJson for string::String {
-    fn to_json(&self) -> Json { Json::String((*self).clone()) }
-}
-
-macro_rules! tuple_impl {
-    // use variables to indicate the arity of the tuple
-    ($($tyvar:ident),* ) => {
-        // the trailing commas are for the 1 tuple
-        impl<
-            $( $tyvar : ToJson ),*
-            > ToJson for ( $( $tyvar ),* , ) {
-
-            #[inline]
-            #[allow(non_snake_case)]
-            fn to_json(&self) -> Json {
-                match *self {
-                    ($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*])
-                }
-            }
-        }
-    }
-}
-
-tuple_impl!{A}
-tuple_impl!{A, B}
-tuple_impl!{A, B, C}
-tuple_impl!{A, B, C, D}
-tuple_impl!{A, B, C, D, E}
-tuple_impl!{A, B, C, D, E, F}
-tuple_impl!{A, B, C, D, E, F, G}
-tuple_impl!{A, B, C, D, E, F, G, H}
-tuple_impl!{A, B, C, D, E, F, G, H, I}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
-
-impl<A: ToJson> ToJson for [A] {
-    fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
-}
-
-impl<A: ToJson> ToJson for Vec<A> {
-    fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
-}
-
-impl<A: ToJson> ToJson for BTreeMap<string::String, A> {
-    fn to_json(&self) -> Json {
-        let mut d = BTreeMap::new();
-        for (key, value) in self.iter() {
-            d.insert((*key).clone(), value.to_json());
-        }
-        Json::Object(d)
-    }
-}
-
-impl<A: ToJson> ToJson for HashMap<string::String, A> {
-    fn to_json(&self) -> Json {
-        let mut d = BTreeMap::new();
-        for (key, value) in self.iter() {
-            d.insert((*key).clone(), value.to_json());
-        }
-        Json::Object(d)
-    }
-}
-
-impl<A:ToJson> ToJson for Option<A> {
-    fn to_json(&self) -> Json {
-        match *self {
-            None => Json::Null,
-            Some(ref value) => value.to_json()
-        }
-    }
-}
-
-struct FormatShim<'a, 'b: 'a> {
-    inner: &'a mut fmt::Formatter<'b>,
-}
-
-impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        match self.inner.write_str(s) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl fmt::Display for Json {
-    /// Encodes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut shim = FormatShim { inner: f };
-        let mut encoder = Encoder::new(&mut shim);
-        match self.encode(&mut encoder) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl<'a> fmt::Display for PrettyJson<'a> {
-    /// Encodes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut shim = FormatShim { inner: f };
-        let mut encoder = Encoder::new_pretty(&mut shim);
-        match self.inner.encode(&mut encoder) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
-    /// Encodes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut shim = FormatShim { inner: f };
-        let mut encoder = Encoder::new(&mut shim);
-        match self.inner.encode(&mut encoder) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl<'a, T> AsPrettyJson<'a, T> {
-    /// Set the indentation level for the emitted JSON
-    pub fn indent(mut self, indent: u32) -> AsPrettyJson<'a, T> {
-        self.indent = Some(indent);
-        self
-    }
-}
-
-impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
-    /// Encodes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut shim = FormatShim { inner: f };
-        let mut encoder = Encoder::new_pretty(&mut shim);
-        if let Some(n) = self.indent {
-            // unwrap cannot panic for pretty encoders
-            let _ = encoder.set_indent(n);
-        }
-        match self.inner.encode(&mut encoder) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl FromStr for Json {
-    type Err = ParserError;
-    fn from_str(s: &str) -> Result<Json, ParserError> {
-        Json::from_str(s)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use self::Animal::*;
-    use {Encodable, Decodable};
-    use super::Json::*;
-    use super::ErrorCode::*;
-    use super::ParserError::*;
-    use super::DecoderError::*;
-    use super::JsonEvent::*;
-    use super::StackElement::*;
-    use super::{Json, DecodeResult, DecoderError, JsonEvent, Parser,
-                StackElement, Stack, Decoder, Encoder, EncoderError};
-    use std::{i64, u64, f32, f64};
-    use std::collections::BTreeMap;
-    use std::string;
-
-    #[derive(RustcDecodable, Eq, PartialEq, Debug)]
-    struct OptionData {
-        opt: Option<usize>,
-    }
-
-    #[test]
-    fn test_decode_option_none() {
-        let s ="{}";
-        let obj: OptionData = super::decode(s).unwrap();
-        assert_eq!(obj, OptionData { opt: None });
-    }
-
-    #[test]
-    fn test_decode_option_some() {
-        let s = "{ \"opt\": 10 }";
-        let obj: OptionData = super::decode(s).unwrap();
-        assert_eq!(obj, OptionData { opt: Some(10) });
-    }
-
-    #[test]
-    fn test_decode_option_malformed() {
-        check_err::<OptionData>("{ \"opt\": [] }",
-                                ExpectedError("Number".to_string(), "[]".to_string()));
-        check_err::<OptionData>("{ \"opt\": false }",
-                                ExpectedError("Number".to_string(), "false".to_string()));
-    }
-
-    #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
-    enum Animal {
-        Dog,
-        Frog(string::String, isize)
-    }
-
-    #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
-    struct Inner {
-        a: (),
-        b: usize,
-        c: Vec<string::String>,
-    }
-
-    #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
-    struct Outer {
-        inner: Vec<Inner>,
-    }
-
-    fn mk_object(items: &[(string::String, Json)]) -> Json {
-        let mut d = BTreeMap::new();
-
-        for item in items.iter() {
-            match *item {
-                (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
-            }
-        };
-
-        Object(d)
-    }
-
-    #[test]
-    fn test_from_str_trait() {
-        let s = "null";
-        assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
-    }
-
-    #[test]
-    fn test_write_null() {
-        assert_eq!(Null.to_string(), "null");
-        assert_eq!(Null.pretty().to_string(), "null");
-    }
-
-    #[test]
-    fn test_write_i64() {
-        assert_eq!(U64(0).to_string(), "0");
-        assert_eq!(U64(0).pretty().to_string(), "0");
-
-        assert_eq!(U64(1234).to_string(), "1234");
-        assert_eq!(U64(1234).pretty().to_string(), "1234");
-
-        assert_eq!(I64(-5678).to_string(), "-5678");
-        assert_eq!(I64(-5678).pretty().to_string(), "-5678");
-
-        assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
-        assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
-    }
-
-    #[test]
-    fn test_write_f64() {
-        assert_eq!(F64(3.0).to_string(), "3.0");
-        assert_eq!(F64(3.0).pretty().to_string(), "3.0");
-
-        assert_eq!(F64(3.1).to_string(), "3.1");
-        assert_eq!(F64(3.1).pretty().to_string(), "3.1");
-
-        assert_eq!(F64(-1.5).to_string(), "-1.5");
-        assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
-
-        assert_eq!(F64(0.5).to_string(), "0.5");
-        assert_eq!(F64(0.5).pretty().to_string(), "0.5");
-
-        assert_eq!(F64(f64::NAN).to_string(), "null");
-        assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
-
-        assert_eq!(F64(f64::INFINITY).to_string(), "null");
-        assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
-
-        assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
-        assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
-    }
-
-    #[test]
-    fn test_write_str() {
-        assert_eq!(String("".to_string()).to_string(), "\"\"");
-        assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
-
-        assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
-        assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
-    }
-
-    #[test]
-    fn test_write_bool() {
-        assert_eq!(Boolean(true).to_string(), "true");
-        assert_eq!(Boolean(true).pretty().to_string(), "true");
-
-        assert_eq!(Boolean(false).to_string(), "false");
-        assert_eq!(Boolean(false).pretty().to_string(), "false");
-    }
-
-    #[test]
-    fn test_write_array() {
-        assert_eq!(Array(vec![]).to_string(), "[]");
-        assert_eq!(Array(vec![]).pretty().to_string(), "[]");
-
-        assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
-        assert_eq!(
-            Array(vec![Boolean(true)]).pretty().to_string(),
-            "\
-            [\n  \
-                true\n\
-            ]"
-        );
-
-        let long_test_array = Array(vec![
-            Boolean(false),
-            Null,
-            Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
-
-        assert_eq!(long_test_array.to_string(),
-            "[false,null,[\"foo\\nbar\",3.5]]");
-        assert_eq!(
-            long_test_array.pretty().to_string(),
-            "\
-            [\n  \
-                false,\n  \
-                null,\n  \
-                [\n    \
-                    \"foo\\nbar\",\n    \
-                    3.5\n  \
-                ]\n\
-            ]"
-        );
-    }
-
-    #[test]
-    fn test_write_object() {
-        assert_eq!(mk_object(&[]).to_string(), "{}");
-        assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
-
-        assert_eq!(
-            mk_object(&[
-                ("a".to_string(), Boolean(true))
-            ]).to_string(),
-            "{\"a\":true}"
-        );
-        assert_eq!(
-            mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
-            "\
-            {\n  \
-                \"a\": true\n\
-            }"
-        );
-
-        let complex_obj = mk_object(&[
-                ("b".to_string(), Array(vec![
-                    mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
-                    mk_object(&[("d".to_string(), String("".to_string()))])
-                ]))
-            ]);
-
-        assert_eq!(
-            complex_obj.to_string(),
-            "{\
-                \"b\":[\
-                    {\"c\":\"\\f\\r\"},\
-                    {\"d\":\"\"}\
-                ]\
-            }"
-        );
-        assert_eq!(
-            complex_obj.pretty().to_string(),
-            "\
-            {\n  \
-                \"b\": [\n    \
-                    {\n      \
-                        \"c\": \"\\f\\r\"\n    \
-                    },\n    \
-                    {\n      \
-                        \"d\": \"\"\n    \
-                    }\n  \
-                ]\n\
-            }"
-        );
-
-        let a = mk_object(&[
-            ("a".to_string(), Boolean(true)),
-            ("b".to_string(), Array(vec![
-                mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
-                mk_object(&[("d".to_string(), String("".to_string()))])
-            ]))
-        ]);
-
-        // We can't compare the strings directly because the object fields be
-        // printed in a different order.
-        assert_eq!(a.clone(), a.to_string().parse().unwrap());
-        assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
-    }
-
-    #[test]
-    fn test_write_enum() {
-        let animal = Dog;
-        assert_eq!(
-            format!("{}", super::as_json(&animal)),
-            "\"Dog\""
-        );
-        assert_eq!(
-            format!("{}", super::as_pretty_json(&animal)),
-            "\"Dog\""
-        );
-
-        let animal = Frog("Henry".to_string(), 349);
-        assert_eq!(
-            format!("{}", super::as_json(&animal)),
-            "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
-        );
-        assert_eq!(
-            format!("{}", super::as_pretty_json(&animal)),
-            "{\n  \
-               \"variant\": \"Frog\",\n  \
-               \"fields\": [\n    \
-                 \"Henry\",\n    \
-                 349\n  \
-               ]\n\
-             }"
-        );
-    }
-
-    macro_rules! check_encoder_for_simple {
-        ($value:expr, $expected:expr) => ({
-            let s = format!("{}", super::as_json(&$value));
-            assert_eq!(s, $expected);
-
-            let s = format!("{}", super::as_pretty_json(&$value));
-            assert_eq!(s, $expected);
-        })
-    }
-
-    #[test]
-    fn test_write_some() {
-        check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
-    }
-
-    #[test]
-    fn test_write_none() {
-        check_encoder_for_simple!(None::<string::String>, "null");
-    }
-
-    #[test]
-    fn test_write_char() {
-        check_encoder_for_simple!('a', "\"a\"");
-        check_encoder_for_simple!('\t', "\"\\t\"");
-        check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
-        check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
-        check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
-        check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
-        check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
-        check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
-    }
-
-    #[test]
-    fn test_trailing_characters() {
-        assert_eq!(Json::from_str("nulla"),  Err(SyntaxError(TrailingCharacters, 1, 5)));
-        assert_eq!(Json::from_str("truea"),  Err(SyntaxError(TrailingCharacters, 1, 5)));
-        assert_eq!(Json::from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
-        assert_eq!(Json::from_str("1a"),     Err(SyntaxError(TrailingCharacters, 1, 2)));
-        assert_eq!(Json::from_str("[]a"),    Err(SyntaxError(TrailingCharacters, 1, 3)));
-        assert_eq!(Json::from_str("{}a"),    Err(SyntaxError(TrailingCharacters, 1, 3)));
-    }
-
-    #[test]
-    fn test_read_identifiers() {
-        assert_eq!(Json::from_str("n"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(Json::from_str("nul"),  Err(SyntaxError(InvalidSyntax, 1, 4)));
-        assert_eq!(Json::from_str("t"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(Json::from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
-        assert_eq!(Json::from_str("f"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(Json::from_str("faz"),  Err(SyntaxError(InvalidSyntax, 1, 3)));
-
-        assert_eq!(Json::from_str("null"), Ok(Null));
-        assert_eq!(Json::from_str("true"), Ok(Boolean(true)));
-        assert_eq!(Json::from_str("false"), Ok(Boolean(false)));
-        assert_eq!(Json::from_str(" null "), Ok(Null));
-        assert_eq!(Json::from_str(" true "), Ok(Boolean(true)));
-        assert_eq!(Json::from_str(" false "), Ok(Boolean(false)));
-    }
-
-    #[test]
-    fn test_decode_identifiers() {
-        let v: () = super::decode("null").unwrap();
-        assert_eq!(v, ());
-
-        let v: bool = super::decode("true").unwrap();
-        assert_eq!(v, true);
-
-        let v: bool = super::decode("false").unwrap();
-        assert_eq!(v, false);
-    }
-
-    #[test]
-    fn test_read_number() {
-        assert_eq!(Json::from_str("+"),   Err(SyntaxError(InvalidSyntax, 1, 1)));
-        assert_eq!(Json::from_str("."),   Err(SyntaxError(InvalidSyntax, 1, 1)));
-        assert_eq!(Json::from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
-        assert_eq!(Json::from_str("-"),   Err(SyntaxError(InvalidNumber, 1, 2)));
-        assert_eq!(Json::from_str("00"),  Err(SyntaxError(InvalidNumber, 1, 2)));
-        assert_eq!(Json::from_str("1."),  Err(SyntaxError(InvalidNumber, 1, 3)));
-        assert_eq!(Json::from_str("1e"),  Err(SyntaxError(InvalidNumber, 1, 3)));
-        assert_eq!(Json::from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
-
-        assert_eq!(Json::from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
-        assert_eq!(Json::from_str("18446744073709551617"), Err(SyntaxError(InvalidNumber, 1, 20)));
-        assert_eq!(Json::from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
-
-        assert_eq!(Json::from_str("3"), Ok(U64(3)));
-        assert_eq!(Json::from_str("3.1"), Ok(F64(3.1)));
-        assert_eq!(Json::from_str("-1.2"), Ok(F64(-1.2)));
-        assert_eq!(Json::from_str("0.4"), Ok(F64(0.4)));
-        assert_eq!(Json::from_str("0.4e5"), Ok(F64(0.4e5)));
-        assert_eq!(Json::from_str("0.4e+15"), Ok(F64(0.4e15)));
-        assert_eq!(Json::from_str("0.4e-01"), Ok(F64(0.4e-01)));
-        assert_eq!(Json::from_str("123456789.5024"), Ok(F64(123456789.5024)));
-        assert_eq!(Json::from_str(" 3 "), Ok(U64(3)));
-
-        assert_eq!(Json::from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
-        assert_eq!(Json::from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
-        assert_eq!(Json::from_str("18446744073709551615"), Ok(U64(u64::MAX)));
-    }
-
-    #[test]
-    fn test_decode_numbers() {
-        let v: f64 = super::decode("3").unwrap();
-        assert_eq!(v, 3.0);
-
-        let v: f64 = super::decode("3.1").unwrap();
-        assert_eq!(v, 3.1);
-
-        let v: f64 = super::decode("-1.2").unwrap();
-        assert_eq!(v, -1.2);
-
-        let v: f64 = super::decode("0.4").unwrap();
-        assert_eq!(v, 0.4);
-
-        let v: f64 = super::decode("0.4e5").unwrap();
-        assert_eq!(v, 0.4e5);
-
-        let v: f64 = super::decode("0.4e15").unwrap();
-        assert_eq!(v, 0.4e15);
-
-        let v: f64 = super::decode("0.4e-01").unwrap();
-        assert_eq!(v, 0.4e-01);
-
-        let v: f64 = super::decode("123456789.5024").unwrap();
-        assert_eq!(v, 123456789.5024);
-
-        let v: u64 = super::decode("0").unwrap();
-        assert_eq!(v, 0);
-
-        let v: u64 = super::decode("18446744073709551615").unwrap();
-        assert_eq!(v, u64::MAX);
-
-        let v: i64 = super::decode("-9223372036854775808").unwrap();
-        assert_eq!(v, i64::MIN);
-
-        let v: i64 = super::decode("9223372036854775807").unwrap();
-        assert_eq!(v, i64::MAX);
-
-        let res: DecodeResult<i64> = super::decode("765.25252");
-        match res {
-            Ok(..) => panic!("expected an error"),
-            Err(ExpectedError(ref s, _)) => assert_eq!(s, "Integer"),
-            Err(..) => panic!("expected an 'expected integer' error"),
-        }
-    }
-
-    #[test]
-    fn test_read_str() {
-        assert_eq!(Json::from_str("\""),     Err(SyntaxError(EOFWhileParsingString, 1, 2)));
-        assert_eq!(Json::from_str("\"lol"),  Err(SyntaxError(EOFWhileParsingString, 1, 5)));
-        assert_eq!(Json::from_str("\"\n\""), Err(SyntaxError(ControlCharacterInString, 2, 1)));
-        assert_eq!(Json::from_str("\"\0\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
-        assert_eq!(Json::from_str("\"\u{1}\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
-        assert_eq!(Json::from_str("\"\u{1F}\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
-
-        // Only C0 control characters are excluded.
-        assert!('\u{7F}'.is_control());
-        assert!('\u{80}'.is_control());
-        assert!('\u{9F}'.is_control());
-        let c1_controls = "\u{7F}\u{80}\u{9F}".to_string();
-        assert_eq!(Json::from_str(&format!("\"{}\"", c1_controls)), Ok(String(c1_controls)));
-
-        assert_eq!(Json::from_str("\"\""), Ok(String("".to_string())));
-        assert_eq!(Json::from_str("\"foo\""), Ok(String("foo".to_string())));
-        assert_eq!(Json::from_str("\"\\\"\""), Ok(String("\"".to_string())));
-        assert_eq!(Json::from_str("\"\\b\""), Ok(String("\x08".to_string())));
-        assert_eq!(Json::from_str("\"\\n\""), Ok(String("\n".to_string())));
-        assert_eq!(Json::from_str("\"\\r\""), Ok(String("\r".to_string())));
-        assert_eq!(Json::from_str("\"\\t\""), Ok(String("\t".to_string())));
-        assert_eq!(Json::from_str(" \"foo\" "), Ok(String("foo".to_string())));
-        assert_eq!(Json::from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
-        assert_eq!(Json::from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
-    }
-
-    #[test]
-    fn test_decode_str() {
-        let s = [("\"\"", ""),
-                 ("\"foo\"", "foo"),
-                 ("\"\\\"\"", "\""),
-                 ("\"\\b\"", "\x08"),
-                 ("\"\\n\"", "\n"),
-                 ("\"\\r\"", "\r"),
-                 ("\"\\t\"", "\t"),
-                 ("\"\\u12ab\"", "\u{12ab}"),
-                 ("\"\\uAB12\"", "\u{AB12}")];
-
-        for &(i, o) in s.iter() {
-            let v: string::String = super::decode(i).unwrap();
-            assert_eq!(v, o);
-        }
-    }
-
-    #[test]
-    fn test_read_array() {
-        assert_eq!(Json::from_str("["),     Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
-        assert_eq!(Json::from_str("[1"),    Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
-        assert_eq!(Json::from_str("[1,"),   Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
-        assert_eq!(Json::from_str("[1,]"),  Err(SyntaxError(InvalidSyntax,        1, 4)));
-        assert_eq!(Json::from_str("[6 7]"), Err(SyntaxError(InvalidSyntax,        1, 4)));
-
-        assert_eq!(Json::from_str("[]"), Ok(Array(vec![])));
-        assert_eq!(Json::from_str("[ ]"), Ok(Array(vec![])));
-        assert_eq!(Json::from_str("[true]"), Ok(Array(vec![Boolean(true)])));
-        assert_eq!(Json::from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
-        assert_eq!(Json::from_str("[null]"), Ok(Array(vec![Null])));
-        assert_eq!(Json::from_str("[3, 1]"),
-                     Ok(Array(vec![U64(3), U64(1)])));
-        assert_eq!(Json::from_str("\n[3, 2]\n"),
-                     Ok(Array(vec![U64(3), U64(2)])));
-        assert_eq!(Json::from_str("[2, [4, 1]]"),
-               Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
-    }
-
-    #[test]
-    fn test_decode_array() {
-        let v: Vec<()> = super::decode("[]").unwrap();
-        assert_eq!(v, vec![]);
-
-        let v: Vec<()> = super::decode("[null]").unwrap();
-        assert_eq!(v, vec![()]);
-
-        let v: Vec<bool> = super::decode("[true]").unwrap();
-        assert_eq!(v, vec![true]);
-
-        let v: Vec<isize> = super::decode("[3, 1]").unwrap();
-        assert_eq!(v, vec![3, 1]);
-
-        let v: Vec<Vec<usize>> = super::decode("[[3], [1, 2]]").unwrap();
-        assert_eq!(v, vec![vec![3], vec![1, 2]]);
-    }
-
-    #[test]
-    fn test_decode_tuple() {
-        let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap();
-        assert_eq!(t, (1, 2, 3));
-
-        let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap();
-        assert_eq!(t, (1, "two".to_string()));
-    }
-
-    #[test]
-    fn test_decode_tuple_malformed_types() {
-        assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err());
-    }
-
-    #[test]
-    fn test_decode_tuple_malformed_length() {
-        assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err());
-    }
-
-    #[test]
-    fn test_read_object() {
-        assert_eq!(Json::from_str("{"),       Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
-        assert_eq!(Json::from_str("{ "),      Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
-        assert_eq!(Json::from_str("{1"),      Err(SyntaxError(KeyMustBeAString,      1, 2)));
-        assert_eq!(Json::from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
-        assert_eq!(Json::from_str("{\"a\""),  Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
-        assert_eq!(Json::from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
-        assert_eq!(Json::from_str("{\"a\" 1"),   Err(SyntaxError(ExpectedColon,         1, 6)));
-        assert_eq!(Json::from_str("{\"a\":"),    Err(SyntaxError(EOFWhileParsingValue,  1, 6)));
-        assert_eq!(Json::from_str("{\"a\":1"),   Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
-        assert_eq!(Json::from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax,         1, 8)));
-        assert_eq!(Json::from_str("{\"a\":1,"),  Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
-
-        assert_eq!(Json::from_str("{}").unwrap(), mk_object(&[]));
-        assert_eq!(Json::from_str("{\"a\": 3}").unwrap(),
-                  mk_object(&[("a".to_string(), U64(3))]));
-
-        assert_eq!(Json::from_str(
-                      "{ \"a\": null, \"b\" : true }").unwrap(),
-                  mk_object(&[
-                      ("a".to_string(), Null),
-                      ("b".to_string(), Boolean(true))]));
-        assert_eq!(Json::from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
-                  mk_object(&[
-                      ("a".to_string(), Null),
-                      ("b".to_string(), Boolean(true))]));
-        assert_eq!(Json::from_str(
-                      "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
-                  mk_object(&[
-                      ("a".to_string(), F64(1.0)),
-                      ("b".to_string(), Array(vec![Boolean(true)]))
-                  ]));
-        assert_eq!(Json::from_str(
-                      "{\
-                          \"a\": 1.0, \
-                          \"b\": [\
-                              true,\
-                              \"foo\\nbar\", \
-                              { \"c\": {\"d\": null} } \
-                          ]\
-                      }").unwrap(),
-                  mk_object(&[
-                      ("a".to_string(), F64(1.0)),
-                      ("b".to_string(), Array(vec![
-                          Boolean(true),
-                          String("foo\nbar".to_string()),
-                          mk_object(&[
-                              ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
-                          ])
-                      ]))
-                  ]));
-    }
-
-    #[test]
-    fn test_decode_struct() {
-        let s = "{
-            \"inner\": [
-                { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
-            ]
-        }";
-
-        let v: Outer = super::decode(s).unwrap();
-        assert_eq!(
-            v,
-            Outer {
-                inner: vec![
-                    Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
-                ]
-            }
-        );
-    }
-
-    #[derive(RustcDecodable)]
-    struct FloatStruct {
-        f: f64,
-        a: Vec<f64>
-    }
-    #[test]
-    fn test_decode_struct_with_nan() {
-        let s = "{\"f\":null,\"a\":[null,123]}";
-        let obj: FloatStruct = super::decode(s).unwrap();
-        assert!(obj.f.is_nan());
-        assert!(obj.a[0].is_nan());
-        assert_eq!(obj.a[1], 123f64);
-    }
-
-    #[test]
-    fn test_decode_option() {
-        let value: Option<string::String> = super::decode("null").unwrap();
-        assert_eq!(value, None);
-
-        let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
-        assert_eq!(value, Some("jodhpurs".to_string()));
-    }
-
-    #[test]
-    fn test_decode_enum() {
-        let value: Animal = super::decode("\"Dog\"").unwrap();
-        assert_eq!(value, Dog);
-
-        let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
-        let value: Animal = super::decode(s).unwrap();
-        assert_eq!(value, Frog("Henry".to_string(), 349));
-    }
-
-    #[test]
-    fn test_decode_result() {
-        let value: Result<i32, i8> = Ok(4);
-        let json_value = super::encode(&value).unwrap();
-        assert_eq!(json_value, "{\"variant\":\"Ok\",\"fields\":[4]}");
-        let decoded_value: Result<i32, i8> = super::decode(&json_value).unwrap();
-        assert_eq!(decoded_value, Ok(4));
-    }
-
-    #[test]
-    fn test_decode_map() {
-        let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
-                  \"fields\":[\"Henry\", 349]}}";
-        let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
-
-        assert_eq!(map.remove(&"a".to_string()), Some(Dog));
-        assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
-    }
-
-    #[test]
-    fn test_multiline_errors() {
-        assert_eq!(Json::from_str("{\n  \"foo\":\n \"bar\""),
-            Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
-    }
-
-    #[derive(RustcDecodable)]
-    #[allow(dead_code)]
-    struct DecodeStruct {
-        x: f64,
-        y: bool,
-        z: string::String,
-        w: Vec<DecodeStruct>
-    }
-    #[derive(RustcDecodable)]
-    enum DecodeEnum {
-        A(f64),
-        B(string::String)
-    }
-    fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
-        let res: DecodeResult<T> = match Json::from_str(to_parse) {
-            Err(e) => Err(ParseError(e)),
-            Ok(json) => Decodable::decode(&mut Decoder::new(json))
-        };
-        match res {
-            Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
-                              to_parse, expected),
-            Err(ParseError(e)) => panic!("`{}` is not valid json: {:?}",
-                                           to_parse, e),
-            Err(e) => {
-                assert_eq!(e, expected);
-            }
-        }
-    }
-    #[test]
-    fn test_decode_errors_struct() {
-        check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
-        check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
-                                  ExpectedError("Number".to_string(), "true".to_string()));
-        check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
-                                  ExpectedError("Boolean".to_string(), "[]".to_string()));
-        check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
-                                  ExpectedError("String".to_string(), "{}".to_string()));
-        check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
-                                  ExpectedError("Array".to_string(), "null".to_string()));
-        check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
-                                  MissingFieldError("w".to_string()));
-    }
-    #[test]
-    fn test_decode_errors_enum() {
-        check_err::<DecodeEnum>("{}",
-                                MissingFieldError("variant".to_string()));
-        check_err::<DecodeEnum>("{\"variant\": 1}",
-                                ExpectedError("String".to_string(), "1".to_string()));
-        check_err::<DecodeEnum>("{\"variant\": \"A\"}",
-                                MissingFieldError("fields".to_string()));
-        check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
-                                ExpectedError("Array".to_string(), "null".to_string()));
-        check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
-                                UnknownVariantError("C".to_string()));
-    }
-
-    #[test]
-    fn test_find(){
-        let json_value = Json::from_str("{\"dog\" : \"cat\"}").unwrap();
-        let found_str = json_value.find("dog");
-        assert!(found_str.unwrap().as_string().unwrap() == "cat");
-    }
-
-    #[test]
-    fn test_find_path(){
-        let json_value = Json::from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
-        let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
-        assert!(found_str.unwrap().as_string().unwrap() == "cheese");
-    }
-
-    #[test]
-    fn test_search(){
-        let json_value = Json::from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
-        let found_str = json_value.search("mouse").and_then(|j| j.as_string());
-        assert!(found_str.unwrap() == "cheese");
-    }
-
-    #[test]
-    fn test_index(){
-        let json_value = Json::from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
-        let ref array = json_value["animals"];
-        assert_eq!(array[0].as_string().unwrap(), "dog");
-        assert_eq!(array[1].as_string().unwrap(), "cat");
-        assert_eq!(array[2].as_string().unwrap(), "mouse");
-    }
-
-    #[test]
-    fn test_is_object(){
-        let json_value = Json::from_str("{}").unwrap();
-        assert!(json_value.is_object());
-    }
-
-    #[test]
-    fn test_as_object(){
-        let json_value = Json::from_str("{}").unwrap();
-        let json_object = json_value.as_object();
-        assert!(json_object.is_some());
-    }
-
-    #[test]
-    fn test_is_array(){
-        let json_value = Json::from_str("[1, 2, 3]").unwrap();
-        assert!(json_value.is_array());
-    }
-
-    #[test]
-    fn test_as_array(){
-        let json_value = Json::from_str("[1, 2, 3]").unwrap();
-        let json_array = json_value.as_array();
-        let expected_length = 3;
-        assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
-    }
-
-    #[test]
-    fn test_is_string(){
-        let json_value = Json::from_str("\"dog\"").unwrap();
-        assert!(json_value.is_string());
-    }
-
-    #[test]
-    fn test_as_string(){
-        let json_value = Json::from_str("\"dog\"").unwrap();
-        let json_str = json_value.as_string();
-        let expected_str = "dog";
-        assert_eq!(json_str, Some(expected_str));
-    }
-
-    #[test]
-    fn test_is_number(){
-        let json_value = Json::from_str("12").unwrap();
-        assert!(json_value.is_number());
-    }
-
-    #[test]
-    fn test_is_i64(){
-        let json_value = Json::from_str("-12").unwrap();
-        assert!(json_value.is_i64());
-
-        let json_value = Json::from_str("12").unwrap();
-        assert!(!json_value.is_i64());
-
-        let json_value = Json::from_str("12.0").unwrap();
-        assert!(!json_value.is_i64());
-    }
-
-    #[test]
-    fn test_is_u64(){
-        let json_value = Json::from_str("12").unwrap();
-        assert!(json_value.is_u64());
-
-        let json_value = Json::from_str("-12").unwrap();
-        assert!(!json_value.is_u64());
-
-        let json_value = Json::from_str("12.0").unwrap();
-        assert!(!json_value.is_u64());
-    }
-
-    #[test]
-    fn test_is_f64(){
-        let json_value = Json::from_str("12").unwrap();
-        assert!(!json_value.is_f64());
-
-        let json_value = Json::from_str("-12").unwrap();
-        assert!(!json_value.is_f64());
-
-        let json_value = Json::from_str("12.0").unwrap();
-        assert!(json_value.is_f64());
-
-        let json_value = Json::from_str("-12.0").unwrap();
-        assert!(json_value.is_f64());
-    }
-
-    #[test]
-    fn test_as_i64(){
-        let json_value = Json::from_str("-12").unwrap();
-        let json_num = json_value.as_i64();
-        assert_eq!(json_num, Some(-12));
-    }
-
-    #[test]
-    fn test_as_u64(){
-        let json_value = Json::from_str("12").unwrap();
-        let json_num = json_value.as_u64();
-        assert_eq!(json_num, Some(12));
-    }
-
-    #[test]
-    fn test_as_f64(){
-        let json_value = Json::from_str("12.0").unwrap();
-        let json_num = json_value.as_f64();
-        assert_eq!(json_num, Some(12f64));
-    }
-
-    #[test]
-    fn test_is_boolean(){
-        let json_value = Json::from_str("false").unwrap();
-        assert!(json_value.is_boolean());
-    }
-
-    #[test]
-    fn test_as_boolean(){
-        let json_value = Json::from_str("false").unwrap();
-        let json_bool = json_value.as_boolean();
-        let expected_bool = false;
-        assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
-    }
-
-    #[test]
-    fn test_is_null(){
-        let json_value = Json::from_str("null").unwrap();
-        assert!(json_value.is_null());
-    }
-
-    #[test]
-    fn test_as_null(){
-        let json_value = Json::from_str("null").unwrap();
-        let json_null = json_value.as_null();
-        let expected_null = ();
-        assert!(json_null.is_some() && json_null.unwrap() == expected_null);
-    }
-
-    #[test]
-    fn test_encode_hashmap_with_numeric_key() {
-        use std::collections::HashMap;
-        let mut hm: HashMap<usize, bool> = HashMap::new();
-        hm.insert(1, true);
-        let json_str = super::as_pretty_json(&hm).to_string();
-        match Json::from_str(&json_str) {
-            Err(_) => panic!("Unable to parse json_str: {}", json_str),
-            _ => {} // it parsed and we are good to go
-        }
-    }
-
-    #[test]
-    fn test_negative_zero() {
-        Json::from_str("{\"test\":-0}").unwrap();
-    }
-
-    #[test]
-    fn test_prettyencode_hashmap_with_numeric_key() {
-        use std::collections::HashMap;
-        let mut hm: HashMap<usize, bool> = HashMap::new();
-        hm.insert(1, true);
-        let json_str = super::as_pretty_json(&hm).to_string();
-        match Json::from_str(&json_str) {
-            Err(_) => panic!("Unable to parse json_str: {}", json_str),
-            _ => {} // it parsed and we are good to go
-        }
-    }
-
-    #[test]
-    fn test_prettyencoder_indent_level_param() {
-        use std::collections::BTreeMap;
-
-        let mut tree = BTreeMap::new();
-
-        tree.insert("hello".to_string(), String("guten tag".to_string()));
-        tree.insert("goodbye".to_string(), String("sayonara".to_string()));
-
-        let json = Array(
-            // The following layout below should look a lot like
-            // the pretty-printed JSON (indent * x)
-            vec!
-            ( // 0x
-                String("greetings".to_string()), // 1x
-                Object(tree), // 1x + 2x + 2x + 1x
-            ) // 0x
-            // End JSON array (7 lines)
-        );
-
-        // Helper function for counting indents
-        fn indents(source: &str) -> usize {
-            let trimmed = source.trim_left_matches(' ');
-            source.len() - trimmed.len()
-        }
-
-        // Test up to 4 spaces of indents (more?)
-        for i in 0..4 {
-            let printed = super::as_pretty_json(&json).indent(i as u32)
-                                .to_string();
-
-            // Check for indents at each line
-            let lines: Vec<&str> = printed.lines().collect();
-            assert_eq!(lines.len(), 7); // JSON should be 7 lines
-
-            assert_eq!(indents(lines[0]), 0 * i); // [
-            assert_eq!(indents(lines[1]), 1 * i); //   "greetings",
-            assert_eq!(indents(lines[2]), 1 * i); //   {
-            assert_eq!(indents(lines[3]), 2 * i); //     "hello": "guten tag",
-            assert_eq!(indents(lines[4]), 2 * i); //     "goodbye": "sayonara"
-            assert_eq!(indents(lines[5]), 1 * i); //   },
-            assert_eq!(indents(lines[6]), 0 * i); // ]
-
-            // Finally, test that the pretty-printed JSON is valid
-            Json::from_str(&printed).ok()
-                 .expect("Pretty-printed JSON is invalid!");
-        }
-    }
-
-    #[test]
-    fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
-        use std::collections::HashMap;
-        use Decodable;
-        let json_str = "{\"1\":true}";
-        let json_obj = match Json::from_str(json_str) {
-            Err(_) => panic!("Unable to parse json_str: {}", json_str),
-            Ok(o) => o
-        };
-        let mut decoder = Decoder::new(json_obj);
-        let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
-    }
-
-    #[test]
-    fn test_hashmap_with_enum_key() {
-        use std::collections::HashMap;
-        use json;
-        #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)]
-        enum Enum {
-            Foo,
-            #[allow(dead_code)]
-            Bar,
-        }
-        let mut map = HashMap::new();
-        map.insert(Enum::Foo, 0);
-        let result = json::encode(&map).unwrap();
-        assert_eq!(result, r#"{"Foo":0}"#);
-        let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
-        assert_eq!(map, decoded);
-    }
-
-    #[test]
-    fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
-        use std::collections::HashMap;
-        use Decodable;
-        let json_str = "{\"a\":true}";
-        let json_obj = match Json::from_str(json_str) {
-            Err(_) => panic!("Unable to parse json_str: {}", json_str),
-            Ok(o) => o
-        };
-        let mut decoder = Decoder::new(json_obj);
-        let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
-        assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
-    }
-
-    fn assert_stream_equal(src: &str,
-                           expected: Vec<(JsonEvent, Vec<StackElement>)>) {
-        let mut parser = Parser::new(src.chars());
-        let mut i = 0;
-        loop {
-            let evt = match parser.next() {
-                Some(e) => e,
-                None => { break; }
-            };
-            let (ref expected_evt, ref expected_stack) = expected[i];
-            if !parser.stack().is_equal_to(&expected_stack) {
-                panic!("Parser stack is not equal to {:?}", expected_stack);
-            }
-            assert_eq!(&evt, expected_evt);
-            i+=1;
-        }
-    }
-    #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
-    fn test_streaming_parser() {
-        assert_stream_equal(
-            r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
-            vec![
-                (ObjectStart,             vec![]),
-                  (StringValue("bar".to_string()),   vec![Key("foo")]),
-                  (ArrayStart,            vec![Key("array")]),
-                    (U64Value(0),         vec![Key("array"), Index(0)]),
-                    (U64Value(1),         vec![Key("array"), Index(1)]),
-                    (U64Value(2),         vec![Key("array"), Index(2)]),
-                    (U64Value(3),         vec![Key("array"), Index(3)]),
-                    (U64Value(4),         vec![Key("array"), Index(4)]),
-                    (U64Value(5),         vec![Key("array"), Index(5)]),
-                  (ArrayEnd,              vec![Key("array")]),
-                  (ArrayStart,            vec![Key("idents")]),
-                    (NullValue,           vec![Key("idents"), Index(0)]),
-                    (BooleanValue(true),  vec![Key("idents"), Index(1)]),
-                    (BooleanValue(false), vec![Key("idents"), Index(2)]),
-                  (ArrayEnd,              vec![Key("idents")]),
-                (ObjectEnd,               vec![]),
-            ]
-        );
-    }
-    fn last_event(src: &str) -> JsonEvent {
-        let mut parser = Parser::new(src.chars());
-        let mut evt = NullValue;
-        loop {
-            evt = match parser.next() {
-                Some(e) => e,
-                None => return evt,
-            }
-        }
-    }
-
-    #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
-    fn test_read_object_streaming() {
-        assert_eq!(last_event("{ "),      Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
-        assert_eq!(last_event("{1"),      Error(SyntaxError(KeyMustBeAString,      1, 2)));
-        assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
-        assert_eq!(last_event("{\"a\""),  Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
-        assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
-        assert_eq!(last_event("{\"a\" 1"),   Error(SyntaxError(ExpectedColon,         1, 6)));
-        assert_eq!(last_event("{\"a\":"),    Error(SyntaxError(EOFWhileParsingValue,  1, 6)));
-        assert_eq!(last_event("{\"a\":1"),   Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
-        assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax,         1, 8)));
-        assert_eq!(last_event("{\"a\":1,"),  Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
-        assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
-
-        assert_stream_equal(
-            "{}",
-            vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
-        );
-        assert_stream_equal(
-            "{\"a\": 3}",
-            vec![
-                (ObjectStart,        vec![]),
-                  (U64Value(3),      vec![Key("a")]),
-                (ObjectEnd,          vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "{ \"a\": null, \"b\" : true }",
-            vec![
-                (ObjectStart,           vec![]),
-                  (NullValue,           vec![Key("a")]),
-                  (BooleanValue(true),  vec![Key("b")]),
-                (ObjectEnd,             vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "{\"a\" : 1.0 ,\"b\": [ true ]}",
-            vec![
-                (ObjectStart,           vec![]),
-                  (F64Value(1.0),       vec![Key("a")]),
-                  (ArrayStart,          vec![Key("b")]),
-                    (BooleanValue(true),vec![Key("b"), Index(0)]),
-                  (ArrayEnd,            vec![Key("b")]),
-                (ObjectEnd,             vec![]),
-            ]
-        );
-        assert_stream_equal(
-            r#"{
-                "a": 1.0,
-                "b": [
-                    true,
-                    "foo\nbar",
-                    { "c": {"d": null} },
-                    "\uD834\uDF06"
-                ]
-            }"#,
-            vec![
-                (ObjectStart,                   vec![]),
-                  (F64Value(1.0),               vec![Key("a")]),
-                  (ArrayStart,                  vec![Key("b")]),
-                    (BooleanValue(true),        vec![Key("b"), Index(0)]),
-                    (StringValue("foo\nbar".to_string()),  vec![Key("b"), Index(1)]),
-                    (ObjectStart,               vec![Key("b"), Index(2)]),
-                      (ObjectStart,             vec![Key("b"), Index(2), Key("c")]),
-                        (NullValue,             vec![Key("b"), Index(2), Key("c"), Key("d")]),
-                      (ObjectEnd,               vec![Key("b"), Index(2), Key("c")]),
-                    (ObjectEnd,                 vec![Key("b"), Index(2)]),
-                    (StringValue("\u{1D306}".to_string()),  vec![Key("b"), Index(3)]),
-                  (ArrayEnd,                    vec![Key("b")]),
-                (ObjectEnd,                     vec![]),
-            ]
-        );
-    }
-    #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
-    fn test_read_array_streaming() {
-        assert_stream_equal(
-            "[]",
-            vec![
-                (ArrayStart, vec![]),
-                (ArrayEnd,   vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[ ]",
-            vec![
-                (ArrayStart, vec![]),
-                (ArrayEnd,   vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[true]",
-            vec![
-                (ArrayStart,             vec![]),
-                    (BooleanValue(true), vec![Index(0)]),
-                (ArrayEnd,               vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[ false ]",
-            vec![
-                (ArrayStart,              vec![]),
-                    (BooleanValue(false), vec![Index(0)]),
-                (ArrayEnd,                vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[null]",
-            vec![
-                (ArrayStart,    vec![]),
-                    (NullValue, vec![Index(0)]),
-                (ArrayEnd,      vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[3, 1]",
-            vec![
-                (ArrayStart,      vec![]),
-                    (U64Value(3), vec![Index(0)]),
-                    (U64Value(1), vec![Index(1)]),
-                (ArrayEnd,        vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "\n[3, 2]\n",
-            vec![
-                (ArrayStart,      vec![]),
-                    (U64Value(3), vec![Index(0)]),
-                    (U64Value(2), vec![Index(1)]),
-                (ArrayEnd,        vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[2, [4, 1]]",
-            vec![
-                (ArrayStart,           vec![]),
-                    (U64Value(2),      vec![Index(0)]),
-                    (ArrayStart,       vec![Index(1)]),
-                        (U64Value(4),  vec![Index(1), Index(0)]),
-                        (U64Value(1),  vec![Index(1), Index(1)]),
-                    (ArrayEnd,         vec![Index(1)]),
-                (ArrayEnd,             vec![]),
-            ]
-        );
-
-        assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1,  2)));
-
-        assert_eq!(Json::from_str("["),     Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
-        assert_eq!(Json::from_str("[1"),    Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
-        assert_eq!(Json::from_str("[1,"),   Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
-        assert_eq!(Json::from_str("[1,]"),  Err(SyntaxError(InvalidSyntax,        1, 4)));
-        assert_eq!(Json::from_str("[6 7]"), Err(SyntaxError(InvalidSyntax,        1, 4)));
-
-    }
-    #[test]
-    fn test_trailing_characters_streaming() {
-        assert_eq!(last_event("nulla"),  Error(SyntaxError(TrailingCharacters, 1, 5)));
-        assert_eq!(last_event("truea"),  Error(SyntaxError(TrailingCharacters, 1, 5)));
-        assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
-        assert_eq!(last_event("1a"),     Error(SyntaxError(TrailingCharacters, 1, 2)));
-        assert_eq!(last_event("[]a"),    Error(SyntaxError(TrailingCharacters, 1, 3)));
-        assert_eq!(last_event("{}a"),    Error(SyntaxError(TrailingCharacters, 1, 3)));
-    }
-    #[test]
-    fn test_read_identifiers_streaming() {
-        assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
-        assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
-        assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
-
-        assert_eq!(last_event("n"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(last_event("nul"),  Error(SyntaxError(InvalidSyntax, 1, 4)));
-        assert_eq!(last_event("t"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
-        assert_eq!(last_event("f"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(last_event("faz"),  Error(SyntaxError(InvalidSyntax, 1, 3)));
-    }
-
-    #[test]
-    fn test_stack() {
-        let mut stack = Stack::new();
-
-        assert!(stack.is_empty());
-        assert!(stack.len() == 0);
-        assert!(!stack.last_is_index());
-
-        stack.push_index(0);
-        stack.bump_index();
-
-        assert!(stack.len() == 1);
-        assert!(stack.is_equal_to(&[Index(1)]));
-        assert!(stack.starts_with(&[Index(1)]));
-        assert!(stack.ends_with(&[Index(1)]));
-        assert!(stack.last_is_index());
-        assert!(stack.get(0) == Index(1));
-
-        stack.push_key("foo".to_string());
-
-        assert!(stack.len() == 2);
-        assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1)]));
-        assert!(stack.ends_with(&[Index(1), Key("foo")]));
-        assert!(stack.ends_with(&[Key("foo")]));
-        assert!(!stack.last_is_index());
-        assert!(stack.get(0) == Index(1));
-        assert!(stack.get(1) == Key("foo"));
-
-        stack.push_key("bar".to_string());
-
-        assert!(stack.len() == 3);
-        assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")]));
-        assert!(stack.starts_with(&[Index(1)]));
-        assert!(stack.starts_with(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1), Key("foo"), Key("bar")]));
-        assert!(stack.ends_with(&[Key("bar")]));
-        assert!(stack.ends_with(&[Key("foo"), Key("bar")]));
-        assert!(stack.ends_with(&[Index(1), Key("foo"), Key("bar")]));
-        assert!(!stack.last_is_index());
-        assert!(stack.get(0) == Index(1));
-        assert!(stack.get(1) == Key("foo"));
-        assert!(stack.get(2) == Key("bar"));
-
-        stack.pop();
-
-        assert!(stack.len() == 2);
-        assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1)]));
-        assert!(stack.ends_with(&[Index(1), Key("foo")]));
-        assert!(stack.ends_with(&[Key("foo")]));
-        assert!(!stack.last_is_index());
-        assert!(stack.get(0) == Index(1));
-        assert!(stack.get(1) == Key("foo"));
-    }
-
-    #[test]
-    fn test_to_json() {
-        use std::collections::{HashMap,BTreeMap};
-        use super::ToJson;
-
-        let array2 = Array(vec!(I64(1), I64(2)));
-        let array3 = Array(vec!(I64(1), I64(2), I64(3)));
-        let object = {
-            let mut tree_map = BTreeMap::new();
-            tree_map.insert("a".to_string(), U64(1));
-            tree_map.insert("b".to_string(), U64(2));
-            Object(tree_map)
-        };
-
-        assert_eq!(array2.to_json(), array2);
-        assert_eq!(object.to_json(), object);
-        assert_eq!(3_isize.to_json(), I64(3));
-        assert_eq!(4_i8.to_json(), I64(4));
-        assert_eq!(5_i16.to_json(), I64(5));
-        assert_eq!(6_i32.to_json(), I64(6));
-        assert_eq!(7_i64.to_json(), I64(7));
-        assert_eq!(8_usize.to_json(), U64(8));
-        assert_eq!(9_u8.to_json(), U64(9));
-        assert_eq!(10_u16.to_json(), U64(10));
-        assert_eq!(11_u32.to_json(), U64(11));
-        assert_eq!(12_u64.to_json(), U64(12));
-        assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
-        assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
-        assert_eq!(().to_json(), Null);
-        assert_eq!(f32::INFINITY.to_json(), Null);
-        assert_eq!(f64::NAN.to_json(), Null);
-        assert_eq!(true.to_json(), Boolean(true));
-        assert_eq!(false.to_json(), Boolean(false));
-        assert_eq!("abc".to_json(), String("abc".to_string()));
-        assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
-        assert_eq!((1, 2).to_json(), array2);
-        assert_eq!((1, 2, 3).to_json(), array3);
-        assert_eq!([1, 2].to_json(), array2);
-        assert_eq!((&[1, 2, 3]).to_json(), array3);
-        assert_eq!((vec![1, 2]).to_json(), array2);
-        assert_eq!(vec!(1, 2, 3).to_json(), array3);
-        let mut tree_map = BTreeMap::new();
-        tree_map.insert("a".to_string(), 1 as u32);
-        tree_map.insert("b".to_string(), 2);
-        assert_eq!(tree_map.to_json(), object);
-        let mut hash_map = HashMap::new();
-        hash_map.insert("a".to_string(), 1 as u32);
-        hash_map.insert("b".to_string(), 2);
-        assert_eq!(hash_map.to_json(), object);
-        assert_eq!(Some(15).to_json(), I64(15));
-        assert_eq!(Some(15 as u32).to_json(), U64(15));
-        assert_eq!(None::<isize>.to_json(), Null);
-    }
-
-    #[test]
-    fn test_encode_hashmap_with_arbitrary_key() {
-        use std::collections::HashMap;
-        #[derive(PartialEq, Eq, Hash, RustcEncodable)]
-        struct ArbitraryType(u32);
-        let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
-        hm.insert(ArbitraryType(1), true);
-        let mut mem_buf = string::String::new();
-        let mut encoder = Encoder::new(&mut mem_buf);
-        let result = hm.encode(&mut encoder);
-        match result.err().unwrap() {
-            EncoderError::BadHashmapKey => (),
-            _ => panic!("expected bad hash map key")
-        }
-    }
-
-    #[test]
-    fn test_encode_decode_phantom_data() {
-        use std::marker::PhantomData;
-
-        #[derive(Debug, RustcDecodable, RustcEncodable, Eq, PartialEq)]
-        struct Foo<P> {
-            phantom_data: PhantomData<P>
-        }
-
-        let f: Foo<u8> = Foo {
-            phantom_data: PhantomData
-        };
-        let s = super::encode(&f).unwrap();
-        let d: Foo<u8> = super::decode(&s).unwrap();
-        assert_eq!(f, d);
-    }
-
-    #[test]
-    fn test_bad_json_stack_depleted() {
-        use json;
-        #[derive(Debug, RustcDecodable)]
-        enum ChatEvent {
-            Variant(i32)
-        }
-        let serialized = "{\"variant\": \"Variant\", \"fields\": []}";
-        let r: Result<ChatEvent, _> = json::decode(serialized);
-        assert!(r.unwrap_err() == EOF);
-    }
-
-    #[test]
-    fn fixed_length_array() {
-        #[derive(Debug, RustcDecodable, RustcEncodable, Eq, PartialEq)]
-        struct Foo {
-            a: [u8; 1],
-            b: [i32; 2],
-            c: [u64; 3],
-        }
-        let f = Foo {
-            a: [0],
-            b: [1, 2],
-            c: [3, 4, 5],
-        };
-        let s = super::encode(&f).unwrap();
-        let d = super::decode(&s).unwrap();
-        assert_eq!(f, d);
-    }
-
-    #[test]
-    fn test_unexpected_token() {
-        match Json::from_str("{\"\":\"\",\"\":{\"\":\"\",\"\":[{\"\":\"\",}}}") {
-            Err(e) => assert_eq!(e, SyntaxError(InvalidSyntax, 1, 32)),
-            _ => ()
-        };
-    }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/lib.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Support code for encoding and decoding types.
-//!
-//! > **NOTE**: This crate is deprecated in favor of [`serde`]. No new feature
-//! > development will happen in this crate, although bug fixes proposed through
-//! > PRs will still be merged. It is very highly recommended by the Rust
-//! > Library Team that you use [`serde`], not this crate.
-//!
-//! [`serde`]: https://serde.rs
-//!
-//! # Usage
-//!
-//! This crate is [on crates.io](https://crates.io/crates/rustc-serialize) and
-//! can be used by adding `rustc-serialize` to the dependencies in your
-//! project's `Cargo.toml`.
-//!
-//! ```toml
-//! [dependencies]
-//! rustc-serialize = "0.3"
-//! ```
-//!
-//! and this to your crate root:
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! ```
-
-#![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
-#![cfg_attr(rustbuild, unstable(feature = "rustc_private", issue = "27812"))]
-
-#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
-       html_favicon_url = "https://www.rust-lang.org/favicon.ico",
-       html_root_url = "https://doc.rust-lang.org/rustc-serialize/")]
-#![cfg_attr(test, deny(warnings))]
-#![allow(trivial_numeric_casts)]
-#![cfg_attr(rust_build, feature(staged_api))]
-#![cfg_attr(rust_build, staged_api)]
-#![cfg_attr(rust_build,
-            unstable(feature = "rustc_private",
-                     reason = "use the crates.io `rustc-serialize` library instead"))]
-
-#[cfg(test)] extern crate rand;
-
-pub use self::serialize::{Decoder, Encoder, Decodable, Encodable,
-                          DecoderHelpers, EncoderHelpers};
-
-
-// Limit collections from allocating more than
-// 1 MB for calls to `with_capacity`.
-fn cap_capacity<T>(given_len: usize) -> usize {
-    use std::cmp::min;
-    use std::mem::size_of;
-    const PRE_ALLOCATE_CAP: usize = 0x100000;
-
-    match size_of::<T>() {
-        0 => min(given_len, PRE_ALLOCATE_CAP),
-        n => min(given_len, PRE_ALLOCATE_CAP / n)
-    }
-}
-
-mod serialize;
-mod collection_impls;
-
-pub mod base64;
-pub mod hex;
-pub mod json;
-
-mod rustc_serialize {
-    pub use serialize::*;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/serialize.rs
+++ /dev/null
@@ -1,1671 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Support code for encoding and decoding types.
-//!
-//! In order to allow extensibility in both what types can be encoded and how
-//! they are encoded, encoding and decoding are split into two part each. An
-//! implementation of the Encodable trait knows how to turn a specific type into
-//! a generic form, and then uses an implementation of the Encoder trait to turn
-//! this into concrete output (such as a JSON string). Decoder and Decodable do
-//! the same for decoding.
-
-/*
-Core encoding and decoding interfaces.
-*/
-
-use std::cell::{Cell, RefCell};
-use std::ffi::OsString;
-use std::path;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::marker::PhantomData;
-use std::borrow::Cow;
-
-use cap_capacity;
-
-/// Trait for writing out an encoding when serializing.
-///
-/// This trait provides methods to encode basic types and generic forms of
-/// collections.  Implementations of `Encodable` use it to perform the actual
-/// encoding of a type.
-///
-/// It is unspecified what is done with the encoding - it could be stored in a
-/// variable, or written directly to a file, for example.
-///
-/// Encoders can expect to only have a single "root" method call made on this
-/// trait. Non-trivial types will call one of the collection-emitting methods,
-/// passing a function that may call other methods on the trait, but once the
-/// collection-emitting method has returned, encoding should be complete.
-pub trait Encoder {
-    /// The error type for method results.
-    type Error;
-
-    // Primitive types:
-    /// Emit a nil value.
-    ///
-    /// For example, this might be stored as the null keyword in JSON.
-    fn emit_nil(&mut self) -> Result<(), Self::Error>;
-
-    /// Emit a usize value.
-    fn emit_usize(&mut self, v: usize) -> Result<(), Self::Error>;
-
-    /// Emit a u64 value.
-    fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
-
-    /// Emit a u32 value.
-    fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
-
-    /// Emit a u16 value.
-    fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
-
-    /// Emit a u8 value.
-    fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;
-
-    /// Emit a isize value.
-    fn emit_isize(&mut self, v: isize) -> Result<(), Self::Error>;
-
-    /// Emit a i64 value.
-    fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
-
-    /// Emit a i32 value.
-    fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
-
-    /// Emit a i16 value.
-    fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
-
-    /// Emit a i8 value.
-    fn emit_i8(&mut self, v: i8) -> Result<(), Self::Error>;
-
-    /// Emit a bool value.
-    ///
-    /// For example, this might be stored as the true and false keywords in
-    /// JSON.
-    fn emit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
-
-    /// Emit a f64 value.
-    fn emit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
-
-    /// Emit a f32 value.
-    fn emit_f32(&mut self, v: f32) -> Result<(), Self::Error>;
-
-    /// Emit a char value.
-    ///
-    /// Note that strings should be emitted using `emit_str`, not as a sequence
-    /// of `emit_char` calls.
-    fn emit_char(&mut self, v: char) -> Result<(), Self::Error>;
-
-    /// Emit a string value.
-    fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>;
-
-    // Compound types:
-    /// Emit an enumeration value.
-    ///
-    /// * `name` indicates the enumeration type name.
-    /// * `f` is a function that will call `emit_enum_variant` or
-    ///   `emit_enum_struct_variant` as appropriate to write the actual value.
-    fn emit_enum<F>(&mut self, name: &str, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a enumeration variant value with no or unnamed data.
-    ///
-    /// This should only be called from a function passed to `emit_enum`.
-    /// Variants with named data should use `emit_enum_struct_variant`.
-    ///
-    /// * `v_name` is the variant name
-    /// * `v_id` is the numeric identifier for the variant.
-    /// * `len` is the number of data items associated with the variant.
-    /// * `f` is a function that will call `emit_enum_variant_arg` for each data
-    ///   item. It may not be called if len is 0.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// enum Message {
-    ///     Quit,
-    ///     ChangeColor(i32, i32, i32),
-    /// }
-    ///
-    /// impl Encodable for Message {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_enum("Message", |s| {
-    ///             match *self {
-    ///                 Message::Quit => {
-    ///                     s.emit_enum_variant("Quit", 0, 0, |s| Ok(()))
-    ///                 }
-    ///                 Message::ChangeColor(r, g, b) => {
-    ///                     s.emit_enum_variant("ChangeColor", 1, 3, |s| {
-    ///                         try!(s.emit_enum_variant_arg(0, |s| {
-    ///                             s.emit_i32(r)
-    ///                         }));
-    ///                         try!(s.emit_enum_variant_arg(1, |s| {
-    ///                             s.emit_i32(g)
-    ///                         }));
-    ///                         try!(s.emit_enum_variant_arg(2, |s| {
-    ///                             s.emit_i32(b)
-    ///                         }));
-    ///                         Ok(())
-    ///                     })
-    ///                 }
-    ///             }
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_enum_variant<F>(&mut self, v_name: &str,
-                            v_id: usize,
-                            len: usize,
-                            f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit an unnamed data item for an enumeration variant.
-    ///
-    /// This should only be called from a function passed to
-    /// `emit_enum_variant`.
-    ///
-    /// * `a_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that variant data items must be emitted in order - starting with
-    /// index `0` and finishing with index `len-1`.
-    fn emit_enum_variant_arg<F>(&mut self, a_idx: usize, f: F)
-                                -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a enumeration variant value with no or named data.
-    ///
-    /// This should only be called from a function passed to `emit_enum`.
-    /// Variants with unnamed data should use `emit_enum_variant`.
-    ///
-    /// * `v_name` is the variant name.
-    /// * `v_id` is the numeric identifier for the variant.
-    /// * `len` is the number of data items associated with the variant.
-    /// * `f` is a function that will call `emit_enum_struct_variant_field` for
-    ///   each data item. It may not be called if `len` is `0`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// enum Message {
-    ///     Quit,
-    ///     Move { x: i32, y: i32 },
-    /// }
-    ///
-    /// impl Encodable for Message {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_enum("Message", |s| {
-    ///             match *self {
-    ///                 Message::Quit => {
-    ///                     s.emit_enum_struct_variant("Quit", 0, 0, |s| Ok(()))
-    ///                 }
-    ///                 Message::Move { x: x, y: y } => {
-    ///                     s.emit_enum_struct_variant("Move", 1, 2, |s| {
-    ///                         try!(s.emit_enum_struct_variant_field("x", 0, |s| {
-    ///                             s.emit_i32(x)
-    ///                         }));
-    ///                         try!(s.emit_enum_struct_variant_field("y", 1, |s| {
-    ///                             s.emit_i32(y)
-    ///                         }));
-    ///                         Ok(())
-    ///                     })
-    ///                 }
-    ///             }
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
-                                   v_id: usize,
-                                   len: usize,
-                                   f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a named data item for an enumeration variant.
-    ///
-    /// This should only be called from a function passed to
-    /// `emit_enum_struct_variant`.
-    ///
-    /// * `f_name` is the name of the data item field.
-    /// * `f_idx` is its (zero-based) index.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that fields must be emitted in order - starting with index `0` and
-    /// finishing with index `len-1`.
-    fn emit_enum_struct_variant_field<F>(&mut self,
-                                         f_name: &str,
-                                         f_idx: usize,
-                                         f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a struct value.
-    ///
-    /// * `name` is the name of the struct.
-    /// * `len` is the number of members.
-    /// * `f` is a function that calls `emit_struct_field` for each member.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// struct Point {
-    ///     x: i32,
-    ///     y: i32,
-    /// }
-    ///
-    /// impl Encodable for Point {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_struct("Point", 2, |s| {
-    ///             try!(s.emit_struct_field("x", 0, |s| {
-    ///                 s.emit_i32(self.x)
-    ///             }));
-    ///             try!(s.emit_struct_field("y", 1, |s| {
-    ///                 s.emit_i32(self.y)
-    ///             }));
-    ///             Ok(())
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_struct<F>(&mut self, name: &str, len: usize, f: F)
-                      -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-    /// Emit a field item for a struct.
-    ///
-    /// This should only be called from a function passed to `emit_struct`.
-    ///
-    /// * `f_name` is the name of the data item field.
-    /// * `f_idx` is its (zero-based) index.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that fields must be emitted in order - starting with index `0` and
-    /// finishing with index `len-1`.
-    fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: usize, f: F)
-                            -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a tuple value.
-    ///
-    /// * `len` is the number of items in the tuple.
-    /// * `f` is a function that calls `emit_tuple_arg` for each member.
-    ///
-    /// Note that external `Encodable` implementations should not normally need
-    /// to use this method directly; it is meant for the use of this module's
-    /// own implementation of `Encodable` for tuples.
-    fn emit_tuple<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a data item for a tuple.
-    ///
-    /// This should only be called from a function passed to `emit_tuple`.
-    ///
-    /// * `idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that tuple items must be emitted in order - starting with index `0`
-    /// and finishing with index `len-1`.
-    fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a tuple struct value.
-    ///
-    /// * `name` is the name of the tuple struct.
-    /// * `len` is the number of items in the tuple struct.
-    /// * `f` is a function that calls `emit_tuple_struct_arg` for each member.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// struct Pair(i32,i32);
-    ///
-    /// impl Encodable for Pair {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         let Pair(first,second) = *self;
-    ///         s.emit_tuple_struct("Pair", 2, |s| {
-    ///             try!(s.emit_tuple_arg(0, |s| {
-    ///                 s.emit_i32(first)
-    ///             }));
-    ///             try!(s.emit_tuple_arg(1, |s| {
-    ///                 s.emit_i32(second)
-    ///             }));
-    ///             Ok(())
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_tuple_struct<F>(&mut self, name: &str, len: usize, f: F)
-                            -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a data item for a tuple struct.
-    ///
-    /// This should only be called from a function passed to
-    /// `emit_tuple_struct`.
-    ///
-    /// * `f_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that tuple items must be emitted in order - starting with index `0`
-    /// and finishing with index `len-1`.
-    fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F)
-                                -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    // Specialized types:
-    /// Emit an optional value.
-    ///
-    /// `f` is a function that will call either `emit_option_none` or
-    /// `emit_option_some` as appropriate.
-    ///
-    /// This method allows encoders to handle `Option<T>` values specially,
-    /// rather than using the generic enum methods, because many encoding
-    /// formats have a built-in "optional" concept.
-    ///
-    /// Note that external `Encodable` implementations should not normally need
-    /// to use this method directly; it is meant for the use of this module's
-    /// own implementation of `Encodable` for `Option<T>`.
-    fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit the `None` optional value.
-    ///
-    /// This should only be called from a function passed to `emit_option`.
-    fn emit_option_none(&mut self) -> Result<(), Self::Error>;
-
-    /// Emit the `Some(x)` optional value.
-    ///
-    /// `f` is a function that will call the appropriate emit method to encode
-    /// the data object.
-    ///
-    /// This should only be called from a function passed to `emit_option`.
-    fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a sequence of values.
-    ///
-    /// This should be used for both array-like ordered sequences and set-like
-    /// unordered ones.
-    ///
-    /// * `len` is the number of values in the sequence.
-    /// * `f` is a function that will call `emit_seq_elt` for each value in the
-    ///   sequence.
-    fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit an element in a sequence.
-    ///
-    /// This should only be called from a function passed to `emit_seq`.
-    ///
-    /// * `idx` is the (zero-based) index of the value in the sequence.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that sequence elements must be emitted in order - starting with
-    /// index `0` and finishing with index `len-1`.
-    fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit an associative container (map).
-    ///
-    /// * `len` is the number of entries in the map.
-    /// * `f` is a function that will call `emit_map_elt_key` and
-    ///   `emit_map_elt_val` for each entry in the map.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// struct SimpleMap<K,V> {
-    ///     entries: Vec<(K,V)>,
-    /// }
-    ///
-    /// impl<K:Encodable,V:Encodable> Encodable for SimpleMap<K,V> {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_map(self.entries.len(), |s| {
-    ///             for (i, e) in self.entries.iter().enumerate() {
-    ///                 let (ref k, ref v) = *e;
-    ///                 try!(s.emit_map_elt_key(i, |s| k.encode(s)));
-    ///                 try!(s.emit_map_elt_val(i, |s| v.encode(s)));
-    ///             }
-    ///             Ok(())
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit the key for an entry in a map.
-    ///
-    /// This should only be called from a function passed to `emit_map`.
-    ///
-    /// * `idx` is the (zero-based) index of the entry in the map
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the key.
-    ///
-    /// Note that map entries must be emitted in order - starting with index `0`
-    /// and finishing with index `len-1` - and for each entry, the key should be
-    /// emitted followed immediately by the value.
-    fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit the value for an entry in a map.
-    ///
-    /// This should only be called from a function passed to `emit_map`.
-    ///
-    /// * `idx` is the (zero-based) index of the entry in the map
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the value.
-    ///
-    /// Note that map entries must be emitted in order - starting with index `0`
-    /// and finishing with index `len-1` - and for each entry, the key should be
-    /// emitted followed immediately by the value.
-    fn emit_map_elt_val<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-}
-
-/// Trait for reading in an encoding for deserialization.
-///
-/// This trait provides methods to decode basic types and generic forms of
-/// collections.  Implementations of `Decodable` use it to perform the actual
-/// decoding of a type.
-///
-/// Note that, as is typical with deserialization, the design of this API
-/// assumes you know in advance the form of the data you are decoding (ie: what
-/// type is encoded).
-///
-/// Decoders can expect to only have a single "root" method call made on this
-/// trait. Non-trivial types will call one of the collection-reading methods,
-/// passing a function that may call other methods on the trait, but once the
-/// collection-reading method has returned, decoding should be complete.
-pub trait Decoder {
-    /// The error type for method results.
-    type Error;
-
-    // Primitive types:
-    /// Read a nil value.
-    fn read_nil(&mut self) -> Result<(), Self::Error>;
-
-    /// Read a usize value.
-    fn read_usize(&mut self) -> Result<usize, Self::Error>;
-
-    /// Read a u64 value.
-    fn read_u64(&mut self) -> Result<u64, Self::Error>;
-
-    /// Read a u32 value.
-    fn read_u32(&mut self) -> Result<u32, Self::Error>;
-
-    /// Read a u16 value.
-    fn read_u16(&mut self) -> Result<u16, Self::Error>;
-
-    /// Read a u8 value.
-    fn read_u8(&mut self) -> Result<u8, Self::Error>;
-
-    /// Read a isize value.
-    fn read_isize(&mut self) -> Result<isize, Self::Error>;
-
-    /// Read a i64 value.
-    fn read_i64(&mut self) -> Result<i64, Self::Error>;
-
-    /// Read a i32 value.
-    fn read_i32(&mut self) -> Result<i32, Self::Error>;
-
-    /// Read a i16 value.
-    fn read_i16(&mut self) -> Result<i16, Self::Error>;
-
-    /// Read a i8 value.
-    fn read_i8(&mut self) -> Result<i8, Self::Error>;
-
-    /// Read a bool value.
-    fn read_bool(&mut self) -> Result<bool, Self::Error>;
-
-    /// Read a f64 value.
-    fn read_f64(&mut self) -> Result<f64, Self::Error>;
-
-    /// Read a f32 value.
-    fn read_f32(&mut self) -> Result<f32, Self::Error>;
-
-    /// Read a char value.
-    fn read_char(&mut self) -> Result<char, Self::Error>;
-
-    /// Read a string value.
-    fn read_str(&mut self) -> Result<String, Self::Error>;
-
-    // Compound types:
-    /// Read an enumeration value.
-    ///
-    /// * `name` indicates the enumeration type name. It may be used to
-    ///   sanity-check the data being read.
-    /// * `f` is a function that will call `read_enum_variant` (or
-    ///   `read_enum_struct_variant`) to read the actual value.
-    fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read an enumeration value.
-    ///
-    /// * `names` is a list of the enumeration variant names.
-    /// * `f` is a function that will call `read_enum_variant_arg` or
-    ///   `read_enum_struct_variant_field` as appropriate to read the
-    ///   associated values. It will be passed the index into `names` for the
-    ///   variant that is encoded.
-    fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F)
-                               -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>;
-
-    /// Read an unnamed data item for an enumeration variant.
-    ///
-    /// This should only be called from a function passed to `read_enum_variant`
-    /// or `read_enum_struct_variant`, and only when the index provided to that
-    /// function indicates that the variant has associated unnamed data. It
-    /// should be called once for each associated data item.
-    ///
-    /// * `a_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to deocde
-    ///   the data object.
-    ///
-    /// Note that variant data items must be read in order - starting with index
-    /// `0` and finishing with index `len-1`. Implementations may use `a_idx`,
-    /// the call order or both to select the correct data to decode.
-    fn read_enum_variant_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                   -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read an enumeration value.
-    ///
-    /// This is identical to `read_enum_variant`, and is only provided for
-    /// symmetry with the `Encoder` API.
-    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F)
-                                      -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>;
-
-    /// Read a named data item for an enumeration variant.
-    ///
-    /// This should only be called from a function passed to `read_enum_variant`
-    /// or `read_enum_struct_variant`, and only when the index provided to that
-    /// function indicates that the variant has associated named data. It should
-    /// be called once for each associated field.
-    ///
-    /// * `f_name` is the name of the field.
-    /// * `f_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to deocde
-    ///   the data object.
-    ///
-    /// Note that fields must be read in order - starting with index `0` and
-    /// finishing with index `len-1`. Implementations may use `f_idx`, `f_name`,
-    /// the call order or any combination to choose the correct data to decode,
-    /// and may (but are not required to) return an error if these are
-    /// inconsistent.
-    fn read_enum_struct_variant_field<T, F>(&mut self,
-                                            f_name: &str,
-                                            f_idx: usize,
-                                            f: F)
-                                            -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read an struct value.
-    ///
-    /// * `s_name` indicates the struct type name. It may be used to
-    ///   sanity-check the data being read.
-    /// * `len` indicates the number of fields in the struct.
-    /// * `f` is a function that will call `read_struct_field` for each field in
-    ///   the struct.
-    fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-                         -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a field for a struct value.
-    ///
-    /// This should only be called from a function passed to `read_struct`. It
-    /// should be called once for each associated field.
-    ///
-    /// * `f_name` is the name of the field.
-    /// * `f_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to deocde
-    ///   the data object.
-    ///
-    /// Note that fields must be read in order - starting with index `0` and
-    /// finishing with index `len-1`. Implementations may use `f_idx`, `f_name`,
-    /// the call order or any combination to choose the correct data to decode,
-    /// and may (but are not required to) return an error if these are
-    /// inconsistent.
-    fn read_struct_field<T, F>(&mut self,
-                               f_name: &str,
-                               f_idx: usize,
-                               f: F)
-                               -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a tuple value.
-    ///
-    /// * `len` is the number of items in the tuple.
-    /// * `f` is a function that will call `read_tuple_arg` for each item in the
-    ///   tuple.
-    ///
-    /// Note that external `Decodable` implementations should not normally need
-    /// to use this method directly; it is meant for the use of this module's
-    /// own implementation of `Decodable` for tuples.
-    fn read_tuple<T, F>(&mut self, len: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a data item for a tuple.
-    ///
-    /// This should only be called from a function passed to `read_tuple`.
-    ///
-    /// * `a_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to encode
-    ///   the data object.
-    ///
-    /// Note that tuple items must be read in order - starting with index `0`
-    /// and finishing with index `len-1`.
-    fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F)
-                            -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a tuple struct value.
-    ///
-    /// * `s_name` is the name of the tuple struct.
-    /// * `len` is the number of items in the tuple struct.
-    /// * `f` is a function that calls `read_tuple_struct_arg` for each member.
-    fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-                               -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a data item for a tuple struct.
-    ///
-    /// This should only be called from a function passed to
-    /// `read_tuple_struct`.
-    ///
-    /// * `a_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to encode
-    ///   the data object.
-    ///
-    /// Note that tuple struct items must be read in order - starting with index
-    /// `0` and finishing with index `len-1`.
-    fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                   -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    // Specialized types:
-    /// Read an optional value.
-    ///
-    /// `f` is a function that will will be passed be passed `false` if the
-    /// value is unset, and `true` if it is set. If the function is passed
-    /// `true`, it will call the appropriate read methods to read the associated
-    /// data type.
-    ///
-    /// This method allows decoders to handle `Option<T>` values specially,
-    /// rather than using the generic enum methods, because many encoding
-    /// formats have a built-in "optional" concept.
-    ///
-    /// Note that external `Decodable` implementations should not normally need
-    /// to use this method directly; it is meant for the use of this module's
-    /// own implementation of `Decodable` for `Option<T>`.
-    fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, bool) -> Result<T, Self::Error>;
-
-    /// Read a sequence of values.
-    ///
-    /// This should be used for both array-like ordered sequences and set-like
-    /// unordered ones.
-    ///
-    /// * `f` is a function that will be passed the length of the sequence, and
-    ///   will call `read_seq_elt` for each value in the sequence.
-    fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>;
-
-    /// Read an element in the sequence.
-    ///
-    /// This should only be called from a function passed to `read_seq`.
-    ///
-    /// * `idx` is the (zero-based) index of the value in the sequence.
-    /// * `f` is a function that will call the appropriate read method to decode
-    ///   the data object.
-    ///
-    /// Note that sequence elements must be read in order - starting with index
-    /// `0` and finishing with index `len-1`.
-    fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read an associative container (map).
-    ///
-    /// * `f` is a function that will be passed the number of entries in the
-    ///   map, and will call `read_map_elt_key` and `read_map_elt_val` to decode
-    ///   each entry.
-    fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>;
-
-    /// Read the key for an entry in a map.
-    ///
-    /// This should only be called from a function passed to `read_map`.
-    ///
-    /// * `idx` is the (zero-based) index of the entry in the map
-    /// * `f` is a function that will call the appropriate read method to decode
-    ///   the key.
-    ///
-    /// Note that map entries must be read in order - starting with index `0`
-    /// and finishing with index `len-1` - and for each entry, the key should be
-    /// read followed immediately by the value.
-    fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F)
-                              -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read the value for an entry in a map.
-    ///
-    /// This should only be called from a function passed to `read_map`.
-    ///
-    /// * `idx` is the (zero-based) index of the entry in the map
-    /// * `f` is a function that will call the appropriate read method to decode
-    ///   the value.
-    ///
-    /// Note that map entries must be read in order - starting with index `0`
-    /// and finishing with index `len-1` - and for each entry, the key should be
-    /// read followed immediately by the value.
-    fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F)
-                              -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    // Failure
-    /// Record a decoding error.
-    ///
-    /// This allows `Decodable` implementations to report an error using a
-    /// `Decoder` implementation's error type when inconsistent data is read.
-    /// For example, when reading a fixed-length array and the wrong length is
-    /// given by `read_seq`.
-    fn error(&mut self, err: &str) -> Self::Error;
-}
-
-/// Trait for serializing a type.
-///
-/// This can be implemented for custom data types to allow them to be encoded
-/// with `Encoder` implementations. Most of Rust's built-in or standard data
-/// types (like `i32` and `Vec<T>`) have `Encodable` implementations provided by
-/// this module.
-///
-/// Note that, in general, you should let the compiler implement this for you by
-/// using the `derive(RustcEncodable)` attribute.
-///
-/// # Examples
-///
-/// ```rust
-/// extern crate rustc_serialize;
-///
-/// #[derive(RustcEncodable)]
-/// struct Point {
-///     x: i32,
-///     y: i32,
-/// }
-/// # fn main() {}
-/// ```
-///
-/// This generates code equivalent to:
-///
-/// ```rust
-/// extern crate rustc_serialize;
-/// use rustc_serialize::Encodable;
-/// use rustc_serialize::Encoder;
-///
-/// struct Point {
-///     x: i32,
-///     y: i32,
-/// }
-///
-/// impl Encodable for Point {
-///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-///         s.emit_struct("Point", 2, |s| {
-///             try!(s.emit_struct_field("x", 0, |s| {
-///                 s.emit_i32(self.x)
-///             }));
-///             try!(s.emit_struct_field("y", 1, |s| {
-///                 s.emit_i32(self.y)
-///             }));
-///             Ok(())
-///         })
-///     }
-/// }
-/// # fn main() {}
-/// ```
-pub trait Encodable {
-    /// Serialize a value using an `Encoder`.
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error>;
-}
-
-/// Trait for deserializing a type.
-///
-/// This can be implemented for custom data types to allow them to be decoded
-/// with `Decoder` implementations. Most of Rust's built-in or standard data
-/// types (like `i32` and `Vec<T>`) have `Decodable` implementations provided by
-/// this module.
-///
-/// Note that, in general, you should let the compiler implement this for you by
-/// using the `derive(RustcDecodable)` attribute.
-///
-/// # Examples
-///
-/// ```rust
-/// extern crate rustc_serialize;
-///
-/// #[derive(RustcDecodable)]
-/// struct Point {
-///     x: i32,
-///     y: i32,
-/// }
-/// # fn main() {}
-/// ```
-///
-/// This generates code equivalent to:
-///
-/// ```rust
-/// extern crate rustc_serialize;
-/// use rustc_serialize::Decodable;
-/// use rustc_serialize::Decoder;
-///
-/// struct Point {
-///     x: i32,
-///     y: i32,
-/// }
-///
-/// impl Decodable for Point {
-///     fn decode<D: Decoder>(d: &mut D) -> Result<Point, D::Error> {
-///         d.read_struct("Point", 2, |d| {
-///             let x = try!(d.read_struct_field("x", 0, |d| { d.read_i32() }));
-///             let y = try!(d.read_struct_field("y", 1, |d| { d.read_i32() }));
-///             Ok(Point{ x: x, y: y })
-///         })
-///     }
-/// }
-/// # fn main() {}
-/// ```
-pub trait Decodable: Sized {
-    /// Deserialize a value using a `Decoder`.
-    fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>;
-}
-
-impl Encodable for usize {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_usize(*self)
-    }
-}
-
-impl Decodable for usize {
-    fn decode<D: Decoder>(d: &mut D) -> Result<usize, D::Error> {
-        d.read_usize()
-    }
-}
-
-impl Encodable for u8 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u8(*self)
-    }
-}
-
-impl Decodable for u8 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<u8, D::Error> {
-        d.read_u8()
-    }
-}
-
-impl Encodable for u16 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u16(*self)
-    }
-}
-
-impl Decodable for u16 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<u16, D::Error> {
-        d.read_u16()
-    }
-}
-
-impl Encodable for u32 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u32(*self)
-    }
-}
-
-impl Decodable for u32 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<u32, D::Error> {
-        d.read_u32()
-    }
-}
-
-impl Encodable for u64 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u64(*self)
-    }
-}
-
-impl Decodable for u64 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<u64, D::Error> {
-        d.read_u64()
-    }
-}
-
-impl Encodable for isize {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_isize(*self)
-    }
-}
-
-impl Decodable for isize {
-    fn decode<D: Decoder>(d: &mut D) -> Result<isize, D::Error> {
-        d.read_isize()
-    }
-}
-
-impl Encodable for i8 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_i8(*self)
-    }
-}
-
-impl Decodable for i8 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<i8, D::Error> {
-        d.read_i8()
-    }
-}
-
-impl Encodable for i16 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_i16(*self)
-    }
-}
-
-impl Decodable for i16 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<i16, D::Error> {
-        d.read_i16()
-    }
-}
-
-impl Encodable for i32 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_i32(*self)
-    }
-}
-
-impl Decodable for i32 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<i32, D::Error> {
-        d.read_i32()
-    }
-}
-
-impl Encodable for i64 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_i64(*self)
-    }
-}
-
-impl Decodable for i64 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<i64, D::Error> {
-        d.read_i64()
-    }
-}
-
-impl Encodable for str {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_str(self)
-    }
-}
-
-impl Encodable for String {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_str(self)
-    }
-}
-
-impl Decodable for String {
-    fn decode<D: Decoder>(d: &mut D) -> Result<String, D::Error> {
-        d.read_str()
-    }
-}
-
-impl Encodable for f32 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_f32(*self)
-    }
-}
-
-impl Decodable for f32 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<f32, D::Error> {
-        d.read_f32()
-    }
-}
-
-impl Encodable for f64 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_f64(*self)
-    }
-}
-
-impl Decodable for f64 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<f64, D::Error> {
-        d.read_f64()
-    }
-}
-
-impl Encodable for bool {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_bool(*self)
-    }
-}
-
-impl Decodable for bool {
-    fn decode<D: Decoder>(d: &mut D) -> Result<bool, D::Error> {
-        d.read_bool()
-    }
-}
-
-impl Encodable for char {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_char(*self)
-    }
-}
-
-impl Decodable for char {
-    fn decode<D: Decoder>(d: &mut D) -> Result<char, D::Error> {
-        d.read_char()
-    }
-}
-
-impl Encodable for () {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_nil()
-    }
-}
-
-impl Decodable for () {
-    fn decode<D: Decoder>(d: &mut D) -> Result<(), D::Error> {
-        d.read_nil()
-    }
-}
-
-impl<'a, T: ?Sized + Encodable> Encodable for &'a T {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<T: ?Sized + Encodable> Encodable for Box<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl< T: Decodable> Decodable for Box<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Box<T>, D::Error> {
-        Ok(Box::new(try!(Decodable::decode(d))))
-    }
-}
-
-impl< T: Decodable> Decodable for Box<[T]> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Box<[T]>, D::Error> {
-        let v: Vec<T> = try!(Decodable::decode(d));
-        Ok(v.into_boxed_slice())
-    }
-}
-
-impl<T:Encodable> Encodable for Rc<T> {
-    #[inline]
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<T:Decodable> Decodable for Rc<T> {
-    #[inline]
-    fn decode<D: Decoder>(d: &mut D) -> Result<Rc<T>, D::Error> {
-        Ok(Rc::new(try!(Decodable::decode(d))))
-    }
-}
-
-impl<'a, T:Encodable + ToOwned + ?Sized> Encodable for Cow<'a, T> {
-    #[inline]
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<'a, T: ?Sized> Decodable for Cow<'a, T>
-    where T: ToOwned, T::Owned: Decodable
-{
-    #[inline]
-    fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, T>, D::Error> {
-        Ok(Cow::Owned(try!(Decodable::decode(d))))
-    }
-}
-
-impl<T:Encodable> Encodable for [T] {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)))
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T:Encodable> Encodable for Vec<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)))
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T:Decodable> Decodable for Vec<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut v = Vec::with_capacity(cap_capacity::<T>(len));
-            for i in 0..len {
-                v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(v)
-        })
-    }
-}
-
-impl<T:Encodable> Encodable for Option<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_option(|s| {
-            match *self {
-                None => s.emit_option_none(),
-                Some(ref v) => s.emit_option_some(|s| v.encode(s)),
-            }
-        })
-    }
-}
-
-impl<T:Decodable> Decodable for Option<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Option<T>, D::Error> {
-        d.read_option(|d, b| {
-            if b {
-                Ok(Some(try!(Decodable::decode(d))))
-            } else {
-                Ok(None)
-            }
-        })
-    }
-}
-
-impl<T:Encodable, E:Encodable> Encodable for Result<T, E> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_enum("Result", |s| {
-            match *self {
-                Ok(ref v) => {
-                    s.emit_enum_variant("Ok", 0, 1, |s| {
-                        try!(s.emit_enum_variant_arg(0, |s| {
-                            v.encode(s)
-                        }));
-                        Ok(())
-                    })
-                }
-                Err(ref v) => {
-                    s.emit_enum_variant("Err", 1, 1, |s| {
-                        try!(s.emit_enum_variant_arg(0, |s| {
-                            v.encode(s)
-                        }));
-                        Ok(())
-                    })
-                }
-            }
-        })
-    }
-}
-
-impl<T: Decodable, E: Decodable> Decodable for Result<T, E> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Result<T, E>, D::Error> {
-        d.read_enum("Result", |d| {
-            d.read_enum_variant(&["Ok", "Err"], |d, idx| {
-                match idx {
-                    0 => {
-                        d.read_enum_variant_arg(0, |d| {
-                            T::decode(d)
-                        }).map(|v| Ok(v))
-                    }
-                    1 => {
-                        d.read_enum_variant_arg(0, |d| {
-                            E::decode(d)
-                        }).map(|v| Err(v))
-                    }
-                    _ => panic!("Internal error"),
-                }
-            })
-        })
-    }
-}
-
-impl<T> Encodable for PhantomData<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_nil()
-    }
-}
-
-impl<T> Decodable for PhantomData<T> {
-    fn decode<D: Decoder>(_d: &mut D) -> Result<PhantomData<T>, D::Error> {
-        Ok(PhantomData)
-    }
-}
-
-macro_rules! peel {
-    ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
-}
-
-/// Evaluates to the number of identifiers passed to it, for example:
-/// `count_idents!(a, b, c) == 3
-macro_rules! count_idents {
-    () => { 0 };
-    ($_i:ident, $($rest:ident,)*) => { 1 + count_idents!($($rest,)*) }
-}
-
-macro_rules! tuple {
-    () => ();
-    ( $($name:ident,)+ ) => (
-        impl<$($name:Decodable),*> Decodable for ($($name,)*) {
-            fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)*), D::Error> {
-                let len: usize = count_idents!($($name,)*);
-                d.read_tuple(len, |d| {
-                    let mut i = 0;
-                    let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 },
-                                                       |d| -> Result<$name,D::Error> {
-                        Decodable::decode(d)
-                    })),)*);
-                    return Ok(ret);
-                })
-            }
-        }
-        impl<$($name:Encodable),*> Encodable for ($($name,)*) {
-            #[allow(non_snake_case)]
-            fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-                let ($(ref $name,)*) = *self;
-                let mut n = 0;
-                $(let $name = $name; n += 1;)*
-                s.emit_tuple(n, |s| {
-                    let mut i = 0;
-                    $(try!(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s)));)*
-                    Ok(())
-                })
-            }
-        }
-        peel! { $($name,)* }
-    )
-}
-
-tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
-
-macro_rules! array {
-    () => ();
-    ($len:expr, $($idx:expr,)*) => {
-        impl<T:Decodable> Decodable for [T; $len] {
-            fn decode<D: Decoder>(d: &mut D) -> Result<[T; $len], D::Error> {
-                d.read_seq(|d, len| {
-                    if len != $len {
-                        return Err(d.error("wrong array length"));
-                    }
-                    Ok([$(
-                        try!(d.read_seq_elt($len - $idx - 1,
-                                            |d| Decodable::decode(d)))
-                    ),*])
-                })
-            }
-        }
-
-        impl<T:Encodable> Encodable for [T; $len] {
-            fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-                s.emit_seq($len, |s| {
-                    for i in 0..$len {
-                        try!(s.emit_seq_elt(i, |s| self[i].encode(s)));
-                    }
-                    Ok(())
-                })
-            }
-        }
-        array! { $($idx,)* }
-    }
-}
-
-array! {
-    32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
-    15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
-}
-
-impl Encodable for path::Path {
-    #[cfg(target_os = "redox")]
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        self.as_os_str().to_str().unwrap().encode(e)
-    }
-    #[cfg(unix)]
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        use std::os::unix::prelude::*;
-        self.as_os_str().as_bytes().encode(e)
-    }
-    #[cfg(windows)]
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        use std::os::windows::prelude::*;
-        let v = self.as_os_str().encode_wide().collect::<Vec<_>>();
-        v.encode(e)
-    }
-}
-
-impl Encodable for path::PathBuf {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        (**self).encode(e)
-    }
-}
-
-impl Decodable for path::PathBuf {
-    #[cfg(target_os = "redox")]
-    fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
-        let string: String = try!(Decodable::decode(d));
-        let s: OsString = OsString::from(string);
-        let mut p = path::PathBuf::new();
-        p.push(s);
-        Ok(p)
-    }
-    #[cfg(unix)]
-    fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
-        use std::os::unix::prelude::*;
-        let bytes: Vec<u8> = try!(Decodable::decode(d));
-        let s: OsString = OsStringExt::from_vec(bytes);
-        let mut p = path::PathBuf::new();
-        p.push(s);
-        Ok(p)
-    }
-    #[cfg(windows)]
-    fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
-        use std::os::windows::prelude::*;
-        let bytes: Vec<u16> = try!(Decodable::decode(d));
-        let s: OsString = OsStringExt::from_wide(&bytes);
-        let mut p = path::PathBuf::new();
-        p.push(s);
-        Ok(p)
-    }
-}
-
-impl<T: Encodable + Copy> Encodable for Cell<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        self.get().encode(s)
-    }
-}
-
-impl<T: Decodable + Copy> Decodable for Cell<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Cell<T>, D::Error> {
-        Ok(Cell::new(try!(Decodable::decode(d))))
-    }
-}
-
-// FIXME: #15036
-// Should use `try_borrow`, returning a
-// `encoder.error("attempting to Encode borrowed RefCell")`
-// from `encode` when `try_borrow` returns `None`.
-
-impl<T: Encodable> Encodable for RefCell<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        self.borrow().encode(s)
-    }
-}
-
-impl<T: Decodable> Decodable for RefCell<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<RefCell<T>, D::Error> {
-        Ok(RefCell::new(try!(Decodable::decode(d))))
-    }
-}
-
-impl<T:Encodable> Encodable for Arc<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<T:Decodable+Send+Sync> Decodable for Arc<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Arc<T>, D::Error> {
-        Ok(Arc::new(try!(Decodable::decode(d))))
-    }
-}
-
-// ___________________________________________________________________________
-// Helper routines
-
-/// Trait with helper functions for implementing `Encodable`.
-///
-/// This trait is implemented for everything that implements `Encoder`.
-/// `Encodable` implementations can make use of it to make their implementations
-/// easier.
-pub trait EncoderHelpers: Encoder {
-    /// Emit a vector as a sequence.
-    ///
-    /// Storing sequences as vectors is a common pattern. This method makes
-    /// encoding such sequences easier by wrapping the calls to
-    /// `Encoder::emit_seq` and `Encoder::emit_seq_elt`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    /// use rustc_serialize::EncoderHelpers;
-    ///
-    /// struct NumberSequence {
-    ///     elements: Vec<i32>,
-    /// }
-    ///
-    /// impl Encodable for NumberSequence {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_struct("NumberSequence", 1, |s| {
-    ///             s.emit_struct_field("elements", 0, |s| {
-    ///                 s.emit_from_vec(&self.elements, |s,e| {
-    ///                     s.emit_i32(*e)
-    ///                 })
-    ///             })
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_from_vec<T, F>(&mut self, v: &[T], f: F)
-                           -> Result<(), <Self as Encoder>::Error>
-        where F: FnMut(&mut Self, &T) -> Result<(), <Self as Encoder>::Error>;
-}
-
-impl<S:Encoder> EncoderHelpers for S {
-    fn emit_from_vec<T, F>(&mut self, v: &[T], mut f: F) -> Result<(), S::Error> where
-        F: FnMut(&mut S, &T) -> Result<(), S::Error>,
-    {
-        self.emit_seq(v.len(), |this| {
-            for (i, e) in v.iter().enumerate() {
-                try!(this.emit_seq_elt(i, |this| {
-                    f(this, e)
-                }));
-            }
-            Ok(())
-        })
-    }
-}
-
-/// Trait with helper functions for implementing `Decodable`.
-///
-/// This trait is implemented for everything that implements `Decoder`.
-/// `Decodable` implementations can make use of it to make their implementations
-/// easier.
-pub trait DecoderHelpers: Decoder {
-    /// Read a sequence into a vector.
-    ///
-    /// Storing sequences as vectors is a common pattern. This method makes
-    /// deserializing such sequences easier by wrapping the calls to
-    /// `Decoder::read_seq` and `Decoder::read_seq_elt`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Decodable;
-    /// use rustc_serialize::Decoder;
-    /// use rustc_serialize::DecoderHelpers;
-    ///
-    /// struct NumberSequence {
-    ///     elements: Vec<i32>,
-    /// }
-    ///
-    /// impl Decodable for NumberSequence {
-    ///     fn decode<D: Decoder>(d: &mut D) -> Result<NumberSequence, D::Error> {
-    ///         d.read_struct("NumberSequence", 2, |d| {
-    ///             Ok(NumberSequence{
-    ///                 elements: try!(d.read_struct_field("elements", 0, |d| {
-    ///                     d.read_to_vec(|d| { d.read_i32() })
-    ///                 }))
-    ///             })
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn read_to_vec<T, F>(&mut self, f: F)
-                         -> Result<Vec<T>, <Self as Decoder>::Error> where
-        F: FnMut(&mut Self) -> Result<T, <Self as Decoder>::Error>;
-}
-
-impl<D: Decoder> DecoderHelpers for D {
-    fn read_to_vec<T, F>(&mut self, mut f: F) -> Result<Vec<T>, D::Error> where F:
-        FnMut(&mut D) -> Result<T, D::Error>,
-    {
-        self.read_seq(|this, len| {
-            let mut v = Vec::with_capacity(cap_capacity::<T>(len));
-            for i in 0..len {
-                v.push(try!(this.read_seq_elt(i, |this| f(this))));
-            }
-            Ok(v)
-        })
-    }
-}
-
-#[test]
-#[allow(unused_variables)]
-fn capacity_rules() {
-    use std::usize::MAX;
-    use std::collections::{HashMap, HashSet};
-
-    struct MyDecoder;
-    impl Decoder for MyDecoder {
-        type Error = ();
-
-        // Primitive types:
-        fn read_nil(&mut self) -> Result<(), Self::Error> { Err(()) }
-        fn read_usize(&mut self) -> Result<usize, Self::Error> { Err(()) }
-        fn read_u64(&mut self) -> Result<u64, Self::Error> { Err(()) }
-        fn read_u32(&mut self) -> Result<u32, Self::Error> { Err(()) }
-        fn read_u16(&mut self) -> Result<u16, Self::Error> { Err(()) }
-        fn read_u8(&mut self) -> Result<u8, Self::Error> { Err(()) }
-        fn read_isize(&mut self) -> Result<isize, Self::Error> { Err(()) }
-        fn read_i64(&mut self) -> Result<i64, Self::Error> { Err(()) }
-        fn read_i32(&mut self) -> Result<i32, Self::Error> { Err(()) }
-        fn read_i16(&mut self) -> Result<i16, Self::Error> { Err(()) }
-        fn read_i8(&mut self) -> Result<i8, Self::Error> { Err(()) }
-        fn read_bool(&mut self) -> Result<bool, Self::Error> { Err(()) }
-        fn read_f64(&mut self) -> Result<f64, Self::Error> { Err(()) }
-        fn read_f32(&mut self) -> Result<f32, Self::Error> { Err(()) }
-        fn read_char(&mut self) -> Result<char, Self::Error> { Err(()) }
-        fn read_str(&mut self) -> Result<String, Self::Error> { Err(()) }
-
-        // Compound types:
-        fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F)
-                                   -> Result<T, Self::Error>
-            where F: FnMut(&mut Self, usize) -> Result<T, Self::Error> { Err(()) }
-        fn read_enum_variant_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                       -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F)
-                                          -> Result<T, Self::Error>
-            where F: FnMut(&mut Self, usize) -> Result<T, Self::Error> { Err(()) }
-        fn read_enum_struct_variant_field<T, F>(&mut self,
-                                                f_name: &str,
-                                                f_idx: usize,
-                                                f: F)
-                                                -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-                             -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-        fn read_struct_field<T, F>(&mut self,
-                                   f_name: &str,
-                                   f_idx: usize,
-                                   f: F)
-                                   -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_tuple<T, F>(&mut self, len: usize, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-        fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-                                   -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-        fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                       -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        // Specialized types:
-        fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-            where F: FnMut(&mut Self, bool) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error> {
-                f(self, MAX)
-            }
-        fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error> {
-            f(self, MAX)
-        }
-        fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F)
-                                  -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-        fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F)
-                                  -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        // Failure
-        fn error(&mut self, err: &str) -> Self::Error { () }
-    }
-
-    let mut dummy = MyDecoder;
-    let vec_result: Result<Vec<u8>, ()> = Decodable::decode(&mut dummy);
-    assert!(vec_result.is_err());
-
-    let map_result: Result<HashMap<u8, u8>, ()> = Decodable::decode(&mut dummy);
-    assert!(map_result.is_err());
-
-    let set_result: Result<HashSet<u8>, ()> = Decodable::decode(&mut dummy);
-    assert!(set_result.is_err());
-}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/.cargo-checksum.json
@@ -0,0 +1,1 @@
+{"files":{".travis.yml":"f73b83dfd8c84e2af27d780e93441a071507c8c2d981a73844558fe72717448e","Cargo.toml":"a97493cb1e3f170d30a5f8d92ae65185103083baf408eb5c0bd8f64a7ffdf007","LICENSE-APACHE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","README.md":"d150ab564033cacab1e6e806b13e78bb241818e950ffa4bf2623e6bd3bc64fb3","benchmark/benchmark.rs":"5ee2d5f68f6fa93f24e3828c9e8e269c22ce3ea96c0804def61b0b3026ad021f","build.rs":"96e9308d3a7a23a4c222892be8f29f45b13bffaed751f2e5b0b247230b65f360","src/buffer/mod.rs":"bcdc3db1c97b36c04c4445c4a7fba768be7a8b16e0f8bc7bab86ac06256a9750","src/common.rs":"f165881b718867b7801044bd29fa7f4322ebfc63d45d462d4a703253f8812a3e","src/d2s.rs":"35e0982e83d8c46f4304148d0454957b62be5f17480ad417d893521d578ad86e","src/d2s_full_table.rs":"7f7e475c54ae69d834574603bde9dcbe9f0d7cb09cfc3cda025319c903996bf8","src/d2s_small_table.rs":"f1bc5b328be636f100315ba818545e7d3c125cacec8487ed12f59f50d70b945e","src/digit_table.rs":"02351ca54cb8cb3679f635115dd094f32fd91750e9f66103c1ee9ec3db507072","src/f2s.rs":"2a59cc3ea57244ef4e926d98284a33363fb67452e20f24141395312173698e32","src/lib.rs":"268d75e445101f1edc0ced93852941ab9b150f1faea642490a03e8a613a33589","src/mulshift128.rs":"b539411c08b7cde489b876addc346a061e3594ed707fe577a3cdff6d26b0e1f8","src/pretty/exponent.rs":"15fd163fdb81573d331f24fda37f5403931512ffb08715a2695f0a0256b69b84","src/pretty/mantissa.rs":"7b0ea97069ee597f3bc0c8f2f3354c75be93d01c6a8135104ae82cd83df318e0","src/pretty/mod.rs":"f691267e66ce6f13d6db17ca6b93065e50a669e73916cbd22c8bfb3e33ad85fe","tests/d2s_table_test.rs":"57b541dc08c54c83979f18a20f8895daac3ad32628b140c66b09f42bce7f2691","tests/d2s_test.rs":"9abea253a30d96815688a34f20e2b3eff40c9d8b9a1209d7e927ba5a63efd74a","tests/exhaustive.rs":"0e01491936cb6b5ae68d92e50b6f7cebb26362774e860df103695ecc1f71fa7b","tests/f2s_test.rs":"7fa9dd515ed42947f570243a6d0656b6e2861c1399f679d96317dc109018d59b","tests/macros/mod.rs":"45eed20e9a3d8d9b673f504e8194f762223346adec46a6fbf1e0717eaeee85bc"},"package":"fd0568787116e13c652377b6846f5931454a363a8fdf8ae50463ee40935b278b"}
\ No newline at end of file
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/.travis.yml
@@ -0,0 +1,13 @@
+language: rust
+
+rust:
+  - nightly
+  - beta
+  - stable
+
+matrix:
+  include:
+    - rust: 1.15.0
+      script:
+        - cargo build
+        - cargo build --features small
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/Cargo.toml
@@ -0,0 +1,39 @@
+# 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 = "ryu"
+version = "0.2.4"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+build = "build.rs"
+description = "Fast floating point to string conversion"
+documentation = "https://docs.rs/ryu"
+readme = "README.md"
+license = "Apache-2.0"
+repository = "https://github.com/dtolnay/ryu"
+
+[[example]]
+name = "benchmark"
+path = "benchmark/benchmark.rs"
+[dependencies.no-panic]
+version = "0.1"
+optional = true
+[dev-dependencies.num_cpus]
+version = "1.8"
+
+[dev-dependencies.rand]
+version = "0.5"
+
+[features]
+small = []
+[badges.travis-ci]
+repository = "dtolnay/ryu"
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/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.
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/README.md
@@ -0,0 +1,74 @@
+# Ryū
+
+[![Build Status](https://api.travis-ci.org/dtolnay/ryu.svg?branch=master)](https://travis-ci.org/dtolnay/ryu)
+[![Latest Version](https://img.shields.io/crates/v/ryu.svg)](https://crates.io/crates/ryu)
+[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/ryu)
+[![Rustc Version 1.15+](https://img.shields.io/badge/rustc-1.15+-lightgray.svg)](https://blog.rust-lang.org/2017/02/02/Rust-1.15.html)
+
+Pure Rust implementation of Ryū, an algorithm to quickly convert floating point
+numbers to decimal strings.
+
+The PLDI'18 paper [*Ryū: fast float-to-string conversion*][paper] by Ulf Adams
+includes a complete correctness proof of the algorithm. The paper is available
+under the creative commons CC-BY-SA license.
+
+This Rust implementation is a line-by-line port of Ulf Adams' implementation in
+C, [https://github.com/ulfjack/ryu][upstream]. The `ryu::raw` module exposes
+exactly the API and formatting of the C implementation as unsafe pure Rust
+functions. There is additionally a safe API as demonstrated in the example code
+below. The safe API uses the same underlying Ryū algorithm but diverges from the
+formatting of the C implementation to produce more human-readable output, for
+example `0.3` rather than `3E-1`.
+
+*Requirements: this crate supports any compiler version back to rustc 1.15; it
+uses nothing from the Rust standard library so is usable from no_std crates.*
+
+[paper]: https://dl.acm.org/citation.cfm?id=3192369
+[upstream]: https://github.com/ulfjack/ryu/tree/4ffc2b759e4b0a431b35dbfbfd6e0e85fdd15a69
+
+```toml
+[dependencies]
+ryu = "0.2"
+```
+
+## Examples
+
+```rust
+extern crate ryu;
+
+fn main() {
+    let mut buffer = ryu::Buffer::new();
+    let printed = buffer.format(1.234);
+    assert_eq!(printed, "1.234");
+}
+```
+
+## Performance
+
+You can run upstream's benchmarks with:
+
+```console
+$ git clone https://github.com/ulfjack/ryu c-ryu
+$ cd c-ryu
+$ bazel run -c opt //ryu/benchmark
+```
+
+And our benchmarks with:
+
+```console
+$ git clone https://github.com/ulfjack/ryu rust-ryu
+$ cd rust-ryu
+$ cargo run --example benchmark --release
+```
+
+These benchmarks measure the average time to print a 32-bit float and average
+time to print a 64-bit float, where the inputs are distributed as uniform random
+bit patterns 32 and 64 bits wide.
+
+The upstream C code, the unsafe direct Rust port, and the safe pretty Rust API
+all perform the same, taking around 21 nanoseconds to format a 32-bit float and
+31 nanoseconds to format a 64-bit float.
+
+## License
+
+Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/benchmark/benchmark.rs
@@ -0,0 +1,86 @@
+extern crate rand;
+extern crate ryu;
+
+use rand::{Rng, SeedableRng};
+
+const SAMPLES: usize = 10000;
+const ITERATIONS: usize = 1000;
+
+struct MeanAndVariance {
+    n: i64,
+    mean: f64,
+    m2: f64,
+}
+
+impl MeanAndVariance {
+    fn new() -> Self {
+        MeanAndVariance {
+            n: 0,
+            mean: 0.0,
+            m2: 0.0,
+        }
+    }
+
+    fn update(&mut self, x: f64) {
+        self.n += 1;
+        let d = x - self.mean;
+        self.mean += d / self.n as f64;
+        let d2 = x - self.mean;
+        self.m2 += d * d2;
+    }
+
+    fn variance(&self) -> f64 {
+        self.m2 / (self.n - 1) as f64
+    }
+
+    fn stddev(&self) -> f64 {
+        self.variance().sqrt()
+    }
+}
+
+macro_rules! benchmark {
+    ($name:ident, $ty:ident) => {
+        fn $name() -> usize {
+            let mut rng = rand::prng::XorShiftRng::from_seed([123u8; 16]);
+            let mut mv = MeanAndVariance::new();
+            let mut throwaway = 0;
+            for _ in 0..SAMPLES {
+                let f = loop {
+                    let f = $ty::from_bits(rng.gen());
+                    if f.is_finite() {
+                        break f;
+                    }
+                };
+
+                let t1 = std::time::SystemTime::now();
+                for _ in 0..ITERATIONS {
+                    throwaway += ryu::Buffer::new().format(f).len();
+                }
+                let duration = t1.elapsed().unwrap();
+                let nanos = duration.as_secs() * 1_000_000_000 + duration.subsec_nanos() as u64;
+                mv.update(nanos as f64 / ITERATIONS as f64);
+            }
+            println!(
+                "{:12} {:8.3} {:8.3}",
+                concat!(stringify!($name), ":"),
+                mv.mean,
+                mv.stddev(),
+            );
+            throwaway
+        }
+    };
+}
+
+benchmark!(pretty32, f32);
+benchmark!(pretty64, f64);
+
+fn main() {
+    println!("{:>20}{:>9}", "Average", "Stddev");
+    let mut throwaway = 0;
+    throwaway += pretty32();
+    throwaway += pretty64();
+    if std::env::var_os("ryu-benchmark").is_some() {
+        // Prevent the compiler from optimizing the code away.
+        println!("{}", throwaway);
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/build.rs
@@ -0,0 +1,54 @@
+use std::env;
+use std::process::Command;
+use std::str::{self, FromStr};
+
+// The rustc-cfg strings below are *not* public API. Please let us know by
+// opening a GitHub issue if your build environment requires some way to enable
+// these cfgs other than by executing our build script.
+fn main() {
+    let minor = match rustc_minor_version() {
+        Some(minor) => minor,
+        None => return,
+    };
+
+    // 128-bit integers stabilized in Rust 1.26:
+    // https://blog.rust-lang.org/2018/05/10/Rust-1.26.html
+    if minor >= 26 {
+        println!("cargo:rustc-cfg=integer128");
+    }
+
+    // #[must_use] on functions stabilized in Rust 1.27:
+    // https://blog.rust-lang.org/2018/06/21/Rust-1.27.html
+    if minor >= 27 {
+        println!("cargo:rustc-cfg=must_use_return");
+    }
+}
+
+fn rustc_minor_version() -> Option<u32> {
+    let rustc = match env::var_os("RUSTC") {
+        Some(rustc) => rustc,
+        None => return None,
+    };
+
+    let output = match Command::new(rustc).arg("--version").output() {
+        Ok(output) => output,
+        Err(_) => return None,
+    };
+
+    let version = match str::from_utf8(&output.stdout) {
+        Ok(version) => version,
+        Err(_) => return None,
+    };
+
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+
+    let next = match pieces.next() {
+        Some(next) => next,
+        None => return None,
+    };
+
+    u32::from_str(next).ok()
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/src/buffer/mod.rs
@@ -0,0 +1,97 @@
+use core::{mem, slice, str};
+
+use pretty;
+
+#[cfg(feature = "no-panic")]
+use no_panic::no_panic;
+
+/// Safe API for formatting floating point numbers to text.
+///
+/// ## Example
+///
+/// ```rust
+/// let mut buffer = ryu::Buffer::new();
+/// let printed = buffer.format(1.234);
+/// assert_eq!(printed, "1.234");
+/// ```
+#[derive(Copy, Clone)]
+pub struct Buffer {
+    bytes: [u8; 24],
+}
+
+impl Buffer {
+    /// This is a cheap operation; you don't need to worry about reusing buffers
+    /// for efficiency.
+    #[inline]
+    #[cfg_attr(feature = "no-panic", no_panic)]
+    pub fn new() -> Self {
+        Buffer {
+            bytes: unsafe { mem::uninitialized() },
+        }
+    }
+
+    /// Print a floating point number into this buffer and return a reference to
+    /// its string representation within the buffer.
+    ///
+    /// # Special cases
+    ///
+    /// This function **does not** check for NaN or infinity. If the input
+    /// number is not a finite float, the printed representation will be some
+    /// correctly formatted but unspecified numerical value.
+    ///
+    /// Please check [`is_finite`] yourself before calling this function, or
+    /// check [`is_nan`] and [`is_infinite`] and handle those cases yourself.
+    ///
+    /// [`is_finite`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_finite
+    /// [`is_nan`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_nan
+    /// [`is_infinite`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_infinite
+    #[inline]
+    #[cfg_attr(feature = "no-panic", no_panic)]
+    pub fn format<F: Float>(&mut self, f: F) -> &str {
+        unsafe {
+            let n = f.write_to_ryu_buffer(&mut self.bytes[0]);
+            debug_assert!(n <= self.bytes.len());
+            let slice = slice::from_raw_parts(&self.bytes[0], n);
+            str::from_utf8_unchecked(slice)
+        }
+    }
+}
+
+impl Default for Buffer {
+    #[inline]
+    #[cfg_attr(feature = "no-panic", no_panic)]
+    fn default() -> Self {
+        Buffer::new()
+    }
+}
+
+/// A floating point number, f32 or f64, that can be written into a
+/// [`ryu::Buffer`][Buffer].
+///
+/// This trait is sealed and cannot be implemented for types outside of the
+/// `ryu` crate.
+pub trait Float: Sealed {
+    // Not public API.
+    #[doc(hidden)]
+    unsafe fn write_to_ryu_buffer(self, result: *mut u8) -> usize;
+}
+
+impl Float for f32 {
+    #[inline]
+    #[cfg_attr(feature = "no-panic", no_panic)]
+    unsafe fn write_to_ryu_buffer(self, result: *mut u8) -> usize {
+        pretty::f2s_buffered_n(self, result)
+    }
+}
+
+impl Float for f64 {
+    #[inline]
+    #[cfg_attr(feature = "no-panic", no_panic)]
+    unsafe fn write_to_ryu_buffer(self, result: *mut u8) -> usize {
+        pretty::d2s_buffered_n(self, result)
+    }
+}
+
+pub trait Sealed {}
+impl Sealed for f32 {}
+impl Sealed for f64 {}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/src/common.rs
@@ -0,0 +1,72 @@
+// Translated from C to Rust. The original C code can be found at
+// https://github.com/ulfjack/ryu and carries the following license:
+//
+// Copyright 2018 Ulf Adams
+//
+// The contents of this file may be used under the terms of the Apache License,
+// Version 2.0.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     http://www.apache.org/licenses/LICENSE-2.0)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+
+use core::ptr;
+
+// Returns e == 0 ? 1 : ceil(log_2(5^e)).
+#[cfg_attr(feature = "no-panic", inline)]
+pub fn pow5bits(e: i32) -> u32 {
+    // This approximation works up to the point that the multiplication overflows at e = 3529.
+    // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater
+    // than 2^9297.
+    debug_assert!(e >= 0);
+    debug_assert!(e <= 3528);
+    ((e as u32 * 1217359) >> 19) + 1
+}
+
+// Returns floor(log_10(2^e)).
+#[cfg_attr(feature = "no-panic", inline)]
+pub fn log10_pow2(e: i32) -> i32 {
+    // The first value this approximation fails for is 2^1651 which is just greater than 10^297.
+    debug_assert!(e >= 0);
+    debug_assert!(e <= 1650);
+    ((e as u32 * 78913) >> 18) as i32
+}
+
+// Returns floor(log_10(5^e)).
+#[cfg_attr(feature = "no-panic", inline)]
+pub fn log10_pow5(e: i32) -> i32 {
+    // The first value this approximation fails for is 5^2621 which is just greater than 10^1832.
+    debug_assert!(e >= 0);
+    debug_assert!(e <= 2620);
+    ((e as u32 * 732923) >> 20) as i32
+}
+
+#[cfg_attr(feature = "no-panic", inline)]
+pub unsafe fn copy_special_str(
+    result: *mut u8,
+    sign: bool,
+    exponent: bool,
+    mantissa: bool,
+) -> usize {
+    if mantissa {
+        ptr::copy_nonoverlapping(b"NaN".as_ptr(), result, 3);
+        return 3;
+    }
+    if sign {
+        *result = b'-';
+    }
+    if exponent {
+        ptr::copy_nonoverlapping(b"Infinity".as_ptr(), result.offset(sign as isize), 8);
+        return sign as usize + 8;
+    }
+    ptr::copy_nonoverlapping(b"0E0".as_ptr(), result.offset(sign as isize), 3);
+    sign as usize + 3
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/src/d2s.rs
@@ -0,0 +1,553 @@
+// Translated from C to Rust. The original C code can be found at
+// https://github.com/ulfjack/ryu and carries the following license:
+//
+// Copyright 2018 Ulf Adams
+//
+// The contents of this file may be used under the terms of the Apache License,
+// Version 2.0.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     http://www.apache.org/licenses/LICENSE-2.0)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+
+use core::{mem, ptr};
+
+use common::*;
+#[cfg(not(feature = "small"))]
+use d2s_full_table::*;
+#[cfg(feature = "small")]
+use d2s_small_table::*;
+use digit_table::*;
+#[cfg(not(integer128))]
+use mulshift128::*;
+
+#[cfg(feature = "no-panic")]
+use no_panic::no_panic;
+
+pub const DOUBLE_MANTISSA_BITS: u32 = 52;
+pub const DOUBLE_EXPONENT_BITS: u32 = 11;
+
+const DOUBLE_POW5_INV_BITCOUNT: i32 = 122;
+const DOUBLE_POW5_BITCOUNT: i32 = 121;
+
+#[cfg_attr(feature = "no-panic", inline)]
+fn pow5_factor(mut value: u64) -> u32 {
+    let mut count = 0u32;
+    loop {
+        debug_assert!(value != 0);
+        let q = value / 5;
+        let r = value % 5;
+        if r != 0 {
+            break;
+        }
+        value = q;
+        count += 1;
+    }
+    count
+}
+
+// Returns true if value is divisible by 5^p.
+#[cfg_attr(feature = "no-panic", inline)]
+fn multiple_of_power_of_5(value: u64, p: u32) -> bool {
+    // I tried a case distinction on p, but there was no performance difference.
+    pow5_factor(value) >= p
+}
+
+// Returns true if value is divisible by 2^p.
+#[cfg_attr(feature = "no-panic", inline)]
+fn multiple_of_power_of_2(value: u64, p: u32) -> bool {
+    // return __builtin_ctzll(value) >= p;
+    (value & ((1u64 << p) - 1)) == 0
+}
+
+#[cfg(integer128)]
+#[cfg_attr(feature = "no-panic", inline)]
+fn mul_shift(m: u64, mul: &(u64, u64), j: u32) -> u64 {
+    let b0 = m as u128 * mul.0 as u128;
+    let b2 = m as u128 * mul.1 as u128;
+    (((b0 >> 64) + b2) >> (j - 64)) as u64
+}
+
+#[cfg(integer128)]
+#[cfg_attr(feature = "no-panic", inline)]
+fn mul_shift_all(
+    m: u64,
+    mul: &(u64, u64),
+    j: u32,
+    vp: &mut u64,
+    vm: &mut u64,
+    mm_shift: u32,
+) -> u64 {
+    *vp = mul_shift(4 * m + 2, mul, j);
+    *vm = mul_shift(4 * m - 1 - mm_shift as u64, mul, j);
+    mul_shift(4 * m, mul, j)
+}
+
+#[cfg(not(integer128))]
+#[cfg_attr(feature = "no-panic", inline)]
+fn mul_shift_all(
+    mut m: u64,
+    mul: &(u64, u64),
+    j: u32,
+    vp: &mut u64,
+    vm: &mut u64,
+    mm_shift: u32,
+) -> u64 {
+    m <<= 1;
+    // m is maximum 55 bits
+    let (lo, tmp) = umul128(m, mul.0);
+    let (mut mid, mut hi) = umul128(m, mul.1);
+    mid = mid.wrapping_add(tmp);
+    hi = hi.wrapping_add((mid < tmp) as u64); // overflow into hi
+
+    let lo2 = lo.wrapping_add(mul.0);
+    let mid2 = mid.wrapping_add(mul.1).wrapping_add((lo2 < lo) as u64);
+    let hi2 = hi.wrapping_add((mid2 < mid) as u64);
+    *vp = shiftright128(mid2, hi2, j - 64 - 1);
+
+    if mm_shift == 1 {
+        let lo3 = lo.wrapping_sub(mul.0);
+        let mid3 = mid.wrapping_sub(mul.1).wrapping_sub((lo3 > lo) as u64);
+        let hi3 = hi.wrapping_sub((mid3 > mid) as u64);
+        *vm = shiftright128(mid3, hi3, j - 64 - 1);
+    } else {
+        let lo3 = lo + lo;
+        let mid3 = mid.wrapping_add(mid).wrapping_add((lo3 < lo) as u64);
+        let hi3 = hi.wrapping_add(hi).wrapping_add((mid3 < mid) as u64);
+        let lo4 = lo3.wrapping_sub(mul.0);
+        let mid4 = mid3.wrapping_sub(mul.1).wrapping_sub((lo4 > lo3) as u64);
+        let hi4 = hi3.wrapping_sub((mid4 > mid3) as u64);
+        *vm = shiftright128(mid4, hi4, j - 64);
+    }
+
+    shiftright128(mid, hi, j - 64 - 1)
+}
+
+#[cfg_attr(feature = "no-panic", inline)]
+pub fn decimal_length(v: u64) -> u32 {
+    // This is slightly faster than a loop.
+    // The average output length is 16.38 digits, so we check high-to-low.
+    // Function precondition: v is not an 18, 19, or 20-digit number.
+    // (17 digits are sufficient for round-tripping.)
+    debug_assert!(v < 100000000000000000);
+
+    if v >= 10000000000000000 {
+        17
+    } else if v >= 1000000000000000 {
+        16
+    } else if v >= 100000000000000 {
+        15
+    } else if v >= 10000000000000 {
+        14
+    } else if v >= 1000000000000 {
+        13
+    } else if v >= 100000000000 {
+        12
+    } else if v >= 10000000000 {
+        11
+    } else if v >= 1000000000 {
+        10
+    } else if v >= 100000000 {
+        9
+    } else if v >= 10000000 {
+        8
+    } else if v >= 1000000 {
+        7
+    } else if v >= 100000 {
+        6
+    } else if v >= 10000 {
+        5
+    } else if v >= 1000 {
+        4
+    } else if v >= 100 {
+        3
+    } else if v >= 10 {
+        2
+    } else {
+        1
+    }
+}
+
+// A floating decimal representing m * 10^e.
+pub struct FloatingDecimal64 {
+    pub mantissa: u64,
+    pub exponent: i32,
+}
+
+#[cfg_attr(feature = "no-panic", inline)]
+pub fn d2d(ieee_mantissa: u64, ieee_exponent: u32) -> FloatingDecimal64 {
+    let bias = (1u32 << (DOUBLE_EXPONENT_BITS - 1)) - 1;
+
+    let (e2, m2) = if ieee_exponent == 0 {
+        (
+            // We subtract 2 so that the bounds computation has 2 additional bits.
+            1 - bias as i32 - DOUBLE_MANTISSA_BITS as i32 - 2,
+            ieee_mantissa,
+        )
+    } else {
+        (
+            ieee_exponent as i32 - bias as i32 - DOUBLE_MANTISSA_BITS as i32 - 2,
+            (1u64 << DOUBLE_MANTISSA_BITS) | ieee_mantissa,
+        )
+    };
+    let even = (m2 & 1) == 0;
+    let accept_bounds = even;
+
+    // Step 2: Determine the interval of legal decimal representations.
+    let mv = 4 * m2;
+    // Implicit bool -> int conversion. True is 1, false is 0.
+    let mm_shift = (ieee_mantissa != 0 || ieee_exponent <= 1) as u32;
+    // We would compute mp and mm like this:
+    // uint64_t mp = 4 * m2 + 2;
+    // uint64_t mm = mv - 1 - mm_shift;
+
+    // Step 3: Convert to a decimal power base using 128-bit arithmetic.
+    let mut vr: u64;
+    let mut vp: u64 = unsafe { mem::uninitialized() };
+    let mut vm: u64 = unsafe { mem::uninitialized() };
+    let e10: i32;
+    let mut vm_is_trailing_zeros = false;
+    let mut vr_is_trailing_zeros = false;
+    if e2 >= 0 {
+        // I tried special-casing q == 0, but there was no effect on performance.
+        // This expression is slightly faster than max(0, log10_pow2(e2) - 1).
+        let q = (log10_pow2(e2) - (e2 > 3) as i32) as u32;
+        e10 = q as i32;
+        let k = DOUBLE_POW5_INV_BITCOUNT + pow5bits(q as i32) as i32 - 1;
+        let i = -e2 + q as i32 + k;
+        vr = mul_shift_all(
+            m2,
+            #[cfg(feature = "small")]
+            unsafe {
+                &compute_inv_pow5(q)
+            },
+            #[cfg(not(feature = "small"))]
+            unsafe {
+                debug_assert!(q < DOUBLE_POW5_INV_SPLIT.len() as u32);
+                DOUBLE_POW5_INV_SPLIT.get_unchecked(q as usize)
+            },
+            i as u32,
+            &mut vp,
+            &mut vm,
+            mm_shift,
+        );
+        if q <= 21 {
+            // This should use q <= 22, but I think 21 is also safe. Smaller values
+            // may still be safe, but it's more difficult to reason about them.
+            // Only one of mp, mv, and mm can be a multiple of 5, if any.
+            if mv % 5 == 0 {
+                vr_is_trailing_zeros = multiple_of_power_of_5(mv, q);
+            } else if accept_bounds {
+                // Same as min(e2 + (~mm & 1), pow5_factor(mm)) >= q
+                // <=> e2 + (~mm & 1) >= q && pow5_factor(mm) >= q
+                // <=> true && pow5_factor(mm) >= q, since e2 >= q.
+                vm_is_trailing_zeros = multiple_of_power_of_5(mv - 1 - mm_shift as u64, q);
+            } else {
+                // Same as min(e2 + 1, pow5_factor(mp)) >= q.
+                vp -= multiple_of_power_of_5(mv + 2, q) as u64;
+            }
+        }
+    } else {
+        // This expression is slightly faster than max(0, log10_pow5(-e2) - 1).
+        let q = (log10_pow5(-e2) - (-e2 > 1) as i32) as u32;
+        e10 = q as i32 + e2;
+        let i = -e2 - q as i32;
+        let k = pow5bits(i) as i32 - DOUBLE_POW5_BITCOUNT;
+        let j = q as i32 - k;
+        vr = mul_shift_all(
+            m2,
+            #[cfg(feature = "small")]
+            unsafe {
+                &compute_pow5(i as u32)
+            },
+            #[cfg(not(feature = "small"))]
+            unsafe {
+                debug_assert!(i < DOUBLE_POW5_SPLIT.len() as i32);
+                DOUBLE_POW5_SPLIT.get_unchecked(i as usize)
+            },
+            j as u32,
+            &mut vp,
+            &mut vm,
+            mm_shift,
+        );
+        if q <= 1 {
+            // {vr,vp,vm} is trailing zeros if {mv,mp,mm} has at least q trailing 0 bits.
+            // mv = 4 * m2, so it always has at least two trailing 0 bits.
+            vr_is_trailing_zeros = true;
+            if accept_bounds {
+                // mm = mv - 1 - mm_shift, so it has 1 trailing 0 bit iff mm_shift == 1.
+                vm_is_trailing_zeros = mm_shift == 1;
+            } else {
+                // mp = mv + 2, so it always has at least one trailing 0 bit.
+                vp -= 1;
+            }
+        } else if q < 63 {
+            // TODO(ulfjack): Use a tighter bound here.
+            // We need to compute min(ntz(mv), pow5_factor(mv) - e2) >= q - 1
+            // <=> ntz(mv) >= q - 1  &&  pow5_factor(mv) - e2 >= q - 1
+            // <=> ntz(mv) >= q - 1    (e2 is negative and -e2 >= q)
+            // <=> (mv & ((1 << (q - 1)) - 1)) == 0
+            // We also need to make sure that the left shift does not overflow.
+            vr_is_trailing_zeros = multiple_of_power_of_2(mv, q - 1);
+        }
+    }
+
+    // Step 4: Find the shortest decimal representation in the interval of legal representations.
+    let mut removed = 0u32;
+    let mut last_removed_digit = 0u8;
+    // On average, we remove ~2 digits.
+    let output = if vm_is_trailing_zeros || vr_is_trailing_zeros {
+        // General case, which happens rarely (~0.7%).
+        while vp / 10 > vm / 10 {
+            vm_is_trailing_zeros &= vm - (vm / 10) * 10 == 0;
+            vr_is_trailing_zeros &= last_removed_digit == 0;
+            last_removed_digit = (vr % 10) as u8;
+            vr /= 10;
+            vp /= 10;
+            vm /= 10;
+            removed += 1;
+        }
+        if vm_is_trailing_zeros {
+            while vm % 10 == 0 {
+                vr_is_trailing_zeros &= last_removed_digit == 0;
+                last_removed_digit = (vr % 10) as u8;
+                vr /= 10;
+                vp /= 10;
+                vm /= 10;
+                removed += 1;
+            }
+        }
+        if vr_is_trailing_zeros && last_removed_digit == 5 && vr % 2 == 0 {
+            // Round even if the exact number is .....50..0.
+            last_removed_digit = 4;
+        }
+        // We need to take vr + 1 if vr is outside bounds or we need to round up.
+        vr + ((vr == vm && (!accept_bounds || !vm_is_trailing_zeros)) || last_removed_digit >= 5)
+            as u64
+    } else {
+        // Specialized for the common case (~99.3%). Percentages below are relative to this.
+        let mut round_up = false;
+        // Optimization: remove two digits at a time (~86.2%).
+        if vp / 100 > vm / 100 {
+            round_up = vr % 100 >= 50;
+            vr /= 100;
+            vp /= 100;
+            vm /= 100;
+            removed += 2;
+        }
+        // Loop iterations below (approximately), without optimization above:
+        // 0: 0.03%, 1: 13.8%, 2: 70.6%, 3: 14.0%, 4: 1.40%, 5: 0.14%, 6+: 0.02%
+        // Loop iterations below (approximately), with optimization above:
+        // 0: 70.6%, 1: 27.8%, 2: 1.40%, 3: 0.14%, 4+: 0.02%
+        while vp / 10 > vm / 10 {
+            round_up = vr % 10 >= 5;
+            vr /= 10;
+            vp /= 10;
+            vm /= 10;
+            removed += 1;
+        }
+        // We need to take vr + 1 if vr is outside bounds or we need to round up.
+        vr + (vr == vm || round_up) as u64
+    };
+    let exp = e10 + removed as i32;
+
+    FloatingDecimal64 {
+        exponent: exp,
+        mantissa: output,
+    }
+}
+
+#[cfg_attr(feature = "no-panic", inline)]
+unsafe fn to_chars(v: FloatingDecimal64, sign: bool, result: *mut u8) -> usize {
+    // Step 5: Print the decimal representation.
+    let mut index = 0isize;
+    if sign {
+        *result.offset(index) = b'-';
+        index += 1;
+    }
+
+    let mut output = v.mantissa;
+    let olength = decimal_length(output);
+
+    // Print the decimal digits.
+    // The following code is equivalent to:
+    // for (uint32_t i = 0; i < olength - 1; ++i) {
+    //   const uint32_t c = output % 10; output /= 10;
+    //   result[index + olength - i] = (char) ('0' + c);
+    // }
+    // result[index] = '0' + output % 10;
+
+    let mut i = 0isize;
+    // We prefer 32-bit operations, even on 64-bit platforms.
+    // We have at most 17 digits, and uint32_t can store 9 digits.
+    // If output doesn't fit into uint32_t, we cut off 8 digits,
+    // so the rest will fit into uint32_t.
+    if (output >> 32) != 0 {
+        // Expensive 64-bit division.
+        let mut output2 = (output - 100000000 * (output / 100000000)) as u32;
+        output /= 100000000;
+
+        let c = output2 % 10000;
+        output2 /= 10000;
+        let d = output2 % 10000;
+        let c0 = (c % 100) << 1;
+        let c1 = (c / 100) << 1;
+        let d0 = (d % 100) << 1;
+        let d1 = (d / 100) << 1;
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked(c0 as usize),
+            result.offset(index + olength as isize - i - 1),
+            2,
+        );
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked(c1 as usize),
+            result.offset(index + olength as isize - i - 3),
+            2,
+        );
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked(d0 as usize),
+            result.offset(index + olength as isize - i - 5),
+            2,
+        );
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked(d1 as usize),
+            result.offset(index + olength as isize - i - 7),
+            2,
+        );
+        i += 8;
+    }
+    let mut output2 = output as u32;
+    while output2 >= 10000 {
+        let c = (output2 - 10000 * (output2 / 10000)) as u32;
+        output2 /= 10000;
+        let c0 = (c % 100) << 1;
+        let c1 = (c / 100) << 1;
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked(c0 as usize),
+            result.offset(index + olength as isize - i - 1),
+            2,
+        );
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked(c1 as usize),
+            result.offset(index + olength as isize - i - 3),
+            2,
+        );
+        i += 4;
+    }
+    if output2 >= 100 {
+        let c = ((output2 % 100) << 1) as u32;
+        output2 /= 100;
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked(c as usize),
+            result.offset(index + olength as isize - i - 1),
+            2,
+        );
+        i += 2;
+    }
+    if output2 >= 10 {
+        let c = (output2 << 1) as u32;
+        // We can't use memcpy here: the decimal dot goes between these two digits.
+        *result.offset(index + olength as isize - i) = *DIGIT_TABLE.get_unchecked(c as usize + 1);
+        *result.offset(index) = *DIGIT_TABLE.get_unchecked(c as usize);
+    } else {
+        *result.offset(index) = b'0' + output2 as u8;
+    }
+
+    // Print decimal point if needed.
+    if olength > 1 {
+        *result.offset(index + 1) = b'.';
+        index += olength as isize + 1;
+    } else {
+        index += 1;
+    }
+
+    // Print the exponent.
+    *result.offset(index) = b'E';
+    index += 1;
+    let mut exp = v.exponent as i32 + olength as i32 - 1;
+    if exp < 0 {
+        *result.offset(index) = b'-';
+        index += 1;
+        exp = -exp;
+    }
+
+    if exp >= 100 {
+        let c = exp % 10;
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked((2 * (exp / 10)) as usize),
+            result.offset(index),
+            2,
+        );
+        *result.offset(index + 2) = b'0' + c as u8;
+        index += 3;
+    } else if exp >= 10 {
+        ptr::copy_nonoverlapping(
+            DIGIT_TABLE.get_unchecked((2 * exp) as usize),
+            result.offset(index),
+            2,
+        );
+        index += 2;
+    } else {
+        *result.offset(index) = b'0' + exp as u8;
+        index += 1;
+    }
+
+    debug_assert!(index <= 24);
+    index as usize
+}
+
+/// Print f64 to the given buffer and return number of bytes written.
+///
+/// At most 24 bytes will be written.
+///
+/// ## Special cases
+///
+/// This function represents any NaN as `NaN`, positive infinity as `Infinity`,
+/// and negative infinity as `-Infinity`.
+///
+/// ## Safety
+///
+/// The `result` pointer argument must point to sufficiently many writable bytes
+/// to hold Ryū's representation of `f`.
+///
+/// ## Example
+///
+/// ```rust
+/// let f = 1.234f64;
+///
+/// unsafe {
+///     let mut buffer: [u8; 24] = std::mem::uninitialized();
+///     let n = ryu::raw::d2s_buffered_n(f, &mut buffer[0]);
+///     let s = std::str::from_utf8_unchecked(&buffer[..n]);
+///     assert_eq!(s, "1.234E0");
+/// }
+/// ```
+#[cfg_attr(must_use_return, must_use)]
+#[cfg_attr(feature = "no-panic", no_panic)]
+pub unsafe fn d2s_buffered_n(f: f64, result: *mut u8) -> usize {
+    // Step 1: Decode the floating-point number, and unify normalized and subnormal cases.
+    let bits = mem::transmute::<f64, u64>(f);
+
+    // Decode bits into sign, mantissa, and exponent.
+    let ieee_sign = ((bits >> (DOUBLE_MANTISSA_BITS + DOUBLE_EXPONENT_BITS)) & 1) != 0;
+    let ieee_mantissa = bits & ((1u64 << DOUBLE_MANTISSA_BITS) - 1);
+    let ieee_exponent =
+        (bits >> DOUBLE_MANTISSA_BITS) as u32 & ((1u32 << DOUBLE_EXPONENT_BITS) - 1);
+    // Case distinction; exit early for the easy cases.
+    if ieee_exponent == ((1u32 << DOUBLE_EXPONENT_BITS) - 1)
+        || (ieee_exponent == 0 && ieee_mantissa == 0)
+    {
+        return copy_special_str(result, ieee_sign, ieee_exponent != 0, ieee_mantissa != 0);
+    }
+
+    let v = d2d(ieee_mantissa, ieee_exponent);
+    to_chars(v, ieee_sign, result)
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/ryu/src/d2s_full_table.rs
@@ -0,0 +1,643 @@
+// Translated from C to Rust. The original C code can be found at
+// https://github.com/ulfjack/ryu and carries the following license:
+//
+// Copyright 2018 Ulf Adams
+//
+// The contents of this file may be used under the terms of the Apache License,
+// Version 2.0.
+//
+//    (See accompanying file LICENSE-Apache or copy at
+//     http://www.apache.org/licenses/LICENSE-2.0)
+//
+// Alternatively, the contents of this file may be used under the terms of
+// the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE-Boost or copy at
+//     https://www.boost.org/LICENSE_1_0.txt)
+//
+// Unless required by applicable law or agreed to in writing, this software
+// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.
+
+pub static DOUBLE_POW5_INV_SPLIT: [(u64, u64); 292] = [
+    (1, 288230376151711744),
+    (3689348814741910324, 230584300921369395),
+    (2951479051793528259, 184467440737095516),
+    (17118578500402463900, 147573952589676412),
+    (12632330341676300947, 236118324143482260),
+    (10105864273341040758, 188894659314785808),
+    (15463389048156653253, 151115727451828646),
+    (17362724847566824558, 241785163922925834),
+    (17579528692795369969, 193428131138340667),
+    (6684925324752475329, 154742504910672534),
+    (18074578149087781173, 247588007857076054),
+    (18149011334012135262, 198070406285660843),
+    (3451162622983977240, 158456325028528675),
+    (5521860196774363583, 253530120045645880),
+    (4417488157419490867, 202824096036516704),
+    (7223339340677503017, 162259276829213363),
+    (7867994130342094503, 259614842926741381),
+    (2605046489531765280, 207691874341393105),
+    (2084037191625412224, 166153499473114484),
+    (10713157136084480204, 265845599156983174),
+    (12259874523609494487, 212676479325586539),
+    (13497248433629505913, 170141183460469231),
+    (14216899864323388813, 272225893536750770),
+    (11373519891458711051, 217780714829400616),
+    (5409467098425058518, 174224571863520493),
+    (4965798542738183305, 278759314981632789),
+    (7661987648932456967, 223007451985306231),
+    (2440241304404055250, 178405961588244985),
+    (3904386087046488400, 285449538541191976),
+    (17880904128604832013, 228359630832953580),
+    (14304723302883865611, 182687704666362864),
+    (15133127457049002812, 146150163733090291),
+    (16834306301794583852, 233840261972944466),
+    (9778096226693756759, 187072209578355573),
+    (15201174610838826053, 149657767662684458),
+    (2185786488890659746, 239452428260295134),
+    (5437978005854438120, 191561942608236107),
+    (15418428848909281466, 153249554086588885),
+    (6222742084545298729, 245199286538542217),
+    (16046240111861969953, 196159429230833773),
+    (1768945645263844993, 156927543384667019),
+    (10209010661905972635, 251084069415467230),
+    (8167208529524778108, 200867255532373784),
+    (10223115638361732810, 160693804425899027),
+    (1599589762411131202, 257110087081438444),
+    (4969020624670815285, 205688069665150755),
+    (3975216499736652228, 164550455732120604),
+    (13739044029062464211, 263280729171392966),
+    (7301886408508061046, 210624583337114373),
+    (13220206756290269483, 168499666669691498),
+    (17462981995322520850, 269599466671506397),
+    (6591687966774196033, 215679573337205118),
+    (12652048002903177473, 172543658669764094),
+    (9175230360419352987, 276069853871622551),
+    (3650835473593572067, 220855883097298041),
+    (17678063637842498946, 176684706477838432),
+    (13527506561580357021, 282695530364541492),
+    (3443307619780464970, 226156424291633194),
+    (6443994910566282300, 180925139433306555),
+    (5155195928453025840, 144740111546645244),
+    (15627011115008661990, 231584178474632390),
+    (12501608892006929592, 185267342779705912),
+    (2622589484121723027, 148213874223764730),
+    (4196143174594756843, 237142198758023568),
+    (10735612169159626121, 189713759006418854),
+    (12277838550069611220, 151771007205135083),
+    (15955192865369467629, 242833611528216133),
+    (1696107848069843133, 194266889222572907),
+    (12424932722681605476, 155413511378058325),
+    (1433148282581017146, 248661618204893321),
+    (15903913885032455010, 198929294563914656),
+    (9033782293284053685, 159143435651131725),
+    (14454051669254485895, 254629497041810760),
+    (11563241335403588716, 203703597633448608),
+    (16629290697806691620, 162962878106758886),
+    (781423413297334329, 260740604970814219),
+    (4314487545379777786, 208592483976651375),
+    (3451590036303822229, 166873987181321100),
+    (5522544058086115566, 266998379490113760),
+    (4418035246468892453, 213598703592091008),
+    (10913125826658934609, 170878962873672806),
+    (10082303693170474728, 273406340597876490),
+    (8065842954536379782, 218725072478301192),
+    (17520720807854834795, 174980057982640953),
+    (5897060404116273733, 279968092772225526),
+    (1028299508551108663, 223974474217780421),
+    (15580034865808528224, 179179579374224336),
+    (17549358155809824511, 286687326998758938),
+    (2971440080422128639, 229349861599007151),
+    (17134547323305344204, 183479889279205720),
+    (13707637858644275364, 146783911423364576),
+    (14553522944347019935, 234854258277383322),
+    (4264120725993795302, 187883406621906658),
+    (10789994210278856888, 150306725297525326),
+    (9885293106962350374, 240490760476040522),
+    (529536856086059653, 192392608380832418),
+    (7802327114352668369, 153914086704665934),
+    (1415676938738538420, 246262538727465495),
+    (1132541550990830736, 197010030981972396),
+    (15663428499760305882, 157608024785577916),
+    (17682787970132668764, 252172839656924666),
+    (10456881561364224688, 201738271725539733),
+    (15744202878575200397, 161390617380431786),
+    (17812026976236499989, 258224987808690858),
+    (3181575136763469022, 206579990246952687),
+    (13613306553636506187, 165263992197562149),
+    (10713244041592678929, 264422387516099439),
+    (12259944048016053467, 211537910012879551),
+    (6118606423670932450, 169230328010303641),
+    (2411072648389671274, 270768524816485826),
+    (16686253377679378312, 216614819853188660),
+    (13349002702143502650, 173291855882550928),
+    (17669055508687693916, 277266969412081485),
+    (14135244406950155133, 221813575529665188),
+    (240149081334393137, 177450860423732151),
+    (11452284974360759988, 283921376677971441),
+    (5472479164746697667, 227137101342377153),
+    (11756680961281178780, 181709681073901722),
+    (2026647139541122378, 145367744859121378),
+    (18000030682233437097, 232588391774594204),
+    (18089373360528660001, 186070713419675363),
+    (3403452244197197031, 148856570735740291),
+    (16513570034941246220, 238170513177184465),
+    (13210856027952996976, 190536410541747572),
+    (3189987192878576934, 152429128433398058),
+    (1414630693863812771, 243886605493436893),
+    (8510402184574870864, 195109284394749514),
+    (10497670562401807014, 156087427515799611),
+    (9417575270359070576, 249739884025279378),
+    (14912757845771077107, 199791907220223502),
+    (4551508647133041040, 159833525776178802),
+    (10971762650154775986, 255733641241886083),
+    (16156107749607641435, 204586912993508866),
+    (9235537384944202825, 163669530394807093),
+    (11087511001168814197, 261871248631691349),
+    (12559357615676961681, 209496998905353079),
+    (13736834907283479668, 167597599124282463),
+    (18289587036911657145, 268156158598851941),
+    (10942320814787415393, 214524926879081553),
+    (16132554281313752961, 171619941503265242),
+    (11054691591134363444, 274591906405224388),
+    (16222450902391311402, 219673525124179510),
+    (12977960721913049122, 175738820099343608),
+    (17075388340318968271, 281182112158949773),
+    (2592264228029443648, 224945689727159819),
+    (5763160197165465241, 179956551781727855),
+    (9221056315464744386, 287930482850764568),
+    (14755542681855616155, 230344386280611654),
+    (15493782960226403247, 184275509024489323),
+    (1326979923955391628, 147420407219591459),
+    (9501865507812447252, 235872651551346334),
+    (11290841220991868125, 188698121241077067),
+    (1653975347309673853, 150958496992861654),
+    (10025058185179298811, 241533595188578646),
+    (4330697733401528726, 193226876150862917),
+    (14532604630946953951, 154581500920690333),
+    (1116074521063664381, 247330401473104534),
+    (4582208431592841828, 197864321178483627),
+    (14733813189500004432, 158291456942786901),
+    (16195403473716186445, 253266331108459042),
+    (5577625149489128510, 202613064886767234),
+    (8151448934333213131, 162090451909413787),
+    (16731667109675051333, 259344723055062059),
+    (17074682502481951390, 207475778444049647),
+    (6281048372501740465, 165980622755239718),
+    (6360328581260874421, 265568996408383549),
+    (8777611679750609860, 212455197126706839),
+    (10711438158542398211, 169964157701365471),
+    (9759603424184016492, 271942652322184754),
+    (11497031554089123517, 217554121857747803),
+    (16576322872755119460, 174043297486198242),
+    (11764721337440549842, 278469275977917188),
+    (16790474699436260520, 222775420782333750),
+    (13432379759549008416, 178220336625867000),
+    (3045063541568861850, 285152538601387201),
+    (17193446092222730773, 228122030881109760),
+    (13754756873778184618, 182497624704887808),
+    (18382503128506368341, 145998099763910246),
+    (3586563302416817083, 233596959622256395),
+    (2869250641933453667, 186877567697805116),
+    (17052795772514404226, 149502054158244092),
+    (12527077977055405469, 239203286653190548),
+    (17400360011128145022, 191362629322552438),
+    (2852241564676785048, 153090103458041951),
+    (15631632947708587046, 244944165532867121),
+    (8815957543424959314, 195955332426293697),
+    (18120812478965698421, 156764265941034957),
+    (14235904707377476180, 250822825505655932),
+    (4010026136418160298, 200658260404524746),
+    (17965416168102169531, 160526608323619796),
+    (2919224165770098987, 256842573317791675),
+    (2335379332616079190, 205474058654233340),
+    (1868303466092863352, 164379246923386672),
+    (6678634360490491686, 263006795077418675),
+    (5342907488392393349, 210405436061934940),
+    (4274325990713914679, 168324348849547952),
+    (10528270399884173809, 269318958159276723),
+    (15801313949391159694, 215455166527421378),
+    (1573004715287196786, 172364133221937103),
+    (17274202803427156150, 275782613155099364),
+    (17508711057483635243, 220626090524079491),
+    (10317620031244997871, 176500872419263593),
+    (12818843235250086271, 282401395870821749),
+    (13944423402941979340, 225921116696657399),
+    (14844887537095493795, 180736893357325919),
+    (15565258844418305359, 144589514685860735),
+    (6457670077359736959, 231343223497377177),
+    (16234182506113520537, 185074578797901741),
+    (9297997190148906106, 148059663038321393),
+    (11187446689496339446, 236895460861314229),
+    (12639306166338981880, 189516368689051383),
+    (17490142562555006151, 151613094951241106),
+    (2158786396894637579, 242580951921985771),
+    (16484424376483351356, 194064761537588616),
+    (9498190686444770762, 155251809230070893),
+    (11507756283569722895, 248402894768113429),
+    (12895553841597688639, 198722315814490743),
+    (17695140702761971558, 158977852651592594),
+    (17244178680193423523, 254364564242548151),
+    (10105994129412828495, 203491651394038521),
+    (4395446488788352473, 162793321115230817),
+    (10722063196803274280, 260469313784369307),
+    (1198952927958798777, 208375451027495446),
+    (15716557601334680315, 166700360821996356),
+    (17767794532651667857, 266720577315194170),
+    (14214235626121334286, 213376461852155336),
+    (7682039686155157106, 170701169481724269),
+    (1223217053622520399, 273121871170758831),
+    (15735968901865657612, 218497496936607064),
+    (16278123936234436413, 174797997549285651),
+    (219556594781725998, 279676796078857043),
+    (7554342905309201445, 223741436863085634),
+    (9732823138989271479, 178993149490468507),
+    (815121763415193074, 286389039184749612),
+    (11720143854957885429, 229111231347799689),
+    (13065463898708218666, 183288985078239751),
+    (6763022304224664610, 146631188062591801),
+    (3442138057275642729, 234609900900146882),
+    (13821756890046245153, 187687920720117505),
+    (11057405512036996122, 150150336576094004),
+    (6623802375033462826, 240240538521750407),
+    (16367088344252501231, 192192430817400325),
+    (13093670675402000985, 153753944653920260),
+    (2503129006933649959, 246006311446272417),
+    (13070549649772650937, 196805049157017933),
+    (17835137349301941396, 157444039325614346),
+    (2710778055689733971, 251910462920982955),
+    (2168622444551787177, 201528370336786364),
+    (5424246770383340065, 161222696269429091),
+    (1300097203129523457, 257956314031086546),
+    (15797473021471260058, 206365051224869236),
+    (8948629602435097724, 165092040979895389),
+    (3249760919670425388, 264147265567832623),
+    (9978506365220160957, 211317812454266098),
+    (15361502721659949412, 169054249963412878),
+    (2442311466204457120, 270486799941460606),
+    (16711244431931206989, 216389439953168484),
+    (17058344360286875914, 173111551962534787),
+    (12535955717491360170, 276978483140055660),
+    (10028764573993088136, 221582786512044528),
+    (15401709288678291155, 177266229209635622),
+    (9885339602917624555, 283625966735416996),
+    (4218922867592189321, 226900773388333597),
+    (14443184738299482427, 181520618710666877),
+    (4175850161155765295, 145216494968533502),
+    (10370709072591134795, 232346391949653603),
+    (15675264887556728482, 185877113559722882),
+    (5161514280561562140, 148701690847778306),
+    (879725219414678777, 237922705356445290),
+    (703780175531743021, 190338164285156232),
+    (11631070584651125387, 152270531428124985),
+    (162968861732249003, 243632850284999977),
+    (11198421533611530172, 194906280227999981),
+    (5269388412147313814, 155925024182399985),
+    (8431021459435702103, 249480038691839976),
+    (3055468352806651359, 199584030953471981),
+    (17201769941212962380, 159667224762777584),
+    (16454785461715008838, 255467559620444135),
+    (13163828369372007071, 204374047696355308),
+    (17909760324981426303, 163499238157084246),
+    (2830174816776909822, 261598781051334795),
+    (2264139853421527858, 209279024841067836),
+    (16568707141704863579, 167423219872854268),
+    (4373838538276319787, 267877151796566830),
+    (3499070830621055830, 214301721437253464),
+    (6488605479238754987, 171441377149802771),
+    (3003071137298187333, 274306203439684434),
+    (6091805724580460189, 219444962751747547),
+    (15941491023890099121, 175555970201398037),
+    (10748990379256517301, 280889552322236860),
+    (8599192303405213841, 224711641857789488),
+    (14258051472207991719, 179769313486231590),
+];
+
+pub static DOUBLE_POW5_SPLIT: [(u64, u64); 326] = [
+    (0, 72057594037927936),
+    (0, 90071992547409920),
+    (0, 112589990684262400),
+    (0, 140737488355328000),
+    (0, 87960930222080000),
+    (0, 109951162777600000),
+    (0, 137438953472000000),
+    (0, 85899345920000000),
+    (0, 107374182400000000),
+    (0, 134217728000000000),
+    (0, 83886080000000000),
+    (0, 104857600000000000),
+    (0, 131072000000000000),
+    (0, 81920000000000000),
+    (0, 102400000000000000),
+    (0, 128000000000000000),
+    (0, 80000000000000000),
+    (0, 100000000000000000),
+    (0, 125000000000000000),
+    (0, 78125000000000000),
+    (0, 97656250000000000),
+    (0, 122070312500000000),
+    (0, 76293945312500000),
+    (0, 95367431640625000),
+    (0, 119209289550781250),
+    (4611686018427387904, 74505805969238281),
+    (10376293541461622784, 93132257461547851),
+    (8358680908399640576, 116415321826934814),
+    (612489549322387456, 72759576141834259),
+    (14600669991935148032, 90949470177292823),
+    (13639151471491547136, 113686837721616029),
+    (3213881284082270208, 142108547152020037),
+    (4314518811765112832, 88817841970012523),
+    (781462496279003136, 111022302462515654),
+    (10200200157203529728, 138777878078144567),
+    (13292654125893287936, 86736173798840354),
+    (7392445620511834112, 108420217248550443),
+    (4628871007212404736, 135525271560688054),
+    (16728102434789916672, 84703294725430033),
+    (7075069988205232128, 105879118406787542),
+    (18067209522111315968, 132348898008484427),
+    (8986162942105878528, 82718061255302767),
+    (6621017659204960256, 103397576569128459),
+    (3664586055578812416, 129246970711410574),
+    (16125424340018921472, 80779356694631608),
+    (1710036351314100224, 100974195868289511),
+    (15972603494424788992, 126217744835361888),
+    (9982877184015493120, 78886090522101180),
+    (12478596480019366400, 98607613152626475),
+    (10986559581596820096, 123259516440783094),
+    (2254913720070624656, 77037197775489434),
+    (12042014186943056628, 96296497219361792),
+    (15052517733678820785, 120370621524202240),
+    (9407823583549262990, 75231638452626400),
+    (11759779479436578738, 94039548065783000),
+    (14699724349295723422, 117549435082228750),
+    (4575641699882439235, 73468396926392969),
+    (10331238143280436948, 91835496157991211),
+    (8302361660673158281, 114794370197489014),
+    (1154580038986672043, 143492962746861268),
+    (9944984561221445835, 89683101716788292),
+    (12431230701526807293, 112103877145985365),
+    (1703980321626345405, 140129846432481707),
+    (17205888765512323542, 87581154020301066),
+    (12283988920035628619, 109476442525376333),
+    (1519928094762372062, 136845553156720417),
+    (12479170105294952299, 85528470722950260),
+    (15598962631618690374, 106910588403687825),
+    (5663645234241199255, 133638235504609782),
+    (17374836326682913246, 83523897190381113),
+    (7883487353071477846, 104404871487976392),
+    (9854359191339347308, 130506089359970490),
+    (10770660513014479971, 81566305849981556),
+    (13463325641268099964, 101957882312476945),
+    (2994098996302961243, 127447352890596182),
+    (15706369927971514489, 79654595556622613),
+    (5797904354682229399, 99568244445778267),
+    (2635694424925398845, 124460305557222834),
+    (6258995034005762182, 77787690973264271),
+    (3212057774079814824, 97234613716580339),
+    (17850130272881932242, 121543267145725423),
+    (18073860448192289507, 75964541966078389),
+    (8757267504958198172, 94955677457597987),
+    (6334898362770359811, 118694596821997484),
+    (13182683513586250689, 74184123013748427),
+    (11866668373555425458, 92730153767185534),
+    (5609963430089506015, 115912692208981918),
+    (17341285199088104971, 72445432630613698),
+    (12453234462005355406, 90556790788267123),
+    (10954857059079306353, 113195988485333904),
+    (13693571323849132942, 141494985606667380),
+    (17781854114260483896, 88434366004167112),
+    (3780573569116053255, 110542957505208891),
+    (114030942967678664, 138178696881511114),
+    (4682955357782187069, 86361685550944446),
+    (15077066234082509644, 107952106938680557),
+    (5011274737320973344, 134940133673350697),
+    (14661261756894078100, 84337583545844185),
+    (4491519140835433913, 105421979432305232),
+    (5614398926044292391, 131777474290381540),
+    (12732371365632458552, 82360921431488462),
+    (6692092170185797382, 102951151789360578),
+    (17588487249587022536, 128688939736700722),
+    (15604490549419276989, 80430587335437951),
+    (14893927168346708332, 100538234169297439),
+    (14005722942005997511, 125672792711621799),
+    (15671105866394830300, 78545495444763624),
+    (1142138259283986260, 98181869305954531),
+    (15262730879387146537, 122727336632443163),
+    (7233363790403272633, 76704585395276977),
+    (13653390756431478696, 95880731744096221),
+    (3231680390257184658, 119850914680120277),
+    (4325643253124434363, 74906821675075173),
+    (10018740084832930858, 93633527093843966),
+    (3300053069186387764, 117041908867304958),
+    (15897591223523656064, 73151193042065598),
+    (10648616992549794273, 91438991302581998),
+    (4087399203832467033, 114298739128227498),
+    (14332621041645359599, 142873423910284372),
+    (18181260187883125557, 89295889943927732),
+    (4279831161144355331, 111619862429909666),
+    (14573160988285219972, 139524828037387082),
+    (13719911636105650386, 87203017523366926),
+    (7926517508277287175, 109003771904208658),
+    (684774848491833161, 136254714880260823),
+    (7345513307948477581, 85159196800163014),
+    (18405263671790372785, 106448996000203767),
+    (18394893571310578077, 133061245000254709),
+    (13802651491282805250, 83163278125159193),
+    (3418256308821342851, 103954097656448992),
+    (4272820386026678563, 129942622070561240),
+    (2670512741266674102, 81214138794100775),
+    (17173198981865506339, 101517673492625968),
+    (3019754653622331308, 126897091865782461),
+    (4193189667727651020, 79310682416114038),
+    (14464859121514339583, 99138353020142547),
+    (13469387883465536574, 123922941275178184),
+    (8418367427165960359, 77451838296986365),
+    (15134645302384838353, 96814797871232956),
+    (471562554271496325, 121018497339041196),
+    (9518098633274461011, 75636560836900747),
+    (7285937273165688360, 94545701046125934),
+    (18330793628311886258, 118182126307657417),
+    (4539216990053847055, 73863828942285886),
+    (14897393274422084627, 92329786177857357),
+    (4786683537745442072, 115412232722321697),
+    (14520892257159371055, 72132645451451060),
+    (18151115321449213818, 90165806814313825),
+    (8853836096529353561, 112707258517892282),
+    (1843923083806916143, 140884073147365353),
+    (12681666973447792349, 88052545717103345),
+    (2017025661527576725, 110065682146379182),
+    (11744654113764246714, 137582102682973977),
+    (422879793461572340, 85988814176858736),
+    (528599741826965425, 107486017721073420),
+    (660749677283706782, 134357522151341775),
+    (7330497575943398595, 83973451344588609),
+    (13774807988356636147, 104966814180735761),
+    (3383451930163631472, 131208517725919702),
+    (15949715511634433382, 82005323578699813),
+    (6102086334260878016, 102506654473374767),
+    (3015921899398709616, 128133318091718459),
+    (18025852251620051174, 80083323807324036),
+    (4085571240815512351, 100104154759155046),
+    (14330336087874166247, 125130193448943807),
+    (15873989082562435760, 78206370905589879),
+    (15230800334775656796, 97757963631987349),
+    (5203442363187407284, 122197454539984187),
+    (946308467778435600, 76373409087490117),
+    (5794571603150432404, 95466761359362646),
+    (16466586540792816313, 119333451699203307),
+    (7985773578781816244, 74583407312002067),
+    (5370530955049882401, 93229259140002584),
+    (6713163693812353001, 116536573925003230),
+    (18030785363914884337, 72835358703127018),
+    (13315109668038829614, 91044198378908773),
+    (2808829029766373305, 113805247973635967),
+    (17346094342490130344, 142256559967044958),
+    (6229622945628943561, 88910349979403099),
+    (3175342663608791547, 111137937474253874),
+    (13192550366365765242, 138922421842817342),
+    (3633657960551215372, 86826513651760839),
+    (18377130505971182927, 108533142064701048),
+    (4524669058754427043, 135666427580876311),
+    (9745447189362598758, 84791517238047694),
+    (2958436949848472639, 105989396547559618),
+    (12921418224165366607, 132486745684449522),
+    (12687572408530742033, 82804216052780951),
+    (11247779492236039638, 103505270065976189),
+    (224666310012885835, 129381587582470237),
+    (2446259452971747599, 80863492239043898),
+    (12281196353069460307, 101079365298804872),
+    (15351495441336825384, 126349206623506090),
+    (14206370669262903769, 78968254139691306),
+    (8534591299723853903, 98710317674614133),
+    (15279925143082205283, 123387897093267666),
+    (14161639232853766206, 77117435683292291),
+    (13090363022639819853, 96396794604115364),
+    (16362953778299774816, 120495993255144205),
+    (12532689120651053212, 75309995784465128),
+    (15665861400813816515, 94137494730581410),
+    (10358954714162494836, 117671868413226763),
+    (4168503687137865320, 73544917758266727),
+    (598943590494943747, 91931147197833409),
+    (5360365506546067587, 114913933997291761),
+    (11312142901609972388, 143642417496614701),
+    (9375932322719926695, 89776510935384188),
+    (11719915403399908368, 112220638669230235),
+    (10038208235822497557, 140275798336537794),
+    (10885566165816448877, 87672373960336121),
+    (18218643725697949000, 109590467450420151),
+    (18161618638695048346, 136988084313025189),
+    (13656854658398099168, 85617552695640743),
+    (12459382304570236056, 107021940869550929),
+    (1739169825430631358, 133777426086938662),
+    (14922039196176308311, 83610891304336663),
+    (14040862976792997485, 104513614130420829),
+    (3716020665709083144, 130642017663026037),
+    (4628355925281870917, 81651261039391273),
+    (10397130925029726550, 102064076299239091),
+    (8384727637859770284, 127580095374048864),
+    (5240454773662356427, 79737559608780540),
+    (6550568467077945534, 99671949510975675),
+    (3576524565420044014, 124589936888719594),
+    (6847013871814915412, 77868710555449746),
+    (17782139376623420074, 97335888194312182),
+    (13004302183924499284, 121669860242890228),
+    (17351060901807587860, 76043662651806392),
+    (3242082053549933210, 95054578314757991),
+    (17887660622219580224, 118818222893447488),
+    (11179787888887237640, 74261389308404680),
+    (13974734861109047050, 92826736635505850),
+    (8245046539531533005, 116033420794382313),
+    (16682369133275677888, 72520887996488945),
+    (7017903361312433648, 90651109995611182),
+    (17995751238495317868, 113313887494513977),
+    (8659630992836983623, 141642359368142472),
+    (5412269370523114764, 88526474605089045),
+    (11377022731581281359, 110658093256361306),
+    (4997906377621825891, 138322616570451633),
+    (14652906532082110942, 86451635356532270),
+    (9092761128247862869, 108064544195665338),
+    (2142579373455052779, 135080680244581673),
+    (12868327154477877747, 84425425152863545),
+    (2250350887815183471, 105531781441079432),
+    (2812938609768979339, 131914726801349290),
+    (6369772649532999991, 82446704250843306),
+    (17185587848771025797, 103058380313554132),
+    (3035240737254230630, 128822975391942666),
+    (6508711479211282048, 80514359619964166),
+    (17359261385868878368, 100642949524955207),
+    (17087390713908710056, 125803686906194009),
+    (3762090168551861929, 78627304316371256),
+    (4702612710689827411, 98284130395464070),
+    (15101637925217060072, 122855162994330087),
+    (16356052730901744401, 76784476871456304),
+    (1998321839917628885, 95980596089320381),
+    (7109588318324424010, 119975745111650476),
+    (13666864735807540814, 74984840694781547),
+    (12471894901332038114, 93731050868476934),
+    (6366496589810271835, 117163813585596168),
+    (3979060368631419896, 73227383490997605),
+    (9585511479216662775, 91534229363747006),
+    (2758517312166052660, 114417786704683758),
+    (12671518677062341634, 143022233380854697),
+    (1002170145522881665, 89388895863034186),
+    (10476084718758377889, 111736119828792732),
+    (13095105898447972362, 139670149785990915),
+    (5878598177316288774, 87293843616244322),
+    (16571619758500136775, 109117304520305402),
+    (11491152661270395161, 136