Merging upstream version 1.70.0+dfsg2.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
author: Daniel Baumann <daniel.baumann@progress-linux.org> 2024-05-04 12:41:35 +0000
committer: Daniel Baumann <daniel.baumann@progress-linux.org> 2024-05-04 12:41:35 +0000
commit: 7e5d7eea9c580ef4b41a765bde624af431942b96 (patch)
tree: 2c0d9ca12878fc4525650aa4e54d77a81a07cc09 /vendor/im-rc
parent: Adding debian version 1.70.0+dfsg1-9. (diff)
download: rustc-7e5d7eea9c580ef4b41a765bde624af431942b96.tar.xz
rustc-7e5d7eea9c580ef4b41a765bde624af431942b96.zip
48 files changed, 21484 insertions, 0 deletions
diff --git a/vendor/im-rc/.cargo-checksum.json b/vendor/im-rc/.cargo-checksum.json
new file mode 100644
index 000000000..098be05eb
--- /dev/null
+++ b/vendor/im-rc/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"8dc51178eb616033721246da3a68f58fe4057b892a8360c8b899253efdcc72d1","CODE_OF_CONDUCT.md":"3db9f112c815ffef9a6f51eef2f5f6a3f3c2900510c243f26ad890321b888473","Cargo.toml":"5e1f3a2e1761284562ab23cdb9bb6f9658e8d32344be934106358b5999e6e41c","LICENCE.md":"e6b6566f085df5746515c6d7e2edcaec0d2b77d527ac40d91409d783fb6c8508","README.md":"324883b8da0710ebab5569722ba909dfc734659b11168faf955f1106c5fc400e","build.rs":"0c187f99a0ce4d13fba739f9dc6c92ed1e0f2307984e101556574796c81406cb","proptest-regressions/hash/map.txt":"60c8ddd64ffe9123a8eff434222045f40f24e1261ee9bf07d972e09d46552b1b","proptest-regressions/hash/set.txt":"8952a3432c81fd8f7a89b78b1f6a6f509db8cc606e2a05d7c3ef7d05c3db1b8f","proptest-regressions/ord/map":"087835db5451b9cd5769f1f63a7d73ddef8dfdb4c11855a0fe13be3676ddd967","proptest-regressions/ord/map.txt":"5dc169320ce44ae8ed82173c41856a62f7bee7a2f8f44bf52668e8a2215c3d1c","proptest-regressions/ord/set.txt":"dd5cbfb0cc81817d4093be5094171ace6f7b2b3503099c792e7d5944a234d932","proptest-regressions/ser.txt":"8d7c3b2731be6e56893a0e46bc70a306e68d92c318abe4bf584d743dab3b15ff","proptest-regressions/sort.txt":"1bbe3ff7a20a6ff854fb6061302d6b608cfee46d1140a52dbc8dacd46e093a93","proptest-regressions/tests/ordset.txt":"692dee74e79dee5c5cf28146e64a3571736fdfa941905cd14712038264b5bc18","proptest-regressions/tests/vector.txt":"2f0ff1b033b941062fd255dd49162786d56a0072022c335574010c74e96173e8","proptest-regressions/vector/mod.txt":"953e29432a610e2432d16ba27adfd5259a941d027f93568ee66b20543c584a96","src/arbitrary.rs":"f144751f0b2b1c73a452c760402cf4efc543d4a8c8c5e83aec8bc9a57c7791eb","src/config.rs":"e4416b5b76f6910183e18c2abdc4acc895b88276893caaa00df6c805afd98e36","src/fakepool.rs":"92092d6deca092cf115a926fa1c606db1f14b8ccb736aaaa21d776fb0c5e3cf9","src/hash/map.rs":"94d234ad4af0dc534e642ec2707cb32da5c5ecf06639813e8beeeb4e4311d378","src/hash/mod.rs":"96e9b19b81c59b248c252b9dd085af45a7a45b1f50087aaa2bd94894f2df5706","src/hash/set.rs":"e3c7224a804534905ecb060362f7bdf98866aadfbf300a921f8d35936e88b2a4","src/iter.rs":"dcc1776ba23927feafc9517f488ce506614704e30610ff1f48de61fe7561cee1","src/lib.rs":"16c96265a66a07048cb1029457aacd95ab964bea42a6cc14c1545a5401fe0644","src/nodes/btree.rs":"6971575fd3a21606ff08969c29f75ac3ec4bb632fb0dfc2d53785406c3f83ec1","src/nodes/hamt.rs":"6fcee0007ae99e7b3dc9f920049caee80c819b01055853ec31b8355192cb8386","src/nodes/mod.rs":"0c9bc416bbcea9badef03970e5b6814056da27f0b0fb08d7a3f0ebad7bb396e0","src/nodes/rrb.rs":"eb0c6f451dc65324ec27fb9a51e15d34f5b7379b0c553e2cbe30b2463271717f","src/ord/map.rs":"064bb9367c028cd75f8ff346f1d0759463c0425066640c0aa79153dc37c882a8","src/ord/mod.rs":"96e9b19b81c59b248c252b9dd085af45a7a45b1f50087aaa2bd94894f2df5706","src/ord/set.rs":"4f80912a6e924a5acb7a540f4968cb4eac14ceec1534a664c7cb86750312cbba","src/ord/test-fixtures/issue_124.txt":"b47660b232309abefe3965f168474db05a65bf6d36b0289454aaba6318ffd017","src/proptest.rs":"b7ddb85a996e9a225460c6f649caeab863a04ca19793c20e775b8ac9de86eda8","src/quickcheck.rs":"3998f5fad4bca1de2099e4f684de72bfb3cb258a1585d251566d118a4a79214c","src/ser.rs":"2253cb11a08823c1a09db8a8677818c323bcb1b9483c93d03e8d37a2717a8d24","src/sort.rs":"806b2a3f5f0f5664164d1ef520a596b7eed16e122ded7b881afc4ce5392a12e7","src/sync.rs":"ebe2821cbf12bc7e167f1ea2d7b0726a4dddccecb78e3268f5c69a4d1ba44639","src/test.rs":"a3521b3429bcb3a89e3053294957c6bef76afe0a49f28554d5b1d85405a200de","src/tests/hashset.rs":"dbb867a786f09872c3815baa6a106f44d69d01c4e334ddad237ade0ebb674784","src/tests/mod.rs":"4e195032b38a3296d91b0dfdd32c16eb0e8d880af775c5965826c6402d63eb5f","src/tests/ordset.rs":"9bae1ec767a1c15e3513aa840207948c4bd119be5a66e7359b75198df73188bd","src/tests/vector.rs":"4f25c4a2e6b24fb1c86c06799288205a0036bde212b411a170635eda5e594231","src/util.rs":"b6fd0df67af6db8f1cb414f2d581aa67e1c27cf1eb58b351c3166b94f33b5723","src/vector/focus.rs":"1faf7b178e77b2e0954a3a4a5de9c7714495d16d7af37b11d415305906ffe903","src/vector/mod.rs":"dc753439caa5b4bef8bf696ec11d22d7be75053e41895649e2b29fef865f01e3","src/vector/pool.rs":"343e7697a8a7329a4ea92471650b3eeed8c11bc1550091dba210e2cc6b95a680","src/vector/rayon.rs":"bbf3a94a89dbe8c02962279eea519726830cce3d697d51a9cc0a5e353b54956f"},"package":"af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe"}
+\ No newline at end of file
diff --git a/vendor/im-rc/CHANGELOG.md b/vendor/im-rc/CHANGELOG.md
new file mode 100644
index 000000000..edcf429cf
--- /dev/null
+++ b/vendor/im-rc/CHANGELOG.md
@@ -0,0 +1,419 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project
+adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [15.1.0] - 2022-04-29
+
+### Added
+
+-   `HashSet` now implements `From<Vector<A>>` and `From<&Vector<A>> where A: Clone`.
+
+### Fixed
+
+-   Fixed a long standing crash bug in `OrdMap`/`OrdSet`. (#154, #143, #152, #124)
+-   The `union` method on maps/sets will now prefer to mutate the larger set (which leads to less
+    work) rather than the first set. (#163)
+-   Ensure `TreeFocus` only implements `Send`/`Sync` when the underlying type does. (#157, #158)
+-   There was an issue where nodes in very large `OrdMap`s could overflow when removing an element
+    and cause a panic, which has now been fixed. (#141)
+-   Assorted doc cleanup. (#150, #173, #186, #194)
+
+## [15.0.0] - 2020-05-15
+
+### Changed
+
+-   Map iterators now return `(&K, &V)` and `(&K, &mut V)` respectively, to be consistent with
+    `std::collections`'s API. `DiffIter` for `OrdMap` has also changed in the same manner. (#121)
+
+### Removed
+
+-   The `pool` feature flag has been removed from the `im` version of the crate, as `refpool` no
+    longer supports threadsafe pools.
+-   `HashSet::iter_mut()` has been removed, because if you modify the hashed values in a hash set,
+    you break the hash set.
+
+### Added
+
+-   The `pool` feature flag was missing from the `im-rc` version of the crate, which is the version
+    where it's actually useful. It's been added now.
+-   `DiffIter` now has a `Debug` implementation.
+-   There is now a `Vector::is_inline()` method to determine whether a `Vector` is currently
+    inlined. (#129)
+
+### Fixed
+
+-   A smarter implementation of the sorting algorithm for `Vector` has improved the performance of
+    `Vector::sort` by approximately 2x. (#126)
+
+## [14.3.0] - 2020-03-03
+
+### Changed
+
+-   `proptest` strategies have been moved to `im::proptest`. The previous locations of the
+    strategies (`im::vector::proptest` etc) are still available, but have been deprecated.
+
+### Added
+
+-   `OrdSet` and `OrdMap` now have `get_prev` and `get_next` methods (with equivalent `get_prev_mut`
+    and `get_next_mut` methods for `OrdMap`) which will return the closest key match to the
+    requested key in the specified direction if the key isn't in the set. (#95)
+-   The `retain` method, inexplicably missing from `HashMap` but not `HashSet`, has been added.
+    (#120)
+-   The `get_mut` method on `OrdMap` was, equally inexplicably, private. It has now been made
+    public.
+
+## [14.2.0] - 2020-01-17
+
+### Added
+
+-   Both map types now have the `get_key_value()` method, corresponding to the equivalent
+    [additions](https://doc.rust-lang.org/std/collections/struct.BTreeMap.html#method.get_key_value)
+    to the standard library.
+-   The `ptr_eq` method has been added to all data types, allowing you to test whether two values
+    refer to the same content in memory, by testing for pointer equality. (#117)
+-   `HashMap` had lost its `Arbitrary` implementation for the `quickcheck` feature flag. It's now
+    been restored. (#118)
+-   Implementations for `Arbitrary` from the [`arbitrary`](https://crates.io/crates/arbitrary/)
+    crate have been added behind the `arbitrary` feature flag.
+
+### Fixed
+
+-   Fixed a bug when reversing a consuming iterator over a `Vector` by replacing the consuming
+    iterator with a much simpler and slightly more efficient version. (#116)
+
+## [14.1.0] - 2019-12-16
+
+### Added
+
+-   If you enable the `pool` feature flag, im now supports constructing data types using
+    [`refpool`](https://crates.io/crates/refpool) to speed up chunk allocation. The performance
+    boost will vary between use cases and operating systems, but generally at least a 10% speedup
+    can be expected when constructing a data type from an iterator, and the more complex an
+    operation is, the more likely it is to benefit from being able to quickly reallocate chunks.
+    Note that in order to use this feature, you have to construct your data types using the
+    `with_pool(&pool)` constructor, it's not enough just to enable the feature flag.
+
+## [14.0.0] - 2019-11-19
+
+### Changed
+
+-   As `sized-chunks` now requires a slightly more recent version of `rustc` to compile,
+    specifically version 1.36.0, so does `im`. This is a breaking change, but will of course only
+    affect your code if you're using an older `rustc`.
+
+### Fixed
+
+-   Fixed a quadratic time worst case scenario in the quicksort implementation for `Vector`. (#101)
+-   Fixed an edge case bug when splitting and joining large `Vector`s. (#105, #107)
+
+## [13.0.0] - 2019-05-18
+
+The minimum supported Rust version is now 1.34.0.
+
+### Changed
+
+-   `im::iter::unfold` now gives you the owned state value rather than an immutable reference to it,
+    which makes it a little more useful.
+
+### Removed
+
+-   The deprecated `singleton` constructors have been removed. Please use `unit` instead.
+-   The deprecated methods `Vector::chunks` and `Vector::chunks_mut` have been removed in favour of
+    `Vector::leaves` and `Vector::leaves_mut` respectively. (#50)
+-   The deprecated reference to [`sized-chunks`](https://crates.io/crates/sized-chunks) has been
+    removed. If you need it, please use the `sized-chunks` crate directly.
+-   `im::iter::unfold_mut` has been removed, as there's no meaningful difference between it and
+    rust-std 1.34.0's `std::iter::from_fn` with a captured state variable.
+
+### Fixed
+
+-   `Vector` now uses
+    [`sized_chunks::InlineArray`](https://docs.rs/sized-chunks/0.3.0/sized_chunks/inline_array/struct.InlineArray.html)
+    instead of an `Empty` enum case to avoid allocation at very small sizes, letting you store a
+    handful of elements on the stack before needing to grow into a full chunk. This has a beneficial
+    effect on performance as well, as there's no pointer into the heap to dereference, making it
+    faster than `std::vec::Vec` in this configuration.
+-   Some complexity timings have been added and corrected. (#87)
+-   `OrdSet::is_subset(&self, other)` now returns immediately when `self` is larger than `other` and
+    thus could not possibly be a subset of it. (#87)
+
+## [12.3.4] - 2019-04-08
+
+### Changed
+
+-   `Clone` constraints have been further relaxed on maps and sets, so that you can now lookup and
+    iterate over them without requiring a `Clone` constraint (though you do still need `Clone` to
+    actually insert data into them to lookup or iterate over). (#81)
+
+### Fixed
+
+-   Enforces the latest bugfix release of sized-chunks. (#78)
+-   Another edge case bugfix to `Vector`'s size table handling. (#79)
+
+## [12.3.3] - 2019-03-11
+
+### Fixed
+
+-   A number of issues were fixed where `Vector`'s size table would get out of sync with the node
+    structure if exercised too much and cause erroneous behaviour. (#72, #74)
+-   Comprehensive generative tests were added to test all data structures through more unexpected
+    code paths.
+
+## [12.3.2] - 2019-03-05
+
+### Changed
+
+-   `Clone` constraints on all data structures, as well as relevant constraints on maps and sets,
+    have been relaxed where possible, so that you can now construct empty instances and call most
+    query methods without requiring values implement `Clone` etc. (#63)
+
+### Fixed
+
+-   Constructing an empty `Vector` will not allocate any heap memory, instead deferring allocation
+    until you perform an operation that would increase its length. (#65)
+-   Some bugs arising when using `Vector::append` repeatedly were fixed. (#67, #70)
+
+## [12.3.1] - 2019-02-19
+
+### Changed
+
+-   Unsafe chunks have been separated out into the `sized-chunks` crate, which is now a dependency
+    of `im`.
+
+## [12.3.0] - 2019-01-15
+
+### Added
+
+-   `singleton` methods have been deprecated and renamed to `unit`.
+-   `Vector::chunks` and `Vector::chunks_mut` have been deprecated and renamed to `leaves` and
+    `leaves_mut` to avoid confusion with `Vec::chunks`. (#50)
+
+### Fixed
+
+-   Fixed an issue where the `HashMap` draining iterator might access uninitialised memory leading
+    to undefined behaviour. (#60)
+-   Fixed multiple issues in `Vector::split_off` and `Vector::append` that would cause lookup errors
+    and unexpectedly unbalanced trees. (#55).
+
+## [12.2.0] - 2018-10-12
+
+### Added
+
+-   `OrdMap` and `OrdSet` now have a `range()` method which makes an iterator over a bounded subset
+    of the values. The improved iterator implementation is also considerably more efficient than the
+    previous (about an order of magnitude faster for nontrivial data sets). `iter()` has been
+    updated to take advantage of this, and is now just an alias for `range(..)`. (#27)
+-   `FocusMut` now has an `unmut` method to turn it into an immutable `Focus`, releasing its
+    exclusive hold on the underlying `Vector`.
+-   `Focus` now implements `Clone`.
+
+## [12.1.0] - 2018-09-25
+
+### Added
+
+-   Maps and sets now have the `clear` method just like `Vector`. (#46)
+
+### Changed
+
+-   Single chunk `Vector`s are no longer allocated directly on the stack, meaning that they're now
+    comparable in performance to `std::vec::Vec` rather than slightly faster, but they also won't
+    eat up your stack space quite as quickly, and they'll clone without copying and share structure
+    with clones as you'd expect.
+
+## [12.0.0] - 2018-08-30
+
+Starting with this release, the `arc` flag is gone, in favour of publishing `im` as two separate
+crates: `im` (using `Arc`) and `im-rc` (using `Rc`). They're identical (and built from the same
+code), except that `im` is thread safe and `im-rc` is a little bit more performant.
+
+This is a major release as a consequence, but there should be no breaking code changes other than
+the new default choice of reference counter.
+
+### Added
+
+-   The `Chunk` datatype that's used to build `Vector` and `OrdMap` has been exposed and made
+    generally usable. It's somewhere between a
+    [`GenericArray`](https://crates.io/crates/generic-array) and a ring buffer, offers O(1)\* push
+    in either direction, and is generally hyperoptimised for its purpose of serving as nodes for
+    Bagwell tries, but it's also a powered up version of
+    [`GenericArray`](https://crates.io/crates/generic-array) that might be useful to others, hence
+    the public API.
+-   `Vector` now has `Focus` and `FocusMut` APIs for caching index lookups, yielding huge
+    performance gains when performing multiple adjacent index lookups. `Vector::iter` has been
+    reimplemented using this API, and is now much simpler and about twice as fast as a result, and
+    `Vector::iter_mut` now runs nearly an order of magnitude faster. Likewise, `Vector::sort` and
+    `Vector::retain` are now using `FocusMut` and run considerably faster as a result.
+-   `Focus` and `FocusMut` can also be used as stand ins for subslices through the `narrow` and
+    `split_at` methods. You can also iterate over foci, making this the most efficient way to
+    iterate over a subset of a `Vector`.
+-   `Vector` now implements [Rayon](https://crates.io/crates/rayon)'s parallel iterators behind the
+    `rayon` feature flag.
+
+### Changed
+
+-   As `std::ops::RangeBounds` is now stabilised in Rust 1.28, the `Vector::slice` method is now
+    unconditionally available on the stable channel.
+-   Union/difference/intersection/is_submap methods on `HashMap` and `OrdMap` that take functions
+    now take `FnMut` instead of `Fn`. This should not affect any existing code. (#34)
+-   `Vector::split_off` can now take an index equal to the length of the vector, yielding an empty
+    vector as the split result. (#33)
+-   `Vector::set` now returns the replaced value.
+
+### Fixed
+
+-   `Vector` is now represented as a single inline chunk until it grows larger than the chunk size,
+    making it even faster than `Vec` at small sizes, though `clone` could now be slower if the clone
+    is expensive (it's still absurdly fast for `A: Copy`).
+
+## [11.0.1] - 2018-07-23
+
+### Fixed
+
+-   Various performance improvements, amounting to a 5-10% speedup for both kinds of map/set.
+-   Fixed an edge case bug in `sort::quicksort`.
+
+## [11.0.0] - 2018-07-10
+
+### Changed
+
+This is a major release with many breaking changes, and is intended to stabilise the API more than
+to denote that the rewrite is now production ready. You should expect future releases with
+significant performance improvements as well as additional APIs, but there should be no further
+major release with breaking changes in the immediate future, barring very serious unforeseen issues.
+
+Specifically, you should expect imminent minor releases with performance improvements for `Vector`
+and `OrdMap`, for which I have a number of known optimisations that remain unimplemented.
+
+#### No More `Arc`
+
+All data structures have been reworked to take values of `A: Clone` instead of `Arc<A>`, meaning
+that there's less performance overhead (as well as mental overhead) when using values that clone
+cheaply. The performance gain when values are `A: Copy` is a factor of two or more. It's expected
+that users should wrap values in `Arc` themselves when using values which are expensive to clone.
+
+Data structures still use reference counters internally to reference nodes, but values are stored
+directly in the nodes with no further indirection. This is also good for cache locality.
+
+Data structures now use `Rc` instead of `Arc` by default to do reference counting. If you need a
+thread safe version that implements `Send` and `Sync`, you can enable the `arc` feature on the
+package to compile with `Arc` instead.
+
+#### `std::collections` Compatible API
+
+The API has been reworked to align more closely with `std::collections`, favouring mutable
+operations by default, so that operations that were previously suffixed with `_mut` are now the
+standard operations, and immutable operations which return a modified copy have been given different
+names altogether. In short, all your code using previous versions of this library will no longer
+work, and if it was relying heavily on immutable operations, it's recommended that you rewrite it to
+be mutable by preference, but you should generally be able to make it work again by using the new
+method names for the immutable operations.
+
+Here is a list of the most notable changed method names for maps and sets:
+
+| Previous immutable | Current immutable | Previous mutable | Current mutable |
+| ------------------ | ----------------- | ---------------- | --------------- |
+| `insert`           | `update`          | `insert_mut`     | `insert`        |
+| `remove`           | `without`         | `remove_mut`     | `remove`        |
+| `pop`              | `extract`         | `pop_mut`        | `remove`        |
+
+You should expect to be able to rewrite code using `std::collections::HashMap` and
+`std::collections::BTreeMap` with minimal or no changes using `im::HashMap` and `im::OrdMap`
+respectively.
+
+`Vector` has been completely rewritten and has an API that aligns closely with
+`std::collections::VecDeque`, with very few immutable equivalents. It's expected that you should use
+`Vector::clone()` to take a snapshot when you need it rather than cause an implicit clone for each
+operation. (It's still O(1) and practically instant.)
+
+I'm considering adding back some of the immutable operations if I can come up with good names for
+them, but for now, just `clone` it if you need it.
+
+#### RRB Vector
+
+`Vector` is now implemented as an
+[RRB tree](https://infoscience.epfl.ch/record/213452/files/rrbvector.pdf) with
+[smart head/tail chunking](http://gallium.inria.fr/~rainey/chunked_seq.pdf), obsoleting the previous
+[Hickey trie](https://hypirion.com/musings/understanding-persistent-vector-pt-1) implementation.
+
+RRB trees have generally similar performance characteristics to the Hickey trie, with the added
+benefit of having O(log n) splitting and concatenation.
+
+| Operation       | RRB tree | Hickey trie | Vec    | VecDeque |
+| --------------- | -------- | ----------- | ------ | -------- |
+| Push front      | O(1)\*   | O(log n)    | O(n)   | O(1)\*   |
+| Push back       | O(1)\*   | O(log n)    | O(1)\* | O(1)\*   |
+| Pop front       | O(1)\*   | O(log n)    | O(n)   | O(1)\*   |
+| Pop back        | O(1)\*   | O(log n)    | O(1)   | O(1)\*   |
+| Lookup by index | O(log n) | O(log n)    | O(1)   | O(1)     |
+| Split           | O(log n) | O(log n)    | O(n)   | O(n)     |
+| Join            | O(log n) | O(n)        | O(n)   | O(n)     |
+
+(Please note that the timings above are for the `im` version of the Hickey trie, based on the
+[Immutable.js](https://facebook.github.io/immutable-js/) implementation, which performs better than
+the original Clojure version on splits and push/pop front, but worse on push/pop back).
+
+The RRB tree is the most generally efficient list like data structure currently known, to my
+knowledge, but obviously it does not and cannot perform as well as a simple `Vec` on certain
+operations. It makes up for that by having no operations you need to worry about the performance
+complexity of: nothing you can do to an RRB tree is going to be more expensive than just iterating
+over it. For larger data sets, being able to concatenate (and, by extension, insert and remove at
+arbitrary locations) several orders of magnitude faster than `Vec` could also be considered a
+selling point.
+
+#### No More `CatList` And `ConsList`
+
+`CatList` has been superseded by `Vector`, and `ConsList` was generally not very useful except in
+the more peculiar edge cases where memory consumption matters more than performance, and keeping it
+in line with current API changes wasn't practical.
+
+#### No More Funny Words
+
+Though it breaks my heart, words like `cons`, `snoc`, `car`, `cdr` and `uncons` are no longer used
+in the `im` API, to facilitiate closer alignment with `std::collections`. Even the `head`/`tail`
+pair is gone, though `head` and `last` remain as aliases for `front` and `back`.
+
+## [10.2.0] - 2018-04-15
+
+### Added
+
+-   Map/set methods which accept references to keys will now also take any value that's borrowable
+    to the key's type, ie. it will take a reference to a type `Borrowable` where the key implements
+    `Borrow<Borrowable>`. This is particularly handy for types such as `String` because you can now
+    pass `&str` to key lookups instead of `&String`. So, instead of the incredibly cumbersome
+    `map.get(&"foo".to_string())` you can just do `map.get("foo")` when looking up a mapping for a
+    string literal.
+
+## [10.1.0] - 2018-04-12
+
+### Added
+
+-   `Vector`, `OrdMap` and `HashMap` now implement `Index` and `IndexMut`, allowing for syntax like
+    `map[key] = value`.
+-   Added `cons`, `snoc`, `uncons` and `unsnoc` aliases where they were missing.
+-   Everything now implements `Sum` and `Extend` where possible.
+
+### Changed
+
+-   Generalised `OrdMap`/`OrdSet`'s internal nodes so `OrdSet` now only needs to store pointers to
+    its values, not pairs of pointers to value and `Unit`. This has caused `OrdMap/Set`'s type
+    constraints to tighten somewhat - in particular, iteration over maps/sets whose keys don't
+    implement `Ord` is no longer possible, but as you would only have been able to create empty
+    instances of these, no sensible code should break because of this.
+-   `HashMap`/`HashSet` now also cannot be iterated over unless they implement `Hash + Eq`, with the
+    same note as above.
+-   Constraints on single operations that take closures on `HashMap` and `OrdMap` have been relaxed
+    from `Fn` to `FnOnce`. (Fixes #7.)
+
+### Fixed
+
+-   Hashes are now stored in `HashMap`s along with their associated values, removing the need to
+    recompute the hash when a value is reordered inside the tree.
+
+## [10.0.0] - 2018-03-25
+
+### Added
+
+This is the first release to be considered reasonably stable. No changelog has been kept until now.
diff --git a/vendor/im-rc/CODE_OF_CONDUCT.md b/vendor/im-rc/CODE_OF_CONDUCT.md
new file mode 100644
index 000000000..02a086970
--- /dev/null
+++ b/vendor/im-rc/CODE_OF_CONDUCT.md
@@ -0,0 +1,73 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at admin@immutable.rs. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
diff --git a/vendor/im-rc/Cargo.toml b/vendor/im-rc/Cargo.toml
new file mode 100644
index 000000000..d42771dcd
--- /dev/null
+++ b/vendor/im-rc/Cargo.toml
@@ -0,0 +1,115 @@
+# 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 are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+rust-version = "1.46.0"
+name = "im-rc"
+version = "15.1.0"
+authors = ["Bodil Stokke <bodil@bodil.org>"]
+build = "./build.rs"
+description = "Immutable collection datatypes (the fast but not thread safe version)"
+homepage = "http://immutable.rs/"
+documentation = "http://immutable.rs/"
+readme = "../../README.md"
+keywords = [
+    "immutable",
+    "persistent",
+    "hamt",
+    "b-tree",
+    "rrb-tree",
+]
+categories = ["data-structures"]
+license = "MPL-2.0+"
+repository = "https://github.com/bodil/im-rs"
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+path = "./src/lib.rs"
+
+[dependencies.arbitrary]
+version = "1.1"
+optional = true
+
+[dependencies.bitmaps]
+version = "2"
+
+[dependencies.proptest]
+version = "1"
+optional = true
+
+[dependencies.quickcheck]
+version = "1"
+optional = true
+
+[dependencies.rand_core]
+version = "0.6"
+
+[dependencies.rand_xoshiro]
+version = "0.6"
+
+[dependencies.rayon]
+version = "1"
+optional = true
+
+[dependencies.refpool]
+version = "0.4"
+optional = true
+
+[dependencies.serde]
+version = "1"
+optional = true
+
+[dependencies.sized-chunks]
+version = "0.6.4"
+
+[dependencies.typenum]
+version = "1.12"
+
+[dev-dependencies.metrohash]
+version = "1"
+
+[dev-dependencies.pretty_assertions]
+version = "1"
+
+[dev-dependencies.proptest]
+version = "1"
+
+[dev-dependencies.proptest-derive]
+version = "0.3"
+
+[dev-dependencies.rand]
+version = "0.8"
+features = ["small_rng"]
+
+[dev-dependencies.rayon]
+version = "1"
+
+[dev-dependencies.serde]
+version = "1"
+
+[dev-dependencies.serde_json]
+version = "1"
+
+[build-dependencies.version_check]
+version = "0.9"
+
+[features]
+debug = []
+pool = [
+    "refpool",
+    "sized-chunks/refpool",
+]
+
+[badges.travis-ci]
+repository = "bodil/im-rs"
diff --git a/vendor/im-rc/LICENCE.md b/vendor/im-rc/LICENCE.md
new file mode 100644
index 000000000..cd44203cd
--- /dev/null
+++ b/vendor/im-rc/LICENCE.md
@@ -0,0 +1,355 @@
+Mozilla Public License Version 2.0
+==================================
+
+### 1. Definitions
+
+**1.1. “Contributor”**
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+**1.2. “Contributor Version”**
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+**1.3. “Contribution”**
+    means Covered Software of a particular Contributor.
+
+**1.4. “Covered Software”**
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+**1.5. “Incompatible With Secondary Licenses”**
+    means
+
+* **(a)** that the initial Contributor has attached the notice described
+    in Exhibit B to the Covered Software; or
+* **(b)** that the Covered Software was made available under the terms of
+    version 1.1 or earlier of the License, but not also under the
+    terms of a Secondary License.
+
+**1.6. “Executable Form”**
+    means any form of the work other than Source Code Form.
+
+**1.7. “Larger Work”**
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+**1.8. “License”**
+    means this document.
+
+**1.9. “Licensable”**
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+**1.10. “Modifications”**
+    means any of the following:
+
+* **(a)** any file in Source Code Form that results from an addition to,
+    deletion from, or modification of the contents of Covered
+    Software; or
+* **(b)** any new file in Source Code Form that contains any Covered
+    Software.
+
+**1.11. “Patent Claims” of a Contributor**
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+**1.12. “Secondary License”**
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+**1.13. “Source Code Form”**
+    means the form of the work preferred for making modifications.
+
+**1.14. “You” (or “Your”)**
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, “You” includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, “control” means **(a)** the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or **(b)** ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+
+### 2. License Grants and Conditions
+
+#### 2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+* **(a)** under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+* **(b)** under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+#### 2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+#### 2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+* **(a)** for any code that a Contributor has removed from Covered Software;
+    or
+* **(b)** for infringements caused by: **(i)** Your and any other third party's
+    modifications of Covered Software, or **(ii)** the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+* **(c)** under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+#### 2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+#### 2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+#### 2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+#### 2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+
+### 3. Responsibilities
+
+#### 3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+#### 3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+* **(a)** such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+* **(b)** You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+#### 3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+#### 3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+#### 3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+
+### 4. Inability to Comply Due to Statute or Regulation
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: **(a)** comply with
+the terms of this License to the maximum extent possible; and **(b)**
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+
+### 5. Termination
+
+**5.1.** The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated **(a)** provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and **(b)** on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+**5.2.** If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+**5.3.** In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+
+### 6. Disclaimer of Warranty
+
+> Covered Software is provided under this License on an “as is”
+> basis, without warranty of any kind, either expressed, implied, or
+> statutory, including, without limitation, warranties that the
+> Covered Software is free of defects, merchantable, fit for a
+> particular purpose or non-infringing. The entire risk as to the
+> quality and performance of the Covered Software is with You.
+> Should any Covered Software prove defective in any respect, You
+> (not any Contributor) assume the cost of any necessary servicing,
+> repair, or correction. This disclaimer of warranty constitutes an
+> essential part of this License. No use of any Covered Software is
+> authorized under this License except under this disclaimer.
+
+### 7. Limitation of Liability
+
+> Under no circumstances and under no legal theory, whether tort
+> (including negligence), contract, or otherwise, shall any
+> Contributor, or anyone who distributes Covered Software as
+> permitted above, be liable to You for any direct, indirect,
+> special, incidental, or consequential damages of any character
+> including, without limitation, damages for lost profits, loss of
+> goodwill, work stoppage, computer failure or malfunction, or any
+> and all other commercial damages or losses, even if such party
+> shall have been informed of the possibility of such damages. This
+> limitation of liability shall not apply to liability for death or
+> personal injury resulting from such party's negligence to the
+> extent applicable law prohibits such limitation. Some
+> jurisdictions do not allow the exclusion or limitation of
+> incidental or consequential damages, so this exclusion and
+> limitation may not apply to You.
+
+
+### 8. Litigation
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+
+### 9. Miscellaneous
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+
+### 10. Versions of the License
+
+#### 10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+#### 10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+#### 10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+#### 10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+## Exhibit A - Source Code Form License Notice
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+## Exhibit B - “Incompatible With Secondary Licenses” Notice
+
+    This Source Code Form is "Incompatible With Secondary Licenses", as
+    defined by the Mozilla Public License, v. 2.0.
diff --git a/vendor/im-rc/README.md b/vendor/im-rc/README.md
new file mode 100644
index 000000000..d95c071f0
--- /dev/null
+++ b/vendor/im-rc/README.md
@@ -0,0 +1,28 @@
+# im-rs
+
+[![Crate Status](https://img.shields.io/crates/v/im.svg)](https://crates.io/crates/im)
+
+Blazing fast immutable collection datatypes for Rust.
+
+Comes in two versions: [`im`](https://crates.io/crates/im) (thread safe) and
+[`im-rc`](https://crates.io/crates/im-rc) (fast but not thread safe).
+
+## Documentation
+
+* [API docs](https://docs.rs/im/)
+
+## Licence
+
+Copyright 2017 Bodil Stokke
+
+This software is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+## Code of Conduct
+
+Please note that this project is released with a [Contributor Code of
+Conduct][coc]. By participating in this project you agree to abide by its
+terms.
+
+[coc]: https://github.com/bodil/im-rs/blob/master/CODE_OF_CONDUCT.md
diff --git a/vendor/im-rc/build.rs b/vendor/im-rc/build.rs
new file mode 100644
index 000000000..02d8da393
--- /dev/null
+++ b/vendor/im-rc/build.rs
@@ -0,0 +1,25 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use std::env;
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    if let Some(channel) = version_check::Channel::read() {
+        if channel.supports_features() {
+            println!("cargo:rustc-cfg=has_specialisation");
+        }
+    }
+    let pkgname = env::var("CARGO_PKG_NAME").expect("Cargo didn't set the CARGO_PKG_NAME env var!");
+    let test_rc = env::var("IM_TEST_RC").is_ok();
+    match pkgname.as_str() {
+        "im" => {
+            if !test_rc {
+                println!("cargo:rustc-cfg=threadsafe")
+            }
+        }
+        "im-rc" => {}
+        _ => panic!("unexpected package name!"),
+    }
+}
diff --git a/vendor/im-rc/proptest-regressions/hash/map.txt b/vendor/im-rc/proptest-regressions/hash/map.txt
new file mode 100644
index 000000000..698800a72
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/hash/map.txt
@@ -0,0 +1,16 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+xs 3591451162 2655640551 804983804 3307909230 # shrinks to ref m = {-13697: 30985, 1338: 29274, -14139: -4092, 673: -19662, -19198: 333, 9155: -4794, -24816: -12851, 14658: -17795, 23662: -25253, -4783: -12972, -31711: -1639, -26495: 16710, -7087: -26434, 18175: -4121, 5045: 8040, -23549: 17012, 6304: -7492, -23305: -28186, 606: 8452, -15872: 2415, 17913: 2306, -20500: 28581}
+xs 1457767450 3825624317 1539332905 3279740856 # shrinks to ref m = {7136: -9742, -7547: 13954, -15860: 17017, -31620: -15850, 25480: -13526, 9943: -13939, 1142: 22444, 20378: -26706, -10165: -14641}
+xs 2468731224 2159341902 336190467 4018852179 # shrinks to ref m = {22114: -20101, -30886: -4356, 29938: 40, 6256: -29990, 8450: -21821, 30253: 901, -10781: -24620, 22431: 593}
+xs 1344206258 166909451 3875523340 3155104601 # shrinks to ref m = {25488: 22186, -4852: 28282, -5097: 4497, 29501: 8087, -29096: -18313, 22286: -17383, 30624: 25063, -2270: -1319, 31014: -28777, 23935: 1507}
+xs 2403854785 21349881 2962261870 427550728 # shrinks to ref pairs = [(-17914, 0), (16838, 0)]
+xs 1508395022 1122347352 4113209817 3965614759 # shrinks to ref m = {0: 0, 1: 0}
+xs 1627474128 2843908894 3937915137 1370561421 # shrinks to ref input = {0: 0}, index_rand = 0
+xs 1863744963 3828268266 3976454353 1279901501 # shrinks to ref m = {1033: ",¦⾘f\u{b}C\u{bae94}}$n\"\u{fc28d}\u{feff}\u{b}-", 2568: "\u{8db77}ꖽ\r\u{7af7f}�7\u{a7bf3}\u{393b9}\u{0}G\u{8}\'%5E\u{cd0dc}?\u{ba311}%\u{ee814}Ѩ\\\u{80aa1}", 3527: "\u{41005}\u{41ff0}$`,L&%\u{1b}~\u{36ada}", 3577: "\u{feff}5\u{109dd9}:\u{8}\u{3}𬃹\u{3c2b6}\\\"5𡂏\'\u{feff}%\u{b8c12}?", 4544: "0*8🕴�\u{33669}\r\"\u{92011}𮡱<\u{0}<\u{1}$\u{1},\u{f1234}{G\u{1b}J\u{ceaa4}\\", 4560: "🕴\r\tѨ@\u{edbda}\u{1b}t�\u{b}\u{2}�ò\u{80090}.\'\u{34690}g%Ѩ\u{0}=\u{1}", 7113: "*", 7944: "¨\u{b6d08}$🕴&{H\rUi\u{feff}\u{0}.¥ô{_*\u{d73fc}:Ѩf`2.*\u{c9c6c}", 8738: "%𬊢*:Ä\u{90}\u{b}\u{48d7b}\"\u{4}"}
+xs 1567907912 1646837549 2298759549 1787615177 # shrinks to ref pairs = [(-28601, 0), (2569, 0), (-3384, 0), (5639, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (-30583, 0), (0, 0), (-154, 0), (-27, 0), (105, 0), (-29, 0), (9, 0), (9, 0), (-508, 0), (-478, 0), (-4095, 0), (-2017, 0), (-130, 0), (27145, 0), (2345, 0), (3241, 0), (458, 0), (-6211, 0), (361, 0), (-4772, 0), (-7717, 0), (4265, 0), (-1144, 0)]
+xs 2574157460 1821361166 2171243272 102290569 # shrinks to ref pairs = [(0, 0), (7, 0), (7, 0), (2055, 0), (0, 0), (-9530, 0), (0, 0), (6, 0), (6, 0), (0, 0), (6, 0), (0, 0), (0, 0), (0, 0), (0, 0), (-11133, 0), (-161, 0), (-2, 0), (-2051, 0), (-3111, 0), (-2092, 0), (0, 0), (24131, 0), (-5278, 0), (6, 0), (70, 0), (0, 0), (6, 0), (6, 0), (-31, 0), (-3492, 0), (-2373, 0), (8902, 0), (-2438, 0), (3014, 0), (7206, 0), (6854, 0), (15161, 0), (-699, 0)]
diff --git a/vendor/im-rc/proptest-regressions/hash/set.txt b/vendor/im-rc/proptest-regressions/hash/set.txt
new file mode 100644
index 000000000..a1071568c
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/hash/set.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+xs 4213962225 2884706512 1606470227 2259275645 # shrinks to ref s = {"\\\u{4}\u{b}\u{c7afb}Q$x/\u{1a4f0}\u{1}\u{399ac}$.\u{0}=J>\"\u{2}=\t\t*q乣\'?6\u{ca350}\u{a20b5}", "\u{b50f2}$", "\u{de54f}/¥\u{1b}{*\"¥*:\\\u{e77d2}*s`?\u{3}/\u{9daa7}\t\u{1b}\":\'\u{7cf05}G🕴j", "\u{a2848}\u{bf244}.$=d\u{51d0f}¥\u{98d35}\u{3457c}<`𖡒{\"k�\t.$u\u{0}.", "!`", "\u{4}\u{9c2d9}r\u{d33a9}¥쇛\u{cd875}\u{7f}\\\u{37b37}`\u{b}\ruR\r\t\u{8aaa0}\\&`\u{b}\u{feff}\u{b868c}\u{a976e}\u{0}\\X\u{514dd}&k", "\u{feff}🕴M", "\u{b162a}S\u{6}\"\r\u{4b435}🕴 \\\u{b16df}\'\u{3468e}\\", "÷/\\\u{4dfaf}\u{7f}*\u{47f16}\"�aZ\r(Tj\u{1b}记\t;¥*<\u{1b}E\u{8d037}"}
diff --git a/vendor/im-rc/proptest-regressions/ord/map b/vendor/im-rc/proptest-regressions/ord/map
new file mode 100644
index 000000000..ce47e6b91
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/ord/map
@@ -0,0 +1,20 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+xs 1087347487 1450735596 3800950698 1648897824 # shrinks to ref m = {29894: -24214, -22768: -29852, -25204: 19090, -22710: 4694, -27608: 14656, -27740: 29393, 7285: -78, -3041: 77, 20980: 467, 13472: 3518, 2845: -9597, 6987: -29072, -30486: 827, -1022: 15821, 22068: -24552, 6293: -21073, -7161: 10155, 3791: -27929, 6361: 15318, 3190: 30164, 31756: 4331, 11824: 30151, -14319: -451, -17781: -5693, -5991: 372, -27192: -2983, 23456: 21711, -19546: 28578, -9753: 30988, 21193: 22302, 432: 24303, -15110: 26679, -11612: -6722, 12373: -31848, -20837: -16031, 25861: -12660, -23775: 32410, -6760: 25269, 21702: -26852, -17649: 27279, -12789: -28758, -26032: 6316, -16837: -16182, 31817: -24478, -3564: -20084, -5315: 23517, 11955: -29343, 9175: -4003, 20615: -19515, -3453: 24768, -28231: 3065, 10336: -24811, -8978: 17861, 23428: 19571, -450: 14904, -5293: -12205, -15735: -13395, 12747: -25893, 29368: 14652, 16863: -31998, 29612: 2394, 3212: 4512, -2804: 16628, -9070: 2599, -8946: -6150, 22872: -15322, -12672: 22236, 8415: -22569, 18541: -20698, 12395: -11080, -3888: -6244, -4893: 21952, -3595: 16707, 11722: -9301, 23547: 8317, -10052: -5551, -8428: -1168, -6805: 1438, 6185: 27026, 9265: 14429, -7016: -19640, 4739: 28713, 27505: -9101, -21379: 11843, 10141: 26568, -27662: -7672, -5384: -15814, -31927: 23347, 28068: -13380, -3075: 11627, -28778: 26949, 821: 22814, 11572: 16591, -10426: 5726, -14986: 6492, -4472: -12187, -22049: -18715, 3822: -26724, -13821: 24964, 14780: 23541, -26068: -17472, 6419: -16387, -21443: -32036, -27285: -11138, -12544: -22185, -25942: -22158, 8799: 22607, 22203: 23175, -29997: 9170, 18341: -19711, -25162: -29851, 29377: -4845, -4337: -3624, -30764: 13318, 2000: 6862, 13510: 4642, 25068: -1590, 16270: -1390, -23439: 16616, -13611: 30094, 10084: -30492, -6677: 12289, 28032: -21767, 10105: 8774, 627: 24722, 27190: 3954, -26665: -7354, 27566: -8037, 15625: -9453, -30151: -25954, -28349: 30379, -6142: 691, -9262: 24633, 27808: -5306, 11490: -10950, 22022: -705, 7283: -7208, 29941: 6208, -4204: -2121, -9279: 17669, -4498: -4582, -4833: 29055, -22069: 27589, 32004: -31982, 4036: 11622, -5971: 6511, 7362: -31402, 2132: 16965, -17605: 3529, 16899: -16958, 20305: -26766, 18755: 21882, 13064: -29474, 1391: -25296, 9071: -8029, -20305: 30895, 167: 21243, 23450: -32278, -22095: 13405, 12963: 18120, 24666: 28046, 14320: 8050, 30437: -12581, 17277: 15852, -19808: -27963, -23409: 24638, 29401: 15328, -21257: -3018, 28299: 29000, 18823: -8987, 15409: 9114, -2476: -12749, 5807: -25088, -17559: 19530, -3994: 32042, -23994: 11576, 17613: -11312, 24203: 30135, 14421: 29461, -8181: 17641, 6171: -20014, 31027: 1105, 20177: 11742, 28023: 10685, -5413: 22256, -29512: -27827, 26068: -31380, 10750: 9166, -19988: 26137, 6165: -12868, -9662: 15887, 12809: -12054, 25972: 23426, -3522: 11010, -13516: 10518, -20198: 8172, -20051: -21390, 17149: 27954, -25908: -3999, 22600: -21800, -15240: -21275, -12894: -31550, 11168: 6165, 1471: -30312, 25562: 31867, -3575: -5407, 16896: -21901, -31594: -2825, 24966: -2987, 31931: 19139, -671: 16835, -13289: 32113, -7420: -21883, -26225: -29508, 14029: -23627, 13600: 7738, 19823: 22879, -7278: -31931, -18518: -15028, -24285: 15271, 30158: -6041, -7778: -10728, 18967: -9084, 12216: 15282, 7667: -29473, -29079: 5065, 28475: 262, 9873: 455, 14700: 2632, -6257: 15024, 2641: -23165, 25766: -21115, 30853: -8411, 24163: -4764, -30666: 17364, -14056: 31344, -16470: -21166, 7863: -28957, 28281: -15377, 4107: -8950, -9388: -32765, 24227: -9133, -10558: 13655, 23295: 9762, -3019: -27437, 11095: 29763, 10609: 12051, -19079: 16494, -638: -5842, 4362: 27932, 2639: -25626, -3030: -14761, 21408: -18773, -21262: -4491, -5008: 1094, -11589: -2784, 15655: 29651, -19013: -9552, 7540: -28066, 18000: 17054, 29752: 18144, 28226: 27155, -12924: 7241, 22083: 13808, -18448: -3080, 29456: 16400, 53: -12710, -1221: 30244, -16504: 24240, 5545: -27714, -20630: -18870, -21090: 28104, 4959: 12418, -15608: 1794, -23432: -22218}
+xs 2470012874 1108569466 2705233914 2105395150 # shrinks to ref m = {-26536: -10140, -31941: 2328, -23547: -9253, -28157: -17639, -2098: -25615, 9417: -4376, 5027: 16722, 17121: -24663, 8128: -25969, 25933: 18490, -25489: 10837, -13402: 29678, 31055: 14092, -3811: 19345, 3565: -15536, 8160: 25591, 21133: -5677, 31382: -12602, -4552: -6140, 23595: 6118, -5496: 2443, 25445: -32364, 1737: -5168, -9077: -15214, 7942: -27346, 503: 29459, 30229: 31798, -21623: -984, -20767: 1391, -20732: -5138, 179: -2480, -30700: 32256, 23991: -29242, 5811: -2677, 8242: -19246, 14001: 121, 23994: 15968, 16850: 22675, 27403: 20078, 28998: 29713, -18285: -28709, 15265: -345, -2024: -7961, -26394: -16075, -15563: -14632, 3611: -4743, -16600: 8421, 9494: 30533, -26355: -7995, -31604: 15030, -28372: -30678, -1460: 4493, 12812: 6867, 3327: 5994, -27683: -25261, -6712: 14346, 20460: 1089, 10960: 1352, 24869: -29446, -8174: 30195, 24471: -27707, 26252: 15759, -17935: 12699, -19327: 31902, 10672: -17255, -3178: -31772, 14367: 13488, 9093: 13209, -20473: -9178, -31120: 3147, -5795: -3982, -24184: 19687, -8033: 16211, -12944: 8417, -9993: 4190, 2100: 30585, -1397: -27306, 68: -17544, 12442: -4284, 7519: -12190, 22795: -29312, -21157: -16782, -32441: -15527, 3210: -4247, 32108: 9123, 24488: 25516, 11162: -10170, -19251: -2295, -28559: -4773, 31985: 172, -227: 30045, -2104: 26418, -3076: 15669, 14672: 12100, 7576: -13667, -5021: -32276, 21621: 29212, 13537: -19166, -2389: 8930, -4556: -31064, -10630: 3433, 29934: 12298, 6640: -32416, 29552: -6676, 2449: 9495, -20587: -24712, -12359: 29691, -26177: -31729, 4421: -9542, -9965: 7463, 28677: 26334, -27845: -6260, 13285: 11380, 32752: -20965, 15706: -17233, 29886: 13339, 17438: -28315, 26609: 30547, 15151: -15429, -2919: -19952, 16934: -32480, 26615: 24385, 233: -32369, -10268: -10139, 29343: -30102, -15885: 30182, 15822: 25778, -26549: -2360, 2001: -4014, -12019: -1196, 731: 29634, -29995: -22547, -15831: -27743, 1976: -14216, 24671: 21678, -10275: -5156, 28289: 17246, 12893: -32150, -16308: 7767, 5729: 11546, 18882: -31578, -4231: 18279, -25379: -31185, -1139: -16861, -18054: -8385, -31606: -23236, 21235: 7426, -6400: -7360, -8606: -2630, -22484: -11090, 15370: -5085, 5679: -17878, -28308: -24539, 9009: -24480, -16109: -19862, -20544: -20765, -6411: -28066, 11890: 21190, 4579: -7721, -22198: -22517, 338: -4143, 12184: -11969, -15946: -24141, -23654: 2485, 9886: -26974, 11733: 28587, -8243: -20115, 13309: 31556, -14397: -19926, 29872: 19550, -4716: -14669, 16769: 14751, 8353: 18931, -22070: -5371, 24224: -26199, 24823: -30739, 9421: -13020, 19874: -2767, -10193: 2881, 6660: 1643, -31321: -16602, -12356: -8592, 7484: 15900, 4220: 7816, 2781: -7331, 17673: 7955, 21734: -2072, -4406: -26944, -2747: 17863, 4584: -2492, 31654: 15772, -10883: 4363, -3737: 3686, -18179: 30440, 18460: 23217, -3702: 15120, 14407: -18596, 7749: -11497, -27197: 12065, 15409: 18406, 1457: 4533, 24941: 24486, 12520: -29147, 9179: 31948, -14078: -21063, -22741: -21277, 29691: 24484, 13093: 30490, 11422: -28999, 19850: 28538, 58: -1946, 26401: -32289, 16997: -26844, -23467: -28453, 24138: -6868, -14289: 2223, -3164: -12604, -24071: -11711, 6645: -19591, 17685: 9616, -29576: 31095, 15812: -19219, -30119: 20657, -9465: -20600, 5077: 19208, -10326: 3699, 27078: -4075, -7152: 28943, 14558: -22676, -10615: 31120, 29487: 29114, -6096: -1001, 5941: -21634, -30352: 30888, 582: -23140, 16391: 7248, 25557: -14944, 21501: 18193, 11316: 11352, 18183: 17500, -18516: 2584, -2107: -32422, -8402: 12344, -17372: 11869, -15723: 2627, -1765: 19581, 2975: 1, -5867: 23341, 25489: -2444, 9809: 21415, 29497: -18101, -25328: 28247, 9621: -3108, 28275: 8915, 6846: 3451, 28008: 18058, 6195: 10677, 12779: 1341, 13248: 30900, -18786: 27113, -26425: 9293, 16195: 8935, -2461: -16811, -31431: 4635, -9480: 779, -22487: 19715, -15600: -8938, 29782: -1315, 8079: -27635, 3322: 10561, -23910: -4240, -10716: 3872, 12155: -11450, -23322: -27745, 3206: 9309, -23080: 1961, 6761: -31058, 28940: -20745, -29586: -5915, -9310: -8874, 23578: -31849, -24336: 2811, -31640: 13432, 17145: 4078, -10857: 25423, -28879: 7602, 8971: -12084, -19239: 2917, -32289: 12788, 10482: -26779, 7196: 18090, 17174: -28319, -16874: -29949, -10772: 15992, -1774: 239, 5296: -15898, -8433: 14050, -12827: 28010, 29685: -21923, -4742: 18358, -9399: 13522, -3136: 23448, 9803: -30280, 4633: 9138, 22129: -3054, -24759: -3027, 13549: -10895, 770: 13115, -22180: -30951, 26425: 26303, 15351: -14655, -2361: 9031, 21063: -15719, 26334: -23261, 1253: 4242, 21284: -31915, -16220: 4816, 957: -25495, -454: 18872, 8183: 8829, -21137: -20303, -6282: 12896, -23187: 23, -32053: 21416, -924: -16666, -30888: 11634, 31358: 22911, -6028: -984, -28864: 9371, 28554: 18962, 13368: -9926, 25395: 11310, -22859: -15920, 24079: 24924, -20238: -29669, -2746: -24651, -21422: 21027, 30773: 9672, -8756: -14597, -11425: 30250, -8475: 3559, 14902: 23939, 32064: 4283, 15572: 18467, -8531: -31074, 26651: -5381, 27619: -17005, -29712: 2868, 16457: 20436, -11057: -2269, 3024: -15357, 15023: -26768, 14212: -26881, -19185: -18690, -4924: 7128, 23174: -20610, -9472: -16907, 17569: -23072, 20118: -14428, 9805: 26597, 6994: -8522, 2040: -32366, 25162: -31175, -1386: 16672, -22403: 26995, 7584: 27458, -17532: -141, 18644: 3005, 24808: 28562, 9341: -5445, -25768: 32689, 16892: 17059, -30689: -12568, 28747: -19363, -2091: 1259, -11643: -20020}
+xs 1943497849 4012822781 687301666 4052323690 # shrinks to ref input = {-14552: -9546, -24687: 4553, -5948: -11033, -30216: 31225, -1329: 18654, 25756: 28243, 26320: 32308, 14380: 20303, 30195: -29219, 12769: -13515, 4261: -10098, -15032: 27827, 22373: -30648, -18543: -27064, 20765: -17004, -7193: 29946, 17191: -11212, -9550: 6145, 30413: -3896, 25650: 15492, 6991: -3005, -27117: -18341, -31108: -14720, 2037: -9230, 21209: -17697, -17478: -15083, -7092: -21790, -18620: -19170, 7611: -13546, -10267: -19624, -32677: 26187, 23727: 29533, -3698: -10243, 5300: -3822, 346: -5404, -22233: 16053, 18668: 22996, 2804: 14570, -7140: -914, 29328: 531, 22194: 580, -29271: 32284, -30855: -25589, -24039: 22663, -17584: -7090, 30655: -22419, 6962: 3019, -11388: -29702, 7470: 10191, 12733: -8953, 31781: 29536, -4713: 28624, 29225: 2850, 10639: -17353, 28644: -28651, 27509: 26751, -21653: -3068, -23302: 16505, 23875: -4223, -12294: 8408, 22871: -26300, -11807: -10674, 11617: -20802, -12917: -3942, 12525: 8275, -28360: 25924, -11694: -17660, -8376: -23674, 28022: -11052, 1701: 16466, -10152: 27738, 25396: 3306, 27309: -15176, -24958: 25332, 13257: -9440, 28652: -31476, 28824: -25210, 19544: -26806, -16312: -554, -29314: -25624, -6344: -27482, 12638: 11012, 29993: -5753, -7052: -5445, 6885: -32534, -2710: 15172, 25838: -29888, -4162: 25600, 8274: 3660, 14914: -11250, 18077: 21149, 30865: 29780, 7652: -29810, -27575: -22324, 27190: 13088, -28712: -24931, 32575: 14212, 16100: 2414, 22459: -12558, 12914: 12488, -5756: 26535, -11609: 21588, -23178: 22887, -6623: 10056, 11425: 5119, -24807: 1930, 20747: -2695, 22174: 28280, 26661: -7627, -22429: 26131, 30256: -13483, -23654: -6600, 23857: 20134, -6396: 26307, 27673: -19775, 21325: -20165, 18149: -5624, -16291: 20822, 30797: -19910, -16498: -12698, -28455: -13778, -19937: 16733, 22899: 23440, 20491: -29335, 6724: -14015, 20327: 29236, -13404: 17062, 21857: 21139, -11068: -11817, -24465: -19689, 13258: -20349, -8846: 24655, -14100: -5192, 18797: -4050, 15238: -20885, 21853: -14590, -21265: -5581, 7767: 16287, -29108: -18338, 15365: -10543, -28008: 20715, -27679: 9383, 28946: -32523, -6815: -11660, 25311: -30043, -24259: -32354, -26480: -29813, -4922: -31962, -23235: -14838, -28240: -16289, -20429: -10753, -31466: 4099, 17742: 9919, 22328: -29633, 11484: 5947, -30743: -3454, 27329: -28404, -1440: 16220, -21058: -15381, -7339: 775, 23003: 3428, -29181: -11177, -7918: 18487, 26135: -17235, 31493: -32374, 8674: -29831, 23135: 3319, 22008: 26647, 14087: 926, 9495: 32645, -28424: 4358, -28839: -25000, 12270: 1203, -3843: 24513, 28974: 3537, -11154: 20241, -308: 15509, -1063: 1938, 22352: 16339, 22065: -4794, 25625: 30704, -29994: 25473, -32588: 8066, -19799: -28784, -16369: -7522, 12819: -26116, -10: -12210, 23530: -8239, -8702: 15218, -29559: -6059, 17386: 8272, 9791: 11158, 31268: -23502, 839: -12740, -20953: 30929, -6498: -6179, 18058: 26452, 17715: 21182, -444: 26708, -12166: -10624, -17286: -11707, -5285: 28283, 26686: 28422, -27560: 24488, -9092: -21679, -341: 5249, -1777: -19160, -8798: -18074, 5664: -26770, 8831: 21172, -15630: 10171, 10815: -23739, 10322: -14746, 3683: -28968, -968: -11470, 4300: -21106, 17329: -3943, 919: 15039, 11736: 24420, 18566: 8425, -6499: 17007, 1038: -20933, -1760: 2435, 32364: 17255, -23412: -10508, -20606: -2288, -12261: -24932, 23266: -16759, 29366: -24835, -4536: -26835, 11130: 15321, 9689: -25898, 10497: -8, 8379: -17866, 32503: 1391, -7464: -7476, -10905: 21006, 28934: 27973, -2489: 22253, 18422: -3749, -16897: -26476, 26037: 24177, 25372: -5235, -17793: 5394, -31916: 8290, 2514: 17926, -12681: 10612, -31402: 4216, -21993: 5489, -333: -29732, -7208: 12324, -2259: 7182, -14269: 19700, 7113: -6447, 312: 21681, 16777: -5191, 19799: -22785, -16984: 20498, 13781: -19721, -15005: -27421, -5197: 16418, -26014: 14386, -21116: -29472, 22218: -3249, -12769: 13282, -962: 27871, 323: -26453, -9145: 28365, 20899: 5521, 2983: -28582, 27272: 17304, 14965: 6793, 1119: -8804, 11980: 24389, -27467: 31369, -6059: 22193, 11148: -13064, 28685: 13279, 9266: 23559, 491: 31840, -24358: 20417, -1039: 32656, -8354: 27428, -6823: 13026, 7306: -28986, -29124: -12391, 11358: 19868, 21852: 31747, -354: 17738, -6380: -31076, 6993: -3593, 7749: -26991, -5736: 26845, -23757: -25868, -23018: 21291, -29482: -13037, -28028: -17152, -11500: -2400, 14240: 27368, 8517: -7890, 3318: 26016, 8702: -21694, -15698: -18674, -29992: -16745, 17497: 3921, 17256: 23908, 12994: 16354, -12133: -5976, -9636: -19253, 13662: 26694, -5291: -27961, -19711: -2634, 24676: 200, -21683: -20419, -10755: -20201, 5389: -24265, -18644: 25881, 24013: 26905, -15710: -40, -1078: 24024, 29202: 25073, 7358: 5121, -23181: -31628, 10282: -26184, -20910: -2762, 31789: -11576, -15966: 18578, -14285: 3170, 1448: -13499, -10080: 23097, 9012: -30126, -15463: -12150, 20289: 31453, -23544: -15457, 14694: -5005, 25006: -25213, 20402: -18375, 29679: 20672, -4570: -7111, 22495: -6454, 28869: 31665, 14191: 13852, 16134: 32353, 4529: 8494, 19093: 6864, -794: 18776, 17957: -11241, 25597: -20134, 18037: -1679, 27835: 3288, 22315: -10272, 13032: 9697, -20215: 3797, -12773: -983, 25848: -4873, 19596: 9706, 8030: -28925, 30246: 12946, 7467: -25254, -10731: 6363, 18631: 8976, 1414: -13096, 1779: 15953, -3595: 21321, 339: -8066, -7639: 14039, 20195: 12164, 7156: -11669, 16411: -8927, 13534: -14503, 13577: 17546, -27772: -32545, -6421: -3173, -12316: 16200, -31884: 603, 12395: 3034, 22659: 25898, 30481: -23170, -16623: 20360, -20279: 30762, 3968: -13181, -2313: -4445, -13314: 13183, 17186: -472, -25465: -11926, -12985: 12936, -17260: 21153, 14971: 366, 5035: 29873, 29: 19702, -29547: -10586, -10368: 11518, -13759: -4543, -29208: -4931, 1605: -15282, 22500: 24270, -25324: -150, -24578: -5930, -25949: 21945, -10053: 2314, 19195: 24191, -6760: 32697, -8885: 28695, 12676: -18931, -24963: 5956, -11667: -32632, 3496: -7015, -3422: 24361, 17031: -19643, -21362: 28410, 11868: -24693, 26928: -25916, -8771: -10298, -19434: 29046, 16057: -21815, -28508: -1488, 17240: -23998, 3146: 4003, -8669: 1658, -2885: 3442, 19212: -25066, 8584: -30453, -19749: 25649, 12925: 1864, -7982: -17592, -18312: -6020, 26066: -12698, 10168: 2258, 23411: -27324, 20913: 2058, -17161: -2704, -28674: -8941, 19334: -154, 29314: -18570, -4291: 13987, 27890: -10595, -6139: -19690, -2185: 29099, -19246: -21481, 18345: -7746, 8792: 32374, -12093: -11963, 27898: 28419, -2679: 31973, -6053: -9814, 28750: -1279, 5512: -22468, 24559: 13801, 29152: 10421, -8834: 21875, -11673: 15773, 28602: -9755, -5742: 6786, 13086: 15119, -10716: 23940, -31277: 6551, -12006: 16878, 31399: 15139, -3499: -14162, -7428: -10133, 31533: -4236, -20111: 23374, -13506: -28699, 31291: 27230, -32598: -7092, -5972: 31899, 15397: -8419, 15791: -2952, 24123: 9853, -32197: -7823, 12564: -18593, 16139: 21230, -23524: -28360, 6509: 20623, -8275: 31514, -6607: -5333, 5101: 31408, 23166: 21657, -12672: 8924, 1406: -11027, -24417: -3430, 27934: -17823, -7960: -29901, -20662: 24784, 9478: -22265, -3096: -26803, -5897: 23795, 29566: 26527, -19057: -10328, -22202: 18967, 11290: 32741, 14225: 4804, -31177: 15798, -23514: -7563, 21445: 15844, 14156: 8570, -23968: -24474, 12089: 5498, -14198: -26135, 12664: -23411, 11111: 27354, 15998: 11423, 2891: 21555, -3889: 17061, 32491: -4625, 110: -9137, -20559: -6986, -28721: 3288, 6697: -23898, 8774: -6890, -24838: 20366, 31820: 27280, 14127: 10447, 605: -23336, -28271: -9387, -1486: -28143, 1623: 19882, 30022: -7494, 16398: 31225, -20320: -23582, -23295: -17336, -14291: -775, 3270: 20106, 11662: 16973, 29041: 3377, 7387: -16397, 18767: 32565, 5022: 19191, 16397: -31024, -16106: 13405, -31898: -23690, -25746: 17046, -8847: -29236, 28656: 21644, -11311: -25314, 4515: -19390, -15847: -1245, -5025: 24474, 24302: 28820, -31534: 24028, -14548: -21272, 20722: -27070, -24083: 29927, -27812: 19042, -18194: 5028, -29732: -8181, 20316: 16946, 3176: -32144, -30223: -25654, 202: 22052, -20234: 6669, 18732: 15730, 7127: -27128, -2948: -22493, -21733: 27859, 25166: -31535, -27174: 28732, -14476: 5256, 20346: -27358, 6308: 18033, -10411: 12780, -5469: -28028, 4884: -15738, -12442: -3065, 24311: -21682, 18679: -10632, -13091: 25595, -18882: 31353, 23626: 20687, -17201: 13186, 4270: 16793, -22089: 5358, 4374: -23552, -13011: 5661, -14593: 1052, -10586: -18438, 9093: -3136, -19492: -30355, -5066: 24396, -9852: 13836, 8770: 30757, -18672: -13421, 16224: -10802, 21800: 12639, -213: 28223, 22311: -6756, 7182: 31529, 19224: 16315, 20067: -19940, 10720: -12330, 8384: 14353, 27730: -24075, -18309: 4570, 5808: -32765, 14330: -24746, -19632: -3605, 4228: 25887, 28783: -30008, 16483: -20439, 16655: 26861, -10047: -14259, 30091: 29732, 29182: -13397, -26897: 14659, -17202: 16830, -15265: -16433, 18554: 18464, 3269: -15505, -11054: -20924, -5253: 3749, 14888: -553, 15310: 29010, 3194: 31220, -13770: 21130, 4236: -15365, 13546: -11695, 32688: -16898, 24524: -8344, -2968: 25207, 1449: 26456, 29046: -5209, 12133: -27981, -27130: -21148, -3586: -24606}, index_rand = 6181253659715007859
+xs 3094145122 1848048556 41621330 1587738279 # shrinks to ref input = {25109: 17547, 13167: -24835, 32450: -27886, 28704: 27530, -29237: -31051, 17202: -31179, -22358: 15751, -17715: -2518, 82: -27363, -26280: -12489, -10711: 1113, 28197: -29265, -12233: 15499, 1578: 18570, -10956: 7886, 957: -15131, -26652: -19109, -1698: 7038, -3697: -2352, -18762: 4688, 2143: -17488, -30936: -28216, 26547: 20891, 20001: -10566, 20162: 12139, -15042: 4332, 23226: 835, -1720: 26602, -9048: -19721, -29320: -13680, 30000: -7286, -3693: -16312, -30022: -21864, 29541: 16785, 4006: -20908, -29599: 14040, -17690: 24907, -3766: 16608, 22217: -29766, -29552: -3913, -4046: -20703, -26412: 21205, -15898: 17844, -4553: 32030, 30908: 18124, -1065: 27619, 1642: -19186, 31516: 28398, -22847: 5892, -31043: 21198, -20284: 25965, -27740: 4090, -750: 29603, 29546: -7601, 19831: 16923, -27337: 27061, -5052: -22512, 19028: 22656, -6128: -20716, -5324: -2624, 7273: 5987, 26259: 28589, -5682: 24455, 19425: -13458, -8687: 1837, -29081: -5536, -5126: 19859, -23172: -26061, -17454: -9093, -14495: -19415, 124: 27981, -214: -15589, 17580: 24995, -22303: 227, -2043: -17283, 13309: -29027, -22094: -31943, -1826: 12330, -26959: 19945, 22155: 4915, 16: 1005, -6802: -8951, -29879: 4766, 21350: 7196, -4292: -29428, -17591: 7350, -23475: 20767, 23372: 13739, -16316: -30392, 17391: 5141, -10827: 27764, -11304: 7731, -4247: -21446, 8251: -19738, -568: 8414, 14787: 5321, 2403: -17445, -19412: -16874, 16247: -30651, 11946: -29414, -7725: -10389, -2002: -20578, -12689: -21992, 15800: -451, 32435: 1683, 16805: 11493, -8068: 32206, 27386: 26184, -14311: 21859, 7208: 19308, -13115: 24029, 32222: 19098, -3951: 20703, 10184: 5095, -3235: 29199, 7358: 3163, -9539: 23015, 17802: -31374, -12478: 18169, 21253: 2717, -4126: 30376, 31545: 13768, 14466: 10983, 26903: -7058, -8377: 21868, -15947: 21121, 31358: -30749, -22714: 23423, 17855: 9349, 7118: -3573, 20807: 30872, -19809: 19037, 3084: 622, -13442: -19023, -9314: 14811, 19551: 9175, 13945: -24551, -9482: 14832, 4058: -11363, -29175: 3097, 26866: -6501, -19528: 16419, 13884: -10693, -30894: 18387, 2434: -11471, -29588: 8302, 9537: 26353, 11223: -4669, 32503: -8454, -17566: -12769, 2898: 31182, -19042: 2208, 18941: -22060, -22700: -31888, -11067: -21667, -23130: -13776, 29835: 5369, -15197: -21652, -31889: 23653, 19121: -20925, -4888: 11878, -23301: -32625, -12188: 18858, 7983: -19066, 30772: 18792, 18565: -29423, -30448: -28531, -29781: -27670, -23123: 24404, -8686: -5154, 1956: 28781, -7050: -19514, -21874: -15534, 27434: 2933, 11568: 8591, 8645: -32175, -24288: -32065, 23708: -16804, -102: -20155, -21298: -10486, -5606: 25010, -6095: -10305, -19200: -11318, -2702: -31591, 10484: -30488, 12966: 18734, 19351: -29225, -10379: 28706, -13211: 13219, -30684: -30410, 12809: 3245, -9528: -14612, -13917: 30016, 15751: 14348, -16078: -20918, 21568: 22488, 18004: 30534, -19602: 18121, 13959: 22532, -9411: 17916, -13153: -12283, -16441: 24688, -31877: -25633, -10943: 21681, -12241: 25973, 18048: -16131, -32576: 16074, -23799: 30191, -27572: -4842, -9917: 17632, 28907: 26864, 1029: -8790, -15458: 5122, 617: 31966, 5083: 20195, 26118: -27966, -31719: 261, -30897: 26416, -28104: 25353, -25183: 10371, -25051: -9876, -8676: -2203, -25965: -25244, 14552: -27117, -6195: -9440, 6733: -15895, -16548: 22340, 7795: -7156, -5548: -8170, 1975: 11313, 26002: 13579, -1090: 16028, 3119: -22116, -26790: 3213, -12524: -21450, 19788: -30362, -11778: 7254, -24041: 18664, 10038: 10500, 12731: 10291, 19886: 8630, -13579: 4280, -10199: 16578, -10637: 18165, -3835: 6271, 14929: 24076, 27938: -31473, -14770: 5512, 15441: -3706, -17185: 2295, 15932: 20222, 13258: -18255, 24353: -11049, 24897: -6737, 365: -23551, 23329: 30521, -31648: -13380, -1552: -25692, -5206: -1325, -27419: 31094, -51: -28413, 12361: -29699, 5402: 26930, -27529: 7188, -12050: -7233, -7996: 20657, -18903: -31229, 2184: -27864, -22198: 8189, -14333: -3151, -8819: 32208, -25427: -1465, -13361: 23768, 25140: -13818, -18482: 5019, -9847: -31791, -17654: -16678, -18171: -25938, 24839: -22327, -10299: 17415, -517: -9938, 11604: 19413, -20522: 25880, -16853: 12843, -19711: 6243, -2217: 17848, 31544: -23358, 32481: -20104, 916: -13297, 21632: 27432, -20301: -905, -28748: -18375, -18946: -26872, -27139: 23619, -28341: -2690, -14751: 3261, -31340: -5866, 14129: -1873, -17466: -19221, -27794: -25683, -16132: -26856, -6446: 21798, -26329: -20765, -19511: 31669, -25708: -5275, 10217: 797, -9016: -17110, 7696: 13723, 6083: -19072, 31100: 8435, 8017: 10175, -23973: -199, 25418: 21954, -5106: 15703, -29119: -14678, -23448: -14905, -1334: 27615, -25389: 21402, 5764: -14910, -25059: -20274, 32586: -21603, 27022: 24446, 30370: -23901, -31423: 31764, -21135: -21011, -6284: 14914, -20672: -4657, 3691: 9397, 1305: -26046, -29806: 1663, 11409: -9037, -25440: 12737, -16350: -30111, -15664: 4544, 29290: -19087, -10773: -15820, -1299: 31105, -9945: -24879, 25445: -1393, 17568: -11207, 2868: 11240, -14478: -5443, -29749: 22046, 30402: 18906, -14676: 28148, -12434: 19407, -8904: -31377, 32723: 19548, 26961: -12468, -20695: 24529, -11186: -16253, 17983: -16005, -22681: 29406, -32124: -28864, 4551: -32279, 16423: 21410, -29467: 30297, -32316: -11084, 19168: 13447, 31777: -17253, -20788: 30789, 10397: 26717, -16290: 10403, 3436: -20939, 24973: 21047, -23977: 19143, -21115: 16465, -32140: -27035, 29494: 19758, -31925: 16559, 25544: 14705, 16117: 2902, 16076: 1994, 1259: -4130, 11871: -31322, 31923: -12428, 6485: 16367, -15055: 17454, -32536: -23142, 19287: -30036, 19046: -6360, 30467: -20193, -1352: 19442, -24389: -32203, -25508: 28905, 13432: -28476, 15794: -2020, 7907: 12590, 19319: -31856, -10096: -8759, 9365: 24849, -11559: 25438, 23762: 21598, -7248: 22542, -16926: 12934, -24708: 4222, 2179: 3309, 1855: -8693, 10786: 29825, 18783: 25809, -5169: 5570, -8235: -4664, -20234: 26252, 18273: -26922, -4496: 19147, 4458: -20329, -18952: -31435, 22439: -27690, -3304: -7512, -17425: 6385, 2885: -18520, 2478: -17666, -16036: 22920, -8658: -18048, -7204: -25509, 28983: 4786, -9146: 16439, -26893: -27056, -31037: 17541, 643: 17042, 27085: 11808, 26037: 20956, 4234: 1346, -14815: -6582, 25700: -8577, -10298: -23247, 5728: 10020, -25496: 10378, -27275: 28186, 24689: -21421, 32092: -15135, 17254: -370, 13808: 18349, 19084: -163, 16447: -25693, -22306: 26140, -1695: 3490, 32119: -6821, 25084: 21803, 10922: -26376, 27134: 21743, 30570: 8146, -12987: 6435, -20456: -22516, -31704: 12485, -23916: 4096, -26088: 20130, -19159: -28657, -3808: -29934, 21346: 18600, -17642: 22758, -9589: 9627, -12541: -16450, 3120: -31143, -5758: -4025, -14764: 22952, 26792: -16315, 12268: -8062, -31344: 20767, -10729: 652, 32354: 30556, 10533: 27076, 18563: 31611, -15395: -16343, -7271: 28710, 28693: -28840, 19304: -31194, 4838: -28332, -15421: 18530, 24139: -28363, -31872: 15347, 17464: -17470, 30063: -21708, -6516: -17705, 14553: 20142, 29460: -4329, -9381: -14281, 3286: 26530, -25478: 18858, 8614: 12250, 3087: 21051, -32628: 24370, -15651: -18351, 8024: 4382, 15805: -11203, -1077: 8609, 32285: -11583, -27614: 7211, -10535: 22639, -20099: 16870, 21230: 28095, 612: -23352, -5544: -26504, -25887: 2679, 14181: -26845, -31967: -7583, 26010: -15169, -6467: 12825, 24107: 4381, 3800: -2605, 2010: -21114, -1414: 6971, -12659: -21065, 20831: 9711, 20073: -8964, -24951: -3223, -6740: -32200, -8304: -23492, 27109: -8227, -17744: -25257, -28537: 18637, -18411: -15041, -25173: 928, -25903: -13895, -21831: -3009, -25678: 1895, 30480: 17166, -25850: 16586, 12531: -10102, 19095: -6338, -26672: -9944, 11671: 1505, -13311: 12087, 8454: 19381, -12936: -31002, -17139: 19189, 11596: 20259, -25535: 3542, 20951: -18777, -6500: -18332, 30742: -277, 31676: -30490, -27517: -19880, -25374: 32088, 21483: -10823, -16979: -18696, 14561: 13047, -13368: -16548, 4720: -14672, -29316: -19115, 1395: 9605, -10992: -10275, -21747: 8507, -4734: -6057, -30595: 16035, -24700: 22816, -2210: 19173, 7671: 24589, 27460: 5788, -10899: -21848, -26840: -3095, -28802: -2572, -3431: -5783, -21943: -31626, -22611: 26127, 3213: 396, -15957: 17787, -11959: 17422, 1613: 22455, 32292: -9957, -23718: -32341, 2795: 4614, -15162: 2211, 26391: 18246, 885: -15549, -29735: 26493, -17763: -9509, 832: 15026, -23215: 22609, 28230: 20969, -32629: 28951, 10402: -11520, 26729: 11732, 14065: -4855, -12988: 5456, -24309: -15464, -20942: -11584, -18355: 1571, 16650: -13337, -7873: -13362, 11313: -19130, 20194: -6007, -9755: -26600, -25013: 21165, -14900: 26513, 17728: 17821, -28277: -25003, -14757: 5100, 13577: -9806, -22115: 27298, 14668: -23429, -25174: -28161, 2367: 4067, -23795: 27843, -3780: 5571, 30910: -13600, 11355: -21254, -7086: 2278, -13419: 3221, 22732: 21622, 24582: 15497, -4771: -18262, -705: -24363, -6490: 13550, -3098: -31941, -20378: -12040, 25336: -18191, 21299: 822, -30797: -23895, -17162: 18699, 228: -17254, -12250: -21242, 4730: -2067, 8150: -16241, 15707: -29248, 6042: 32137, -26556: 15175, 14154: -28226, 9935: -23158, -29846: -22516, 9461: -29500, 11475: -19325, 31974: 2561, 1330: 8660, -1271: -17382, 3482: -8519, -25956: 15786, 25713: 3023, -394: -27817, 19478: 32434, -12289: 12678, -2608: 9330, -26485: -7465, -27840: 12092, -31666: 3630, 15748: -11979, 30892: 30006, -21505: -30879, 10340: 14885, 11619: 5575, -7216: -30397, -15140: -11637, 16761: -16433, -21925: 12562, 28429: 18057, -12739: -25584, 13377: -24419, -3752: 22641, 21444: -30136, -27669: 23044, 521: 28473, 9286: 5030, 29721: -14329, 10899: 8578, 9145: 15065, -30537: -15209, -21221: -5525, -16581: -17871, 27355: 23268, 56: 17851, -2659: 22647, -1630: 31617, -30759: -18270, -28584: -4801, 1875: 10171, -8604: -27218, -16634: -19036, -17802: -16413, 13379: -6140, 23704: 6880, 8765: -1719, -21255: -6806, -19546: 23388, -22379: -4391, -17126: -18724, -21340: -9110, 18182: -10221, -2471: 2014, 13850: 25597, 18153: -5252, 13325: -21738, -27130: 19737, 8324: -57, 16162: 17766, 30735: -1934, -13008: 18027, -14177: -26344, -3410: -15352, -22373: 13456, 23820: 30037, -16682: -8556, 2771: 32686, 7700: 2288, -15586: 23950, -23520: -30119, 24085: -27227, 28343: -27847, 11661: 11000, -2690: 6058, -30191: 21458, -10655: -20377, -18377: 8672, 15970: 29352, 13854: -28243, -12566: 12732, -11424: -5467, -13021: 19087, 4285: -20833, 4850: 15552, -28485: -26386, 8290: 259, -11749: 19444, 26075: -905, 30605: -1488, 6438: 27983, 9535: 25448, 10668: -26317, 9228: 2787, -9342: 6996, 3077: 2077, 14575: -17406, -13263: -28914, -16497: -8505, 17807: 29989, 17642: 27683, -7320: 22167, -28413: 23955, -29262: 1610, -7611: 20341, 13742: -22167, 1948: -3978, -26335: -18254, 7765: 4432, 22110: -27003, -3021: -16057, 15606: -23087, 8263: -28114, -28389: 28514, -24292: -3802, 593: -22012, -11632: 18700, -8493: -17690, -24000: 29402, -30405: 18870, 2054: -12353, 6302: 13902, 14627: 20456, -20713: -6796, 59: -27945, 15401: 3763, -31282: 2136, -30080: -21448, 596: 31173, -3777: 10969, -27062: -12955, 10983: -10220, 23508: 7525, 18741: -17043, -2752: -3564, 1045: 29156, -23741: -18438, -20412: -20083, 31569: 5108, -19554: 24719, -31716: -26184, 3254: 30063, -23755: -474, -10974: 24808, 32587: 24856, 13274: -13294, -23140: -5331, -1612: -8780, -12950: 16875, -7602: -1367, -8407: 24480, -18043: -18814, 5557: -14426, 23239: -32629, 12839: 10100, -23881: -9397, 9000: 1367, -16739: 24959, 27731: -23120, 1404: 16785, 26722: 2067, 13575: 21126, -4894: 14658, 13344: -7459, -3522: 8125, 10021: -14961, -10653: -5225, -23802: 25545, -6938: -12602, 3949: -14698, 29660: 11675, -2952: -7008, -30398: 12733, 24591: -27470, -8108: -1693, 8378: 6293, 19409: 107, -24293: 13979, -26643: 24382, -8928: 14933, -15145: -3845, -22551: 10211, 425: -15224, 16478: 7707, 2338: 16763, -23791: 31613, -8916: 7382, -5384: -31297, 10300: -1373, -27891: 1916, 2999: -30008, 1165: 24301, -397: -18055, -4201: -8619, -23959: -1718, 16219: -26007, -15100: -24529, -32527: -12160, 19770: -292, -10008: 22619, -26772: 3604, 236: 105, -7879: 31666, 19242: 10567, -6348: 14664, 5832: 13312, 1492: 10163, 8927: 21565, -26318: -18183, -10174: -25158, 9807: -26056, 26076: 17814, -15366: -19761, 2621: 12814, 30193: -31344, 4206: -18921, 7126: 22715, 16128: -10023, 25936: -31820}, index_rand = 5224467844040644997
+xs 361304641 2604218693 3136857884 1914902562 # shrinks to ref input = {-19354: 24819, -16292: -12090, -14434: -17000, 7065: 3299, -18458: 22292, 19194: 12574, 1: 18507, 32098: 548, 3309: 3711, 30631: 31499, -9540: -31601, 29472: 15053, 28278: 16574, 10805: -6409, 1937: -29445, -27617: -19598, 14618: -13991, -31216: -14546, -8002: -19976, 24690: -11392, 19023: 6532, -4475: -15383, -3276: 3043, -22021: -831, 7566: 28669, 7414: 7538, 3289: 1498, 32294: 11245, 27957: -24717, 394: -5551, -25550: 7578, -10781: 17801, -15265: 22301, -22600: -27228, 18049: 28811, -5680: -4765, 6393: -26312, -3763: 19239, 12387: -7834, -17270: 15102, -849: -18294, -11185: -8909, 5848: 28816, 4822: -1284, 9283: 17434, 5749: 13204, 11282: 18054, -30054: -1590, -5733: -8222, 27256: -17099, 25828: 27982, -26680: -20087, -31170: -3715, -27215: 20014, -3297: -27491, -4237: -9165, -3803: 6289, -13220: -7922, -31962: 28987, 15542: 18604, -17133: -25302, 13426: -25405, 2685: 15869, 5642: -8384, -8618: -21494, 696: -6333, 30169: 22735, -31498: -2698, -16350: -30346, 23455: -30868, 24880: 8411, 12752: -26951, 807: 5479, -31915: -6948, -6797: 32084, -27450: -5011, 12562: -16186, 16308: 9586, 8802: -8309, 22958: 1367, 5967: -7809, 7342: 9794, -21809: -30257, 22051: -8714, 11489: 27098, 9636: -24412, -22926: 4643, 16522: 3404, -13679: 20161, -20645: -4604, -27194: 2276, -1203: -23043, 15177: -16488, 17368: 19938, 18129: 13518, 29506: 13683, 30487: 29314, 22806: 20773, -1727: -29216, 8206: -19496, 7127: -23074, -2964: 1656, -8043: -15180, 31783: -24797, -14997: -8251, -9625: -985, -3485: -1572, 3259: 1018, 4124: 31363, -6871: 11567, -15128: -13650, -30770: 9112, -2638: 21963, -19057: 16043, 20685: 214, 17778: 6821, 27947: 8329, -13235: -3670, -15954: -21158, 12517: 13054, 23898: 16751, 16216: -18722, 15237: -7624, -31732: 21365, 30822: -28157, -17438: -30023, -26596: 3301, -13414: 5061, 17372: -8376, 30362: 28469, -20309: 143, 24393: 10508, -6411: 32337, -18972: 19110, 30365: 10104, -5140: 19909, 11898: 18406, -14442: -15467, -32552: 22492, -11355: 5350, -8307: -18294, 17475: 7093, 22597: 1992, 20469: 30777, -32614: -6165, 32573: 8339, 1514: 25969, 10701: -20617, -3021: -12256, 6587: 18950, -25402: 12031, -9936: 16285, -29946: 22912, -14064: -10944, 671: 13716, 5073: 7865, 5197: -26128, 19416: 9507, -30681: 8287, -21677: 28198, 3770: -21258, 14103: -8796, 21840: 6932, -14302: -3120, 18835: -21353, -19863: -30682, 30904: -24579, 23767: -2876, 14140: -7923, 23444: -8002, 20015: 24236, -8959: -10261, 19803: 10542, 13739: 29511, -28569: -14754, -3714: -30519, -14450: 8383, -11394: -30165, -32079: -13880, 13248: -30479, 11781: 9474, -10436: -2853, 6759: 27954, 25845: 29391, -31738: -26454, 30132: -23278, -18345: -23422, -25979: 16664, 9607: 29137, 8336: 22464, 20324: -23583, 15078: 31805, -28529: -17128, -12412: 9041, 5972: -27525, 10224: -32042, -6332: 7448, 26995: 20876, -12473: -28199, -23999: -23159, -18299: 21242, -14408: -31328, -29246: -10044, -10164: -28095, -27052: -5400, 10173: -25267, 23822: -17900, -23953: -13219, 28791: -8090, -21909: 21407, 17530: 26269, 29655: 29973, -16374: -16957, 13982: -24366, 11639: -20136, -18021: -4470, -28776: -14271, -19637: 20591, 17096: -6224, 19899: -7035, 10911: -124, 5706: -16549, 2364: -24950, -10944: 31678, 31723: 11433, 6413: 4440, 32675: 19466, 27096: -13819, -10806: 6633, -4937: 28751, -27140: -13550, -12557: 13547, 8629: 3152, 3413: 2565, -25866: 10729, -15566: -15218, -3621: -23194, 7527: -27521, -24127: -29997, 12909: -25868, 31772: 4680, 31014: 29821, 18678: -16508, 30298: 9039, 14505: -3668, 22669: -10595, 26152: -16178, 24944: -8114, 16694: -19338, -14047: 24498, -30270: 26317, -16665: -26461, -30656: 20249, 25517: -20809, -23571: 1882, 23007: 17866, -25659: 8076, -23717: -5810, 6904: 2115, 11784: -31335, 30197: 18033, 12572: -30508, 17268: -18072, 10674: -22655, 29365: 24132, -17185: 10599, 8749: -31736, -3334: 32668, 21915: -2453, 17556: -26978, -9373: 26250, 22616: 30289, 2165: 15435, 10766: 1818, 13715: -20952, 2935: -9271, 25227: 15051, 13045: 23934, 13260: 30812, 10690: -10114, 824: 8266, -14298: -13127, 11000: -14100, -18008: 21650, -8299: 6540, 3128: -12265, -7224: -8911, 19209: 14023, -8038: 24840, -26622: -26079, 14895: 22828, 31625: 20961, -2636: 19675, -17021: -28086, -5946: 15939, -32313: -153, -14012: 30196, 31144: 31395, 7996: 24091, 28923: -29327, -9247: 15709, -26391: -9285, -14883: 27089, -15544: -12422, 1374: 28261, -22870: -12032, 26286: -20763, 4080: 2040, -14599: 9484, 32660: -3226, -22977: 5487, 18067: 3363, -6489: -21852, -10804: -13137, 27933: 20036, 15275: -12004, -13892: -676, 16130: 22039, -24538: 21841, 24641: -3642, 21784: -26054, -20651: -27826, 5295: 32093, -24305: -3414, -18446: 10556, 4517: 526, 24294: 10881, 24194: 26364, -13901: 18395, -12783: -27360, -713: -29957, 8644: 14950, -6324: 9260, 9506: -30362, -29129: 6181, -3784: 18178, -28466: -21361, -18659: 3987, -10595: -19837, 7499: 30194, -12558: 7406, 28463: 12837, 27107: -2298, -6932: 4389, -32374: 25500, 23110: -23112, 8747: -22926, 4097: -2613, 3462: 30698, 3398: 31612, 30467: 23139, -1641: -3740, 3293: -19082, -20228: 31473, 20793: -17194, 17724: -25522, 8074: 32013, 23712: 19733, 31907: 8354, 12744: 28197, -24606: -11268, 23637: 3704, -3436: -24423, -2739: 10852, -4260: 18850, 12969: 6263, -26425: -6431, -28020: 25049, 31644: -1993, -20327: -6272, 22470: 17788, -28205: 31716, -21534: 32498, -4889: 19628, -825: 16644, -30248: -31584, -26932: -3743, -28597: 27796, 10641: 29403, 18736: 11379, 17445: 4741, 15954: -22253, 28955: 3994, -18758: -20179, -16666: -22951, -23409: 7546, 28441: 28286, -6600: 29204, 245: 5060, 21723: -31646, 13693: -28832, 17526: 19157, -3421: -30798, -12920: 25702, -13396: 4699, 25125: -17956, -378: 30900, -29352: 13943, 21551: -27295, -31207: 316, -5104: -20171, 10981: -14599, 13127: 7748, 12536: 20062, 15315: -493, 10111: 24216, 3207: -31216, 18499: -20515, 4815: 26753, 24865: -18658, 28562: -27549, -14256: -3818, 22292: 9007, 9550: -22562, -18174: -5902, 18354: -4282, -14416: 6361, -20722: -24289, 31715: 29227, 29704: 15935, -5533: -8673, 10845: -30941, 14160: 12144, 1992: 1318, -11404: 28138, -5428: 18711, -1624: 3223, -20437: 19171, -13983: -15469, 29721: -11600, -32689: 14340, -12675: 7713, -21501: 21229, -3729: 27686, 13580: -5131, -17708: 16700, 20809: 25221, -28564: -3272, 29509: 26850, -9889: -9564, 938: 25880, -17223: 18566, -20452: -799, -4292: -17811, -19061: -11617, 25764: -11388, -3347: -14170, 29220: -7185, -21149: -4187, -8341: -13996, -9012: -22916, 5303: -18306, 14513: 21706, -4815: 9868, 4316: 3968, 28688: -1524, -19338: 14733, -13386: -14098, 18253: 3130, -1221: -5690, 5093: 24217, -12424: -8733, 25791: 31206, 6697: 29204, 31192: 12158, 31407: 749, 17618: -3504, -3199: -3206, -11293: -20357, -16165: -3563, -27497: -25700, -27297: -3825, -23521: -23715, 4652: -29245, -17313: 10246, 22202: 28783, 12621: 7793, -25616: -9539, -8209: 11244, 2018: -23988, -29161: 7278, -17743: 748, 6678: -15931, -31969: -10178, 11253: -18267, 9135: -23204, -31002: 27729, 22133: 28453, -31372: 16243, 29200: -18504, 27344: -7996}, index_rand = 12865908526723545602
+xs 2514330554 4021224636 4249159765 809946243 # shrinks to ref input = {22983: 25567, -21524: 12652, -31419: -14369, 24781: -3215, -6098: -3626, -4344: 6615, 11513: -5995, -32129: -25765, 19648: -32475, 5272: 26666, 6416: 22836, 27222: -3403, -4042: 3636, 13253: -27848, 27331: -4442, 666: -14459, 13044: -27108, 2407: -18269, -11769: -23455, 6186: 23587, 3702: 7914, 29676: -21600, 12424: 12219, 27941: -5207, 15122: -12497, -11158: -27362, -8282: 26473, 3415: 26408, 12831: 17512, 5795: 28896, 21721: -11462, 20429: 9497, -12438: 9683, -3959: -13001, -25293: -23380, 5700: 24227, -21071: 9692, -18808: -24549, -27808: -4112, 14687: -13091, -14445: 10864, 8680: 29230, 28793: 2289, 572: 22804, -12907: -22882, 19549: 29926, -24247: -3077, -96: 16251, 8929: 32524, 18444: -31578, 24622: 19896, -20594: 13891, -22943: 19132, 31425: -2940, -12580: 30389, -526: 2891, -10880: -20465, -20861: -9108, -1990: -1706, -14673: -3333, -12415: 12446, 1711: -3619, 2889: 26166, 5135: -9934, 9761: 7314, -13727: -30121, 23167: -14068, 7972: -16912, 792: -2110, -23816: -11162, -14613: -11944, 2276: 16327, -1710: -513, 14501: 12803, -14424: 12359, 8166: 23242, 7132: -5033, 2661: 18395, -29564: -10169, -24378: -28753, -6535: -12561, 8864: 16922, 5509: 24075, 6948: -31451, 9166: -16562, -15552: -22739, -23577: -11089, -23262: 15724, 7935: -226, -15831: 22789, 19431: 12267, -32692: 13439, 8190: -27259, 5177: 21511, -25935: -29614, -23804: -9779, -5144: -13329, 13090: -1785, -24277: 11514, 23943: -7920, -5978: -7247, -10397: -26707, 25026: -2168, 16104: 8686, 1807: -29851, -24649: -22813, -19629: 11095, 22893: -20902, -23916: 17574, 1476: -25217, -24340: -19076, 28100: 15570, -22175: 22320, -6586: 6492, -18649: 11816, 16251: -21463, 17368: 3798, -20189: 3235, 16961: -6580, -8404: 20372, 16047: -15304, 29490: -3055, -24776: 15119, 27563: 16145, -22311: -2158, -15739: -32392, 2484: 14964, 21250: 7246, -9967: -28930, 31387: 5103, 14859: -2042, 16259: 31622, 29267: 26762, 6688: -2894, -25600: -27724, -22795: -11228, 2779: -25135, 3592: -29746, 2684: 25084, -14032: -6792, 16004: -29800, 10914: 6250, -15582: -26248, 21285: 13207, 22458: 2337, -13517: 14340, -29653: -16328, -9174: 8207, 6822: -22380, -13230: -5805, -24662: -20758, 23527: 6218, 21957: -1144, -29983: -14789, -25776: -10625, 29489: -29112, -634: -1687, 16362: -5095, 24103: 17173, -28568: 4122, -27366: -2615, -3220: 25064, 990: -31755, -14609: 23575, 31478: -24182, -15842: 9193, 7823: -20861, 32558: 23623, 28629: 20621, -27884: 26432, -14903: -17295, -20813: -25646, -14902: -25559, -13309: -1218, -12300: -17285, 31853: -3859, 1399: -7893, -26296: -29878, 19179: 13265, 15479: 17728, -25448: -8456, 13588: 27559, -24783: -7128, -32103: 29322, -1758: -3572, 13728: 31962, -17236: 5243, -21230: 27588, 20742: -27977, -20661: 4578, 9198: -15494, 5045: 25517, 29565: 31629, 20558: -6873, 24626: -30679, -7805: -9759, -3591: -19001, 28566: 18547, -13063: -28236, -19655: -4068, -9420: -16081, 25403: 23876, -17448: 2581, -26642: 1171, -24759: -17468, 20219: 24202, -30341: 13934, 27839: -18353, -545: -28904, 381: 6631, -14539: 19857, -2539: 19520, 31691: -3655, 1385: -507, 30959: -12761, -16041: 8706, 21997: -15520, -11702: 28136, -19969: -15001, -575: -19615, 15183: 2436, 5198: -26540, -18493: 24520, -17505: -5183, -2493: -30253, -25067: -4479, -1283: -3796, 31471: 3428, 25734: 30828, -12627: -6061, 11155: -26067, -26923: 20405, -24052: 21789, -435: -23207, 30135: -13145, -15985: 11367, 16307: 15640, 28752: -18459, 22594: 7750, 22206: -269, 12789: 803, 5691: -26452, 31114: 1532, -15192: -30273, 23101: 3141, 6407: 15910, -1158: -18687, -25606: 29881, 17713: 19127, -1122: -12940, -6489: -9054, 15743: 3691, 21427: -22498, 10898: 19136, -15369: 8230, 30219: 3776, 1353: 27070, 31264: 29339, 31831: -20760, -9233: -18316, 24841: -26176, -12699: 3016, -22370: -9549, -6545: -22728, -8574: -14535, -31864: -12833, 768: 15313, -19955: -22453, -30880: 9396, 29543: 755, -9778: -32702, -22077: -25372, -2605: 16746, -30839: 29080, 32699: 16318, 2417: -12052, -31380: 12651, 24376: -19710, -32686: 761, 5677: 30160, 12035: 12228, 32125: -20315, -20314: 5439, 11493: -17794, -26680: 11610, -28132: -20467, 16900: -25287, 25461: -31865, 24573: -32602, 9200: -1505, 27518: -25693, 12990: -27271, -9397: -803, 14105: 1387, 2651: 8640, 17112: 30678, -969: 19205, 19710: 31993, 1893: 5361, -17816: 24812, 2765: 16979, 1966: -21769, -26954: -1952, 29816: -1928, 26782: -29372, 18567: -22726, -10111: 5989, 14917: 22916, -14570: -2257, 1263: -4715, 18190: 30641, 11528: 12151, 4035: 20675, 20933: 20327, 20055: -30733, -14881: 6272, -26276: -44, 10879: -30096, -9294: -16413, 2817: 13299, 643: 15982, -7677: 4313, -20647: 31903, 3668: 29744, -895: 14661, -17897: -17401, -11844: -19818, -10186: 29763, -32372: 29925, -28816: 10622, 31355: 10910, -17637: -27328, 9535: -27794, 12855: 2934, -3109: 3109, -6427: -16454, -15442: 8398, -23169: 31026, 12834: -25030, 10930: -16079, -12447: 9572, 398: -5332, -11374: 27256, -12183: 32336, -14535: 14519, 12753: -3875, 8795: -11151, -3712: -16993, -26508: 14252, 20375: -14368, -13681: -745, -30307: -5112, 13277: 25773, -7944: -31433, -28425: -12788, 20210: 15294, 17797: -5799, -19999: -7498, 31427: -21005, 11063: 16683, -12187: -11576, 25180: 1372, 12244: -7444, 27900: 20262, 28587: 7083, 18724: 8161, -20180: 25818, 15692: -31648, -28303: 17209, -720: 21874, -16321: 31013, -454: 5366, 31803: 29349, 13754: 24292, 21162: -20849, -23732: -27863, 25477: -6654, -26061: -12152, 20032: -20593, -12006: 28036, 6291: -26468, 14737: 5272, 32728: 5626, -1731: -29345, 24503: 19404, -24868: -21379, -6468: -22831, 22287: 10296, 2631: -26020, 14590: 19330, -9565: 26433, -15283: 5147, 6630: 31769, -17396: -21499, -25553: -10823, 13619: -10207, 23182: -25363, -23069: -32662, 19477: 15524, -1868: 5359, 7929: 27049, -12723: 9380, -16172: -20285, -10286: -10075, -9506: 31490, -25795: 13824, -17148: -32529, -21164: -9272, 20979: 9504, -18600: -2080, 27700: -20006, 9823: 31533, -6997: -19415, 28861: 17091, 26758: -15191, 24983: -24729, -28254: -1130, 25914: -26157, -24819: 405, 20339: 9923, 30368: 1691, -21613: -748, 1453: -19462, 3731: 13394, -32452: 3223, 24913: -6930, -21912: 19356, -24594: 21413, -4422: -29373, -15940: -23075, 27267: 7024, 2732: -24160, -28400: 18241, -24538: 1422, -426: 12283, -10915: -11143, -22114: 31517, 28357: 14424, 19009: 15527, -11167: -4468, 22854: -18910, -23106: 19639, 10382: 23860, 6220: -23926, -26385: -10089, -7503: -5631, 22781: -1889, 16878: -26298, 18982: 21243, 31681: 22201, -7993: 27285, -7299: 25550, 610: 16890, 8167: 21304, -16920: -617, -22339: 30620, 11333: -26987, -26992: -20496, -7985: -22986, 10141: -7469, 372: -21212, 17081: -17544, -11618: -922, 27971: 8305, -28364: -29445, 15932: 3403, 20712: -21072, 14139: 24028, -1589: -1905, 32372: -17183, -21555: 12537, 31409: 17560, 3035: -19927, -5300: 22560, -4845: 21856, 15699: -25855, 7642: 27579, 30284: -15949, -30974: -30226, 15786: 8546, -5179: 30950, 5765: 5052, 1410: -23757, -2705: -31393, 4012: 30468, -1359: -31879, -24808: 31414, 7542: 20843, -26533: -25712, 16975: 8303, -3145: -28727, 30626: -4547, 7331: -22347, -229: -15652, 26743: 8164, -28242: -12747, -13570: 28103, -31635: -32305, 25882: -22303, 392: -21213, -3910: -419, -24637: -4685, 15423: -4564, 16842: -5323, 2530: -6191, -28954: -20857, 12709: -1223, -29605: -31941, -15037: 9147, -2441: -9869, -30549: -24089, -2045: -24975, -6257: 5642, 19458: -26673, -11026: -32379, 11073: -2714, -16340: 29939, 22558: -389, -282: -29137, -8915: 10668, 13276: -26492, -6567: 15209, 18167: 6255, 18833: 9305, 23382: 9685, 22344: -6270, -5200: -17657, -27124: -17742, -19079: -568, 31073: -16882, 28075: 23525, -27683: -6870, -4980: 20988, 15716: -12047, -17167: -27903, 14047: 1751, 18332: 17369, -4584: -13960, -19312: -7004, 24390: -26226, -31358: -20950, 2846: 8574, 23256: -28403, -12965: -970, -10968: 6290, 31485: 3696, -14595: -24510, 8331: -24508, 16660: -6434, -21947: -11573, -13276: 18857, -11196: 13858, 20146: 29787, 26780: 16229, 22109: -21982, 3218: 12243, 20958: -15577, -25637: -8935, -29695: -30458, -27502: -9512, 6608: -10482, 260: -12910, 7060: 3640, 20729: -5920, 9177: 17672, 23669: 9673, -4719: -23531, 12804: -12848, -29031: -3714, 17216: -27527, -23101: 8400, -6250: 26869, -26842: -26986, -21952: 31092, 14811: 3573, -6081: 2717, -10912: -16202, -24595: 20431, -11358: -22184, 21588: -21605, -6061: 3518, 18275: -24618, 24224: 28119, -32273: 6717, -25485: -19967, -21076: -16695, -16947: -17173, 6350: -31349, 21046: 2696, 16207: -13750, -6710: 6770, 24774: -11316, -26121: -7976, 24586: -1831, -28350: -32385, -28591: 6607, 19897: 5582, 10787: -15060, 10497: -6872, -10294: 17802, -8472: 16304, -25702: 1771, 24559: 25237, -22562: 12409, 5848: 32381, 6698: 29851, -29088: -2362, -25758: -7282, 13364: 9287, 9286: -21108, -5875: 7021, 10384: -19100, -14947: -31087, 9224: -30160, 10825: 11627, 15906: 24744, -2491: 14682, 25078: -8675, -1487: 9277, 20301: -16262, -16721: 3749, 12876: 2719, -17183: 4920, -7383: -20989, 587: -29137, 1359: -18302, -31714: 5165, -10671: 13375, -1014: 25286, -5237: 14127, -20162: -15366, -17597: -27172, -16427: 24301, 21080: 29359, -16296: 21156, -27123: 17636, -14475: -17380, 3677: 3071, -13795: -14542, 25583: 2939, -18388: 26695, -30563: -10031, -19535: 16570, 22004: 14784, 4240: 16012, -26396: -7757, 1009: -24215, 10291: 31948, 31730: 31672, -27181: 4692, -7558: 15578, 8628: 18466, 15093: -25146, 15115: -23111, -25498: 19694, -29510: -6893, 10810: -20013, -7953: 24646, 17484: -6921, -22020: 317, 6794: 31084, 3107: 30850, 31725: 21696, -27069: -15468, 20231: -10374, 13074: -27686, -5761: 4056, 6032: 974, -515: -19247, -21834: -21830, 12853: -24945, -12244: 15573, 22762: -30055, 21333: 27246, 17857: -18844, 7569: -30916, 2863: 30220, 24301: -32097, -26608: -8747, -32337: -4850, 27215: 16975, -28845: 5184, 29948: 16776, -8096: -19809, 28922: 1579, -22399: -10320, 23633: 9402, 25594: -10014, -19789: 21539, 7783: -5857, 6413: 28988, 18148: 24286, 16425: -21685, -2117: 24914, 22809: -2465, -4052: 29220, -17437: -20536, 1701: -13236, 3559: -26792, 13260: 28650, 24280: 28935, -31390: 4155, -27444: 448, -15557: -22317, -26261: 14775, 8621: -19065, 854: -24623, -13346: -13154, 28008: 7670, 8308: -26926, -15207: -30554, -4728: -30539, 19116: -14938, -31105: 13428, -17085: 28001, 640: 29984, -30694: -21836, 31336: 29388, -23090: 26134, -22064: -8217, 23023: 25281, 28377: 3055, -826: 32149, -10250: 30089, -21073: -18570, -18476: -26801, -26910: -26764, -23220: -30649, 11262: 14325, 3587: 12688, -20447: -11553, -14604: -1133, 3267: 12700, -30988: -604, 31066: -5487, 4192: 1516, -9863: 26649, -12142: 839, -5180: -23733, 4771: 18192, -30173: 21726, 5816: -6256, -332: -23918, 9971: 21833, 368: 10035, 7709: 315, 18131: 27655, -12214: -2422, 8036: -21700, -12127: 30496, -17331: 23521, -5948: -28752, 9996: -22175, -12256: -9599, 12127: -14043, 8773: 23434, -24251: 31338, -30890: 4170, 796: 22060, -9480: -23318, 30137: -12439, -11200: -14846, -20960: -6630, -11449: -12059, 1710: -25246, 27339: -29509, 23266: -11878, 11424: 13957, -31513: -6604, 29223: 6248, 18427: 26701, -12933: -29661, -22958: 17397, -20885: -7075, -12532: 11832, -11207: -31040, -25413: -32634, -24423: 1136, 27748: -23097, 6865: -20862, 18880: -20717, -10317: -13842, -13186: -15707, 26939: -25776, 28970: 10404, -5636: 14068, -20214: 17872, 24853: 30283, 9956: 8484, 9398: -6284, -16839: 21664, 22800: -14869, 6033: 9989, -4795: -32223, 7279: -20473, 1275: -11857, 22338: 29810, 27015: -1704, -19258: 30646, 29954: 8034, -25853: 14141, 3311: -18597, -23320: -20940, -29480: 24564, 10547: 5534, -242: -13465, 24209: -1327, 10490: -5572, 7640: -20006, -8432: 5032, -11149: -24754, -4663: -23686, -10592: -7167, -25371: 22450, 4522: 7837, 6151: 19181, -18379: -20567, -31877: -18894, 17881: 7374, 24203: -4232, -15566: 16796, 5510: -31735, 15169: -20736, -29601: -27463, 7747: -430, 25280: -6754, -15509: 2251, -3086: -2933, 5884: 27703, -11157: -24312, 14484: -912, -3230: -9668, 16082: -25169, -137: 14744, -2665: -8726, 32412: 31615, -7276: -27566, 6279: 1989, -25300: -15901, 2440: 7619, 31956: 264, -5369: 16171, 14418: 1610, 18599: 4848, 20977: -22077, -6321: -4946, -8343: -22193, 1775: -19058, 26761: -28761, -12920: 27027, 4448: -11253, 25002: 4314, -22369: 23526, -12022: -7474, 32105: -12895, 1455: -4159, 15674: -28876, 11387: 18072, -27516: -8671, -10452: 32061, -29518: 28392, 29722: -20187, 15094: -22775, -31173: 17747, 28936: -12104, -19139: -6836, 10489: -818, -19250: 2431, -24391: 29686, 5886: 4259, 11123: 7634, 14067: 14441}, index_rand = 8788646705830835008
+xs 1144700111 3351133221 1701312047 4140849688 # shrinks to ref input = {-995: -18367, -30184: -27030, 4338: -17464, -26495: 18470, -23875: 6714, 11043: 22383, -7998: 11935, 16847: 5368, -9936: 1676, 469: -14105, -25789: -439, 2949: -19822, -13219: -11532, -13024: 24096, 7755: -32141, 5267: 20461, 13213: 5297, -7746: 31930, -24638: 20376, 11502: 161, 28692: -9359, -5352: 788, 17858: 16574, -4832: 26375, 3089: 1666, -27646: -21448, -29415: 27692, 5699: -11459, 9914: -14535, 10779: 11740, -29883: 790, 1921: -17804, -2606: 26661, 355: 10341, -9220: -21783, 10130: 2847, -28778: -8331, -26138: 21104, 19481: -11787, 23407: -22704, -13780: 6006, 7248: 6188, 9583: -27582, -19931: 21871, 7757: 32217, 7030: 24321, 13903: -28335, -6040: -8746, -16956: 3084, -27320: 10074, -11931: 23573, -14684: -2347, 25890: 13771, 770: -22088, 3703: -21750, -20005: -1416, -7260: -3308, -13212: 5663, 11568: -1211, -31546: -12571, 1625: -28634, 29510: -27517, -14067: -32392, -6952: -15279, 32194: -28535, 22530: -9153, 23590: -10792, -24830: 4545, -1413: 4698, 13676: -29216, -22119: 20809, 11493: -23219, 30324: -19957, -19740: 9364, -28332: 23760, 7598: -15700, 5250: 5262, 8892: -11149, 512: 21208, -26713: -22645, 15901: -16244, -11774: 25184, -27782: 31736, 1932: 28625, -19899: -15534, -14500: 28168, -31943: -10376, 5096: -6393, -12529: -28083, 15871: -31782, 24491: 9705, -13197: -2280, 20267: 26985, -2805: -7895, -12439: -25986, -1013: 18461, 1975: 32395, 22412: 8807, 18620: -21921, 18836: -11655, 20099: 15576, -15176: -556, -16690: 10393, -20701: -25137, 16023: 6541, 6323: 30693, 22672: 4962, 6262: -6543, 16070: 8710, 16145: 28518, -1209: -18693, -28389: -24853, 17412: -24261, 3497: 10996, 9187: -19998, -32168: 10884, 3560: 7346, 22807: 23444, -23068: 18732, -26136: -17299, 4558: -4291, 16805: 25070, 23084: 30635, -25411: 22895, -2902: 31559, -7150: -27951, -20232: 1338, 6838: 27765, -31069: -28409, 11606: -29065, -13760: 30312, -2036: -14916, 25218: 18519, -10854: -7745, 27820: 15149, 102: 7496, 804: 9488, 30201: -8547, 32678: 20708, -25202: 31329, -5584: -22884, -5108: 30003, 25093: -865, 27335: 6724, -10328: 15249, 5215: -12859, 25426: -6436, 4131: 8277, -19570: 7708, 20395: 7626, 3155: 12890, 19644: 581, -19031: -9366, -7803: 24805, 6673: -15061, -10892: -20442, -28410: 17433, -18136: 18606, 16432: 31698, -9848: 7414, 10831: 4060, -19606: -19806, -26041: -14198, 7826: 18579, -12900: -19535, -21442: 30662, -9253: -13676, 4185: -25497, -32472: -11113, -20772: -21936, 30731: 247, -17401: -28973, -11698: -26755, -17077: -5017, 22536: -3777, 13939: 16609, -8959: -24782, 29183: 15322, 28738: -31932, 12914: -31447, 27024: 19561, -6230: -2767, -18069: 12291, -3808: -532, 8699: -30308, -13072: 26305, -24174: -1772, 5083: -26578, 32374: -29090, -32055: 12554, 8496: -6213, 3295: 7339, 13897: 31817, -32448: -28910, 16533: 26195, 16795: -8295, 23292: -32385, 15102: 2439, 9462: 19663, 24237: 21643, 5357: 20413, 2361: 5794, 25247: -17229, -4187: 5207, -21262: 19783, -24684: -4240, -24679: -18791, 2368: -8363, 12208: -20319, 23264: 16664, -13617: 1275, -19198: -25513, 5092: 16212, 15124: 28714, 21439: -1196, -4432: 30044, 9557: -4855, -22916: 1046, -26280: 25826, -27674: -20014, -13633: 27408, -10975: -4991, 26520: -9235, -6589: 27583, -31631: -21487, 31832: 8595, -18451: -12811, -10412: -24981, 17602: -10428, -25014: 15888, 21325: 14946, 7746: 2626, -29626: -22668, 29538: -5978, 21901: 5842, 13851: 31830, -11034: 29385, -3586: 7536, -6063: 32614, -11727: 16659, 29320: -1367, -21326: 9220, 3205: -1974, -4787: 12852, 30793: 2568, 25796: 9433, 19016: -13799, -9621: -14129, 20136: 20434, -18060: -13251, -634: 18285, 15435: 22675, 29971: 5174, 31997: -29557, 18450: 7875, 22519: -12860, -10973: -20277, -26809: 31348, 6220: 11504, -178: 22232, 9592: -1419, -13548: 27708, 6172: 20899, 27648: 15593, -12157: 24765, -3131: 27366, -1827: -2958, 18365: 18538, -17861: -8596, -25217: -20668, -4257: -9796, -27958: -17570, -11603: -23589, -17591: -21385, 23905: 22546, -6098: 13776, -26132: 18512, 8204: 14798, 29533: 4545, 62: 22711, -9020: -8280, 11140: -8181, 1781: 10516, -1334: 15284, -7224: 7160, -28987: 22020, -4891: 8434, -4403: 19578, -20394: 14965, 29827: -30255, -560: 29091, -23917: -11862, -13868: -21175, -10219: 16295, 2577: 3128, 9484: -11742, 8668: 21789, -25813: -8178, -21404: 29342, -21751: 13687, 18052: 7524, -19144: -30345, 24903: -25167, 30700: 1834, -28266: 27752, -30375: 954, -11219: -5836, 28011: 8806, 20451: -23577, 10616: -15512, 6848: 4786, -5701: -16618, 10552: -612, 14323: -30855, 25785: -3039, -423: -22087, 20028: 21248, -31919: 15338, -19884: 15952, -22678: -176}, index_rand = 4536586039788573449
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+xs 888006417 2608449019 3789353629 478040202 # shrinks to ref m = {0: 0}
diff --git a/vendor/im-rc/proptest-regressions/ord/map.txt b/vendor/im-rc/proptest-regressions/ord/map.txt
new file mode 100644
index 000000000..9111b32b6
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/ord/map.txt
@@ -0,0 +1,8 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+xs 888006417 2608449019 3789353629 478040202 # shrinks to ref m = {0: 0}
+cc 1cc795607ade8b03fded509b229a329cf489559bf1ffd51710469db6532ef3c3 # shrinks to ref orig = {13654: -29485, -24329: 12447, 28073: 17462, -11155: 3551, 11565: -26208, -15232: 7608, 29759: 20320, 438: -16354, 571: -10462, 7614: -10288, 23780: -23920, -6563: 29101, 26479: 3890, 26520: -11140, -17636: -22688, -9506: 1900, -30037: -31504, -26114: 12976, 22103: 27666, -16535: 28839, -16809: -30920, 20788: 18978, -20423: 26728, -31348: -22678, -9794: -21451, 16178: -20708, 31232: 29025, -30976: 4474, -29215: -26793, 852: -11649, -4772: -14366, -19460: -5289, -5325: 24856, 45: -20269, -23801: -29271, 27724: -17783, -23212: -18476, 30206: -16727, 435: -2093, 15924: 4857, -25633: 29368, -20962: -9007, -7339: 27158, -30115: -25527, 14804: -18380, -14522: 29035, 15562: 23077, -20118: 17616, 28098: 8432, -27495: 12350, 14609: -13814, -9145: 29859, -31933: 16305, 19469: -825, 2409: -19471, 20578: 22502, 7884: -12550, 11389: -14638, -21015: -16375, 9053: 16535, 4588: -7460, 9046: -8592, 9482: -10249, -30236: 32067, -5302: 27299, 30181: -6167, -29843: 7210, 16374: -32301, -25407: 20496, 2749: -11107, -5975: 27109, -27089: 2177, 8897: -31616, -29271: 2162, -31613: 20560, 31507: -14262, 21540: -25321, 24744: -7423, 26657: -26369, -12605: -22618, -27512: -21723, 291: -9951, -12495: -32742, 7539: 30444, -27269: -12562, 29899: 26866, -587: 20631, -31271: -32202, -15662: -21784, 28126: -31732, -9749: -6578, -13352: -5663, -5080: 21203, -31106: -8714, 29841: -16964, -11827: -13788, -24678: 4958, 6499: 17700, -5695: 1260, 12631: 29706, 21390: 794, 5009: -5889, -32578: -14971, -26389: -8078, 26546: 17151, -22373: 15689, 27572: 568, -5244: -1643, 23163: 11329, -28715: -15929, -25818: 12223, -4427: 28582, 26061: -32554, -14351: 5137, 3017: -15529, -23194: -19328, 30499: 5974, 16990: -31204, 28136: 23024, -13986: 5556, 12355: -10820, 2837: -15764, -8318: -22640, 19390: -32081, 5443: -11767, 14269: 4778, 12880: -8658, 23857: 15963, 29819: 14185, -28642: -14213, 1092: -1891, 3065: 7306, 5667: -16519, 13195: 30960, 30981: 3805, -18227: 17519, 26714: -10844, 1867: 3065, -21164: -23958, -27908: 23652, -3016: -25807, 21021: -24516, 601: 6650, 10464: -30444, -25383: 21397, 16149: -20990, -23678: 19268, 13651: -30926, -30193: 4015, -20550: -3813, 8984: 23024, 8529: 12538, 13423: 3073, 24037: -11619, -20993: -31582, -7056: -2892, -12795: 10504, -16197: 1330, -20748: -17973, -31199: 22341, 31286: -22643, 9674: -18049, -29206: -15460, -25215: -15832, 28334: 11339, 14680: 15220, -25943: 24920, 32275: -6093, 13259: 30579, -29041: -17489, 15886: 7941, 15683: 9359, -1635: 54, -30492: -21635, 10271: 18315, 13384: -5318, 31595: -23502, 14243: 5855, 10461: -11363, -3155: -29668, -5835: -8232, -28140: 19386, -761: 30096, -2515: 27267, -17737: -31871, 31096: -26754, -24336: 13642, -14011: -8588, -14996: 25507, 28759: 9825, -14214: 9160, -14712: -24558, 19038: -18469, -30816: -20086, 4334: -10671, -17006: 1184, -3730: 13058, 31026: -16485, 9580: -17771, -21186: 18345, -9664: -11262, -8480: 7648, 22920: -14965, -21022: -28133, -8744: -11234, -30252: -16231, -26305: 12363, -28149: -24604, -26462: 3796, 3057: -18784, 16634: 13983, 6987: -20371, 7469: 11214, 1205: -21956, -29086: 28404, 12269: 16334, 32493: -11094, 18386: -27104, -25066: -26762, -8850: 27225, -21958: -12209, -13409: -10100, -14283: -27726, -339: -26813, -25875: -8615, -9605: 8712, 10133: 21989, 9858: -12796, -19094: 32285, 32169: -26413, 2531: 30679, 15476: -23974, 14526: 26173, 32030: -8035, -32658: -23894, 32452: 31750, 8858: 3008, -22939: -30641, -570: 27228, -21127: -27648, 24710: 19973, 1390: 4422, 26123: 30745, -1229: -11664, -14679: 21300, -23645: -21514, -19979: -21143, 187: 26447, 1962: 103, -22968: 29896, 15464: 15061, 21532: 12811, -22803: -28425, 13579: -3285, -20628: -1077, -1080: 1008, 15835: -683, 29901: -2994, 8479: -3328, 21105: -27495, -3175: 19378, -30585: -24530, 17220: -24097, 30652: -32638, -21764: -4829, 24103: 19016, -21401: -27015, -31558: 18025, 30591: 11391, -22504: -23421, 5082: 27279, -2537: 27017, -12136: -749, 1815: -31786, -9416: -175, -12810: 30806, -9899: -2793, -32007: 30752, 20930: 30725, -28783: 8969, 29565: 2902, 18834: 2903, 31282: 30845, -10893: 28071, -20454: 1174, 27915: 5772, 29383: -1684, -5885: -19780, -9746: 17492, 8958: -7053, -1675: 24931, -20548: 29629, 10029: 19670, 372: 251, -22290: 1847, -22754: -8267, 15349: 14893, 6565: -16252, 5100: 31913, -21771: 247, 3407: -27092, 31264: 8619, -31498: 30586, -26457: -15280, 13900: -6472, 20237: 23494, -9435: -20123, 6560: 684, 6684: 13629, -19962: 31911, 7387: 22300, -16475: -211, 18073: -14359, 9010: -16589, -8927: 28464, -20438: -14947, 29302: -13068, 5174: -12114, -2684: 8886, 22145: -17371, -11264: -13950, -25938: -12728, -28145: -25911, -2871: -16462, -9775: -19757, 18920: 21013, 22571: 13793, -7253: 614, 1353: -19656, 22230: 14776, -25153: 4229, -26295: 15362, -25138: -16289, -26420: 21238, 32553: 2348, -17295: -15555, -18560: -30281, 25786: -5042, -10591: 10906, 17986: -1866, -32187: 14848, -8185: -18226, 28767: -25694, 15864: 740, -13565: -5281, 16351: -17855, 20798: 32488, 30621: 17130, -605: -12389, 11190: 6647, -5191: -7463, -17293: 21338, -1894: -29073, 10118: 15281, -24187: 12088, -13829: 32655, 19616: -29201, 32331: 26134, -22497: 12542, 2780: 29682, -8061: 20915, -15085: 21858, -2284: 1496, 12256: 14729, -12669: 8208, 12081: -20514, -19564: 21060, -5230: -3232, -47: 12452, -23297: 25490, 15469: 19166, -31330: -1486, 22627: 6048, 2274: 14307, -32613: -17602, 31993: -20703, 14408: -24288, -1425: 2191, -27528: 12719, -13137: -19771, -10087: -15533, 23123: 13133, -310: 28795, -17066: -28238, -323: -28130, 30008: -23016, 29855: 9227, -11934: -24563, -16278: -19539, 3943: -23354, 13038: 8483, -1376: -15228, 7177: -28754, 5920: -21813, 1028: -27574, -27086: -11996, -2451: 31603, -22198: 32494, 20534: 11352, -6499: 17474, -17125: -9124, 30067: 29674, -12170: -27056, 987: 10245, 20189: 7215, -17598: -31297, 20584: 32174, -27159: -25146, 15669: 14996, 22287: 32183, -17952: -27435, -20978: 29156, 17502: 23504, -2148: -3829, 14096: 8068, -25471: -11783, -10066: 25659, 14854: 17031, -16055: 30964, -24705: 9847, -21845: 27718, 30004: 14241, -2415: -3601, -23396: -26488, 27072: 4241, -25740: -23800, -32283: -6378, -20149: -2325, -29938: -25721, 26132: -5055, 4443: -8672, -4050: 19873, -936: -11208, -17559: 20749, 14497: 11691, 16966: 20137, -29672: 686, -11408: -10767, -2153: 29746, -31040: 2878, 2624: 10124, 7960: -27203, 17944: 18886, 5964: -30909, -6166: 25605, 13164: 10691, -27151: -18494, 6796: 10814, -9287: 8912, -27917: -2697, 21533: 22935, -27712: -24484, 8240: 27279, -10392: 24267, -5470: -32174, 18400: -29304, 6357: 9981, -10733: -30914, -20535: -266, -26868: -11399, -157: -13150, -7205: 6723, 23256: -6764, -786: 31308, -10664: 1606, -20685: -882, -24938: -1889, -7206: -3509, -25250: 31979, 30426: 128, 23897: -24001, -2859: -19488, -32217: 31472, 2593: 8890, 4407: 30506, 22878: 31925, -7560: -2864, -2411: -26849, 22106: -6447, 24278: 28527, 27516: -9012, 5476: -6024, 9147: 13764, 24213: -24869, -1759: -16068, -5603: -30129, 31029: -2919, -14714: 19182, -1590: 12635, -28358: 3872, -2090: -12305, -20911: -2417, 20313: 18181, -12831: -31538, 10130: 12759, -15468: 14679, 12923: 22142, 18271: -29174, -30962: 23155, 27775: -4512, -26395: -2421, -17588: 16263, 7453: 31385, 8023: 2389, -12214: 21076, 18059: 27701, -8734: 21859, 12513: -5333, 25322: -8656, 12712: 23597, 25917: -21636, -19326: -24361, 4360: -11045, -22272: 31718, -20938: -18069, 13566: -7383, -23839: -21705, -24263: 21476, -24653: 13628, -23521: 15327, -7348: -27475, -19318: -806, -8248: 14683, -29376: -8615, 24517: 4415, 19604: 19484, -32302: 22802, -24795: -13299, -12528: 32372, 13871: 5985, -8162: -19078, -22665: -32732, 9803: -4532, 27376: -14806, 15809: -23444, 16523: -6943, -25262: -4067, 12042: 6032, -13822: 21798, 11271: 16788, -6415: 783, 8921: -12257, -10523: 11184, 13024: 26551, -8164: -15301, 26059: 21139, -19775: -15038, 28467: 13920, 24798: 27943, 23346: 24954, 22060: -14719, 4525: -7210, -27468: -30621, 25871: -1553}
diff --git a/vendor/im-rc/proptest-regressions/ord/set.txt b/vendor/im-rc/proptest-regressions/ord/set.txt
new file mode 100644
index 000000000..9380d494a
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/ord/set.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc d2977c225bfd8d461dea19c554cae04a48f9155854b53118264fb27b2dab49cb # shrinks to max = 1
diff --git a/vendor/im-rc/proptest-regressions/ser.txt b/vendor/im-rc/proptest-regressions/ser.txt
new file mode 100644
index 000000000..d5c25a33f
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/ser.txt
@@ -0,0 +1,10 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+xs 3983395997 40281418 114824171 2339847213 # shrinks to ref v = {1285771567, -841112960, -2090277076, 1080385872, 900828884, 615148720, -333870035, -1551786909, -1167746969, -1453736382, -1747821313, 367596715, 1982056530, -1495713558}
+xs 2832291072 3367532499 2480853836 1445020057 # shrinks to ref v = {-1006265241: 1190299023, -874470135: -656918271, -747552887: -119701798, -446035143: 289470610, -38617499: -70412299, -28555422: 742423513, 549345238: -1218765301, 1006459863: 373426025, 1730586809: 1217890615, 1741069766: 1330906833}
+xs 497222929 1550339526 1868828736 2852494662 # shrinks to ref v = {-33, -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, 0}
+xs 3367619631 4093181880 814513877 3641392342 # shrinks to ref v = {-33: 0, -32: 0, -31: 0, -30: 0, -29: 0, -28: 0, -27: 0, -26: 0, -25: 0, -24: 0, -23: 0, -22: 0, -21: 0, -20: 0, -19: 0, -18: 0, -17: 0, -16: 0, -15: 0, -14: 0, -13: 0, -12: 0, -11: 0, -10: 0, -9: 0, -8: 0, -7: 0, -6: 0, -5: 0, -4: 0, -3: 0, -2: 0, 0: 0}
diff --git a/vendor/im-rc/proptest-regressions/sort.txt b/vendor/im-rc/proptest-regressions/sort.txt
new file mode 100644
index 000000000..a6b62f5d4
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/sort.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+xs 1397459766 1987461941 1386942626 306293423 # shrinks to ref input = [0, 777418683, 1143505337, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1422499358, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1143505337, 0, -275943289, -1, 0, 0, 0, 777418684, 0, 777418684]
diff --git a/vendor/im-rc/proptest-regressions/tests/ordset.txt b/vendor/im-rc/proptest-regressions/tests/ordset.txt
new file mode 100644
index 000000000..9f4a7cbf8
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/tests/ordset.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc ad212dea44eb83bbfd86396a2e0f9460ecb93f6b1a2644bc700ffc317638a37a # shrinks to actions = let mut set = OrdSet::new(); set.insert(0); let expected = vec![0]; assert_eq!(OrdSet::from(expected), set); 
diff --git a/vendor/im-rc/proptest-regressions/tests/vector.txt b/vendor/im-rc/proptest-regressions/tests/vector.txt
new file mode 100644
index 000000000..1fa3f5210
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/tests/vector.txt
@@ -0,0 +1,9 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc a81c870198d194d869b85a541fca54b5a3f3ea4e84705bfdede6212ad7451789 # shrinks to actions = [PushFront(0), PushFront(0), PushFront(0), PushFront(0), PushFront(0), PushFront(0), SplitLeft(0), PushFront(0), PushFront(0), PushFront(0), Remove(0), PopFront, PushFront(0), PushFront(0), PushFront(0), PushFront(0), PushFront(0), PushFront(0), SplitLeft(1026178654884686841), PushFront(0), PushFront(0), SplitLeft(2673257349917114567), PushFront(0), PushFront(0), PushFront(0), PushFront(0), JoinLeft([0, 0, 0, 0, 0, 0, 0]), PushFront(0), PushFront(0), SplitRight(6380212717721778205), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), PopFront, Insert(0, 0), PushFront(0), PushFront(0), SplitRight(12236220624414400388), Insert(0, 0), PushFront(0), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), SplitLeft(13848748256934322935), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), SplitLeft(13115524110820767241), Insert(0, 0), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), PushFront(0), PopFront, PopFront, Remove(0), Insert(0, 0), PopFront, JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), PopFront, PushFront(0), PopFront, PushFront(0), PushFront(0), Remove(0), SplitLeft(9383655485369749481), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), PopBack, PushFront(0), Insert(455053961473158936, 0), SplitRight(676041696221001931), PushBack(0), PopFront, JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]), PushFront(0), PushFront(0), PushFront(0), JoinLeft([0])]
+cc bae4a6aa243531a345cb36883fda4aebc84848fffe12d051df4e24ff22af3689 # shrinks to actions = let mut vec = Vector::new(); let mut vec_new = Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); vec_new.append(vec); vec = vec_new; vec = vec.split_off(6); vec.pop_front(); vec.pop_front(); vec.push_front(0); vec.pop_front(); vec.push_front(0); vec.append(Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])); vec.split_off(141); let mut vec_new = Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); vec_new.append(vec); vec = vec_new; vec.insert(41, 0); vec.pop_front(); vec.pop_front(); vec = vec.split_off(5); vec.pop_front(); vec.append(Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])); vec.append(Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])); vec.push_front(0); vec.push_front(0); let mut vec_new = Vector::from([0]); vec_new.append(vec); vec = vec_new; 
+cc 2c8368d1e6fe86c9b944a688cc167d961767ffb028ca724bb3c12e2716cbfbf9 # shrinks to actions = let mut vec = Vector::new(); let mut vec_new = Vector::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); // size 70 vec_new.append(vec); vec = vec_new; // len = 70 vec.append(Vector::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 53, 59, 108, 189, 95, 24, 92, 116, 211, 64, 195, 2, 58, 198, 130, 44, 163, 180, 50, 176, 78, 24, 2, 180, 91, 132, 176, 205, 155, 65, 228, 182, 175, 100, 204, 222])); // size 61 // len = 131 vec.insert(8, 88); // len = 132 vec.push_back(252); // len = 133 vec.insert(1, 65); // len = 134 let mut vec_new = Vector::from(vec![57, 103, 160, 147, 241, 248, 112, 54, 152, 245, 195, 156, 245, 143, 175, 51, 27, 183, 236, 77, 126, 27, 160, 172, 73, 179]); // size 26 vec_new.append(vec); vec = vec_new; // len = 160 vec.insert(0, 112); // len = 161 let mut vec_new = Vector::from(vec![191, 78, 196, 239, 181, 187, 82, 160]); // size 8 vec_new.append(vec); vec = vec_new; // len = 169 vec.pop_front(); // len = 168 vec.pop_back(); // len = 167 vec.insert(153, 32); // len = 168 vec.split_off(10); // len = 10 vec.insert(6, 131); // len = 11 vec.pop_front(); // len = 10 vec.insert(4, 235); // len = 11 vec.remove(8) // len = 10 vec.insert(6, 48); // len = 11 vec.insert(3, 194); // len = 12 vec.push_back(31); // len = 13 vec.pop_front(); // len = 12 vec.push_front(96); // len = 13 vec.push_back(77); // len = 14 vec.append(Vector::from(vec![70, 240, 146, 141, 164, 160, 150, 102, 163, 137, 14, 197, 249, 2, 249, 52, 9, 203, 50, 161, 148, 209, 86, 161, 34, 32, 189, 39, 208, 106, 47, 100, 194, 160, 147, 69, 4, 249, 250, 77, 73, 181, 49, 228, 141, 195, 210, 102, 73, 75, 167, 106, 233, 141, 182, 243, 42, 102, 166, 184, 248, 127, 120, 88, 246, 204, 127, 214, 30, 201, 205, 115, 28, 204, 26, 17, 67, 228, 44, 158, 15, 79, 141, 86, 101, 148, 76, 44, 216, 65])); // size 90 // len = 104 let mut vec_new = Vector::from(vec![123, 94, 60, 147, 41, 173, 214, 101, 145, 201, 69, 78, 61, 38, 60, 170, 56, 33, 65, 151, 28, 93, 16, 187, 49, 103, 52, 133, 253, 244, 125, 66, 56, 190, 17, 235, 117, 101, 212, 129, 170, 112, 203, 78, 217, 49, 176, 252, 8, 153, 178, 205, 211, 165, 197, 32, 171, 224, 17, 127, 56, 45, 36, 248, 66, 126, 110, 109, 94, 116, 189, 185, 24, 215, 87, 239, 248, 98, 134, 0, 249, 147, 197, 237, 6, 150, 30, 51, 149, 12, 31, 93, 95, 158, 229]); // size 95 vec_new.append(vec); vec = vec_new; // len = 199 vec.append(Vector::from(vec![127, 142, 241, 16, 254, 11, 153, 252, 3, 104, 61, 225, 73, 56, 149, 247, 142, 67, 4, 24, 96, 169, 234, 215, 227, 30, 84, 45, 209])); // size 29 // len = 228 vec.append(Vector::from(vec![194, 101, 202, 247, 108, 248, 86, 224, 255, 187, 50, 123, 93, 110, 63, 83, 122, 101, 48, 38])); // size 20 // len = 248 vec.push_front(80); // len = 249 vec.append(Vector::from(vec![228, 25, 146, 89, 230, 224, 101])); // size 7 // len = 256 let mut vec_new = Vector::from(vec![89, 252, 187, 201, 31, 229, 16, 211, 172, 223, 209, 123, 120, 100, 91, 241, 223, 42, 71, 212, 42, 113, 211, 128, 54, 142]); // size 26 vec_new.append(vec); vec = vec_new; // len = 282 vec = vec.split_off(188); // len = 94 let expected = vec![233, 141, 182, 243, 42, 102, 166, 184, 248, 127, 120, 88, 246, 204, 127, 214, 30, 201, 205, 115, 28, 204, 26, 17, 67, 228, 44, 158, 15, 79, 141, 86, 101, 148, 76, 44, 216, 65, 127, 142, 241, 16, 254, 11, 153, 252, 3, 104, 61, 225, 73, 56, 149, 247, 142, 67, 4, 24, 96, 169, 234, 215, 227, 30, 84, 45, 209, 194, 101, 202, 247, 108, 248, 86, 224, 255, 187, 50, 123, 93, 110, 63, 83, 122, 101, 48, 38, 228, 25, 146, 89, 230, 224, 101]; assert_eq!(Vector::from(expected), vec); 
diff --git a/vendor/im-rc/proptest-regressions/vector/mod.txt b/vendor/im-rc/proptest-regressions/vector/mod.txt
new file mode 100644
index 000000000..6ac612271
--- /dev/null
+++ b/vendor/im-rc/proptest-regressions/vector/mod.txt
@@ -0,0 +1,16 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+xs 781088174 2402437932 46071810 3445483747 # shrinks to ref vec = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+xs 1236163365 497060525 1875560600 3785939576
+xs 2440477773 3871129562 3025797391 1057174199 # shrinks to ref vec1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ref vec2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+xs 3956050500 706730731 3245945489 2502775722 # shrinks to ref vec1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ref vec2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+cc cf2875f6f7c5648d87ffcab4ccac7f8a8f720c93ee377e89f8c86e542cc643bc
+cc 3f8ab4d20e0696c9811622b868e9e2e11df5e6195ffd427aa305e4c6b36937f0 # shrinks to ref input = [2074036082, -13825946, 1485618086, 938025892, 1634050283, 343602973, -606035941, 2086123502, 756455726, 1967901285, 417064296, 912931675, -48362083, -439614021, -192545534, 353571790, -1804858855, 908622705, 1183010347, -2019732894, 474300008, -1087280630, 1989024406, -1862412421, 1817688323, 1779903690, 645225408, 1290443907, 739077543, 1459983883, -19629421, 921340531, 1254057305, -1854941617, 339275035, 1177377681, -107461978, 1556951107, 1142459430, 418860714, -1711737411, 1787159709, -316274917, 1302348247, 181570291, -2076292901, -1093494155, 1763629984, -1195124258, 490574341, -681065204, 1238632378, 853854507, 42089611, 1831408714, -1041889085, -421564140, -1913933099, 926289166, 279182650, -2127045141, 1738196395, 2053843176, -2017898141, -399808861, 457054821, 1398259288, 560215405, 538259370, -1037968371, -737896076, 341049037, -1211866783, -1843247477, 602815427, -1981792594, -932949201, 1730346408, 173892487, -118710082, -993398654, -852952873, -1368077643, 321394671, 2093514113, 1831301356, 2104751555, -183869811, -1503190860, 1135803650, -25841157, 1218834281, -479227795, -1808365999, -1532913102, -1328086922, 1318622180, -1280127583, -802930281, -508955020, -1574788467, -1982208682, -563261649, -418424840, 2029013774, -1362803987, -638036545, -947262269, 1950557609, 1187410224, -1464584417, 1384726544, 413235774, 1436482752, 1395432848, 1656858203, 147231077, 1946166606, -701896304, 410570040, -1905606977, -1122557347, 2122591018, 567266348, -943154118, -1971951936, 590807013, 1967462062, 255252417, 2073823043, 1541319971, 1453203803, 1421341138, 132882974, -1352759657, 538478979, -140652930, -1307846641, -221794328, 584699783, 51954554, -1851000469, 400639112, -1849914695, -608123546, -1897558717, -938554976, -1021874582, -1619777886, 2098079695, -188166053, -654806278, -1089147663, 1364112441, -2080156329, 485140329, 1867162848, -1435377175, 1281905818, 464841556, 1285796301, 1233354604, 1251770836, 972787149, 194394838, -408637346, 297940676, -764140760, -535189066, -1222082930, 1999659587, -1466965620, -545915560, -33381613, -3391831, -1726247123, 1541843291, 618382071, 1692204756, -556631887, -1010281118, 547567742, 262071110, 1315561258, 1041276450, -200019451, 155953937, -1918010523, -2034646338, 179308692, -1851545907, 518204726, -1644852449, -930708052, -1533983680, 174298704, -1142603020, 400835696, -1032416568, -143748802, 89618872, 1498511740, -1964329731, 1985385121, 1338534044, 63395119, -2024486383, -1608930868, -2132981855, -1724578322, -1192711882, 1794405014, -1875127241, 220328451, -914341018, 1456640965, 1592862117, 1416491276, 457921478, 694438266, 1597638181, -1033179164, 1392568444, 1320710298, -1026116152, -1107223499, 2046373754, -802840884, 167120902, 2132541214, -1939037919, 376672960, -809965082, -629582607, -1849899910, -49034754, 814355126, 1904252470, -1995358474, -1535123866, 1964249876, 1541812798, 1216319781, 1448772690, -1676360707, -593183425, 367191330, -1015415169, -209835596, 973923323, -1379232452, -1678253796, -504812765, -2093303787, 1352940938, 1298454946, 1581876111, -1223031747, 2069730200, -1460608552, -1737622339, 1109644043, 2026556453, 1759367532, 1086741250, -167537825, 1616204085, -326437736, 955819637, 1295445215, 336028006, -1727534730, -968937744, -553518261, 1670053153, -1349953260, -2120024551, 1980134547, -1068452794, 1219491483, -390297250, -1475253674, 415787435, 1873218319, -964316540, 221387283, 1591083275, 1444258216, -1881949415, 776917485, -1456154045, -1552934014, 2084443571, -1120296261, -1579431939, -1519754301, -1709430045, -303381422, 129976350, 254373149, 1407938652, -334266500, 24715971, -1489003805, -344545827, -30707531, -1037864976, -1932107944, -1947334424, -450501819, -717436421, 555717916, 341387118, 369635675, 1599459501, -1778790486, -1104209594, -2118365426, -2054102940, -1118790563, 850092741, 2031700649, -2032648691, 209452659, 1033303173, -2138994429, 747531727, -1564008984, 479576488, -1210763963, -147017823, -78176051, -894576638, -1997663736, 414627089, -460407928, 242360038, -521406219, -1628996761, -744872182, -1441232914, 1846502295, -943262183, -1393886050, -2018639700, 145134549, 187913768, 69737401, -1313998467, 1510329953, -621473150, -982308299, 1043016699, -1651933122, -1244551793, -289264939, 1877434840, -885867921, -1455488637, 1208421381, -195139456, -507382900, -1417009162, -801223255, 913934347, 1483498591, 313323757, 684949109, -2138586829, -2071891390, -812202386, 1737302175, 1076518260, -526641190, -2049254033, 112548900, 323995436, -791419496, -1225118760, 642320913, 383365901, 1380650886, -339607804, 2033605956, 1103328389, -914762689, 1158292416, 1643458103, 139201662, -565020354, -1313785974, -863936467, 897894968, -1312998944, 1790634237, -752758530, 439608095, 1681084131, 233508147, 2013294518, 1823519587, 1660588466, 1812760899, 508524059, 1184818398, 213279538, -1222991812, -1978978464, 971476813, 1841261427, 2132433812, 1958231930, -117862732, 1650837593, 1029355018, 779022208, -1419168200, -340738059, -467041175, 329912954, 2132095988, -1585519098, 1323577018, -810116712, -1865039613, 1617692461, -1807759080, 344751862, 1450322400, -248458668, 237856838, 934330482, -649300467, -1895742412, -68722199, 288157201, -1819800236, 636713948, 1350627276, 86963139, 707515305, 1637864209, -951128924, 1833027683, -660390999, 727450477, -178917142, -1756743187, 153010136, 1146380330, 1149200284, -112449880, -1722382195, -1105256026, -562353456, 735928455, 1980254150, 166745367, 1589677843, 239612358, -1375912249, -232347030, -513829568, -715230968, -951636353, 35308988, 1058861976, -939881777, 389606025, -1455012972, 1789973526, 819109054, 2072323170, -1718042069, 415141655, 91908874, -375749327, 1622668705, 575657694, -1904593276, -67784013, -172853454, -484633603, -93271368, -1345817662, -1137764517, -1270761846, 726587010, 473120028, 178775245, -1701651765, 1526034877, -959144121, -183434587, -1617575041, 638251420, -1667918115, -829628671, 2035538892, 1670451796, 1392586407, -496019207, 903216680, 2100415815, -1980994623, -1052104848, 1457997902, 135859152, -108183568, -1097707977, -1374810787, 1180961208, -1307964614, -655644955, 1068486096, 581472280, 479947778, 136787664, -1476233191, -771095637, -1946363681, -21954842, -1629269370, 398541279, -1381636972, 456435952, 549611143, 1226758538, -665527736, 921771361, 1732495943, 857537416, -1311210307, 259851132, 54363142, -1872821125, -1558611717, -1561079726, -2050987563, 1820207889, 428187339, -1822780242, 676403468, -1654516077, 1731138284, -459002904, -2110845122, -621879519, 957958995, 1265282103, 243944836, -1271620168, 212486812, 1544089397, 1225721531, 1373272554, -1146075901, -31903557, -2122165744, 716785949, 773898185, -1697590745, 1139026087, -1128365692, -625874054, 1620393856, 2049458344, -638108114, 1006443422, 244013891, -959077606, 590687801, 1457741822, -836587639, 1164800185, 715176364, -1990226498, 1876286734, 1104112736, -1019905535, 1546003147, -1944204741, -1441042435, -1003488031, 1193976065, 454296507, 88091747, -1241971921, -372366427, -1131355056, -1993192868, 612679547, -1014555561, -2072304807, -181217339, -1230739815, 144971487, 636393978, -571012714, -1037687907, -1159249903, -656360123, -752128517, -616386904, 1621018842, 2120187290, 840041366, 1046715186, -213798416, 1220245598, -672389981, 963148331, -1445841173, -1758726199, 1919633920, -2120029560, -1217985998, 1161564327, -185318835, -1236360705, -956544035, -2144416202, -613210283, 1670320117, 828779231, 1146210465, 2096904410, -896703053, -1793409666, 484239052, 1374451134, -170334499, -1298101602, -1884559050, 120611217, 561196767, 825646390, -379512545, -1181612672, 1725080453, 894394587, -344082758, 736879648, 674694083, 1619268347, -496023195, -102002782, -842294653, 1841077684, -1510106855, 182713856, -202141272, -1506286097, -745352139, -1623254497, 1993580158, -1458213604, -1063096945, 1838489414, -1507167817, -1800227771, -1597408579, -786176532, 652248741, 369542434, 1568176235, 2131816918, 1675019550, -35228538, -626903300, 925830026, -2112784346, 417584189, -1057780140, 338713052, 825189157, -541098859, 795314319, 834369951, 1813578641, 1853897695, -508754162, 1131302557, 1842805572, -1386265126, -105109281, 1929191619, 365363316, 30848530, 1648738008, -5477858, -128018202, -1616404752, -706096224, -669233949, 1470778925, -818029978, -1123804154, -1801848224, -128380870, 1979870858, -2034279195, 24763756, 146178405, -87107679, -1276578948, -931079626, -19523975, -352157139, -2089700377, 878963733, -933252824, 177118516, 2007822342, 369516438, -223358742, 1555386773, 172477838, 696822368, 1734455136, -1691821089, -1710391517, -852385941, 985649133, -990853305, 2132107158, 1027224135, 1243623279, 1140262391, -680877276, -487308262, -2012563745, -158258209, -776719120, -280474401, -2089800633, 1110970379, 2042227416, 1822232534, 434874365, -1708107889, 564960608, 603651451, 670259206, 496003746, 1781379733, 263720034, 1348487686, -500344248, -47605549, 1083823409, -2112131381, 1360946561, 1032611909, 722713543, 631919140, -2020465896, -1425404176, -1057926350, 2016005948, 1500712949, -572195007, 1705736830, -607815961, -1110944216, 1521417863, -1845376244, 1600750078, 726936858, 1057595290, 621086544, -1389672811, 605472649, 1332661070, -906674643, -1110321279, -1411856682, -1152283803, 1551997284, -1920544851, -923902286, -1158501532, -183191214, -1440914774, 2039809837, 708032355, -783129450, 1757226306, -1934942490, -387201262, 954917910, 2047838574, 1011062626, 2013368665, -785120726, 2110535812, 1784304612, -1463847791, 1144411860, -245946308, -80365437, 1567197443, 1327272314, -140150720, 149507793, 1159202773, 1002514003, -1744390956, -1782985230, 1673971410, -777733567, -129088441, -79017303, 52585550, -334069958, 1154008540, -430846671, 1438426004, 1802651992, -1130101106, -1840626986, 436239024, -1031507775, 1338703766, -1672638532, -185408152, 2138867350, 1455179070, 495841734, 243789940, 119847865, 1584300320, -967618123, 450392156, -333159947, -658236010, 985332812, -828567444, -703879489, 810152232, 1362837274, 538318967, 1493290149, -795241024, -329956784, 1555841105, 1288467661, -712740577, -1555985260, -1096322447, -587003901, -1969396615, 1262483995, -745308685, 1415894777, -927442975, -1119406446, -841365439, 1590961822, -1137095817, -471430773, -1724561514, 1632082470, 1452194693, 1573724207, -1056390572, 1409850492, 1986869003, -1338889943, 1028065063, 852777652, -1970303190, -162211687, 191430130, 73303236, 1248707160, 1147073730, 1963985187, 85123011, 943234918, -589830911, 1615305226, 877377745, 413476354, -1485535096, 292861396, 587319220, -1093011335, -1323555037, -1357193160, 164263022, -972519902, 279224127, 711182294, -1995243735, -1793989650, 1352628071, -866818457, -77298747, 425992637, -1595732809, -700857521, 94834560, -351790881, -1648488658, -450350491, -2086521426, 125456589, 1699220019, 2068296684, -710274617, 646836800, 1804572376, 1258920542, -1787200449, -1903274259, 1206277195, 772958010, 303500230, -15790904, -1612308290, 1658129395, -395132767, -176780729, 701517154, -1141166097, -506094904, 419452540, -447817973, -1944275095, -587149278, 440910705, -1954163668, 284196487, 110272837, 1383525792, -1590873999, -2046627948, 1609135967, 1576362735, 1351579814, 1215558731, -1571835272, 1164889714, -1687222223, -308301954, 548400081, -1603661876, -1492992204, -1069693438, -146086196, 1654865162, -1744673963, -1916511304, 1156765219, 705280294, -1351994050, -1457658843, -1643654416, 1939831051, 592724212, -77904168, -841119817, -1916382996, 332785278, -523144810, -1937360372, -1783779649, -1296361371, -1334714400, -340608540, -557600043, -2121148923, 336729750, 70670973, 1700104880, 1211975311, -2065301796, 1350766899, 1008664094, 914213634, 1451337520, 72519135, 1621122800, -880167527, -1996260667, 1543405835, 19988, -1006109465, 1022821761, 1920504508, 1853584207, -1219874606, 818730373, -389483600, 1126720754, 1200031245, 90176802, 400890505, -632493449, 2126131937, 81577335, -831586672, -1557362007, 1624430684, -97733102, -874664357, 1859678361, -2058068798, 810835444, -797049033, 1588534622, 722602759, 587748230, -306983628, 2112257232, 222045709, 1806043771, -1995279884, 708369281, 1593214010, -594305532, -835696452, -261598470, 1700209807, 2132552449, 1134259195, -557873538, 666199347, -1370860865, -1291669929, -1982793775, -964359611, 1411523767, 874684473, 280843736, -772863939, -1760910534, 1834571177, -113850263, 964555207, 1700093129, -1291386198, -453641221, 1575423428, 1737962346, -1205243353, -1815954346, 69474747, 923104036, 1181772263, -1954223897, 1640227821, -2032732182, 741984480, 695783719, -1075712461, -451815548, 2088922812, -1074740902, 1530562045, 1991403690, 784239790, 840688915, -1065420476, -1783096063, 729574579, -721908166, -806317184, 804801148, 990212065, 166291018, -1286443454, -667451876, -308501055, -194874181, -1871320761, -1358248959, 2057411783, -1382427531, -710083396, 1875533947, -57075992, -1381920306, 511702421, 1053171309, -1989916206, 1155691146, 1768712079, -579366500, -1487994331, 1109105390, -448084072, -1316657967, 23535972, -610752518, 920167859, -685935559, -361038175, 614940771, -1835683232, -1464216722, 1567931048, -1994985293, -1575541261, -250001784, 1659320670, -1129013935, 1227172121, 1021763464, 1360636903, -1009013211, -658125530, -1375782121, 1240924938, 587120020, 251840472, 1919062628, 326163621, -1388285489, 1216631946, 95329632, -1263592868, 1431874243, 475640951, -1885419865, 138624677, -231681197, 1594004410, -114908843, -126965190, -897916266, -646374849, 2140471964, -42192764, -1136579062, -960331802, -1914310317, -161196491, -887650349, 1751087483, 1695100819, 910614545, 2031160212, 1827844249, 1184629796, -143447496, -1098200504, 189279679, 1324510949, -1446474674, 374348185, 814073640, 1059475157, 2106225596, -1353443328, 1489890147, -1710764596, -1784900998, -251447273, 2054477315, 1585596197, -961315036, -826391659, 910636006, 1693044605, 1064368829, 1494075395, 1316546601, -1915811198, -1968971680, 917565630, -911293726, 527747479, 1226513819, -1194618477, -1066559495, 615261865, 109378971, 1985712025, -2121477532, -710315708, 462546122, 244402885, -1169605677, -239741560, -1389817631, -2074550579, 426106154, -1406477206, -1611764701, 1220612586, -169469038, 1633206125, 703871587, 653033018, -1812149862, -143687434, 1563767746, -2029373357, 1133913077, -1365421112, 1830895650, -1241992896, -526096394, -1504042041, 2034202791, -116306895, -105403378, 1320613411, 914735204, -603131075, -1337211362, -709897527, -398529917, 864272188, 745999546, 65547189, 1861061706, 1212542882, 1333816648, -66085575, 746272134, -1975437052, 309057506, 1861395667, -1621979177, 1634029512, 1155954467, -967116681, -1160188235, 2144749944, 612130365, -1694063490, 1188913513, 1817673964, 1581379395, 850453154, -1821257251, 314169881, -586612280, 704538858, -550049394, -209614563, 662701873, -311754096, 1377384853, -2115678459, 838659047, 1425206620, 265309427, -1769712716, 794796500, 1776676236, 180574163, 1731804946, -1245564323, 124720676, 1536773954, -460052747, 1697871505, 1131379069, -230355481, -375495423, 649038466, -2053993612, 1646267153, 1066665731, 66317061, -357886827, -1529226434, -1720347572, 1374808084, -1683348431, -657294744, -1648480561, -142156380, 804824504, -393825521, 808709041, -666437984, -217705813, -2137435184, 1878510110, -1106819282, 801244361, -1643847311, -2000588465, 1420335452, -377832648, -1181104589, 710498099, 1776638075, 823288316, 1610711184, -1652544835, 132984139, -296219092, -114074886, -302097585, 1314050769, 1841154579, -1644619138, 528246600, -1276685666, -245772515, 507798437, -373604894, -1594177389, 53530042, 651204691, -2047265000, -311902066, 880688919, -1613610621, -400217694, 82248699, 642273308, -962271244, 762202930, 1377472172, -55275715, 1724616384, 487093745, -437663694, 168541739, -1812211398, -1672271840, 881873677, 1114714497, -904275714, 980093336, 540542544, 365158655, -916121916, -1187305107, 534011775, 782554968, 1163745042, 2035150524, -1512225129, -651081570, 362911732, -358329340, 1150492243, 182748386, 625114055, 882334292, 1098022965, 661677805, 1546581972, -514109477, 1643063823, -316855599, -442291463, 314094648, 1406436485, 767663595, 332893275, 1988709222, -1693267882, 474960718, -1711721184, 342144578, -1863678194, 2081877579, 2089996190, -471238875, -1097388511, 152530052, -993210765, -1805356187, -937869973, 112616890, -1650110162, -1948553974, 1610043089, -324810425, 1153590211, -2120221729, 1747016685, 1048445071, -200354549, -186862725, -815791749, -1319742901, -1672326416, 154887756, 600989314, 1621636945, -1511044851, -1989762847, 1244663259, -1972206082, -971692935, 159648606, 1886894019, 1256820220, -305051454, -1992313537, -1614655295, 2062970258, -732510151, -327269492, -972065271, 314883827, -804361736, -1802664745, -1393097923, 841119789, 1306073353, -1268939377, -1212140202, -5727530, -1219272851, -1944932538, -1284292025, 1613138533, -1566829015, -2124065514, -890344075, -1725254559, -340276035, 1888494158, 670809273, 490260198, -450901623, 1062109421, 1212084769, -1501158577, -1298993648, 1911739572, 1772401749, 1740321100, -114970408, 1894338453, -485024171, -997653831, -1343152304, -1902325295, 2020326338, -2021698673, -1714917529, -558328846, -1898519224, 1269234258, -1911896692, 1184951814, -724811169, -145504403, -593702511, 1898191072, -1480726052, 953055855, -1821482370, -1887272472, -546961180, -1304957288, -531926924, 823439575, 724449411, -1271201114, 927202475, -1535450500, -2147175631, -1112598415, 866322046, -1564446585, 29633599, -825456558, 150100279, -2101568583, 359203977, -1237656177, -1816457309, 1642157330, 1610350540, 765556957, 1631810071, -233161011, 1845036552, -1946832639, -720202126, 1238716982, -111929575, -61735137, 460862103, -964499783, -1719796295, 1431908922, -2021835794, 534546885, 606442281, 1595336494, 207703461, 1994438784, -896480284, 1985525729, -1708393804, 1394205953, -271754554, -563841883, -819961696, -1646837392, 343169754, -182200579, 1202996831, -1078270387, 1345234359, 393601534, -434470623, -1593472207, 1842910383, -1801179439, -1099448595, -823573945, -356217029, 1217853059, 420981607, 1454030672, 403134304, 867996715, 1600236310, -1419419307, -1419962415, 1305298669, 2020494006, -2109351160, 1650520625, -825913866, 1069743846, -1862232186, 606928841, 1158621547, 2104404684, -485894381, 1851371246, -50298200, -853066598, 985824221, 1004369806, 1102935179, 1510783885, 1656067979, 927075135, 1170380815, 1774084327, -481903018, 47851310, 44620135, 1330599795, 1350266355, -1554545431, 1064732618, 66409816, 65526106, 21165577, 427740885, 483723017, 35454706, -7354557, 1047226914, -945721408, 345991533, 1571094729, -1971201628, -1894897988, 1447332988, -1233870505, 603392934, 1072266402, 514282162, -1642540303, 1762619187, -832224359, 2077531767, -1517254591, -1712552797, -819974299, -1875907532, -1661342398, -990812716, -1240965349, 1607455043, -1377916738, -963550263, -1211027112, -1628311755, 1463570154, -1672122427, 894733706, 544168552, 606117200, -2026249981, -1974738484, -1158307622, -1365243007, -1562950578, 2079141243, -235622301, 614947263, 611227439, 85917271, -1177848821, -664696881, 1488438760, 1177956309, 59705022, 711345438, 923223046, 1203371455, -549647450, -35023964, -1505117893, 710465445, -1296368867, 1630729548, 1557945985, 844231014, 2005708325, -1290199164, 1304486157, -217612581, -1931913813, -970249370, 473025451, -200709418, 184538323, 1213312738, -2013039594, -1639401940, 525613809, 1245902519, 1706341080, 650706587, -1773352619, -1179651170, -575729581, -1730951972, -260659192, 1468639200, 1162190522, 1682825499, -878374032, 771849933, 240576651, 155325731, -960977566, -992840686, 2056114509, 1738055400, 294977645, 1264418031, -958333813, -1380453956, 499832797, 817392330, -1247263376, -777045122, -836124598, 899690640, 1527550217, 1305253225, 1044413882, 1814223024, 931157089, -1723631238, -817502582, -829951866, 2087626889, -1947546236, 971164418, 1939629075, 952567194, 1967395635, 1289866873, -1744342751, -13909708, -1681951265, -73308599, -1335323714, 337521938, 898485675, -961252002, -904441097, -829430518, 1647349729, 859110940, 1009996690, 1175364, -1731015109, -82089215, -1874190134, -1582759345, -595698798, -1796552845, 639185195, -2059403318, -637567169, -635726071, 1506201648, 971714982, -1001821939, 572478864, 186545027, -1574180302, -32768479, -576949254, 2052783601, -151628868, -2036643463, 1778894281, -1197478516, 1753628928, -946610274, 882925391, -1256849931, -222651507, -906735335, 1938435700, 345182693, 1104965399, -1649155143, 435000686, -1909422785, 1216166408, -1692256880, -888695288, -1768507878, -2063241053, 1828957201, -46194893, -489710286, -410395703, -2103572352, 988971566, -2101803910, -1895006133, -1195331642, -1252662530, 1707417472, -967229313, 1792762625, -1102087985, 387508985, 1231080158, 630489021, 880641861, 159427921, -516227521, -1630783764, 1115924174, 1425792795, -566104154, -1150501290, 1969777362, -1230136655, 684335591, -1027332760, 915071942, 838375480, 1507691727, 28096794, -1619278869, 1961812843, 1596475991, 1386509383, -1225479197, 1220206769, -1381497381, 1291039841, -803224587, -895608024, -1364075382, 958971519, 864821661, 243797844, 342931602, -164939684, -411568688, -618750496, -708408003, -1872778333, -1002871277, -584030075, -1666646320, -1808942452, -1981790540, -913956051, -60986585, -1792184994, -1238634575, 570040290, -1753449480, -1592475740, 749966826, -1880520928, -272864035, 1936731130, -773985737, -544732237, -1698904105, 2129148869, -2035046528, 829219482, 905659495, 1582796391, -192820708, -2001536680, 1701433266, 773507903, -766695198, 445972053, 1953498627, 2130699149, 1082788801, -818872630, -346828415, -1325716989, 1744486675, -1565767710, -1835163165, -867656874, 1335135691, 1793823082, -658815696, -689290922, -309120621, -1955820388, 93013624, 1486938108, -284530947, 1524825754, 1733900812, 1457593653, -1355871840, 648014650, 1755325084, -709076667, -764763066, 1739307655, 257954771, 2047109644, -156656991, 558478547, 1258135392, -656024989, 1024959894, -1512664685, -378250925, -1949903037, -139772205, 641075170, -1036173394, 881333798, -82300171, -974627005, 475862077, -1911663845, -1599081849, 23810813, 1957974322, 1503233714, -1722056665, -1378688795, 302037199, 826208596, -141706235, -1206737332, 669753363, 1982305051, -749055015, 1039516909, -498251521, 24230781, -866890024, 1905972132, 2121969063, 1568323848, 1982848987, -1672235500, -63968325, -325701882, 661605179, 1812026469, -399265824, 719541907, 1410608334, 1777006498, -1049031294, -1420572565, 1750207842, -329757753, -1457069586, 1420911533, 2141384494, 574688220, -535474851, 1817098927, 1745079322, -1397130927, 673154800, 1128049219, -9664779, -117030017, 1215158711, 609783724, -964683549, -354644958, 892408159, -1015147858, 1688871110, 786905015, -807927458, -1426313497, 738749954, 432699143, 2034921165, -1200485975, -1413453463, 1937157348, -362092578, 1356874957, -1709834974, 594752720, 946796298, 1854767205, -776650823, 213518265, -37832322, 377817837, -1549358859, 1865874275, -675793518, -853299874, 408852684, -2101382816, 2106904971, 641549702, 872639835, -1625781499, 1578043569, -1869099544, -1520434438, -5792783, -1501624842, 1591670846, -1679808201, 307611723, -1669856920, -1732370715, -1435788919, 1349286702, 1762122722, 444504859, 434118061, 1531872154, -1921635151, 461501365, 171995757, -787029246, 1450608733, -965916943, 2109390499, -968905926, -555935451, 197622877, -1273797603, -1146425472, 1025007550, -2044487715, -1766399309, 1444621382, -1366310202, -1920916880, -1555651494, -1535193099, -644504916, 1008757743, 2114227944, 2146670725, 1615083220, -375991599, 169656183, 347162435, 832769616, -1215247623, 714458165, -444110872, -310018744, 1499610027, 1464902845, -748242684, 863157776, 1156691939, -876228300, 1914798725, -716881422, -34404712, -1073518267, -1842831631, -1827986121, 1149347194, 1108742924, -1812776801, -1347072639, 703653852, -1664322579, -1516110764, 960302225, -2037192203, 152564419, 1172752504, -458652203, -416139558, 1395448680, -1562149933, 846592421, 1478024746, 1382685158, -1212006349, 62959140, -1052743695, 431591648, -1456232854, -144177870, -655319813, -1525278474, -872244779, -721521788, 45166108, 1095986725, -1077614150, -1456137894, 1438074383, -217036601, 958421168, -231776335, 1741860394, 242567606, -20690983, -804748349, -409173917, 22481376, 686480262, 2127592680, 89614444, 1684548825, -984033810, 244142203, -1819765814, -5864415, -1621233543, -1063410560, -986930256, -130908238, 508599121, 1318739213, 896055054, -90612498, -317988103, -264654415, -1329221037, 1470575530, 1164650924, -1071623508, -1437421278, 2135634422, -1240821586, 1076346272, -1266511203, 1250699414, -928392746, -1177069029, 1318782928, 843470750, -248021515, 1187937926, 1443419921, 878529241, -1118633192, 1947534301, 1494772836, 779692278, 253098856, 658362515, 84661694, 400271970, 1523996720, -1712995981, -267561915, 480800796, 1922989838, -460091455, -1832061899, -2047758766, -1864498316, 1124875090, 1574530078, 626652963, -1541103034, 674196527, 1569962865, -1372652113, 1385927992, 340709540, 171708628, 619839443, -348877606, 2027369285, -843916036, 1637078240, -814551079, 164779239, -485665085, -1588076105, 755263840, -115516048, -46400229, 1238897345, -395198949, -1800028195, 1773904467, 870834333, 1729827340, -661543153, 1964144948, -455531520, 1137110697, -281908104, -800939374, 1841735580, -1945155635, -1078994053, -1727806263, -2114522102, -694243633, 121866799, -2019364398, -1776580513, 266209479, 1672380585, -946581043, -815000738, -782944163, 2109990170, 514632370, -1636390124, -1146493658, 1808746770, 271495095, -1730754553, -2031292872, 1782264703, -1085845477, 45845271, -61199851, -1452794038, 766525656, 465624801, 564578530, -1536401328, -1350960158, -822844540, -1675533314, 1463564272, -858456464, 830256249, -1402020590, 1061822244, 2056427231, -818237356, 532810618, -135657641, -495351699, -1523926091, -1264935009, -864112343, -1121277765, -1387523599, 339045071, 696066596, 796576915, -368902456, 687860556, 1598519608, 455454634, -432810106, -1782184913, -1134133295, 1815259154, 248760036, 714170821, -66177395, -1543284772, -781067614, 1488997215, 1189488805, 74603448, 1015125628, -1352920507, -1585448216, -1565182640, 478156282, 1179041562, 1820827756, -1157795129, -1802276672, 209807979, -1309984341, 1129463870, -1886483323, 1281556385, 537249359, -1462568933, 1408903083, 2002922014, -1599364601, -1954412043, 364995218, 2130230766, -45339351, 1809174838, -597555785, -1694863938, 1590113653, -1515483817, -697800002, -856001429, 235165263, 507560979, 2127875549, -851572918, -1675427211, 1750307663, -614113733, -214111301, 1775363940, 1935997873, 821649232, 205051377, 1511250329, 298712720, -462817078, -1611814691, 1585121429, 612069516, -210320298, -925801814, -980440069, -2107723588, 117209888, 983127763, 1317541730, -717236993, -1876759792, -1316138379, -256985663, 1497690548, 1536687898, 266189925, 1992605358, 1062600270, -663324143, -975208133, 389924880, 1274310235, 170158308, -1384484254, -1831200218, 1898972867, -492853557, 61806028, 1273757991, -1160788979, -424235333, 437862120, -1059353567, 1853494041, 72071260, -1109873047, 167168738, 1520669889, 1180353142, -1481132995, -357402117, -369109703, 1291650654, -1600486499, -1082549661, -1749813781, 2105194217, 1032420477, 262986466, 194821755, 951729698, -275962403, 171767054, -674920470, 959584790, -679108067, -536711441, 887066445, -86563567, 1212841687, -421100963, -214630196, -1543529359, 937281409, -74279649, 963974934, -1990658056, 503440542, 2109210720, -232706253, 1009908221, -1854072025, -882006402, 712057373, -2109350230, 913223831, -161622508, -1964288122, 431926902, -401951225, -921597038, 711616884, 443179653, 806599158, -1633467433, -1651928717, -1227985736, -692216005, -2043662074, 1657634295, -279432510, 1688185410, 1329733075, 1925894026, -361652441, -2100044059, 614627571, -1988406558, -1093670315, -225607928, 1040892877, -551764273, 258020151, 1764708688, 1379025933, -1301742585, 193852539, -1049683994, 2096234346, 1441367841, -169123979, 1790047960, 1718395001, 1916251528, -823831239, 2028778371, -1263190013, 1773093197, 1464745833, 1557101023, 1171095454, -1305732503, -57688736, 534714168, 1336831841, 577399491, -1694162936, -688985713, -957445079, 1479776685, 1009735413, -1481884552, -2118003710, -107595726, 453231361, -1278085937, -1371933214, -1326750180, -1509814098, 104964229, -2124793331, -726494051, -1405813182, -569417804, 1350247623, -1893729588, -526892997, -523092364, -119332878, 690575897, 1356673196, 1240271248, 1336359033, -1424078190, 777312073, -698621368, -1265466655, -913875957, 414763056, -2024757661, 150811391, 1985421865, -276870421, -734979648, -1159784487, 1908805935, -1412188802, 3707295, -803678155, 1353282903, 1092966435, -519856726, 688511683, -1315285217, 1754532099, 731675915, 2036642622, -490675351, 702933419, 2054538165, -1605673030, 530137404, 631630234, -396828210, -457910645, 328936322, 1459368517, -626717242, -1493160930, -2024598588, 1185915275, 696036597, -761221335, -1456523719, 1046970154, -138840183, -1141389775, -1082707957, -1190849711, 1056337011, -522959331, 1010405190, -382694875, -1964500446, 1247583659, 1038167337, -1978296836, 1266009218, -1296473165, -1145916624, -899275827, 1193825143, 1413595896, -634764006, -878342348, 1542505892, 875211556, -166409244, 502753504, 1213055506, -603568940, 76615997, -1421135218, -213490441, -1168059769, -231967227, 1978211993, -1960258751, -1930974314, 360249920, -1919900572, -2062200627, -268952584, -1153432068, 627820224, -2130086132, -1868552892, -1909712430, 959778829, 1212057528, 258670222, -840166096, 1943036424, 116014457, -1384564186, 1184824951, 908074466, 1585254178, 98466435, -168240947, -863531830, -1427312059, 1284229190, 507098737, 941402140, -219402260, 1346622990, 1231522110, 507733839, -1610263475, 144940486, -1736219543, -1985784682, -1736477148, 603323115, -1129349621, 1089272848, 992075028, 36696481, -657430524, -1705217716, 327007641, 492791025, -1259407248, -1251063263, -111142734, 1450262749, -1220553021, 477158174, -70417219, -1694169983, -876747649, -523121266, 541922519, 1767514138, -149436036, 742074375, 467226103, -1645352866, 1463142293, -1079931863, -2079781743, 1248229926, 1321418176, 2048066386, -1608973805, 1544685842, -443485137, 690831677, 1640492515, 513242750, -1755983918, -672226322, 1549624163, 816639186, 646205565, -2142323173, -905952197, 703777055, -361653501, 44826984, -1379377990, 820248537, -1473766197, -2072259218, -388366794, -744795441, 873255125, -696641358, 433712478, 207213832, -1560365070, 2127711832, -1451704177, -1565862607, -893138308, 1456692780, 1348910332, -2121013998, 980276993, -1843061248, 604634047, -1232571302, -1165472835, 1156164852, -24630408, 1150613935, -203576330, 1286773721, 1977554936, -2039880063, -896639261, 381035347, -100644266, 219587978, 554988181, -393548497, -127309584, 909855725, -729457340, 1244918128, 337717193, 1722032001, 993989177, -898880404, 592326961, 1243729511, -465647747, -175536179, 777125268, -1471335967, -665574837, 1685142415, 1597001581, 840231777, -882099121, -316303168, 498831327, -662886359, -204322356, -41289200, 1585296337, 686025290, -169769641, 1003321996, -655288081, 1005986195, 814550702, 65769638, 2077078909, -1542497868, -2146482548, 379744626, -1963950020, -1557933593, 360176856, -121386100, -2078743455, 720428054, -119841489, 1154785840, 1515275690, -314559824, 1875610627, -1076311913, -1082989363, -181445483, -935200241, -61787913, 2135864170, 341352098, -159713250, -215695069, -397899140, -512684949, -12334642, -827156706, 740332051, -1763474847, 1204803845, -266555084, 895305683, 41473725, 1628813578, -112444784, -2111837439, -2108547200, -73161153, -702781657, 515297797, 1235614775, 10629611, -530023308, -548143140, 28726025, 449800942, 823846666, -714581681, 148920007, -54038626, -1051920081, -476868902, -1703879247, -938905943, -844892171, -1723049906, -933077256, -405211328, 66095241, -911785435, -1304378355, -1959897308, 952937046, 2123136523, 1205958787, 491498347, -1479208316, -1539225545, 1892839403, 2022346914, -268091380, -1868316126, -1040787542, -980745392, 1331153007, 386141789, 905136649, 1684659822, 162135379, 414483581, 701005460, 1480201692, -1378734756, -26663830, 2123027811, 2137781510, 1787376948, 1402927997, 527423640, 658729620, 1365138809, -18518360, -1230600230, 1013529188, 62224866, -477888403, -1253825556, 446687634, 941525323, 303729260, 1847788660, -1922037783, -477693880, 2017702746, -756743447, -244660715, 614705266, 255273660, -1393183902, 1670522150, -1560879023, 987843854, -166329927, 333448683, 804001381, 2067859291, -1199315134, -2078029009, 153842, 701127658, -1531549608, -1683478668, 1987577619, -1640582263, -2009199526, -412380532, 98749849, -1622982931, -149553096, 1542882428, -115820399, -1850379151, 4360834, -1533034354, -60836772, 655035911, -112587015, -1014416375, -734618575, 228765388, 356365259, -1720978146, 1710607987, -1789263947, 357197964, 410350068, -376736347, -501374844, -452867016, 1282014807, -11985927, 866210915, -1115431305, 1513930489, -1008652725, -551342155, 1941015218, 737178471, 1243940774, -1015983675, -53098971, 1175052126, -706117912, 517538224, -41378405, 1045433289, -1523129539, -1747847230, 638526342, 1915722861, -1698342417, -690431884, -955134729, -931915076, 328490030, -493518972, 984960214, -1886902365, 847353486, 798836730, -1054139840, -225804666, 407385152, -2147014033, -817638518, 1392445506, -961976157, -1421291746, -969326438, 1854942995, -484593744, -178727688, -1445470311, 1053803562, 1738927941, -1664962209, -899079492, 407751969, -1398488508, -973290192, 920431027, 1856922128, 2096160299, 1969255694, 203478216, -1338364749, -1652169167, -1533707229, -50510061, -1523764991, -691586996, -53824577, -737226924, -1426166019, 1281653039, -53358504, -1929518512, -529993360, -651674151, 1498810198, 1031393196, -1652135346, -51111247, 2091523585, 463536701, 1071500444, 540748347, -1795803951, -1915732026, -1661419024, 1029114990, -943529072, 1191387116, -548955746, -1234894541, 597527317, 276199807, 1534347243, -1314792800, 1431327081, 219153107, 972023687, 1901811873, 208388106, -125631310, -349149337, -1584150966, 1886912642, 910816749, -1929990238, -944824810, -1512832057, 763956042, -147358629, -803941828, 2051946990, -1094453475, -1929845707, 1147677932, 1509703282, -2023367159, 433193027, -1576664844, 467784813, 22707195, -1306487477, 1816452998, -1689783528, -1325463290, -1730861539, -1305484409, 921663692, 1095739859, -1693175328, -282877545, -2057324113, 692037929, 1371996733, 1523501989, 122700143, -1091200891, -1829463609, -535515134, -1275135525, 2082791475, -520777512, -1776275494, -720306156, 1033873346, 285927881, -231741121, 1128723274, -956072348, 1439571541, 400465914, -1709917383, 1521453111, 497485965, 1761977252, 957916923, 1519928337, -1868347828, 2058859760, -358080945, -735750927, -373871869, -1397041945, 766223779, 1953031959, -174605878, -550189113, -578254936, 2082017934, 2146629123, 652233524, 1695194840, 514322181, 306067373, 955171379, 1754955550, -648275577, -1536160045, 1152150347, 604002190, 751839298, -1689626970, 929055119, 13379357, -1571319025, -641498014, -215056514, 244571851, -1704294277, -1630617596, 281545329, 274608783, -1734503580, -748864779, 516015612, 1080659711, -2100788843, -1808091194, 1583937858, 999838812, -80396371, 1696942708, 972384977, 813845578, -1619818522, -827535035, 738564182, 1534735370, 1178084327, 1062099304, 649971853, -700047417, -1924569531, -1071445519, -1211292415, -1593959669, -612844096, -1489226422, 507356064, 2053936928, 1017591240, 1266532126, 1431797905, 1587222715, 412743829, -1337081654, -545271364, 145199956, -808302537, -1199919563, -633947214, 167847619, 1807643435, 1346678288, 1355332320, -1666549008, 1632904986, -1427036767, 1670652838, -1479994595, 2089300643, -1047712382, 1391799561, 75631797, 948338528, 1312184720, 1023391218, -1195405238, 1015022648, 235798234, 350656348, 1568644988, 1297496858, -449555341, -515678563, -1864857293, -975601193, -787245172, -1490952641, -1279827921, -1156382894, -646116073, 858316145, -769950195, -39710393, 88536925, -2001591585, 218665428, 917160146, -1814524748, -1137967214, -879059513, -1790020379, 324738303, 1766102514, 1542662684, -924069648, 849207790, -491346181, -536819925, -132727520, 1857712941, 16245144, -866306331, -1419882343, 107014671, 1621166321, -68371792, -2071733847, -1658684180, -440067934, -1950770570, 1094581455, 1213349283, 764120071, -1166648492, 1488933296, -1773499402, -1703199123, 591044452, -1960323109, -33062195, -1165353733, 1213061246, 1415146231, 503178368, -446015207, -1495681265, 1604961090, -293643754, -153737604, -1984907329, 1733363335, -224751819, 796487852, 291842267, -1523522304, -1999692197, 1585224455, -1947336254, 652171247, 2125622736, -1729122005, 1630500369, -1033340691, -1573825480, -1425784021, 643475951, 642365324, -410417441, -1117474800, -909065953, 1194559962, 219654505, 63902071, 1290842847, -152761154, -510349809, -1924129042, 876929856, -1542946447, -475627974, 639979112, -252277489, 1919595738, -1727027988, -927128707, 1089814321, -491152785, 1638330106, -171769176, -1916941547, 1184844161, -1432066173, -1846428288, 220569594, 2140975619, 1452208905, 545709105, 194454757, 1372868620, 976549084, -1111806262, 1888253043, 579383590, -122749484, 168602881, -843792615, 1156474714, 427561130, -491579788, -154084101, 281990897, -2145365970, -1736855559, -438031098, -461649071, -306375756, -1541604875, 457219811, -1582055094, 1071799174, 192394806, -1766023671, 29265591, 2016019049, -611312914, 1318164059, 182883028, 673515689, 183005279, 1973182098, -738598558, 1649146052, -1011477718, -674883198, -1440025384, 1485943453, -1540612093, 1751645316, -2023346810, 1172217580, -1979057075, -736452510, 2134957890, -1701950844, 899095091, 1714720890, -1332274654, 65951221, -810976604, 1157241557, -1165276632, -1542772984, 1812399258, -1829440226, 152305708, 1670513630, 305284046, 696737278, 1933663867, 861576708, 1839383951, -278897829, -79305507, 441656324, -2008503123, 1621004839, -870578638, -1730208427, 1957759346, 1103575856, 292047568, -1604654269, -1510607322, -994649786, 853450133, 763234175, 770708060, 207245487, -1652224543, -490118797, 809015561, 882514568, -389634273, -1607640505, -1569563654, -1682730374, -754592188, 809697056, -1630238741, -1059853554, 280545453, -1176206795, -1620359007, -540935421, 391335261, 2057639650, -498384398, 1717509668, -466886631, 2099709458, -1010958427, 237492257, -873659995, -863100008, -423916400, 889325355, -237567456, -1363946305, -1830059701, 1851239243, 1894589071, 2008064337, 987008987, -219902400, 1323847226, -779715482, -1308702154, -1072433298, -769712548, -2012197226, 353818730, 690469944, 1063129068, -699150855, -752626518, -1173024120, 782754308, -899165002, -2137234434, -891176536, -405501175, 1333656964, -1256821647, -1077501077, 901009235, 378761437, 599284084, 666828278, 55874734, 377787807, 1798946341, 1194014376, 1876826962, 1608228205, -1076408145, 1398475380, 301348623, -2054022313, 432707081, 708175639, 323240415, 60633891, -973452200, -1689748893, -2977077, 1113338446, 1416515366, 1349334298, 1360506403, -838025730, -1952999649, 892626520, 603370344, -1348924970, -1514831615, 1621780120, 1904091156, -376542737, -172218436, 2018768947, -907105355, -1188075675, 1648932414, -899254596, 1109814078, -1793918913, -1548947405, -603102396, 2133289174, 890080233, -2113689655, -1146758468, 1489026587, -743563222, -861689370, 884389758, 449661587, 1077338769, 1897813232, 328663778, -1130090121, 1275118235, 1366341604, -1532401782, -422522473, -349218791, 2140373727, 1873900768, 1876051608, 1766397489, -1767224732, 131722965, 982727640, -752126908, -805647151, 638454515, 1374318748, -1561916119, 561587896, -2064139410, -1281816449, 240506899, -513360137, 1282074327, 1296125714, 625818120, 1199136890, -506723482, 1891863429, -82757734, -1416947287, 1445796244, -413901900, 1937555621, 2107091689, 117504348, 508323586, -1186024288, 1899017606, -1440021746, 521842459, -545367972, -612927121, 1955002522, -1881853770, -552571106, 797659330, 1065526245, -612345780, -41590496, 674019778, -1001718101, -1160268420, -454980785, 854171887, -1245143394, -1791015528, 438117783, 307914154, 337432457, -1090078396, -876162814, -1289713183, 327803597, 1697976843, -558907482, -1321389478, 2044641609, -411540004, 1823501589, 864101340, -1834526660, 1373944591, -1470872387, -226948560, 1372901370, -343459744, -371903978, -1312661143, 2079977874, 742408150, -1499057941, 148641425, 930992199, 544815673, 721621148, -115765913, 973369083, 424415980, -1549216758, -618597574, 1958625024, 1409447570, -603057203, -1527975650, 2104993273, -1785576485, 1908566458, -1018595235, -1710853318, -2085488267, 1281240065, 2113803374, 13943608, -1602197456, 2118886771, 173527948, 1826580684, 1240872132, 1756539355, 2087896242, 922143479, -191504695, -647281978, -171958154, -1255476289, 294425289, 927598937, 21643811, 752692611, -1216529539, -1822079014, 727835201, -577227146, 1165470644, 1786365507, -1813710101, -427640263, -47602469, 53783715, 1730451702, -987636326, -466143974, -1589553810, -1546085501, -1579856642, -899045269, 1505340166, -1164671405, 1072451860, -270630959, 1127407499, -540868162, -619655340, -2126409526, 938216901, -919985099, -1495017247, -1669832294, -151931637, 1839544242, 322354554, 1162744525, 2020189868, -287543513, -483345027, 1446638495, 325228959, -81595817, 1256944124, -1335443082, 1174488134, 364886827, -432665666, -272256721, 400759525, 473083836, -76586090, 244784110, 1188380885, 47224998, -68517340, -237020813, 225843503, 809268006, 41025352, 246789768, 1562386753, 617286531, 1324190717, -1506349386, -816060755, -1047085903, -1256320331, -1689755530, -509368697, -1252406445, -493635213, -2068517664, 899953449, 1581255537, -1617441226, 566665114, -1418703509, -668728976, 1805297953, -1529964729, -834572918, 1689145568, 948831972, 1271117184, -1687381788, 869449980, 1442881835, 197891807, 1621361190, 763601265, 970005330, -816032339, -1241430961, 1117056540, -877805313, 1778383552, -159774267, 1240555093, 933104706, -361664214, -1811290450, 894792515, -1974847711, -1011138336, -572652545, -1707302102, 1140169109, -1335453049, -754708933, -1798188869, -1754444925, 1609153383, 1462870019, -741108495, -1724820016, -1169570857, -1084569577, 166777230, 479334092, 434596987, -1160735569, -1683063484, -1881199759, 1722044665, -1020537872, 1439400109, -370373873, 1753098600, 119497153, 1576101051, -2115202912, 435633137, 1306599882, 2144034428, -943895489, 1197688145, -1690081745, 1966957071, -348851055, -1361463887, -1888382666, -706634846, 972485267, -891440476, -1427508609, 941311775, -204585274, -1584501749, 886272286, 1571755314, 2043848673, 311817685, -408680502, -1862166670, 1635880377, 1527572249, -1278096467, 1377118958, 1262652294, -1091118984, 2086516397, 329263994, 1552769867, -1527200486, -288433628, -563095458, -1584940289, 1334024223, 84739785, -259323643, 1100044557, -1708124818, -1646970400, -1936117242, 2072709245, -1091407826, -1108277230, -373676421, -67633340, 657604325, 1041026038, -1028341463, 1679570632, 1239226158, 1795718869, -1488333441, 670992852, 1251054416, -1773451308, 1508564948, -1108870741, 1848096751, 1893161372, 2042195526, -362483196, -189831198, -285495841, 2043709061, 549374138, -111287294, 478916407, -643916159, 2142122101, 1137203221, 205551013, -1758558588, -1189008453, -451701807, 355995071, 330062930, 310199126, 224784831, 1892658682, -120385839, 1178968057, 1566699717, 798371275, -101779713, -941844963, -564997779, 2069034392, 1798122540, 85386757, -784717221, 788256701, -1179078391, 1135154351, 445136728, 1500872790, 1491120999, -1018865227, 199051662, 1631248559, 1766760035, -1782879050, 308670372, 97810757, 1899550948, -2115836087, -696785835, -1049465052, -1289485631, 444214640, 2073806889, -1021030787, 1894878195, -382280428, -1643933612, 844385613, 1415378315, 821275460, 2102153981, -1064533629, 1944293771, -1998418297, 1242240229, 1699066528, 2040562092, -637924728, -771300786, -169991445, 778433373, 840770087, 1838070208, 1752717773, 1618897921, 1875774154, -373420583, 414868140, -493259749, 494145806, 1231826404, -1989016460, 1203203125, -1135260036, 1977748055, -1283449017, 950247212, 555052392, -488604066, 98995573, 985206533, 607174138, 1924737373, -1737859837, 1869378340, -1977557385, -1858853390, -714707441, -84622775, 802100375, 1434368049, -92901442, 1296808709, 1044407033, -258855319, -1814197593, -1180528805, -1869160359, 2100941288, 812234670, 1274094733, -277835, 228226215, 232912929, -1647043102, 183688632, 1136157093, -268463502, -1739267292, -888602788, -1385421084, -731134281, -1986935102, 459189529, -2015786464, 1342661868, 1240237828, -1293099296, -1094483741, 734711780, -1319809365, 1216592081, 1827537819, -179100428, -329093053, -577009030, -164967258, -1454796743, 1971805902, -323992780, 411470479, -27745064, 1579764247, 770766563, 553750912, 647003888, 1967845144, 1545891632, -595124049, 332495090, 1036458285, 974929185, 784439635, -298652921, 573884910, -349289444, 2064444653, -1621191130, 1255429289, 1369286628, -1433326243, -36551775, -106999787, 451044656, -87845812, -1083898758, -1546608651, 959535292, 1139314193, 276523676, 1541728863, -141361712, 2012223166, 805615487, 1648293994, -1323439451, -186640956, 1373899813, 1796657697, -17274317, 1173436414, -2061081665, -104692029, 552834229, 427672444, -40957158, -598521306, 78868621, -1010455675, -1536817788, -1612736110, 1248796439, -248308003, 1572783690, -670686989, 673543969, 11031149, -1864475537, -1453479741, -1969593833, 273071032, 1189603735, -89223578, 735883119, -1514604429, 1725576379, 1994560422, 1775114857, 896871317, 243717529, 1105336340, -1479198180, 931758820, -1344797382, -777718000, -937648208, -1633310533, -1898865004, -885327079, -694800286, -1859490843, -1212249688, 1240546906, -748514324, -1394103798, 2073669105, -1980277407, -590188717, -1109104871, 1684070352, -2069414525, -1660187001, -2111825961, -201318458, -498248281, -1902567486, 1423117527, -1031737099, -983508297, -823424708, 2069553657, -335142975, -1326063098, 1486359973, -733643559, -786761187, 1697038670, -1091436486, -1928944452, -1695442241, -401154532, 1209432056, 1098530933, 1885489601, 1179541608, 331935293, 176913743, 3081219, -1434190816, -1505383146, 1803905797, -457572185, -1071534803, 11571048, 1131962527, -1771869382, 241183795, 37823486, 1217427161, 1987203666, -568735427, -306617172, 1161643530, 590564904, 1400167229, 1701097954, -952201977, -1129228133, 2095430190, -1000081087, -1923201529, -1761301594, 1927547539, -2123161595, -880460130, -1753228718, -1319847666, -90424752, -1833724758, -1161370626, 1746396178, 1152137535, 1297624921, 693033342, 1235425011, -808117992, -1844322023, 1203230081, 1792834707, -859528231, -1033081524, -572373380, 1990195773, -162570317, 1714745520, -1990949916, 1329926727, -776376214, -2114245141, 2135487702, -1416937561, 286296009, -304241500, 1576212335, 1259961504, -1889004976, -738773038, -1234269522, 1336373882, -382861588, -1933786274, 1993284879, -778592344, 1673217994, 734054451, 1265958727, 470887463, -1136611770, -797826828, -845643334, -464718680, 1264641961, -1214830467, 492726206, 251812049, 746694449, 1899336026, -51762697, -759125365, 1637988900, 673749776, 1473515398, -693266942, -1732826881, 157760323, -23029609, -2113927790, -1190920987, 1646600475, 310793168, -367260854, -1915046107, -1004175641, 1490227158, -1287766122, -1770297209, 2097838891, 1335129038, 408269560, 296936593, -1718727486, -487059993, -662017890, -1309116197, 426018789, 152263385, 719152480, -144526094, -126083625, -1731173609, -468284909, -554786558, 60877782, -1525879147, 1781464866, 151185691, 343636334, 1860584536, 1196616106, -1184296278, 620772008, 1769090949, -1944954026, 1901058524, 738333538, 754721325, -1476349118, 1745185259, 425188529, 1286989520, 402033204, 857854440, 145004339, -737493166, 2043189171, -858248635, 197383432, -358487916, -101346052, 828719427, 1163463215, 513712662, -86911793, -1238467517, 1703799957, -1003879642, -509271454, -1810329514, -2138156127, -950637028, 953540266, -785952983, 517116806, 1146919570, 1884706964, -2043708214, 233153451, 1858488921, 2081122223, 182807755, 1017136123, -1227998082, 569102866, 971760511, -1337926428, -967396970, 714451755, 936890372, 1657304674, 159246135, 1737453408, 889274779, 1093705692, 1902009733, -37633448, -1234081166, -473867125, 1219066117, 829674752, -44923731, -934855099, -878942314, -472397992, -1768482520, 1692918869, 1500983525, -1048871130, 349234751, -1950738688, 44237037, -958358960, -146976346, -2036028016, 1586327603, -167209353, 1899496947, 1738501276, 878188643, -426972254, -864406208, -1551660693, -2088937598, -2061053943, -1931753692, -1583219289, 176444714, 1743454252, -305535081, -1216351997, 1814870305, -237628264, 653602890, -616896896, -778803951, -959013264, -772004972, 1483984089, -793023314, -1254258183, -1070184181, -286779787, 556508486, -1765271586, -1510248020, 892731305, -1095823761, -1145760983, 1279293536, -1258762364, 1174533003, -434460605, -1643499501, -694465319, 1249839444, 1769811645, 469526682, -363913390, 1669258944, 1398157972, 642493446, 239282979, 1756119045, -880464279, 54315273, 862358681, 1151159196, -447772998, -238614009, 1624173119, -49335278, -1898197275, 421288608, 1263513648, -1952853509, -1204312840, 1007760506, -1631468313, 1662367972, -116668764, -537632551, -1094572564, -1262550033, 1104729134, -1779658610, 451398948, -512984257, 1579936149, 1168918838, 1844776551, 1424824056, 119232521, 838131160, 576387104, -1952740534, 2139630082, -1404800115, 440431011, -1020708846, -1476487036, -761323034, -1760043890, -586163271, -1066091016, 1491215679, -2028304454, -744471179, 1823203439, 1858757912, -2102915996, 1398459514, 886637164, 1839257546, -7107191, 1275403245, 1810290977, -542075957, 700835203, 1429066447, 676759135, -834382466, -953039724, -1749087564, 120317812, 17072646, -1942125795, 972240712, 148020674, -1591316233, -910449245, 1426073050, 1147534318, -936550476, -2081241319, -208748296, -960267372, -994110123, -613427933, -201595969, -205196827, 1647051338, 1800255508, -228058846, 70624346, -1842306369, 444655177, 1519873942, 198743973, 2123434816, -522298181, 1694721492, 1747571840, 852083982, 1546848600, -924944917, 356821868, 1709189508, 1668557110, -546818375, -1952199112, 989863762, 877136595, 992412062, 468931108, -463588557, -1022299235, -1046424340, 1420079433, 1548862723, 2137388235, 215317625, -271630187, -615775243, 190807702, -405769929, -1576130825, 1496142733, -1816684069, 135144401, -27072909, -981631974, -111025619, -692242667, -299529448, -1687847043, -392941988, 971233702, 600794222, -1051683690, -1122250514, 2111564991, -1602199506, -1701950254, 823121359, 1547122641, 1467659883, 133498611, 1065266807, 736412120, -1535887524, 449203580, 861102027, 1402576846, 328245414, 1153931228, 679875697, 1131167819, 596755769, 1338750611, -1730948388, -601796230, 670851701, 1563967767, 1992741842, 1659260503, 85445763, -533428286, 360259523, 1891477125, 1855743279, -652463979, 2088965943, 2079231939, -832482670, 1463180761, -801182039, -1160588152, 1630924181, 1733681719, 1859897246, -1218870190, -178910436, 2128076427, -1696546617, -692249829, -1995884661, 2107745556, 1827043533, 2038838233, -1448254580, -538119379, -372960911, -99879391, 1062853129, -1203762349, -1132583315, 623474890, 2118341926, -1549691210, -186827350, -594591207, -679962823, -68245454, -367434618, 426495, 586318770, -591370912, 2092805730, -100148441, 1709716404, 571477958, -185568072, 1046582057, -1047478805, 1831440204, 465849328, -350939875, 210582224, -1729745183, 75244795, -396883531, -243319899, -1969436122, 1314731936, -1918753892, -830896817, 684447648, -1544392575, 619529880, -330622431, -994511347, 2045003157, 1702070421, 490862419, 748577944, 291389637, -935634362, 1872525645, -1919864962, 1972665458, -35727230, -1716530400, 1168047645, -1064624250, 726532814, -1797857541, 394949659, 700463859, -379501333, -307664985, 1315401226, 1326569301, 1803528155, 2101958569, 1601695987, -1287374120, -1092751566, -1039584456, -2038173482, 1218511439, 1087579784, 588280399, 1309035880, -1852388772, -1257814555, -530773262, 1071041812, -1964545898, 1056903014, -1324831597, -859705221, 157302000, 481765849, 878480411, -1742504093, -1335975804, 1523860378, 731675379, 655850775, 1464113121, 1229879349, -251011086, 127432841, 280181141, 100193492, -109082009, 70498174, -1222911310, 779119011, -154051694, 1457747732, 937304362, -1018489071, -109525563, -885944448, -700534214, 929194314, -24302403, 19252334, 1605221340, 110622696, 1145782755, 1532085456, 692870428, -876682148, -1217491345, -1859580331, 1200856996, 156936207, -78999386, -202473350, 1957494031, 1217258624, -840951573, 446690427, -1554112269, -1474023399, 1159667145, -1373856588, -956707787, -300758204, -1079712574, -908623770, -552043928, -2125205393, -17902291, -1576782502, 1861074752, -1735575563, 570152198, 1043235675, 2114020604, 113362085, -675038828, -1701644914, 1294456644, 2002826066, 656766203, -1860683636, 1666227457, 1350539743, -1158617354, -764264913, 1232908095, -1043903274, -355073201, -934926572, 357353202, -1133796212, -118483349, 343744975, 1480665850, -235339094, -890930135, 703181016, 1593901304, -2116499641, -2136025892, 1886250291, -1421351409, 1995789030, 2011021743, -97709252, -529744802, -977079763, 1461719437, -263098075, -1631477150, 1732390911, -1473074318, -1386450233, -1527641596, -556198416, 1554454189, 913242433, -442030097, 750757981, -464848653, -560135963, 1463283303, -575727544, -2101442342, 1111285145, -1802737985, -1647880052, 310516965, 1321872843, 31232586, -1082359948, 1305288621, 101976628, -106800635, 905762446, 1405925544, -975354904, -1911913665, -1262258650, -2096778152, -397839680, 707372112, -2100946576, -1649095945, -1937463837, -1326087674, 780088137, -289955576, -1991644442, -1424190086, 791103730, 696238544, -1200068271, 176051935, -2085488814, -1522879659, -1386910667, -741143752, -1044807339, 1833100441, -1388385218, 243186997, -47865005, -1762318004, 789749490, 1371176934, -1263914852, -369045848, 481876275, 1372926182, -2012472678, -1853824242, -1896567703, -1089943017, -1667761452, -264180301, 228157639, -1916780821, 1985867650, 897451767, 153917328, -905842727, -1220592946, -631629644, -716032020, 2025552307, 1562522355, -1010334971, -927267644, 754628258, 1272622097, 1104384221, -1191154385, 302129978, 1429817251, -960492749, 1644424133, -432607704, 976364174, -1684542904, 1041548268, 606620247, 1864262959, 1486820202, -1829132864, 526926870, 1691389284, -2143249599, -1240381542, -1236473569, -1825200060, -499895390, -1637535245, -902454684, -829107044, 528212553, 107198702, -1012973430, -990199684, -1965130567, -676513468, -1620543935, 470941096, -1654856265, -2048023307, 1204292631, -285460060, -1041645981, 309005246, -838590854, -794658927, 1570231794, -479573069, -154676931, -849990516, 905343764, -499132333, 467057758, 1969418208, -445207676, 2118601161, 718466116, 1324001445, -760912398, -1290246249, 182358651, -1019630363, 129483290, -274190333, -1651993714, -801670429, 43806078, 1935129416, 833913418, 756357517, -1178262913, -806416792, 333729519, 1345590262, -675687454, -1241029615, -971185697, -2033122062, -150126464, 752197541, 1257262996, -1559877980, -1113563444, -1471836203, -2007241830, 1187672164, -986901908, 1445846479, -2114639958, -544630187, 1091212071, -1624183497, -2004556494, -166279234, 798117463, -1670153399, -1432361867, 258628212, -2004477786, -304798408, -1148921742, -1091694152, 1244634716, -1802075338, 399011352, 1776825991, -1819251867, -2122786300, 366608225, 57505644, 1203759938, 1952010824, -1277074148, -875778267, -269726540, -1779917729, -172824242, 1450740065, 571533550, 1018399355, -917165589, -1537685861, -468413845, -112354081, 356053472, 986848556, 1045826577, 531034714, -494638766, 282530995, -648991207, 952087813, -1350575928, -85554593, -1433724313, -1106876537, -92355303, -19732342, 1279456531, -511004989, 2090995347, -194068701, -931731999, -1538206530, -1552383898, 1963519743, -1262967083, 1533354297, 1360187660, -635195693, -1460496431, 39935695, -443925678, -1258451114, 1896558763, -1043378822, -497425755, 1591810520, -135620511, -1635599941, 394692628, -330139562, 1543271410, -1087167487, 1833490804, 2145519002, -1849664784, 1966398456, 245189112, 1504568730, 469359097, -1794286574, 795164740, 154462290, -1132404487, -770876585, 2067624732, 1732871411, -1099848450, -2128319171, 210355300, -566289010, -1875910766, -480568172, 759449271, 637007572, 1220173900, 707230374, -1881577458, -1805267881, -1440820388, -326639744, -498089825, -1219644263, -2114438404, 937098841, -1644360943, 1149071621, 13711491, 645592525, 1857886503, 1276685503, -666910404, -266525754, -1669889761, 264234806, 1942278121, -1720574312, -643229384, 2000722726, -1573775580, 424751713, 1675835969, -1507691437, 1341007072, 1461057880, 89175645, 1284879519, -289397664, 829547553, 810368094, -1499886709, 1527321152, 589356112, -1055023562, -1809562043, 630704973, -1198396920, 1959028384, 51047183, -301144489, 632190403, 2081882212, -724580298, 2960323, 1737756651, -296986722, -71500043, 428711865, 520330322, -913649778, -360470309, -229840389, 17668127, 1836815800, -204069960, 439927126, -1231647731, 1803185177, 979344492, -1811730920, 389991226, -428787354, 648547699, 1604400083, 610540386, -284111845, -409677162, 1827323956, 1066890655, -2036376927, 1625912905, 33644313, -654908008, 711866787, 1166450727, -1854177502, -1672411081, -2136266252, 256114931, -766448457, 1486804296, -687045679, 1141973195, 348013692, 1719141639, 151815235, -515836906, -1973594612, -1336567005, -1786283799, -255995280, -1697254859, -197079406, -355509594, -775387994, 242346369, 1320772486, -355027753, 669325257, -1915807227, -1563840374, 1591832013, -864114483, 1771449603, -1358512000, -1696431172, 396663951, 1980618706, -1797636647, -1318072264, -2100252126, 1676268892, -2041332538, 949691227, -1396800636, -1501010902, -264804697, 605240005, -2018431252, -1823549506, 466310182, -599408057, 2061867463, -1955295038, 167063533, -1117278095, 1046514742, 1317399331, -1487521166, 1708600723, -1532741043, 524638800, 539771184, -1567346127, -1902421047, 1327690622, -399452625, 1978419839, -629061309, 517688324, -437534223, -1848642769, -1139690349, 1678750513, 2079880294, -154610982, -1206647349, 1026064888, -1563666412, -1019699737, -165240022, -1257386366, 16302777, -262978839, -972882478, -1596255938, -1007073849, -1693791556, -1740592051, 1920877952, 571275343, -1913072584, -112346533, 140687899, 142746125, 1539887879, 1124219102, -2042017316, 1159369026, -325843437, -1548040643, 437748400, -945663933, 133028676, -602009872, 1021336736, -233900216, 2145278193, -1685176493, 848377624, 713661621, -1603239815, 1253527041, -785278329, -2086268247, -99491729, 441078542, 2089559025, -1736814327, -2050507416, -1941490914, -512316064, -334217179, 940238206, 1399465411, -181039888, -572169948, 51555859, 675967667, -1980359596, -1723433772, -1886919738, 635420604, -583742593, -1634534623, 1290419560, -171286316, -817731524, 1312434906, -1759898785, -597641420, -544637197, -786446916, 841976872, -1791656634, -1569334239, -398713270, -1059294103, -1867585648, -734953327, -880867153, -837556602, -279074386, -473751100, 425227347, -727733420, 445990327, 635489545, -171288146, 626570935, -811611765, -2129693076, 1815181583, 2125699706, 1040368352, -1500182902, -827534427, -383495021, 1789798837, -2010095577, 2113181078, -1661360834, -1572673619, -156940158, 795771145, 1163588952, -1802413131, 1401931213, 91226831, 2133220100, 935639448, -794624944, -1207195477, -1907460372, 1017424463, -680334818, 537568387, 230845850, -1921146749, -107784639, 1448104587, 175526440, -827678372, -565172898, 892702235, 696460198, -523011714, -336228181, -53616394, 1484216828, 265473548, -811628463, -1426021115, 563112684, -728445080, -2108323126, 1770008742, 598117421, 289095112, -998266551, -991483720, 1012931207, 862005234, 1157773152, -856461279, 718081425, 890695050, -740010500, -1927331273, 732297547, -1060523192, -1610911492, -890318860, -2017287250, -1120743580, -203363363, -1043762290, -22037002, -264942164, -2021176334, -1800389354, -1504514478, -2063684746, 507745979, 811594422, 92249453, -839707683, 507943321, 550798292, -949118789, 932689129, -1483738191, 1759552051, -576389545, 1762152188, 1834491834, -701055718, 883658446, -1901711315, -22631475, 1904271650, -2135132253, 1461801992, -1523997509, 1816037203, 222963140, -463417628, -1086614918, -586342172, -1296250552, 1889492219, -1044343908, -1078371457, 1417179645, 1346055525, -1338333065, 240401292, 898463601, 2028103463, 1377471906, -1836081296, 476069707, 1776633981, -530452195, 968288932, 890819322, -1721041526, 881436101, -716205717, 1255670978, -698960771, 186221364, -1901368678, 13181266, -2021821419, 460530331, -1429362158, 1697726533, 1670115754, -1966795588, -168772316, -1214244161, 1209299080, 1476610933, -1445477393, -1336885137, -1458416740, -710253153, 717281492, -756110181, 1841549480, -1755847037, 1332182527, 955341156, 609214889, -811914714, 1628590942, -93174401, -1388811628, -516356831, -439546673, -1893975994, 1663021042, 1221883868, 239980858, -1466840556, -1619368065, 322640641, -951835123, -1038985615, -683118049, -670282787, -690866931, -449847012, -2061995824, -1388102853, 1516477368, 640253607, -1294087941, 309512468, -1611487107, -1909178758, 1235324156, -1017876933, 1118500709, 1110078562, -1170032855, 2051276038, -2022107000, -723906642, -1101379734, 1864642487, 632483563, -791748618, -986341006, -1908799289, 1305123120, 1726845770, 1850076284, 10511938, -867482539, 306639099, 1716648769, 202374649, -349524953, 1892990254, 1358814887, 1316030237, -577592670, -307946206, 1001830832, -528012684, 5525052, 243506457, -1323434124, 1375456664, -1165563580, -1343647460, 2085752549, 2102600358, -1043876060, 688338850, -667790744, 863013870, 723589796, -2068797193, -192827102, -2091522913, -1125941991, 40717391, -980112913, 1531854866, 1378300095, -865037397, 492844750, -1072377504, -1366962286, -569487310, 442014001, 2007878499, 1922820830, 926929369, 1093596960, 1736700104, -1370953907, -1084090578, 1974542370, -835520428, 515532608, 560437430, -813446277, -832587750, -1658872626, 588658049, 983262531, -1138021283, -915679804, -1808842116, -1732775241, -37732711, -139382643, -198280124, -753073922, -1661346037, 2026396101, 1432382120, -373896278, -1924437090, 730209528, -1593592886, -1259921071, 1366064174, 1343817041, -1974113258, -2104197288, -463028945, -2003101712, -1158200293, -482546759, -1202123214, 1106144636, -1048992621, -1716920381, -1983708276, -872999994, 1658308024, -161843086, -1104434361, -1810553563, 1586629286, 1943507021, 1239585779, 1497381990, 23941066, -1511485983, -1292172121, -525319595, 881872134, -537970334, -1261921096, -1481128204, -181565511, -908995954, 1261259922, -289729113, 908906986, 827560189, -744583768, -1774545524, 1641401552, 1479675189, 2094110052, -1660646617, -467649449, 1176466223, -1971337345, -142127535, 16936052, 92032033, 588921646, 430204899, 1450378766, -1294295346, 953133127, 2109622255, -44060504, -1628122187, -1965740641, -1291543529, -595254331, 751934582, -14179300, 1903705376, -282027011, -626177449, 1787407780, -1606210013, 202969546, -569436844, 1802381428, 1214079296, 1979721392, -474518336, 888014255, 947457302, -1629617301, -750493122, -582516055, -1556977732, -1156580924, -386127641, -1474706510, 1043354379, 779865585, 1492331480, -907328017, 1712098283, -1560289910, 446047665, 1828028329, -829261274, -89699967, 743025664, -1689810597, 1383953176, 155486689, -714590538, 944445991, -757630916, 1258251027, 901437248, -1666374860, -278797100, -1588249212, 60265301, -888566258, -975212770, -1050667488, 1132897368, -568759879, 1778024782, 1265136, 432500843, -395613238, -481388386, -1295348292, -1063206471, 1182932192, 763997125, -1668438736, 1147987730, -1299591081, 1798711578, -1431081630, -995701160, -1937413884, -271552178, -1138524257, -1167464766, -1346163499, 1232997848, 79055216, 731065700, -135452621, 2142188485, -1696629842, 1291212111, -1256697752, 2107450363, -1532556144, 1594302050, -32439309, 671974139, 1184833140, 116018108, 1134849256, 1278619505, -1266026451, 649868591, -1293351797, -869726441, 1154499396, 1306229413, -334065883, -102088072, -1722293900, -397427540, -1264896145, -1265834122, -1158632899, 1727689690, 1394681036, 846314537, 22693533, -1473756825, -1168173184, 1566834549, 205766209, -188916286, 2018032159, 657159513, -1353289563, 950448763, -824578740, -1330551497, 1131370037, 2104825653, -1815931767, 1010327410, -429692101, 1889839321, 1390735967, -805901740, -1812076627, 2117839183, -1332543379, 1488558198, -984084432, -1212941465, 1919241598, -481513581, 495416308, 1678145196, 164935808, 62940067, -445100256, 636973430, -2109503989, -740546976, 1325287205, 269595300, -127163463, -485030574, 1757518990, 1525841992, 786502900, 34685337, -1827246441, -637214929, -2132456108, -2145068466, 482366670, 136455404, -1189251634, 1193571702, 1399591423, -605412824, 456959856, -240983508, 1101790475, 406309509, 1450379739, 1138603224, -1610604815, 1474957962, 737892750, -1863352403, 782239378, -96244599, 1166826194, 1430597679, -1414842655, -67896559, -1714244320, 1876213576, -141594411, 743227148, 1326103887, -2123741245, 1920795101, -1113100821, 1065934167, 1941371950, -1827742881, -1220891549, 384687433, 537505044, -1590238063, 1594202044, -825511470, -1928316518, -668030363, -97323434, -876701055, -1998473144, -1778352483, -1352806925, -1758641284, -553100970, -211681906, 387257811, 1507039009, 1804193901, 1058651819, 1161575196, 674709347, -319546981, -779538207, -1056611535, 251256344, 693404186, 437194922, -1658713950, -1801288432, 1018113721, 1338780308, -1216670331, -177752440, -761877877, -2089265100, -1613587474, -2056412345, 1869809804, -1135095829, 1896739193, -1652210165, -1381792955, 1347460579, 412548609, -1064099555, -222860994, 963497213, 534582273, -2145645948, -1695619591, -1053984336, 949046371, -1798042468, 1382981640, 914975224, 1977758142, -115912768, -927854003, -1888101238, 759311622, -1150381132, -635242601, 1702378448, 656920190, 330170442, -165869015, 786177024, -591730421, 1612998781, -1899126271, 765249873, 2087512946, 619979470, 2052306960, 1949077802, 725654678, 1809778443, -1222211418, 317127039, 1010145479, 2061683757, -28032099, 542650206, 1414017883, -2121220796, 1201370668, -1533701885, 1673507780, 1459625516, 1550957424, 562508126, -1439791928, -1008327214, -112005967, 163783558, -1608877525, 838637880, 1477659230, 830635822, -1080878017, 272070669, 1273867620, 180955359, 1457347688, -1933934457, 345622681, -2050107879, 517258659, 1585272397, 994567680, 1218919543, 673055822, 1771297071, 1827698889, -1982687164, 1076111895, 493057230, -1345851163, -843715648, 1444793790, -1680572085, 626572748, -797425747, 1736137105, 30668615, 615715417, 1386133100, 1844470421, -706966327, 1649859039, -853695528, -1699075962, 705101023, -1927867404, -210990334, 285119545, -63456911, 885527086, 1225888133, -1438597758, 1482202891, 1115394917, -1813462066, -325271838, -917557262, -1485034469, -2071964070, 1967708471, -308957317, 779168177, 680869515, 868021049, 1179897975, 885986630, -1201125406, 1007672284, -1995778044, 1669237647, 1102775073, -479698377, 112012052, 677407472, -2008228544, 1520295092, 1323540059, 1470520212, 247201932, -951322631, 1532334039, 2063700344, 1444835377, -1035289057, 1410714078, -1083505963, -1379420174, 1013396002, 1190436573, -1582951442, -821151101, -1942151161, -1380163371, 330171520, -2130715659, -28583501, -459995767, 973667761, -100453177, 307008783, 1345216289, 1524951312, 406465274, -28206299, 974183900, 536799226, 1630672756, 1129990123, 1353618907, 1089668189, 1904850333, 761952938, -871029652, -1822050367, -688586504, 272640830, 369035972, -1950878186, 1506509752, -998795898, -204219768, -1297629703, -899589825, -670683472, 1787960576, 1644016105, 338201866, 2116326931, -1899970629, 1642768842, -1131482762, -2112417422, 1778001898, -751926370, -459737543, -1847863240, 1624309077, 371959479, -306346411, 57355273, 1848838224, -453576818, -403673626, 157858522, 259945674, -2040696480, -1270438547, 959821219, 1235621123, -1200623479, 1865048288, -1413993835, 2095560907, -756457302, 1513341614, -1894743885, 465802130, 259217706, -1371355875, -825134093, -37760439, 1982607371, 982100976, -251461770, -109420740, -135303870, 1728254082, -1008755595, 1322635974, -1707814277, 1875502416, -606219798, 1414767934, 814026842, 260673651, 1060717532, -284469926, 603652165, -1926380281, -1480763498, -466085677, 1196938735, 1933902021, -1796760197, 1706198895, -366050591, 910643691, 97056506, -1141503023, 1588567766, 1279567070, -2028703996, 942925896, 243771320, -1111380510, -636551777, 1116350337, -858479096, 243543472, 1086819327, 986580791, 2007861973, 1031384023, -1143022022, 1912414163, 2142694296, 1007376573, 1311167569, 213499779, -740458032, -625478066, 1842838241, -593960214, 2128229231, -1955287224, -145847355, -1458464530, 87155307, -1040275014, -158823132, 1513561869, 913385656, 73953344, -1452911678, -777397744, 340137327, -370994148, 1573194720, -1663087073, -1990978380, 795522786, -83650937, -146455910, 483609360, 1585855387, -1943097118, -333323737, -1624074792, 667889848, -856114419, -1697745416, 1003506487, -1243529990, 607591537, -1811621020, -830991550, -1991348671, 1654977098, -1438865202, 1533704444, 1922463110, -1736638706, 1669981662, -345829244, -145942950, -625932037, -483179218, -221123135, -239959610, 282543504, -1599203680, -1742006890, 2012300773, -1105430060, -488277845, 1250922319, 838863466, -602547084, -1270174970, -797094148, -1801674023, -756778832, -941754326, -1189116397, -804409462, 1961039732, 74719705, 1030593184, -525977012, 1976015107, -1909474899, -1438007205, 943751455, 1598647373, -1126223250, 708225303, -1118695985, 536789188, 907843596, -607290504, 1439638712, -1198673677, 1300488445, 954212379, -1287227424, -2038595461, -1700445824, 1660525456, 1542921516, 1081759101, 1019408725, -129931464, 885268106, 1827191247, 329526872, 798939352, 900885749, 2090204093, 473854029, 6695964, -1571885698, -110882082, 1360464789, -1764692592, 624152982, 2090893717, 1282083699, 1890283721, -1713072328, 2101004478, 1907251765, 2068308684, -1149940849, 158125327, -306262136, -878617842, 1189970943, 2021037619, 477519483, 573804935, -93298682, 131138697, -1686110965, 1996378147, 1218292861, -1065325500, 1153402104, 999429539, -825020119, -946863686, -546491620, 792965663, -1478230982, 1434355582, -1694587107, -1249998648, -1855177361, -165161591, 1900361506, 1150385829, -1133265106, -1185711560, -1601032693, 437639327, -762564174, 639983304, -2138540512, -145096692, 1615100466, -467352404, -158476663, 452435267, -450434914, 195998539, -1259992039, 795224178, -661157535, 841030443, -403277952, -1768037422, -1335240071, -550512051, -397812846, 1018278885, -232161122, 1269834741, 634632086, 1926132132, 41228271, 487936248, -1508845369, 917116262, 1281813022, 1704212280, 2111810946, 148202946, -1653513101, 405820496, 812478127, -952723355, -1462311828, 1261885727, 1355900418, 39907862, -1911695180, -1559337887, 1815492105, 1292313827, 1132464543, -1269081408, 1898988954, 1193860859, 874988722, -1821956494, -621347948, 584514376, -1702834466, -465070338, 608773666, 474381651, -1245585111, -895717575, 644848640, -1881777820, 143635668, -1709756281, -1386888345, 1190555952, 714512230, -1973957462, -1499364946, -1511587839, 896202, 1290661604, -402237274, 1428127237, 579764631, 529519317, 979321212, -1892940262, 1779521679, -398148027, 934598603, -749246543, -1100967958, 508803829, -1630055310, 360609136, 158452743, 1211077932, 2103255460, 56670632, -909447983, -1342511656, 1930148350, -435514010, -770012698, 1039873800, 60907859, -718848142, -1506054984, -1686872750, 1908002704, -1955072156, 973271765, -307695281, 271730751, 1954004650, -2089919630, -846140224, -2131570169, -1572407944, 1375770961, 1147452128, 1896431281, -373818574, 235371173, -1779227785, 198950782, -658496693, -1926918750, 1869666309, -699287279, -856560017, 1963282157, 1680103846, -326458250, -1110867595, -1560846156, 535507168, -1129704981, -1297440470, 1215457189, 850033624, -1543009727, 1280572133, -675991366, 109180501, -1797046838, 462655578, -529046673, -1965948407, -90951162, -380177492, -1745766119, 470634811, -1988136729, -1181484889, 2043371297, -201899802, -2051985861, 773608572, 1298870683, 510816179, 2024816508, 1390836454, -1965452238, 1573743511, 2101971164, -557058113, 2047008705, -572878059, -2082464174, 2045885280, -1618586685, 1493452403, 315480741, -67987897, 1223469625, -211714735, 1149868853, -935657783, 1466493203, 2017301009, -363746981, -1409286889, -1604842239, -1721593741, -537192233, -601988941, -1205793450, -1967814592, 1809022425, 1932153337, -1357861460, 1123475538, 1147013933, 1007919760, -699694192, -1621215384, 2066906763, 1593585584, -475179165, 1143779301, -586129542, 581667142, 1492996665, -134971460, -235503615, 1688906035, 1609196744, 804863894, -1108706764, -646274671, -1069027098, 311553694, -1470507906, -1491583483, -844554526, -1171833315, 528747721, -1553568712, -1214535735, 1833189196, 2038088431, 392821632, -763421480, 181827223, 1913070046, -138432946, -304292182, 788965993, 1363804715, 369791559, -790756598, -1515406361, 1410804574, 1418922680, -441340813, -815009575, -1319477066, -728139288, -1449300487, 825291269, -924837484, 1542189515, -270906537, 1400435540, -358233852, -569487515, -99471149, -1444933215, 1522524067, 1446272080, 1487929120, 1943218273, 658282521, 7347755, 961561183, 228439552, 1137293755, 363938864, -930460368, -1262721440, -869797469, 195520033, 1856208903, -1381644842, -592305889, 1757003289, 1106835980, -1025502300, 1224396970, 2030538064, 1003485845, -1144370309, -1414702345, -228124146, -1074354608, 858772232, -2021953086, 1064276939, 1069010619, 1723806992, -1007188432, 1223648261, -32515918, -623447269, -1448072414, 413259913, 1310414793, 1980915107, 493570171, -638293668, -1896394894, 166398873, 1409785101, 1913979640, -1369339660, -144931303, 1398112338, 60412969, -1943421350, -1259699187, 860635849, -703617878, 912943583, -68782392, -1462452538, 1048712056, 2125593372, -1041579446, 1055064102, -262831341, -390597151, -1886237962, -876353887, -1915419926, -739741206, 670877982, -887505070, -736496554, -1482640793, -1289390476, -1860099076, 913978138, 2073436184, -697867410, -892805022, 1207152920, 1501257191, 615876472, -1651410936, 873983899, -902943686, 1156004525, 1832528959, -70970686, 1700299358, -876801647, -1957871498, -1568919510, -1048671770, -1289317034, 134106918, -1505588421, -1849118863, 1199316838, -2035170223, 747626921, 1116667945, 1985054427, -1498370169, -1471611405, -2080774379, -1278151647, -1584771942, 1495636961, -1873481907, 999261603, -883260509, -1723319277, 1082082621, 2112267517, 256910441, 1997830435, 1388706801, -1269559003, -1378663323, 631109243, -1147447055, -498407177, -503070464, -80867569, 587142723, -1530994870, -1895948844, 879602891, -2146732507, 1539449883, 696223252, -774555031, -1632124035, -819276009, -1958336108, -1315318305, 1399945276, -1438713330, 333027049, 785191597, -1133532244, -544335033, -1583465980, 1044996113, -801383905, -1882042242, -1767000104, -81361628, 711688180, -1179435524, -1637699251, 1038689704, 2082705598, -440781644, -880896018, -1880945319, 746337773, -1962866863, 1607533296, 1414422096, -216229277, 1491338910, 1268751922, 868522498, 1949357131, 150085240, -823049178, 519874998, 906136211, 1880165097, -296882572, 240315750, -219188289, -1271262921, 1386352457, 954316131, 1773419711, -1676181866, 1692695249, 1162872812, -796950845, -454589314, 1363666157, -368936427, 1913907725, -2037447971, -1255659661, 487915960, 1125865361, -2072867838, 1895727173, -1926421755, 1909077464, -297156218, 1141419492, 445083635, 1903099022, 1578252925, 1615689799, 9784283, 945365131, 1869253655, 1363070015, 1415617857, -1374773332, -24053714, 1925912383, -1151725608, 1963254455, -115511523, 685088653, 1994257752, -2072935340, -1763247037, 738357279, 1788765089, 599689465, 299419577, -1338585751, -870923977, 1106427347, 1046307483, -1722366216, -1562445700, 1349834553, -1900560798, -1002876056, 1410932156, 206008985, 1932581636, 1120415175, -1107515363, 2122814359, 2115419589, 677032854, -960179552, -1032597134, 1306093785, 250598985, 1399346257, 1263885409, -1359723772, 127748795, -1507208801, -345316697, -319755401, 1817741375, -846437971, -200035232, 2032312812, 1229335204, -1083031187, -608035888, 1709684861, 1758175813, 1578717725, 731742106, 388472928, -1640530790, -424153774, -1226394775, -1185515317, 1467306038, 1804681745, 1774559423, -850048234, 2040572450, -1304240389, -1311073416, -288264857, 894150318, 433611492, 1942311868, -1264482697, 1651399709, 1494322772, 1145757174, -92428104, -180343351, -87504189, 1500850477, 1794815867, 1110876534, -82490581, -46497552, -564501467, 1463635859, 1190109641, -784415639, -2142848349, 350761483, 1814798667, -934644213, 187100501, 1579970904, -586308816, -935549978, 1257543356, 767611618, 99787424, -342521857, -1961608285, 109480681, -1436127526, 322671461, 551301944, 2019301372, 693391259, -569069231, -786187815, 1479195472, 522160502, -376816829, -231805591, -739346990, -1235881491, -132802300, -236315866, -1649160848, 612730780, -100952179, -592361085, 342552280, -1816075130, 673167457, 1317780803, 2063807754, -132379254, -1418234343, 1499984473, -1409360615, -728707861, -1974335171, -1313137885, -1609282390, 1430499621, 1523677325, 124994091, -707775005, 2087940175, 1642400182, 1855929786, 1622443457, -1778512979, -1634604238, 1154697200, -1803419191, 1748161442, -1651637928, 2036482523, 392144337, 1033708636, -1016121353, -1987713610, -754978281, -1628297382, -71273841, -1198093568, 256920147, 1166332723, 142219233, 1523109504, 1627351811, -835890113, -259316639, -122400349, -760823620, -1666156910, 1482428045, -1206379991, -749673126, -312537401, -1540369943, 1355015623, -1833521536, -590564618, 1736424678, -361506754, -511774703, 1447411201, 1232222002, 1918963668, -413877214, 1262435748, -490948743, 1408161504, -233871369, 1936684741, -865381569, -215528641, 970074732, 1621153848, -59102633, -179431796, -720491220, 1719189073, 1498905059, -514838544, -615472888, -1274722182, -1891936203, -1721272720, -363118408, -1044558805, 1242905928, 1436161059, -1600558211, -1692503435, -1061188758, -634857415, -1663890429, 897194027, 1212571456, -673313552, -1225956934, 479241108, -1931596749, 1293948144, -482554295, -869657421, -1514249432, 477405933, 2145290478, -757286371, 277994965, -1261504661, 139991951, 1887011790, -456366895, 1406093317, -886402325, 252494506, 689950503, 1356598053, -1004137644, -1192753277, 670062665, 1083906569, -1329649859, 1488888513, -969685318, 459043016, 1161313952, -1129497754, 1324467055, -1099019764, -203704355, -1069029839, 1278937085, 1073181115, 226875896, -264842983, 1980864560, -656047475, 1323231642, -601401053, -1946802418, -253790903, 119956763, -44364644, -1995613000, 1610683387, -1699262499, -2103180928, -63167324, -1300352141, -1009321940, -1044929750, -1800105049, -1979944148, 14222471, -1432640628, 1688235742, 424114623, 30308972, 1462966850, -359476729, 1488377264, -527220589, 1186931100, 1101973752, -1472579895, 1914931104, 283107098, -1931279151, -1718200491, 1792738082, 1667244170, -114658266, -1224265059, 351047092, -1605815820, 1516659109, 1462102522, 681751559, -807956376, -786865187, -1693372931, -673156580, 1309653081, 446052025, -186550220, -642009792, -2134745073, -449421949, -237043221, 1975064865, -1652125684, 382056507, 1942350801, 1154312036, -1127994577, -1260892858, -70777083, 594868445, -447760497, -1329308630, 1024084550, 766358247, 1827325386, 2144728345, -1298174473, 231860022, -418919919, -2085785440, 2141510387, 1462173083, -661695332, -1156528440, -1959187193, 807454502, -1248709382, 37646812, 1920730334, -661832103, -1190920655, -1881837225, -1201869824, -1208235575, -113727977, -1764793855, -1550797371, -1204731695, 186747613, -1218435074, 1957746366, 454163363, -65971481, -1304482776, 1544857664, 930738730, 1678677373, -1003320057, 1265725736, 1956891693, -417894949, 517277694, 891796487, 1228794427, -176209, 141634552, -439467150, 38106221, -1495901082, 2127996072, -1503461118, 1809040108, 1627496104, -333002288, 2137185931, -1073007113, 1720941082, -1271215886, -1127754397, -1851449345, -1880413021, 353079556, 1459902589, -1921484492, -1510958623, 751470763, -1833747000, -721794635, 2049922754, -291520455, -267044280, 1179388024, 155806298, 1307439864, -709701511, -1081407653, 428855877, -1835958873, -831847952, 2136018861, 1024638104, -1881292992, 936646378, -180466400, 126984382, -1639949024, -444567803, 1091572596, 492144947, -1486723177, 510355722, 33891022, 1803350302, 660921310, 638050765, 874880528, -1986177967, -993906518, 1593021621, -1452112927, -506004895, 437341923, 2119609533, -355668060, -1687323724, -1900041588, 704316977, -1283123831, -709142656, 1680380685, 1343855333, 844516429, -418250255, -656024350, 1228458056, -148191680, -1114556213, 260694258, -441056449, -536921038, -1942265700, -2125229175, -1696362218, -701065156, 560077529, 1036623286, -340511558, 553174342, -737076946, 247187933, -1843075350, -2014538342, -286725762, -830648809, 1006640706, 814528877, -1562137403, -1383810808, 936725162, -1832046635, -595664406, 235633427, 1215009721, -1330003543, 643602705, 9070321, -2122985511, -180874289, -434075224, 1320572600, 448007596, -355760708, -2139522265, 726143704, -558263286, 1711644270, 277293540, -1745861874, -238194849, -1650157982, 891602958, 202684487, -1288519012, 779269420, 716011377, -1529774751, 1115632997, -1246420280, -628585597, 605344052, 1095918929, 1991661933, 83529150, -734389870, 1180932781, -277376191, -872980168, -206171015, -2004269296, -1265516718, -496598906, -1999564102, -1393244179, -1186931866, 915367475, 1194803503, -1462110844, 1340433009, 106022459, 894231254, -494012522, 891382372, -1595168117, -718710097, -868678737, -1876520821, 1350247070, -256081870, -1126707659, 219836420, 607227376, -410259630, -298324977, 141330521, 898675034, 927792137, 1290363279, -595199101, 741850881, -584294764, -836313982, 847360395, 453335563, -1201739726, -286110583, -1890611187, 2950286, 643569779, 1497722778, 1897060465, 677554663, -982550542, -914478017, -992895552, -447444064, 1548929412, -116532649, -578468620, -275364510, -230633369, 1343574242, -1094772458, 84301202, -469969878, 406646030, 2124798447, -1890016752, 758405837, 1651791103, 391191697, -1928726777, -861867533, 4741298, 1816363658, -1473740502, 1922521014, 342230988, -121510671, 1164335844, 256081002, -567311466, 561087273, 1025637901, -613306517, 737542525, 1639112109, 1541340586, -1681025335, 95351556, 1885451465, -1128416918, -1699479660, 198419038, -1666750215, 604793566, 111605059, 683781445, 58947048, 38197788, 1131261318, 964566156, 651980285, -150493665, 1238783127, -1490740101, -73516038, 2066122730, -292995522, -204470899, 349527483, 2059205508, 1492966785, -271090742, 650255319, 178177003, -848926172, -14606861, 912695250, -459254434, 117523430, -545965159, 66550492, 1282668264, -1961586127, 55097911, -360396794, -1918077941, 1377716475, 1988039182, -38646403, -1326950323, 200257735, -1258891143, 375803543, 958470486, 194595748, -1260178113, 1714164163, -1315669042, -492111163, 892128870, 1704553781, 1558430931, -479396028, -728478785, 750924349, 355414235, 478559711, -1434394503, -1008211010, -1717713405, 189750720, -1264975434, 896427939, 978847597, -362686550, -1228966901, 677635207, -1512285449, -1461241351, 1666783574, 824410920, -1417763943, -603173782, -1141448292, -490432104, 1276321843, -12875786, 703613299, -515699362, 1191568619, 1549121985, -2057741765, -1223897867, -1156575124, -1335888653, -1074885462, 435418687, -1577552900, -166211098, -1705461745, 114134930, -1397417735, 2138784264, -1634583703, -2006347946, -909630394, -1965144503, -484300210, 1856096070, -723413990, 1793185962, 1614055343, 810913952, 1662972360, 1182830722, -1471719274, -1546129270, -307483904, 1968956976, -799070156, 1050658604, -1144697434, 89460728, -941428410, -122161052, -1350549960, 1607351415, 1932091470, 1523524394, -1823383970, 960590694, 847249804, -1149243035, -695583853, 686459825, -1343363100, -367498297, 2015530271, 16136716, 1958929914, 1503526383, 296919109, 814553155, 723033123, 580496578, -51354493, 1643839467, -617817823, 1224027864, -1236233218, 765971743, -1224816592, -1208290440, -913761583, -1770804960, -382906420, 1718065547, -429735563, 1912746017, -185128900, -1100384588, 1876289588, -300747725, -1227196825, 1835371648, 1076813716, -2006649175, -673100686, -215048223, -391801397, 123246221, 1158190854, -929001098, -817005448, 1781589109, -274468116, -1995063986, 1742686779, -1201077001, -213531050, 1284583888, -2041131732, -1496569734, -282273172, 183531725, -491997656, -447879478, -1265834145, 1583500155, -1210291916, -878092245, 1607261760, -1666100980, 1120309729, 1002218188, -1531157653, 1393530317, -2008773159, 1415749472, 972906647, -1758198483, -208300303, 1892302216, 494033915, -358341674, 840060403, -1966814599, -1287829260, -1459539048, -772357942, 59900265, -1506353715, -1319659359, -1663555389, 252836352, -656883971, 428100479, 151423145, 1418181703, 1694553898, 1858314111, -1262057723, -545181481, 788235257, 1044460438, 177740558, -1921328030, -322923173, -613090052, -512763215, -669801844, 1722324584, -463603493, 2146427480, 698414532, -1233859098, -1412257772, 120379379, 105339858, -1070572887, 2060852360, -1515083037, 2004731835, 118263430, 1141114334, -413524875, -501302207, -1490521176, 811346316, 884835676, 225107240, 1061444245, -829676748, 426127849, -941093591, 1129629822, -81832228, -1317037345, -1964677234, 275235138, 1502488877, -1554352636, 640613906, -1437798555, 196702482, 1902902971, -472103645, -1670986930, -1688408456, -278506322, -1782195120, -1393346494, -1349310538, 2042497814, 748168186, -444671224, 1338156424, -2145383314, -1514258676, 96996643, -1011442041, -1872055867, 152290864, 322225395, 570061937, -1124117913, -1033305006, -470630024, -81960967, 1464901700, 197750318, -164270934, 1271742859, 463512555, 776858483, 811851213, 1313823641, 1068864647, 905285845, -1067114775, 680811370, -656530561, -1325429453, 2080653677, -1595711403, -567009045, 322923102, 1502953872, 903482515, 1864192536, -757924707, -952190312, -1661511502, -1510483862, -330091202, -652277362, 468740797, -1760350751, -1897316850, -1667560635, 843087663, -2036900525, 1706138183, 1692755666, 409461481, 612918398, -981637914, -478080458, 672151357, 1620269160, -2003279943, 1425552948, -996267201, 71811080, 1689541523, -298179555, -1991497825, 2063037353, 354490008, 1304739678, -684427893, 1314608828, -2074732138, -1318288178, 446712634, -535533431, 1868742830, 1307429836, -1110701257, -752103582, -594250510, -1075350152, -124476854, -1044009920, 684010993, 767483345, -421437497, 2128934646, 1554106672, -1210282217, 1317462638, 1119098170, -489689085, 1242501075, 1474438679, 802577422, -1562705469, -1044966662, 348889038, -1638823850, -1457837203, 1441466964, 1208555157, -711054124, -1231243915, -1150925993, -1220754411, 1307470481, 622936937, -30094442, 1289118, -388114648, 754635617, 856727668, -291283758, 831410314, -1808557882, 87182148, 600411597, 1059398288, -1007267185, -615660547, -1669061323, 1476538285, 2048353399, 468484099, 1420871458, -101588779, -649442911, -97163154, -1613496541, -140285139, -1884559249, -1112984573, -1686654756, 1025522180, 184813412, 2141097723, -1257367414, 553224438, 25301844, -2142562813, 1755485472, 1839193418, -173533633, 371190304, 2018089405, -959463330, -18054443, 102729411, 1838998089, -1269614741, -824599975, -575373865, 1498056256, -678046591, 1553189018, -2018672366, -1793538382, 1462846791, -776054819, -1289769222, -525822720, 2109700966, -1358503882, 1667924983, 1269108284, 1175706598, 1626798475, 2129561451, -887248608, 1513759056, -1931683412, 1952942399, -1889093829, 1913030140, 1106814650, 315507327, -1184354610, -845267304, 86200420, -587958390, 970371571, -495246149, 1087212814, -929663949, -1988622590, -1087217094, -1294581982, -2002943521, -1511705422, -33438, 306070164, -794474068, -607379400, 995075290, -1947574462, 291138661, -1862026425, -284994431, 1981331325, -295095652, -1640664050, -502391647, -298147006, -759845877, -57850817, 62687211, -867523503, -2045788990, -1888838589, -429975345, -1618629335, -61416479, -1120648789, 258517897, -1270073923, 660994092, -1429166385, -840504072, -1435140398, -1341126539, -395745828, -811500847, -1160710657, 940755305, 270032119, -493228936, 796034185, -596653897, -1821200654, 1355130577, 1063640085, -462968182, 2128283302, -1913776328, 359717262, -1152333962, -998979542, 1975954391, -557806346, -463622556, 1216253080, -635822680, 718622920, 2013281180, -2004887289, 1829369658, 666403036, -349103516, 1527813962, -1135439226, -1161633003, -443906754, -1923472597, 1815774854, 1568116969, 2136400151, -827712414, 119489899, -2091704143, 1578039823, -204310972, 1639073175, 1973581756, -1405492023, 464695482, -574900055, 986315757, 1743760258, -132155111, 950211624, -570553748, -1038810430, 778193004, -1468229997, 234884206, -372299627, -751441573, 1425166080, 317414273, 1358862764, 1949216581, 1862852961, 1400729205, 416699274, -2023791725, -556950324, -1276507218, 1367038669, 810158340, -1253834255, 1547203648, 1712426469, -2040438668, -942745551, 1914533793, -1937965113, 1800509634, 2029585463, 1384292693, 1181618494, -413404740, 1561115879, 297314112, 229917094, -1978493305, 1214251529, -837122023, -833015636, 1954960522, 1006169068, -1531846893, 333842166, -1012672929, -469850904, 637048029, -395312868, -1380943487, -1892576823, 442180993, -1646482639, 1446446226, -1682016398, -1007453652, 888411462, 331116203, -629682089, -1718482518, 265043760, -1019221259, 1869846781, 936747089, -1517311213, 372562696, 906859232, -1425676017, 48975252, -1341854859, -2089180612, -1068076055, 1874892782, 1652169965, 1157943384, -773225543, -323996276, -818862632, 156005302, 2000519514, 1427820008, -1021442831, 1804302941, -1609750249, 1228352825, -1290885767, -1899483953, -1272003119, -1035472828, 2001303805, 1279880126, -1972758673, -860699977, -895677, 1553908866, -256889456, -54349105, 1935563167, 1959654550, 1342306927, -463860350, 2018212448, -1976136873, -1321789709, 519290351, -878196271, 1416391706, 1997808027, -741508841, -647346054, 646400542, -1106467688, 1468263050, -1425279304, 1170563435, -1841378329, 1184969864, 1914824652, -1325456412, 988552147, 884565065, 415800418, -453574918, 275834609, 48207744, 2135467314, 702477650, 102965566, -763968440, 471224482, -1279720951, 739300156, 2136013176, -2115946465, 823955913, -1847689566, -859494013, -1717723340, 421442946, -775469653, -1602093703, 628061442, -1156466954, 2146056167, 1163863080, 613966968, -268941904, 1130830948, -1580207712, -1766534996, 385727357, 320405604, -2144049214, 1276259991, 1344448621, 489194245, -1847841712, 756151600, -151969326, 164358178, 697709449, -370308967, 2093670590, -665704333, -134953266, 759941983, 672239619, 279015781, 1395133283, -842458038, -1524105337, 182288246, 1431853343, 78700095, 1433355670, -24593159, 527405240, 1406613517, -764183089, 686495640, 2053356436, 1543473442, 1665227150, -16894973, 1892440712, 1791400383, -1510847956, -1214782850, 916872379, -1086841580, -1084208313, 416347580, -268161060, -594948841, -1010051534, -54545220, 22879806, 22079373, 260808346, 1499853288, 752706288, -1446555783, -1508906906, -142572826, 2085624580, -1694570799, 1322533584, -1634778380, 1720243426, -446724573, -966715585, -1060769188, -303942680, 101162157, -478783329, -2024114681, -254341969, 979137120, -303649029, 808347593, 321882488, 1493080090, 1691499643, -418789643, -1064499066, -1102944414, 879990377, 1588432383, 1150856295, -1680509849, 1970957530, -797026769, -73327919, 748785685, 1215011973, 585217952, -886677309, 1766904120, 365332543, -1482001054, -326119897, -1445345695, 1456094038, 1027199429, 1010128020, -1080582474, 2023702212, 1350470435, 390289859, -165678955, 1391872715, -2036012256, 583114991, -1027988504, -872534637, -980212881, -1929975011, -327092927, 734121734, 1585555479, 550659297, 1974120794, -923753061, 2043915994, 1159226886, -1806512234, -1828935780, -1530965616, 873171067, -1789687415, -1872307293, -417901750, 1741334968, -360712375, -1022301158, 1865882568, 1200151331, 2145666141, -2027655890, 687151700, 1410594918, 974900322, -1519354448, -156678080, -226110093, -1047772447, -1719525872]
+cc e62da794bbaf569bec601c6ce85d8ca80d85b726d10347a487524807c76e9e9a # shrinks to ref input = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+cc 6bb8dfa5f2a1b8c2e7cbd18e81b31724ea1e121e84061ee6fa6a8ad7ed62fbe2 # shrinks to ref input = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+cc a2ce9c3a2234cbda6bcf2e0d84a3c3e607d730def32a5dfff59b9c680a18b5af # shrinks to ref mut input_src = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+cc bc29377410935c0e4cd1d3a56cb6e5ccc8bb23ca1fc7e11dae15e57066482739 # shrinks to ref input = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
diff --git a/vendor/im-rc/src/arbitrary.rs b/vendor/im-rc/src/arbitrary.rs
new file mode 100644
index 000000000..777a3b36f
--- /dev/null
+++ b/vendor/im-rc/src/arbitrary.rs
@@ -0,0 +1,98 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use std::hash::{BuildHasher, Hash};
+
+use ::arbitrary::{size_hint, Arbitrary, Result, Unstructured};
+
+use crate::{HashMap, HashSet, OrdMap, OrdSet, Vector};
+
+impl<'a, A: Arbitrary<'a> + Clone> Arbitrary<'a> for Vector<A> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_iter()?.collect()
+    }
+
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_take_rest_iter()?.collect()
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        size_hint::recursion_guard(depth, |depth| {
+            size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None))
+        })
+    }
+}
+
+impl<'a, K: Arbitrary<'a> + Ord + Clone, V: Arbitrary<'a> + Clone> Arbitrary<'a> for OrdMap<K, V> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_iter()?.collect()
+    }
+
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_take_rest_iter()?.collect()
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        size_hint::recursion_guard(depth, |depth| {
+            size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None))
+        })
+    }
+}
+
+impl<'a, A: Arbitrary<'a> + Ord + Clone> Arbitrary<'a> for OrdSet<A> {
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_iter()?.collect()
+    }
+
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_take_rest_iter()?.collect()
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        size_hint::recursion_guard(depth, |depth| {
+            size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None))
+        })
+    }
+}
+
+impl<'a, K, V, S> Arbitrary<'a> for HashMap<K, V, S>
+where
+    K: Arbitrary<'a> + Hash + Eq + Clone,
+    V: Arbitrary<'a> + Clone,
+    S: BuildHasher + Default + 'static,
+{
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_iter()?.collect()
+    }
+
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_take_rest_iter()?.collect()
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        size_hint::recursion_guard(depth, |depth| {
+            size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None))
+        })
+    }
+}
+
+impl<'a, A, S> Arbitrary<'a> for HashSet<A, S>
+where
+    A: Arbitrary<'a> + Hash + Eq + Clone,
+    S: BuildHasher + Default + 'static,
+{
+    fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_iter()?.collect()
+    }
+
+    fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> {
+        u.arbitrary_take_rest_iter()?.collect()
+    }
+
+    fn size_hint(depth: usize) -> (usize, Option<usize>) {
+        size_hint::recursion_guard(depth, |depth| {
+            size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None))
+        })
+    }
+}
diff --git a/vendor/im-rc/src/config.rs b/vendor/im-rc/src/config.rs
new file mode 100644
index 000000000..f8611396c
--- /dev/null
+++ b/vendor/im-rc/src/config.rs
@@ -0,0 +1,20 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use typenum::*;
+
+/// The branching factor of RRB-trees
+pub(crate) type VectorChunkSize = U64;
+
+/// The branching factor of B-trees
+pub(crate) type OrdChunkSize = U64; // Must be an even number!
+
+/// The level size of HAMTs, in bits
+/// Branching factor is 2 ^ HashLevelSize.
+pub(crate) type HashLevelSize = U5;
+
+/// The size of per-instance memory pools if the `pool` feature is enabled.
+/// This is set to 0, meaning you have to opt in to using a pool by constructing
+/// with eg. `Vector::with_pool(pool)` even if the `pool` feature is enabled.
+pub(crate) const POOL_SIZE: usize = 0;
diff --git a/vendor/im-rc/src/fakepool.rs b/vendor/im-rc/src/fakepool.rs
new file mode 100644
index 000000000..5ff36f7e5
--- /dev/null
+++ b/vendor/im-rc/src/fakepool.rs
@@ -0,0 +1,208 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#![allow(dead_code)]
+
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::rc::Rc as RRc;
+use std::sync::Arc as RArc;
+
+use crate::nodes::chunk::Chunk;
+
+pub(crate) trait PoolDefault: Default {}
+pub(crate) trait PoolClone: Clone {}
+
+impl<A> PoolDefault for Chunk<A> {}
+impl<A> PoolClone for Chunk<A> where A: Clone {}
+
+pub(crate) struct Pool<A>(PhantomData<A>);
+
+impl<A> Pool<A> {
+    pub(crate) fn new(_size: usize) -> Self {
+        Pool(PhantomData)
+    }
+
+    pub(crate) fn get_pool_size(&self) -> usize {
+        0
+    }
+
+    pub(crate) fn fill(&self) {}
+}
+
+impl<A> Clone for Pool<A> {
+    fn clone(&self) -> Self {
+        Self::new(0)
+    }
+}
+
+// Rc
+
+#[derive(Default)]
+pub(crate) struct Rc<A>(RRc<A>);
+
+impl<A> Rc<A> {
+    #[inline(always)]
+    pub(crate) fn default(_pool: &Pool<A>) -> Self
+    where
+        A: PoolDefault,
+    {
+        Self(Default::default())
+    }
+
+    #[inline(always)]
+    pub(crate) fn new(_pool: &Pool<A>, value: A) -> Self {
+        Rc(RRc::new(value))
+    }
+
+    #[inline(always)]
+    pub(crate) fn clone_from(_pool: &Pool<A>, value: &A) -> Self
+    where
+        A: PoolClone,
+    {
+        Rc(RRc::new(value.clone()))
+    }
+
+    #[inline(always)]
+    pub(crate) fn make_mut<'a>(_pool: &Pool<A>, this: &'a mut Self) -> &'a mut A
+    where
+        A: PoolClone,
+    {
+        RRc::make_mut(&mut this.0)
+    }
+
+    #[inline(always)]
+    pub(crate) fn ptr_eq(left: &Self, right: &Self) -> bool {
+        RRc::ptr_eq(&left.0, &right.0)
+    }
+
+    pub(crate) fn unwrap_or_clone(this: Self) -> A
+    where
+        A: PoolClone,
+    {
+        RRc::try_unwrap(this.0).unwrap_or_else(|r| (*r).clone())
+    }
+}
+
+impl<A> Clone for Rc<A> {
+    #[inline(always)]
+    fn clone(&self) -> Self {
+        Rc(self.0.clone())
+    }
+}
+
+impl<A> Deref for Rc<A> {
+    type Target = A;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        self.0.deref()
+    }
+}
+
+impl<A> PartialEq for Rc<A>
+where
+    A: PartialEq,
+{
+    #[inline(always)]
+    fn eq(&self, other: &Self) -> bool {
+        **self == **other
+    }
+}
+
+impl<A> Eq for Rc<A> where A: Eq {}
+
+impl<A> std::fmt::Debug for Rc<A>
+where
+    A: std::fmt::Debug,
+{
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        self.0.fmt(f)
+    }
+}
+
+// Arc
+
+#[derive(Default)]
+pub(crate) struct Arc<A>(RArc<A>);
+
+impl<A> Arc<A> {
+    #[inline(always)]
+    pub(crate) fn default(_pool: &Pool<A>) -> Self
+    where
+        A: PoolDefault,
+    {
+        Self(Default::default())
+    }
+
+    #[inline(always)]
+    pub(crate) fn new(_pool: &Pool<A>, value: A) -> Self {
+        Self(RArc::new(value))
+    }
+
+    #[inline(always)]
+    pub(crate) fn clone_from(_pool: &Pool<A>, value: &A) -> Self
+    where
+        A: PoolClone,
+    {
+        Self(RArc::new(value.clone()))
+    }
+
+    #[inline(always)]
+    pub(crate) fn make_mut<'a>(_pool: &Pool<A>, this: &'a mut Self) -> &'a mut A
+    where
+        A: PoolClone,
+    {
+        RArc::make_mut(&mut this.0)
+    }
+
+    #[inline(always)]
+    pub(crate) fn ptr_eq(left: &Self, right: &Self) -> bool {
+        RArc::ptr_eq(&left.0, &right.0)
+    }
+
+    pub(crate) fn unwrap_or_clone(this: Self) -> A
+    where
+        A: PoolClone,
+    {
+        RArc::try_unwrap(this.0).unwrap_or_else(|r| (*r).clone())
+    }
+}
+
+impl<A> Clone for Arc<A> {
+    #[inline(always)]
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<A> Deref for Arc<A> {
+    type Target = A;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        self.0.deref()
+    }
+}
+
+impl<A> PartialEq for Arc<A>
+where
+    A: PartialEq,
+{
+    #[inline(always)]
+    fn eq(&self, other: &Self) -> bool {
+        **self == **other
+    }
+}
+
+impl<A> Eq for Arc<A> where A: Eq {}
+
+impl<A> std::fmt::Debug for Arc<A>
+where
+    A: std::fmt::Debug,
+{
+    #[inline(always)]
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        self.0.fmt(f)
+    }
+}
diff --git a/vendor/im-rc/src/hash/map.rs b/vendor/im-rc/src/hash/map.rs
new file mode 100644
index 000000000..2c2761b0e
--- /dev/null
+++ b/vendor/im-rc/src/hash/map.rs
@@ -0,0 +1,2379 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! An unordered map.
+//!
+//! An immutable hash map using [hash array mapped tries][1].
+//!
+//! Most operations on this map are O(log<sub>x</sub> n) for a
+//! suitably high *x* that it should be nearly O(1) for most maps.
+//! Because of this, it's a great choice for a generic map as long as
+//! you don't mind that keys will need to implement
+//! [`Hash`][std::hash::Hash] and [`Eq`][std::cmp::Eq].
+//!
+//! Map entries will have a predictable order based on the hasher
+//! being used. Unless otherwise specified, this will be the standard
+//! [`RandomState`][std::collections::hash_map::RandomState] hasher.
+//!
+//! [1]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie
+//! [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
+//! [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html
+//! [std::collections::hash_map::RandomState]: https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html
+
+use std::borrow::Borrow;
+use std::cmp::Ordering;
+use std::collections;
+use std::collections::hash_map::RandomState;
+use std::fmt::{Debug, Error, Formatter};
+use std::hash::{BuildHasher, Hash, Hasher};
+use std::iter::{FromIterator, FusedIterator, Sum};
+use std::mem;
+use std::ops::{Add, Index, IndexMut};
+
+use crate::nodes::hamt::{
+    hash_key, Drain as NodeDrain, HashBits, HashValue, Iter as NodeIter, IterMut as NodeIterMut,
+    Node,
+};
+use crate::util::{Pool, PoolRef, Ref};
+
+/// Construct a hash map from a sequence of key/value pairs.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::hashmap::HashMap;
+/// # fn main() {
+/// assert_eq!(
+///   hashmap!{
+///     1 => 11,
+///     2 => 22,
+///     3 => 33
+///   },
+///   HashMap::from(vec![(1, 11), (2, 22), (3, 33)])
+/// );
+/// # }
+/// ```
+#[macro_export]
+macro_rules! hashmap {
+    () => { $crate::hashmap::HashMap::new() };
+
+    ( $( $key:expr => $value:expr ),* ) => {{
+        let mut map = $crate::hashmap::HashMap::new();
+        $({
+            map.insert($key, $value);
+        })*;
+        map
+    }};
+
+    ( $( $key:expr => $value:expr ,)* ) => {{
+        let mut map = $crate::hashmap::HashMap::new();
+        $({
+            map.insert($key, $value);
+        })*;
+        map
+    }};
+}
+
+def_pool!(HashMapPool<K,V>, Node<(K,V)>);
+
+/// An unordered map.
+///
+/// An immutable hash map using [hash array mapped tries] [1].
+///
+/// Most operations on this map are O(log<sub>x</sub> n) for a
+/// suitably high *x* that it should be nearly O(1) for most maps.
+/// Because of this, it's a great choice for a generic map as long as
+/// you don't mind that keys will need to implement
+/// [`Hash`][std::hash::Hash] and [`Eq`][std::cmp::Eq].
+///
+/// Map entries will have a predictable order based on the hasher
+/// being used. Unless otherwise specified, this will be the standard
+/// [`RandomState`][std::collections::hash_map::RandomState] hasher.
+///
+/// [1]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie
+/// [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
+/// [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html
+/// [std::collections::hash_map::RandomState]: https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html
+
+pub struct HashMap<K, V, S = RandomState> {
+    size: usize,
+    pool: HashMapPool<K, V>,
+    root: PoolRef<Node<(K, V)>>,
+    hasher: Ref<S>,
+}
+
+impl<K, V> HashValue for (K, V)
+where
+    K: Eq,
+{
+    type Key = K;
+
+    fn extract_key(&self) -> &Self::Key {
+        &self.0
+    }
+
+    fn ptr_eq(&self, _other: &Self) -> bool {
+        false
+    }
+}
+
+impl<K, V> HashMap<K, V, RandomState> {
+    /// Construct an empty hash map.
+    #[inline]
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Construct an empty hash map using a specific memory pool.
+    #[cfg(feature = "pool")]
+    #[must_use]
+    pub fn with_pool(pool: &HashMapPool<K, V>) -> Self {
+        let root = PoolRef::default(&pool.0);
+        Self {
+            size: 0,
+            hasher: Default::default(),
+            pool: pool.clone(),
+            root,
+        }
+    }
+}
+
+impl<K, V> HashMap<K, V, RandomState>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+{
+    /// Construct a hash map with a single mapping.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map = HashMap::unit(123, "onetwothree");
+    /// assert_eq!(
+    ///   map.get(&123),
+    ///   Some(&"onetwothree")
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn unit(k: K, v: V) -> HashMap<K, V> {
+        HashMap::new().update(k, v)
+    }
+}
+
+impl<K, V, S> HashMap<K, V, S> {
+    /// Test whether a hash map is empty.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// assert!(
+    ///   !hashmap!{1 => 2}.is_empty()
+    /// );
+    /// assert!(
+    ///   HashMap::<i32, i32>::new().is_empty()
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Get the size of a hash map.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// assert_eq!(3, hashmap!{
+    ///   1 => 11,
+    ///   2 => 22,
+    ///   3 => 33
+    /// }.len());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.size
+    }
+
+    /// Test whether two maps refer to the same content in memory.
+    ///
+    /// This is true if the two sides are references to the same map,
+    /// or if the two maps refer to the same root node.
+    ///
+    /// This would return true if you're comparing a map to itself, or
+    /// if you're comparing a map to a fresh clone of itself.
+    ///
+    /// Time: O(1)
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        std::ptr::eq(self, other) || PoolRef::ptr_eq(&self.root, &other.root)
+    }
+
+    /// Get a reference to the memory pool used by this map.
+    ///
+    /// Note that if you didn't specifically construct it with a pool, you'll
+    /// get back a reference to a pool of size 0.
+    #[cfg(feature = "pool")]
+    pub fn pool(&self) -> &HashMapPool<K, V> {
+        &self.pool
+    }
+
+    /// Construct an empty hash map using the provided hasher.
+    #[inline]
+    #[must_use]
+    pub fn with_hasher<RS>(hasher: RS) -> Self
+    where
+        Ref<S>: From<RS>,
+    {
+        let pool = HashMapPool::default();
+        let root = PoolRef::default(&pool.0);
+        HashMap {
+            size: 0,
+            hasher: hasher.into(),
+            pool,
+            root,
+        }
+    }
+
+    /// Construct an empty hash map using a specific memory pool and hasher.
+    #[cfg(feature = "pool")]
+    #[must_use]
+    pub fn with_pool_hasher<RS>(pool: &HashMapPool<K, V>, hasher: RS) -> Self
+    where
+        Ref<S>: From<RS>,
+    {
+        let root = PoolRef::default(&pool.0);
+        Self {
+            size: 0,
+            hasher: hasher.into(),
+            pool: pool.clone(),
+            root,
+        }
+    }
+
+    /// Get a reference to the map's [`BuildHasher`][BuildHasher].
+    ///
+    /// [BuildHasher]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html
+    #[must_use]
+    pub fn hasher(&self) -> &Ref<S> {
+        &self.hasher
+    }
+
+    /// Construct an empty hash map using the same hasher as the
+    /// current hash map.
+    #[inline]
+    #[must_use]
+    pub fn new_from<K1, V1>(&self) -> HashMap<K1, V1, S>
+    where
+        K1: Hash + Eq + Clone,
+        V1: Clone,
+    {
+        let pool = HashMapPool::default();
+        let root = PoolRef::default(&pool.0);
+        HashMap {
+            size: 0,
+            pool,
+            root,
+            hasher: self.hasher.clone(),
+        }
+    }
+
+    /// Get an iterator over the key/value pairs of a hash map.
+    ///
+    /// Please note that the order is consistent between maps using
+    /// the same hasher, but no other ordering guarantee is offered.
+    /// Items will not come out in insertion order or sort order.
+    /// They will, however, come out in the same order every time for
+    /// the same map.
+    #[inline]
+    #[must_use]
+    pub fn iter(&self) -> Iter<'_, K, V> {
+        Iter {
+            it: NodeIter::new(&self.root, self.size),
+        }
+    }
+
+    /// Get an iterator over a hash map's keys.
+    ///
+    /// Please note that the order is consistent between maps using
+    /// the same hasher, but no other ordering guarantee is offered.
+    /// Items will not come out in insertion order or sort order.
+    /// They will, however, come out in the same order every time for
+    /// the same map.
+    #[inline]
+    #[must_use]
+    pub fn keys(&self) -> Keys<'_, K, V> {
+        Keys {
+            it: NodeIter::new(&self.root, self.size),
+        }
+    }
+
+    /// Get an iterator over a hash map's values.
+    ///
+    /// Please note that the order is consistent between maps using
+    /// the same hasher, but no other ordering guarantee is offered.
+    /// Items will not come out in insertion order or sort order.
+    /// They will, however, come out in the same order every time for
+    /// the same map.
+    #[inline]
+    #[must_use]
+    pub fn values(&self) -> Values<'_, K, V> {
+        Values {
+            it: NodeIter::new(&self.root, self.size),
+        }
+    }
+
+    /// Discard all elements from the map.
+    ///
+    /// This leaves you with an empty map, and all elements that
+    /// were previously inside it are dropped.
+    ///
+    /// Time: O(n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::HashMap;
+    /// let mut map = hashmap![1=>1, 2=>2, 3=>3];
+    /// map.clear();
+    /// assert!(map.is_empty());
+    /// ```
+    pub fn clear(&mut self) {
+        if !self.is_empty() {
+            self.root = PoolRef::default(&self.pool.0);
+            self.size = 0;
+        }
+    }
+}
+
+impl<K, V, S> HashMap<K, V, S>
+where
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    fn test_eq(&self, other: &Self) -> bool
+    where
+        K: Hash + Eq,
+        V: PartialEq,
+    {
+        if self.len() != other.len() {
+            return false;
+        }
+        let mut seen = collections::HashSet::new();
+        for (key, value) in self.iter() {
+            if Some(value) != other.get(key) {
+                return false;
+            }
+            seen.insert(key);
+        }
+        for key in other.keys() {
+            if !seen.contains(&key) {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Get the value for a key from a hash map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map = hashmap!{123 => "lol"};
+    /// assert_eq!(
+    ///   map.get(&123),
+    ///   Some(&"lol")
+    /// );
+    /// ```
+    #[must_use]
+    pub fn get<BK>(&self, key: &BK) -> Option<&V>
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.root
+            .get(hash_key(&*self.hasher, key), 0, key)
+            .map(|&(_, ref v)| v)
+    }
+
+    /// Get the key/value pair for a key from a hash map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map = hashmap!{123 => "lol"};
+    /// assert_eq!(
+    ///   map.get_key_value(&123),
+    ///   Some((&123, &"lol"))
+    /// );
+    /// ```
+    #[must_use]
+    pub fn get_key_value<BK>(&self, key: &BK) -> Option<(&K, &V)>
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.root
+            .get(hash_key(&*self.hasher, key), 0, key)
+            .map(|&(ref k, ref v)| (k, v))
+    }
+
+    /// Test for the presence of a key in a hash map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map = hashmap!{123 => "lol"};
+    /// assert!(
+    ///   map.contains_key(&123)
+    /// );
+    /// assert!(
+    ///   !map.contains_key(&321)
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn contains_key<BK>(&self, k: &BK) -> bool
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.get(k).is_some()
+    }
+
+    /// Test whether a map is a submap of another map, meaning that
+    /// all keys in our map must also be in the other map, with the
+    /// same values.
+    ///
+    /// Use the provided function to decide whether values are equal.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn is_submap_by<B, RM, F>(&self, other: RM, mut cmp: F) -> bool
+    where
+        F: FnMut(&V, &B) -> bool,
+        RM: Borrow<HashMap<K, B, S>>,
+    {
+        self.iter()
+            .all(|(k, v)| other.borrow().get(k).map(|ov| cmp(v, ov)).unwrap_or(false))
+    }
+
+    /// Test whether a map is a proper submap of another map, meaning
+    /// that all keys in our map must also be in the other map, with
+    /// the same values. To be a proper submap, ours must also contain
+    /// fewer keys than the other map.
+    ///
+    /// Use the provided function to decide whether values are equal.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn is_proper_submap_by<B, RM, F>(&self, other: RM, cmp: F) -> bool
+    where
+        F: FnMut(&V, &B) -> bool,
+        RM: Borrow<HashMap<K, B, S>>,
+    {
+        self.len() != other.borrow().len() && self.is_submap_by(other, cmp)
+    }
+
+    /// Test whether a map is a submap of another map, meaning that
+    /// all keys in our map must also be in the other map, with the
+    /// same values.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 2 => 2};
+    /// let map2 = hashmap!{1 => 1, 2 => 2, 3 => 3};
+    /// assert!(map1.is_submap(map2));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_submap<RM>(&self, other: RM) -> bool
+    where
+        V: PartialEq,
+        RM: Borrow<Self>,
+    {
+        self.is_submap_by(other.borrow(), PartialEq::eq)
+    }
+
+    /// Test whether a map is a proper submap of another map, meaning
+    /// that all keys in our map must also be in the other map, with
+    /// the same values. To be a proper submap, ours must also contain
+    /// fewer keys than the other map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 2 => 2};
+    /// let map2 = hashmap!{1 => 1, 2 => 2, 3 => 3};
+    /// assert!(map1.is_proper_submap(map2));
+    ///
+    /// let map3 = hashmap!{1 => 1, 2 => 2};
+    /// let map4 = hashmap!{1 => 1, 2 => 2};
+    /// assert!(!map3.is_proper_submap(map4));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_proper_submap<RM>(&self, other: RM) -> bool
+    where
+        V: PartialEq,
+        RM: Borrow<Self>,
+    {
+        self.is_proper_submap_by(other.borrow(), PartialEq::eq)
+    }
+}
+
+impl<K, V, S> HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher,
+{
+    /// Get a mutable iterator over the values of a hash map.
+    ///
+    /// Please note that the order is consistent between maps using
+    /// the same hasher, but no other ordering guarantee is offered.
+    /// Items will not come out in insertion order or sort order.
+    /// They will, however, come out in the same order every time for
+    /// the same map.
+    #[inline]
+    #[must_use]
+    pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        IterMut {
+            it: NodeIterMut::new(&self.pool.0, root, self.size),
+        }
+    }
+
+    /// Get a mutable reference to the value for a key from a hash
+    /// map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let mut map = hashmap!{123 => "lol"};
+    /// if let Some(value) = map.get_mut(&123) {
+    ///     *value = "omg";
+    /// }
+    /// assert_eq!(
+    ///   map.get(&123),
+    ///   Some(&"omg")
+    /// );
+    /// ```
+    #[must_use]
+    pub fn get_mut<BK>(&mut self, key: &BK) -> Option<&mut V>
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        match root.get_mut(&self.pool.0, hash_key(&*self.hasher, key), 0, key) {
+            None => None,
+            Some(&mut (_, ref mut value)) => Some(value),
+        }
+    }
+
+    /// Insert a key/value mapping into a map.
+    ///
+    /// If the map already has a mapping for the given key, the
+    /// previous value is overwritten.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let mut map = hashmap!{};
+    /// map.insert(123, "123");
+    /// map.insert(456, "456");
+    /// assert_eq!(
+    ///   map,
+    ///   hashmap!{123 => "123", 456 => "456"}
+    /// );
+    /// ```
+    #[inline]
+    pub fn insert(&mut self, k: K, v: V) -> Option<V> {
+        let hash = hash_key(&*self.hasher, &k);
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        let result = root.insert(&self.pool.0, hash, 0, (k, v));
+        if result.is_none() {
+            self.size += 1;
+        }
+        result.map(|(_, v)| v)
+    }
+
+    /// Remove a key/value pair from a map, if it exists, and return
+    /// the removed value.
+    ///
+    /// This is a copy-on-write operation, so that the parts of the
+    /// set's structure which are shared with other sets will be
+    /// safely copied before mutating.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let mut map = hashmap!{123 => "123", 456 => "456"};
+    /// assert_eq!(Some("123"), map.remove(&123));
+    /// assert_eq!(Some("456"), map.remove(&456));
+    /// assert_eq!(None, map.remove(&789));
+    /// assert!(map.is_empty());
+    /// ```
+    pub fn remove<BK>(&mut self, k: &BK) -> Option<V>
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.remove_with_key(k).map(|(_, v)| v)
+    }
+
+    /// Remove a key/value pair from a map, if it exists, and return
+    /// the removed key and value.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let mut map = hashmap!{123 => "123", 456 => "456"};
+    /// assert_eq!(Some((123, "123")), map.remove_with_key(&123));
+    /// assert_eq!(Some((456, "456")), map.remove_with_key(&456));
+    /// assert_eq!(None, map.remove_with_key(&789));
+    /// assert!(map.is_empty());
+    /// ```
+    pub fn remove_with_key<BK>(&mut self, k: &BK) -> Option<(K, V)>
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        let result = root.remove(&self.pool.0, hash_key(&*self.hasher, k), 0, k);
+        if result.is_some() {
+            self.size -= 1;
+        }
+        result
+    }
+
+    /// Get the [`Entry`][Entry] for a key in the map for in-place manipulation.
+    ///
+    /// Time: O(log n)
+    ///
+    /// [Entry]: enum.Entry.html
+    #[must_use]
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V, S> {
+        let hash = hash_key(&*self.hasher, &key);
+        if self.root.get(hash, 0, &key).is_some() {
+            Entry::Occupied(OccupiedEntry {
+                map: self,
+                hash,
+                key,
+            })
+        } else {
+            Entry::Vacant(VacantEntry {
+                map: self,
+                hash,
+                key,
+            })
+        }
+    }
+
+    /// Construct a new hash map by inserting a key/value mapping into a map.
+    ///
+    /// If the map already has a mapping for the given key, the previous value
+    /// is overwritten.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map = hashmap!{};
+    /// assert_eq!(
+    ///   map.update(123, "123"),
+    ///   hashmap!{123 => "123"}
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn update(&self, k: K, v: V) -> Self {
+        let mut out = self.clone();
+        out.insert(k, v);
+        out
+    }
+
+    /// Construct a new hash map by inserting a key/value mapping into
+    /// a map.
+    ///
+    /// If the map already has a mapping for the given key, we call
+    /// the provided function with the old value and the new value,
+    /// and insert the result as the new value.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn update_with<F>(&self, k: K, v: V, f: F) -> Self
+    where
+        F: FnOnce(V, V) -> V,
+    {
+        match self.extract_with_key(&k) {
+            None => self.update(k, v),
+            Some((_, v2, m)) => m.update(k, f(v2, v)),
+        }
+    }
+
+    /// Construct a new map by inserting a key/value mapping into a
+    /// map.
+    ///
+    /// If the map already has a mapping for the given key, we call
+    /// the provided function with the key, the old value and the new
+    /// value, and insert the result as the new value.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn update_with_key<F>(&self, k: K, v: V, f: F) -> Self
+    where
+        F: FnOnce(&K, V, V) -> V,
+    {
+        match self.extract_with_key(&k) {
+            None => self.update(k, v),
+            Some((_, v2, m)) => {
+                let out_v = f(&k, v2, v);
+                m.update(k, out_v)
+            }
+        }
+    }
+
+    /// Construct a new map by inserting a key/value mapping into a
+    /// map, returning the old value for the key as well as the new
+    /// map.
+    ///
+    /// If the map already has a mapping for the given key, we call
+    /// the provided function with the key, the old value and the new
+    /// value, and insert the result as the new value.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn update_lookup_with_key<F>(&self, k: K, v: V, f: F) -> (Option<V>, Self)
+    where
+        F: FnOnce(&K, &V, V) -> V,
+    {
+        match self.extract_with_key(&k) {
+            None => (None, self.update(k, v)),
+            Some((_, v2, m)) => {
+                let out_v = f(&k, &v2, v);
+                (Some(v2), m.update(k, out_v))
+            }
+        }
+    }
+
+    /// Update the value for a given key by calling a function with
+    /// the current value and overwriting it with the function's
+    /// return value.
+    ///
+    /// The function gets an [`Option<V>`][std::option::Option] and
+    /// returns the same, so that it can decide to delete a mapping
+    /// instead of updating the value, and decide what to do if the
+    /// key isn't in the map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// [std::option::Option]: https://doc.rust-lang.org/std/option/enum.Option.html
+    #[must_use]
+    pub fn alter<F>(&self, f: F, k: K) -> Self
+    where
+        F: FnOnce(Option<V>) -> Option<V>,
+    {
+        let pop = self.extract_with_key(&k);
+        match (f(pop.as_ref().map(|&(_, ref v, _)| v.clone())), pop) {
+            (None, None) => self.clone(),
+            (Some(v), None) => self.update(k, v),
+            (None, Some((_, _, m))) => m,
+            (Some(v), Some((_, _, m))) => m.update(k, v),
+        }
+    }
+
+    /// Construct a new map without the given key.
+    ///
+    /// Construct a map that's a copy of the current map, absent the
+    /// mapping for `key` if it's present.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn without<BK>(&self, k: &BK) -> Self
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        match self.extract_with_key(k) {
+            None => self.clone(),
+            Some((_, _, map)) => map,
+        }
+    }
+
+    /// Filter out values from a map which don't satisfy a predicate.
+    ///
+    /// This is slightly more efficient than filtering using an
+    /// iterator, in that it doesn't need to rehash the retained
+    /// values, but it still needs to reconstruct the entire tree
+    /// structure of the map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::HashMap;
+    /// let mut map = hashmap!{1 => 1, 2 => 2, 3 => 3};
+    /// map.retain(|k, v| *k > 1);
+    /// let expected = hashmap!{2 => 2, 3 => 3};
+    /// assert_eq!(expected, map);
+    /// ```
+    pub fn retain<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&K, &V) -> bool,
+    {
+        let old_root = self.root.clone();
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        for ((key, value), hash) in NodeIter::new(&old_root, self.size) {
+            if !f(key, value) && root.remove(&self.pool.0, hash, 0, key).is_some() {
+                self.size -= 1;
+            }
+        }
+    }
+
+    /// Remove a key/value pair from a map, if it exists, and return
+    /// the removed value as well as the updated map.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn extract<BK>(&self, k: &BK) -> Option<(V, Self)>
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.extract_with_key(k).map(|(_, v, m)| (v, m))
+    }
+
+    /// Remove a key/value pair from a map, if it exists, and return
+    /// the removed key and value as well as the updated list.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn extract_with_key<BK>(&self, k: &BK) -> Option<(K, V, Self)>
+    where
+        BK: Hash + Eq + ?Sized,
+        K: Borrow<BK>,
+    {
+        let mut out = self.clone();
+        out.remove_with_key(k).map(|(k, v)| (k, v, out))
+    }
+
+    /// Construct the union of two maps, keeping the values in the
+    /// current map when keys exist in both maps.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 3 => 3};
+    /// let map2 = hashmap!{2 => 2, 3 => 4};
+    /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 3};
+    /// assert_eq!(expected, map1.union(map2));
+    /// ```
+    #[must_use]
+    pub fn union(self, other: Self) -> Self {
+        let (mut to_mutate, to_consume) = if self.len() >= other.len() {
+            (self, other)
+        } else {
+            (other, self)
+        };
+        for (k, v) in to_consume {
+            to_mutate.entry(k).or_insert(v);
+        }
+        to_mutate
+    }
+
+    /// Construct the union of two maps, using a function to decide
+    /// what to do with the value when a key is in both maps.
+    ///
+    /// The function is called when a value exists in both maps, and
+    /// receives the value from the current map as its first argument,
+    /// and the value from the other map as the second. It should
+    /// return the value to be inserted in the resulting map.
+    ///
+    /// Time: O(n log n)
+    #[inline]
+    #[must_use]
+    pub fn union_with<F>(self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(V, V) -> V,
+    {
+        self.union_with_key(other, |_, v1, v2| f(v1, v2))
+    }
+
+    /// Construct the union of two maps, using a function to decide
+    /// what to do with the value when a key is in both maps.
+    ///
+    /// The function is called when a value exists in both maps, and
+    /// receives a reference to the key as its first argument, the
+    /// value from the current map as the second argument, and the
+    /// value from the other map as the third argument. It should
+    /// return the value to be inserted in the resulting map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 3 => 4};
+    /// let map2 = hashmap!{2 => 2, 3 => 5};
+    /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 9};
+    /// assert_eq!(expected, map1.union_with_key(
+    ///     map2,
+    ///     |key, left, right| left + right
+    /// ));
+    /// ```
+    #[must_use]
+    pub fn union_with_key<F>(self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(&K, V, V) -> V,
+    {
+        if self.len() >= other.len() {
+            self.union_with_key_inner(other, f)
+        } else {
+            other.union_with_key_inner(self, |key, other_value, self_value| {
+                f(key, self_value, other_value)
+            })
+        }
+    }
+
+    fn union_with_key_inner<F>(mut self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(&K, V, V) -> V,
+    {
+        for (key, right_value) in other {
+            match self.remove(&key) {
+                None => {
+                    self.insert(key, right_value);
+                }
+                Some(left_value) => {
+                    let final_value = f(&key, left_value, right_value);
+                    self.insert(key, final_value);
+                }
+            }
+        }
+        self
+    }
+
+    /// Construct the union of a sequence of maps, selecting the value
+    /// of the leftmost when a key appears in more than one map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 3 => 3};
+    /// let map2 = hashmap!{2 => 2};
+    /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 3};
+    /// assert_eq!(expected, HashMap::unions(vec![map1, map2]));
+    /// ```
+    #[must_use]
+    pub fn unions<I>(i: I) -> Self
+    where
+        S: Default,
+        I: IntoIterator<Item = Self>,
+    {
+        i.into_iter().fold(Self::default(), Self::union)
+    }
+
+    /// Construct the union of a sequence of maps, using a function to
+    /// decide what to do with the value when a key is in more than
+    /// one map.
+    ///
+    /// The function is called when a value exists in multiple maps,
+    /// and receives the value from the current map as its first
+    /// argument, and the value from the next map as the second. It
+    /// should return the value to be inserted in the resulting map.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn unions_with<I, F>(i: I, f: F) -> Self
+    where
+        S: Default,
+        I: IntoIterator<Item = Self>,
+        F: Fn(V, V) -> V,
+    {
+        i.into_iter()
+            .fold(Self::default(), |a, b| a.union_with(b, &f))
+    }
+
+    /// Construct the union of a sequence of maps, using a function to
+    /// decide what to do with the value when a key is in more than
+    /// one map.
+    ///
+    /// The function is called when a value exists in multiple maps,
+    /// and receives a reference to the key as its first argument, the
+    /// value from the current map as the second argument, and the
+    /// value from the next map as the third argument. It should
+    /// return the value to be inserted in the resulting map.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn unions_with_key<I, F>(i: I, f: F) -> Self
+    where
+        S: Default,
+        I: IntoIterator<Item = Self>,
+        F: Fn(&K, V, V) -> V,
+    {
+        i.into_iter()
+            .fold(Self::default(), |a, b| a.union_with_key(b, &f))
+    }
+
+    /// Construct the symmetric difference between two maps by discarding keys
+    /// which occur in both maps.
+    ///
+    /// This is an alias for the
+    /// [`symmetric_difference`][symmetric_difference] method.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 3 => 4};
+    /// let map2 = hashmap!{2 => 2, 3 => 5};
+    /// let expected = hashmap!{1 => 1, 2 => 2};
+    /// assert_eq!(expected, map1.difference(map2));
+    /// ```
+    ///
+    /// [symmetric_difference]: #method.symmetric_difference
+    #[inline]
+    #[must_use]
+    pub fn difference(self, other: Self) -> Self {
+        self.symmetric_difference(other)
+    }
+
+    /// Construct the symmetric difference between two maps by discarding keys
+    /// which occur in both maps.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 3 => 4};
+    /// let map2 = hashmap!{2 => 2, 3 => 5};
+    /// let expected = hashmap!{1 => 1, 2 => 2};
+    /// assert_eq!(expected, map1.symmetric_difference(map2));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn symmetric_difference(self, other: Self) -> Self {
+        self.symmetric_difference_with_key(other, |_, _, _| None)
+    }
+
+    /// Construct the symmetric difference between two maps by using a function
+    /// to decide what to do if a key occurs in both.
+    ///
+    /// This is an alias for the
+    /// [`symmetric_difference_with`][symmetric_difference_with] method.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// [symmetric_difference_with]: #method.symmetric_difference_with
+    #[inline]
+    #[must_use]
+    pub fn difference_with<F>(self, other: Self, f: F) -> Self
+    where
+        F: FnMut(V, V) -> Option<V>,
+    {
+        self.symmetric_difference_with(other, f)
+    }
+
+    /// Construct the symmetric difference between two maps by using a function
+    /// to decide what to do if a key occurs in both.
+    ///
+    /// Time: O(n log n)
+    #[inline]
+    #[must_use]
+    pub fn symmetric_difference_with<F>(self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(V, V) -> Option<V>,
+    {
+        self.symmetric_difference_with_key(other, |_, a, b| f(a, b))
+    }
+
+    /// Construct the symmetric difference between two maps by using a function
+    /// to decide what to do if a key occurs in both. The function
+    /// receives the key as well as both values.
+    ///
+    /// This is an alias for the
+    /// [`symmetric_difference_with`_key][symmetric_difference_with_key]
+    /// method.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 3 => 4};
+    /// let map2 = hashmap!{2 => 2, 3 => 5};
+    /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 9};
+    /// assert_eq!(expected, map1.difference_with_key(
+    ///     map2,
+    ///     |key, left, right| Some(left + right)
+    /// ));
+    /// ```
+    ///
+    /// [symmetric_difference_with_key]: #method.symmetric_difference_with_key
+    #[must_use]
+    pub fn difference_with_key<F>(self, other: Self, f: F) -> Self
+    where
+        F: FnMut(&K, V, V) -> Option<V>,
+    {
+        self.symmetric_difference_with_key(other, f)
+    }
+
+    /// Construct the symmetric difference between two maps by using a function
+    /// to decide what to do if a key occurs in both. The function
+    /// receives the key as well as both values.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 3 => 4};
+    /// let map2 = hashmap!{2 => 2, 3 => 5};
+    /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 9};
+    /// assert_eq!(expected, map1.symmetric_difference_with_key(
+    ///     map2,
+    ///     |key, left, right| Some(left + right)
+    /// ));
+    /// ```
+    #[must_use]
+    pub fn symmetric_difference_with_key<F>(mut self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(&K, V, V) -> Option<V>,
+    {
+        let mut out = self.new_from();
+        for (key, right_value) in other {
+            match self.remove(&key) {
+                None => {
+                    out.insert(key, right_value);
+                }
+                Some(left_value) => {
+                    if let Some(final_value) = f(&key, left_value, right_value) {
+                        out.insert(key, final_value);
+                    }
+                }
+            }
+        }
+        out.union(self)
+    }
+
+    /// Construct the relative complement between two maps by discarding keys
+    /// which occur in `other`.
+    ///
+    /// Time: O(m log n) where m is the size of the other map
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 4};
+    /// let map2 = ordmap!{2 => 2, 3 => 5};
+    /// let expected = ordmap!{1 => 1};
+    /// assert_eq!(expected, map1.relative_complement(map2));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn relative_complement(mut self, other: Self) -> Self {
+        for (key, _) in other {
+            let _ = self.remove(&key);
+        }
+        self
+    }
+
+    /// Construct the intersection of two maps, keeping the values
+    /// from the current map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 2 => 2};
+    /// let map2 = hashmap!{2 => 3, 3 => 4};
+    /// let expected = hashmap!{2 => 2};
+    /// assert_eq!(expected, map1.intersection(map2));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn intersection(self, other: Self) -> Self {
+        self.intersection_with_key(other, |_, v, _| v)
+    }
+
+    /// Construct the intersection of two maps, calling a function
+    /// with both values for each key and using the result as the
+    /// value for the key.
+    ///
+    /// Time: O(n log n)
+    #[inline]
+    #[must_use]
+    pub fn intersection_with<B, C, F>(self, other: HashMap<K, B, S>, mut f: F) -> HashMap<K, C, S>
+    where
+        B: Clone,
+        C: Clone,
+        F: FnMut(V, B) -> C,
+    {
+        self.intersection_with_key(other, |_, v1, v2| f(v1, v2))
+    }
+
+    /// Construct the intersection of two maps, calling a function
+    /// with the key and both values for each key and using the result
+    /// as the value for the key.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashmap::HashMap;
+    /// let map1 = hashmap!{1 => 1, 2 => 2};
+    /// let map2 = hashmap!{2 => 3, 3 => 4};
+    /// let expected = hashmap!{2 => 5};
+    /// assert_eq!(expected, map1.intersection_with_key(
+    ///     map2,
+    ///     |key, left, right| left + right
+    /// ));
+    /// ```
+    #[must_use]
+    pub fn intersection_with_key<B, C, F>(
+        mut self,
+        other: HashMap<K, B, S>,
+        mut f: F,
+    ) -> HashMap<K, C, S>
+    where
+        B: Clone,
+        C: Clone,
+        F: FnMut(&K, V, B) -> C,
+    {
+        let mut out = self.new_from();
+        for (key, right_value) in other {
+            match self.remove(&key) {
+                None => (),
+                Some(left_value) => {
+                    let result = f(&key, left_value, right_value);
+                    out.insert(key, result);
+                }
+            }
+        }
+        out
+    }
+}
+
+// Entries
+
+/// A handle for a key and its associated value.
+///
+/// ## Performance Note
+///
+/// When using an `Entry`, the key is only ever hashed once, when you
+/// create the `Entry`. Operations on an `Entry` will never trigger a
+/// rehash, where eg. a `contains_key(key)` followed by an
+/// `insert(key, default_value)` (the equivalent of
+/// `Entry::or_insert()`) would need to hash the key once for the
+/// `contains_key` and again for the `insert`. The operations
+/// generally perform similarly otherwise.
+pub enum Entry<'a, K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher,
+{
+    /// An entry which exists in the map.
+    Occupied(OccupiedEntry<'a, K, V, S>),
+    /// An entry which doesn't exist in the map.
+    Vacant(VacantEntry<'a, K, V, S>),
+}
+
+impl<'a, K, V, S> Entry<'a, K, V, S>
+where
+    K: 'a + Hash + Eq + Clone,
+    V: 'a + Clone,
+    S: 'a + BuildHasher,
+{
+    /// Insert the default value provided if there was no value
+    /// already, and return a mutable reference to the value.
+    pub fn or_insert(self, default: V) -> &'a mut V {
+        self.or_insert_with(|| default)
+    }
+
+    /// Insert the default value from the provided function if there
+    /// was no value already, and return a mutable reference to the
+    /// value.
+    pub fn or_insert_with<F>(self, default: F) -> &'a mut V
+    where
+        F: FnOnce() -> V,
+    {
+        match self {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(default()),
+        }
+    }
+
+    /// Insert a default value if there was no value already, and
+    /// return a mutable reference to the value.
+    pub fn or_default(self) -> &'a mut V
+    where
+        V: Default,
+    {
+        self.or_insert_with(Default::default)
+    }
+
+    /// Get the key for this entry.
+    #[must_use]
+    pub fn key(&self) -> &K {
+        match self {
+            Entry::Occupied(entry) => entry.key(),
+            Entry::Vacant(entry) => entry.key(),
+        }
+    }
+
+    /// Call the provided function to modify the value if the value
+    /// exists.
+    pub fn and_modify<F>(mut self, f: F) -> Self
+    where
+        F: FnOnce(&mut V),
+    {
+        match &mut self {
+            Entry::Occupied(ref mut entry) => f(entry.get_mut()),
+            Entry::Vacant(_) => (),
+        }
+        self
+    }
+}
+
+/// An entry for a mapping that already exists in the map.
+pub struct OccupiedEntry<'a, K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher,
+{
+    map: &'a mut HashMap<K, V, S>,
+    hash: HashBits,
+    key: K,
+}
+
+impl<'a, K, V, S> OccupiedEntry<'a, K, V, S>
+where
+    K: 'a + Hash + Eq + Clone,
+    V: 'a + Clone,
+    S: 'a + BuildHasher,
+{
+    /// Get the key for this entry.
+    #[must_use]
+    pub fn key(&self) -> &K {
+        &self.key
+    }
+
+    /// Remove this entry from the map and return the removed mapping.
+    pub fn remove_entry(self) -> (K, V) {
+        let root = PoolRef::make_mut(&self.map.pool.0, &mut self.map.root);
+        let result = root.remove(&self.map.pool.0, self.hash, 0, &self.key);
+        self.map.size -= 1;
+        result.unwrap()
+    }
+
+    /// Get the current value.
+    #[must_use]
+    pub fn get(&self) -> &V {
+        &self.map.root.get(self.hash, 0, &self.key).unwrap().1
+    }
+
+    /// Get a mutable reference to the current value.
+    #[must_use]
+    pub fn get_mut(&mut self) -> &mut V {
+        let root = PoolRef::make_mut(&self.map.pool.0, &mut self.map.root);
+        &mut root
+            .get_mut(&self.map.pool.0, self.hash, 0, &self.key)
+            .unwrap()
+            .1
+    }
+
+    /// Convert this entry into a mutable reference.
+    #[must_use]
+    pub fn into_mut(self) -> &'a mut V {
+        let root = PoolRef::make_mut(&self.map.pool.0, &mut self.map.root);
+        &mut root
+            .get_mut(&self.map.pool.0, self.hash, 0, &self.key)
+            .unwrap()
+            .1
+    }
+
+    /// Overwrite the current value.
+    pub fn insert(&mut self, value: V) -> V {
+        mem::replace(self.get_mut(), value)
+    }
+
+    /// Remove this entry from the map and return the removed value.
+    pub fn remove(self) -> V {
+        self.remove_entry().1
+    }
+}
+
+/// An entry for a mapping that does not already exist in the map.
+pub struct VacantEntry<'a, K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher,
+{
+    map: &'a mut HashMap<K, V, S>,
+    hash: HashBits,
+    key: K,
+}
+
+impl<'a, K, V, S> VacantEntry<'a, K, V, S>
+where
+    K: 'a + Hash + Eq + Clone,
+    V: 'a + Clone,
+    S: 'a + BuildHasher,
+{
+    /// Get the key for this entry.
+    #[must_use]
+    pub fn key(&self) -> &K {
+        &self.key
+    }
+
+    /// Convert this entry into its key.
+    #[must_use]
+    pub fn into_key(self) -> K {
+        self.key
+    }
+
+    /// Insert a value into this entry.
+    pub fn insert(self, value: V) -> &'a mut V {
+        let root = PoolRef::make_mut(&self.map.pool.0, &mut self.map.root);
+        if root
+            .insert(&self.map.pool.0, self.hash, 0, (self.key.clone(), value))
+            .is_none()
+        {
+            self.map.size += 1;
+        }
+        // TODO it's unfortunate that we need to look up the key again
+        // here to get the mut ref.
+        &mut root
+            .get_mut(&self.map.pool.0, self.hash, 0, &self.key)
+            .unwrap()
+            .1
+    }
+}
+
+// Core traits
+
+impl<K, V, S> Clone for HashMap<K, V, S>
+where
+    K: Clone,
+    V: Clone,
+{
+    /// Clone a map.
+    ///
+    /// Time: O(1)
+    #[inline]
+    fn clone(&self) -> Self {
+        HashMap {
+            root: self.root.clone(),
+            pool: self.pool.clone(),
+            size: self.size,
+            hasher: self.hasher.clone(),
+        }
+    }
+}
+
+#[cfg(not(has_specialisation))]
+impl<K, V, S> PartialEq for HashMap<K, V, S>
+where
+    K: Hash + Eq,
+    V: PartialEq,
+    S: BuildHasher,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.test_eq(other)
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V, S> PartialEq for HashMap<K, V, S>
+where
+    K: Hash + Eq,
+    V: PartialEq,
+    S: BuildHasher,
+{
+    default fn eq(&self, other: &Self) -> bool {
+        self.test_eq(other)
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V, S> PartialEq for HashMap<K, V, S>
+where
+    K: Hash + Eq,
+    V: Eq,
+    S: BuildHasher,
+{
+    fn eq(&self, other: &Self) -> bool {
+        if PoolRef::ptr_eq(&self.root, &other.root) {
+            return true;
+        }
+        self.test_eq(other)
+    }
+}
+
+impl<K, V, S> Eq for HashMap<K, V, S>
+where
+    K: Hash + Eq,
+    V: Eq,
+    S: BuildHasher,
+{
+}
+
+impl<K, V, S> PartialOrd for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone + PartialOrd,
+    V: PartialOrd + Clone,
+    S: BuildHasher,
+{
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        if Ref::ptr_eq(&self.hasher, &other.hasher) {
+            return self.iter().partial_cmp(other.iter());
+        }
+        self.iter().partial_cmp(other.iter())
+    }
+}
+
+impl<K, V, S> Ord for HashMap<K, V, S>
+where
+    K: Hash + Eq + Ord + Clone,
+    V: Ord + Clone,
+    S: BuildHasher,
+{
+    fn cmp(&self, other: &Self) -> Ordering {
+        if Ref::ptr_eq(&self.hasher, &other.hasher) {
+            return self.iter().cmp(other.iter());
+        }
+        self.iter().cmp(other.iter())
+    }
+}
+
+impl<K, V, S> Hash for HashMap<K, V, S>
+where
+    K: Hash + Eq,
+    V: Hash,
+    S: BuildHasher,
+{
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        for i in self.iter() {
+            i.hash(state);
+        }
+    }
+}
+
+impl<K, V, S> Default for HashMap<K, V, S>
+where
+    S: BuildHasher + Default,
+{
+    #[inline]
+    fn default() -> Self {
+        let pool = HashMapPool::default();
+        let root = PoolRef::default(&pool.0);
+        HashMap {
+            size: 0,
+            pool,
+            root,
+            hasher: Ref::<S>::default(),
+        }
+    }
+}
+
+impl<K, V, S> Add for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher,
+{
+    type Output = HashMap<K, V, S>;
+
+    fn add(self, other: Self) -> Self::Output {
+        self.union(other)
+    }
+}
+
+impl<'a, K, V, S> Add for &'a HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher,
+{
+    type Output = HashMap<K, V, S>;
+
+    fn add(self, other: Self) -> Self::Output {
+        self.clone().union(other.clone())
+    }
+}
+
+impl<K, V, S> Sum for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn sum<I>(it: I) -> Self
+    where
+        I: Iterator<Item = Self>,
+    {
+        it.fold(Self::default(), |a, b| a + b)
+    }
+}
+
+impl<K, V, S, RK, RV> Extend<(RK, RV)> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone + From<RK>,
+    V: Clone + From<RV>,
+    S: BuildHasher,
+{
+    fn extend<I>(&mut self, iter: I)
+    where
+        I: IntoIterator<Item = (RK, RV)>,
+    {
+        for (key, value) in iter {
+            self.insert(From::from(key), From::from(value));
+        }
+    }
+}
+
+impl<'a, BK, K, V, S> Index<&'a BK> for HashMap<K, V, S>
+where
+    BK: Hash + Eq + ?Sized,
+    K: Hash + Eq + Borrow<BK>,
+    S: BuildHasher,
+{
+    type Output = V;
+
+    fn index(&self, key: &BK) -> &Self::Output {
+        match self.root.get(hash_key(&*self.hasher, key), 0, key) {
+            None => panic!("HashMap::index: invalid key"),
+            Some(&(_, ref value)) => value,
+        }
+    }
+}
+
+impl<'a, BK, K, V, S> IndexMut<&'a BK> for HashMap<K, V, S>
+where
+    BK: Hash + Eq + ?Sized,
+    K: Hash + Eq + Clone + Borrow<BK>,
+    V: Clone,
+    S: BuildHasher,
+{
+    fn index_mut(&mut self, key: &BK) -> &mut Self::Output {
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        match root.get_mut(&self.pool.0, hash_key(&*self.hasher, key), 0, key) {
+            None => panic!("HashMap::index_mut: invalid key"),
+            Some(&mut (_, ref mut value)) => value,
+        }
+    }
+}
+
+#[cfg(not(has_specialisation))]
+impl<K, V, S> Debug for HashMap<K, V, S>
+where
+    K: Hash + Eq + Debug,
+    V: Debug,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let mut d = f.debug_map();
+        for (k, v) in self {
+            d.entry(k, v);
+        }
+        d.finish()
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V, S> Debug for HashMap<K, V, S>
+where
+    K: Hash + Eq + Debug,
+    V: Debug,
+    S: BuildHasher,
+{
+    default fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let mut d = f.debug_map();
+        for (k, v) in self {
+            d.entry(k, v);
+        }
+        d.finish()
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V, S> Debug for HashMap<K, V, S>
+where
+    K: Hash + Eq + Ord + Debug,
+    V: Debug,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let mut keys = collections::BTreeSet::new();
+        keys.extend(self.keys());
+        let mut d = f.debug_map();
+        for key in keys {
+            d.entry(key, &self[key]);
+        }
+        d.finish()
+    }
+}
+
+// // Iterators
+
+/// An iterator over the elements of a map.
+pub struct Iter<'a, K, V> {
+    it: NodeIter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for Iter<'a, K, V> {
+    type Item = (&'a K, &'a V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|((k, v), _)| (k, v))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Iter<'a, K, V> {}
+
+/// A mutable iterator over the elements of a map.
+pub struct IterMut<'a, K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+    it: NodeIterMut<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for IterMut<'a, K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+    type Item = (&'a K, &'a mut V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|((k, v), _)| (&*k, v))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+}
+
+impl<'a, K, V> FusedIterator for IterMut<'a, K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+}
+
+/// A consuming iterator over the elements of a map.
+pub struct ConsumingIter<A: HashValue> {
+    it: NodeDrain<A>,
+}
+
+impl<A> Iterator for ConsumingIter<A>
+where
+    A: HashValue + Clone,
+{
+    type Item = A;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|(p, _)| p)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<A> ExactSizeIterator for ConsumingIter<A> where A: HashValue + Clone {}
+
+impl<A> FusedIterator for ConsumingIter<A> where A: HashValue + Clone {}
+
+/// An iterator over the keys of a map.
+pub struct Keys<'a, K, V> {
+    it: NodeIter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for Keys<'a, K, V> {
+    type Item = &'a K;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|((k, _), _)| k)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
+
+/// An iterator over the values of a map.
+pub struct Values<'a, K, V> {
+    it: NodeIter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for Values<'a, K, V> {
+    type Item = &'a V;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|((_, v), _)| v)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Values<'a, K, V> {}
+
+impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>
+where
+    K: Hash + Eq,
+    S: BuildHasher,
+{
+    type Item = (&'a K, &'a V);
+    type IntoIter = Iter<'a, K, V>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<K, V, S> IntoIterator for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher,
+{
+    type Item = (K, V);
+    type IntoIter = ConsumingIter<(K, V)>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        ConsumingIter {
+            it: NodeDrain::new(&self.pool.0, self.root, self.size),
+        }
+    }
+}
+
+// Conversions
+
+impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn from_iter<T>(i: T) -> Self
+    where
+        T: IntoIterator<Item = (K, V)>,
+    {
+        let mut map = Self::default();
+        for (k, v) in i {
+            map.insert(k, v);
+        }
+        map
+    }
+}
+
+impl<K, V, S> AsRef<HashMap<K, V, S>> for HashMap<K, V, S> {
+    #[inline]
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
+impl<'m, 'k, 'v, K, V, OK, OV, SA, SB> From<&'m HashMap<&'k K, &'v V, SA>> for HashMap<OK, OV, SB>
+where
+    K: Hash + Eq + ToOwned<Owned = OK> + ?Sized,
+    V: ToOwned<Owned = OV> + ?Sized,
+    OK: Hash + Eq + Clone + Borrow<K>,
+    OV: Borrow<V> + Clone,
+    SA: BuildHasher,
+    SB: BuildHasher + Default,
+{
+    fn from(m: &HashMap<&K, &V, SA>) -> Self {
+        m.iter()
+            .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
+            .collect()
+    }
+}
+
+impl<'a, K, V, S> From<&'a [(K, V)]> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn from(m: &'a [(K, V)]) -> Self {
+        m.iter().cloned().collect()
+    }
+}
+
+impl<K, V, S> From<Vec<(K, V)>> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn from(m: Vec<(K, V)>) -> Self {
+        m.into_iter().collect()
+    }
+}
+
+impl<'a, K, V, S> From<&'a Vec<(K, V)>> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn from(m: &'a Vec<(K, V)>) -> Self {
+        m.iter().cloned().collect()
+    }
+}
+
+impl<K, V, S> From<collections::HashMap<K, V>> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn from(m: collections::HashMap<K, V>) -> Self {
+        m.into_iter().collect()
+    }
+}
+
+impl<'a, K, V, S> From<&'a collections::HashMap<K, V>> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn from(m: &'a collections::HashMap<K, V>) -> Self {
+        m.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
+    }
+}
+
+impl<K, V, S> From<collections::BTreeMap<K, V>> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn from(m: collections::BTreeMap<K, V>) -> Self {
+        m.into_iter().collect()
+    }
+}
+
+impl<'a, K, V, S> From<&'a collections::BTreeMap<K, V>> for HashMap<K, V, S>
+where
+    K: Hash + Eq + Clone,
+    V: Clone,
+    S: BuildHasher + Default,
+{
+    fn from(m: &'a collections::BTreeMap<K, V>) -> Self {
+        m.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
+    }
+}
+
+// impl<K: Ord + Hash + Eq, V, S> From<OrdMap<K, V>> for HashMap<K, V, S>
+// where
+//     S: BuildHasher + Default,
+// {
+//     fn from(m: OrdMap<K, V>) -> Self {
+//         m.into_iter().collect()
+//     }
+// }
+
+// impl<'a, K: Ord + Hash + Eq, V, S> From<&'a OrdMap<K, V>> for HashMap<K, V, S>
+// where
+//     S: BuildHasher + Default,
+// {
+//     fn from(m: &'a OrdMap<K, V>) -> Self {
+//         m.into_iter().collect()
+//     }
+// }
+
+// Proptest
+#[cfg(any(test, feature = "proptest"))]
+#[doc(hidden)]
+pub mod proptest {
+    #[deprecated(
+        since = "14.3.0",
+        note = "proptest strategies have moved to im::proptest"
+    )]
+    pub use crate::proptest::hash_map;
+}
+
+// Tests
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::test::LolHasher;
+    use ::proptest::num::{i16, usize};
+    use ::proptest::{collection, proptest};
+    use std::hash::BuildHasherDefault;
+
+    #[test]
+    fn safe_mutation() {
+        let v1: HashMap<usize, usize> = (0..131_072).map(|i| (i, i)).collect::<HashMap<_, _>>();
+        let mut v2 = v1.clone();
+        v2.insert(131_000, 23);
+        assert_eq!(Some(&23), v2.get(&131_000));
+        assert_eq!(Some(&131_000), v1.get(&131_000));
+    }
+
+    #[test]
+    fn index_operator() {
+        let mut map = hashmap![1 => 2, 3 => 4, 5 => 6];
+        assert_eq!(4, map[&3]);
+        map[&3] = 8;
+        assert_eq!(hashmap![1 => 2, 3 => 8, 5 => 6], map);
+    }
+
+    #[test]
+    fn proper_formatting() {
+        let map = hashmap![1 => 2];
+        assert_eq!("{1: 2}", format!("{:?}", map));
+
+        assert_eq!("{}", format!("{:?}", HashMap::<(), ()>::new()));
+    }
+
+    #[test]
+    fn remove_failing() {
+        let pairs = [(1469, 0), (-67, 0)];
+        let mut m: collections::HashMap<i16, i16, _> =
+            collections::HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+        for &(ref k, ref v) in &pairs {
+            m.insert(*k, *v);
+        }
+        let mut map: HashMap<i16, i16, _> =
+            HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+        for (k, v) in &m {
+            map = map.update(*k, *v);
+        }
+        for k in m.keys() {
+            let l = map.len();
+            assert_eq!(m.get(k).cloned(), map.get(k).cloned());
+            map = map.without(k);
+            assert_eq!(None, map.get(k));
+            assert_eq!(l - 1, map.len());
+        }
+    }
+
+    #[test]
+    fn match_string_keys_with_string_slices() {
+        let mut map: HashMap<String, i32> =
+            From::from(&hashmap! { "foo" => &1, "bar" => &2, "baz" => &3 });
+        assert_eq!(Some(&1), map.get("foo"));
+        map = map.without("foo");
+        assert_eq!(Some(3), map.remove("baz"));
+        map["bar"] = 8;
+        assert_eq!(8, map["bar"]);
+    }
+
+    #[test]
+    fn macro_allows_trailing_comma() {
+        let map1 = hashmap! {"x" => 1, "y" => 2};
+        let map2 = hashmap! {
+            "x" => 1,
+            "y" => 2,
+        };
+        assert_eq!(map1, map2);
+    }
+
+    #[test]
+    fn remove_top_level_collisions() {
+        let pairs = vec![9, 2569, 27145];
+        let mut map: HashMap<i16, i16, BuildHasherDefault<LolHasher>> = Default::default();
+        for k in pairs.clone() {
+            map.insert(k, k);
+        }
+        assert_eq!(pairs.len(), map.len());
+        let keys: Vec<_> = map.keys().cloned().collect();
+        for k in keys {
+            let l = map.len();
+            assert_eq!(Some(&k), map.get(&k));
+            map.remove(&k);
+            assert_eq!(None, map.get(&k));
+            assert_eq!(l - 1, map.len());
+        }
+    }
+
+    #[test]
+    fn entry_api() {
+        let mut map = hashmap! {"bar" => 5};
+        map.entry("foo").and_modify(|v| *v += 5).or_insert(1);
+        assert_eq!(1, map[&"foo"]);
+        map.entry("foo").and_modify(|v| *v += 5).or_insert(1);
+        assert_eq!(6, map[&"foo"]);
+        map.entry("bar").and_modify(|v| *v += 5).or_insert(1);
+        assert_eq!(10, map[&"bar"]);
+        assert_eq!(
+            10,
+            match map.entry("bar") {
+                Entry::Occupied(entry) => entry.remove(),
+                _ => panic!(),
+            }
+        );
+        assert!(!map.contains_key(&"bar"));
+    }
+
+    #[test]
+    fn refpool_crash() {
+        let _map = HashMap::<u128, usize>::new();
+    }
+
+    #[test]
+    fn large_map() {
+        let mut map = HashMap::new();
+        let size = 32769;
+        for i in 0..size {
+            map.insert(i, i);
+        }
+        assert_eq!(size, map.len());
+        for i in 0..size {
+            assert_eq!(Some(&i), map.get(&i));
+        }
+    }
+
+    proptest! {
+        #[test]
+        fn update_and_length(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+            let mut map: HashMap<i16, i16, BuildHasherDefault<LolHasher>> = Default::default();
+            for (index, (k, v)) in m.iter().enumerate() {
+                map = map.update(*k, *v);
+                assert_eq!(Some(v), map.get(k));
+                assert_eq!(index + 1, map.len());
+            }
+        }
+
+        #[test]
+        fn from_iterator(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+            let map: HashMap<i16, i16> =
+                FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            assert_eq!(m.len(), map.len());
+        }
+
+        #[test]
+        fn iterate_over(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+            let map: HashMap<i16, i16> = FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            assert_eq!(m.len(), map.iter().count());
+        }
+
+        #[test]
+        fn equality(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+            let map1: HashMap<i16, i16> = FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            let map2: HashMap<i16, i16> = FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            assert_eq!(map1, map2);
+        }
+
+        #[test]
+        fn lookup(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+            let map: HashMap<i16, i16> = FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            for (k, v) in m {
+                assert_eq!(Some(*v), map.get(k).cloned());
+            }
+        }
+
+        #[test]
+        fn without(ref pairs in collection::vec((i16::ANY, i16::ANY), 0..100)) {
+            let mut m: collections::HashMap<i16, i16, _> =
+                collections::HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+            for &(ref k, ref v) in pairs {
+                m.insert(*k, *v);
+            }
+            let mut map: HashMap<i16, i16, _> = HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+            for (k, v) in &m {
+                map = map.update(*k, *v);
+            }
+            for k in m.keys() {
+                let l = map.len();
+                assert_eq!(m.get(k).cloned(), map.get(k).cloned());
+                map = map.without(k);
+                assert_eq!(None, map.get(k));
+                assert_eq!(l - 1, map.len());
+            }
+        }
+
+        #[test]
+        fn insert(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+            let mut mut_map: HashMap<i16, i16, BuildHasherDefault<LolHasher>> = Default::default();
+            let mut map: HashMap<i16, i16, BuildHasherDefault<LolHasher>> = Default::default();
+            for (count, (k, v)) in m.iter().enumerate() {
+                map = map.update(*k, *v);
+                mut_map.insert(*k, *v);
+                assert_eq!(count + 1, map.len());
+                assert_eq!(count + 1, mut_map.len());
+            }
+            assert_eq!(map, mut_map);
+        }
+
+        #[test]
+        fn remove(ref pairs in collection::vec((i16::ANY, i16::ANY), 0..100)) {
+            let mut m: collections::HashMap<i16, i16, _> =
+                collections::HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+            for &(ref k, ref v) in pairs {
+                m.insert(*k, *v);
+            }
+            let mut map: HashMap<i16, i16, _> = HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+            for (k, v) in &m {
+                map.insert(*k, *v);
+            }
+            for k in m.keys() {
+                let l = map.len();
+                assert_eq!(m.get(k).cloned(), map.get(k).cloned());
+                map.remove(k);
+                assert_eq!(None, map.get(k));
+                assert_eq!(l - 1, map.len());
+            }
+        }
+
+        #[test]
+        fn delete_and_reinsert(
+            ref input in collection::hash_map(i16::ANY, i16::ANY, 1..100),
+            index_rand in usize::ANY
+        ) {
+            let index = *input.keys().nth(index_rand % input.len()).unwrap();
+            let map1: HashMap<_, _> = HashMap::from_iter(input.clone());
+            let (val, map2) = map1.extract(&index).unwrap();
+            let map3 = map2.update(index, val);
+            for key in map2.keys() {
+                assert!(*key != index);
+            }
+            assert_eq!(map1.len(), map2.len() + 1);
+            assert_eq!(map1, map3);
+        }
+
+        #[test]
+        fn proptest_works(ref m in proptest::hash_map(0..9999, ".*", 10..100)) {
+            assert!(m.len() < 100);
+            assert!(m.len() >= 10);
+        }
+
+        #[test]
+        fn exact_size_iterator(ref m in proptest::hash_map(i16::ANY, i16::ANY, 0..100)) {
+            let mut should_be = m.len();
+            let mut it = m.iter();
+            loop {
+                assert_eq!(should_be, it.len());
+                match it.next() {
+                    None => break,
+                    Some(_) => should_be -= 1,
+                }
+            }
+            assert_eq!(0, it.len());
+        }
+    }
+}
diff --git a/vendor/im-rc/src/hash/mod.rs b/vendor/im-rc/src/hash/mod.rs
new file mode 100644
index 000000000..27a56a5e2
--- /dev/null
+++ b/vendor/im-rc/src/hash/mod.rs
@@ -0,0 +1,8 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#[macro_use]
+pub mod map;
+#[macro_use]
+pub mod set;
diff --git a/vendor/im-rc/src/hash/set.rs b/vendor/im-rc/src/hash/set.rs
new file mode 100644
index 000000000..edc4ad60c
--- /dev/null
+++ b/vendor/im-rc/src/hash/set.rs
@@ -0,0 +1,1134 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! An unordered set.
+//!
+//! An immutable hash set using [hash array mapped tries] [1].
+//!
+//! Most operations on this set are O(log<sub>x</sub> n) for a
+//! suitably high *x* that it should be nearly O(1) for most sets.
+//! Because of this, it's a great choice for a generic set as long as
+//! you don't mind that values will need to implement
+//! [`Hash`][std::hash::Hash] and [`Eq`][std::cmp::Eq].
+//!
+//! Values will have a predictable order based on the hasher
+//! being used. Unless otherwise specified, this will be the standard
+//! [`RandomState`][std::collections::hash_map::RandomState] hasher.
+//!
+//! [1]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie
+//! [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
+//! [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html
+//! [std::collections::hash_map::RandomState]: https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html
+
+use std::borrow::Borrow;
+use std::cmp::Ordering;
+use std::collections::hash_map::RandomState;
+use std::collections::{self, BTreeSet};
+use std::fmt::{Debug, Error, Formatter};
+use std::hash::{BuildHasher, Hash, Hasher};
+use std::iter::FusedIterator;
+use std::iter::{FromIterator, IntoIterator, Sum};
+use std::ops::{Add, Deref, Mul};
+
+use crate::nodes::hamt::{hash_key, Drain as NodeDrain, HashValue, Iter as NodeIter, Node};
+use crate::ordset::OrdSet;
+use crate::util::{Pool, PoolRef, Ref};
+use crate::Vector;
+
+/// Construct a set from a sequence of values.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::hashset::HashSet;
+/// # fn main() {
+/// assert_eq!(
+///   hashset![1, 2, 3],
+///   HashSet::from(vec![1, 2, 3])
+/// );
+/// # }
+/// ```
+#[macro_export]
+macro_rules! hashset {
+    () => { $crate::hashset::HashSet::new() };
+
+    ( $($x:expr),* ) => {{
+        let mut l = $crate::hashset::HashSet::new();
+        $(
+            l.insert($x);
+        )*
+            l
+    }};
+
+    ( $($x:expr ,)* ) => {{
+        let mut l = $crate::hashset::HashSet::new();
+        $(
+            l.insert($x);
+        )*
+            l
+    }};
+}
+
+def_pool!(HashSetPool<A>, Node<Value<A>>);
+
+/// An unordered set.
+///
+/// An immutable hash set using [hash array mapped tries] [1].
+///
+/// Most operations on this set are O(log<sub>x</sub> n) for a
+/// suitably high *x* that it should be nearly O(1) for most sets.
+/// Because of this, it's a great choice for a generic set as long as
+/// you don't mind that values will need to implement
+/// [`Hash`][std::hash::Hash] and [`Eq`][std::cmp::Eq].
+///
+/// Values will have a predictable order based on the hasher
+/// being used. Unless otherwise specified, this will be the standard
+/// [`RandomState`][std::collections::hash_map::RandomState] hasher.
+///
+/// [1]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie
+/// [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
+/// [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html
+/// [std::collections::hash_map::RandomState]: https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html
+pub struct HashSet<A, S = RandomState> {
+    hasher: Ref<S>,
+    pool: HashSetPool<A>,
+    root: PoolRef<Node<Value<A>>>,
+    size: usize,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+struct Value<A>(A);
+
+impl<A> Deref for Value<A> {
+    type Target = A;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+// FIXME lacking specialisation, we can't simply implement `HashValue`
+// for `A`, we have to use the `Value<A>` indirection.
+impl<A> HashValue for Value<A>
+where
+    A: Hash + Eq,
+{
+    type Key = A;
+
+    fn extract_key(&self) -> &Self::Key {
+        &self.0
+    }
+
+    fn ptr_eq(&self, _other: &Self) -> bool {
+        false
+    }
+}
+
+impl<A> HashSet<A, RandomState> {
+    /// Construct an empty set.
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Construct an empty set using a specific memory pool.
+    #[cfg(feature = "pool")]
+    #[must_use]
+    pub fn with_pool(pool: &HashSetPool<A>) -> Self {
+        Self {
+            pool: pool.clone(),
+            hasher: Default::default(),
+            size: 0,
+            root: PoolRef::default(&pool.0),
+        }
+    }
+}
+
+impl<A> HashSet<A, RandomState>
+where
+    A: Hash + Eq + Clone,
+{
+    /// Construct a set with a single value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashset::HashSet;
+    /// # use std::sync::Arc;
+    /// let set = HashSet::unit(123);
+    /// assert!(set.contains(&123));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn unit(a: A) -> Self {
+        HashSet::new().update(a)
+    }
+}
+
+impl<A, S> HashSet<A, S> {
+    /// Test whether a set is empty.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashset::HashSet;
+    /// assert!(
+    ///   !hashset![1, 2, 3].is_empty()
+    /// );
+    /// assert!(
+    ///   HashSet::<i32>::new().is_empty()
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Get the size of a set.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashset::HashSet;
+    /// assert_eq!(3, hashset![1, 2, 3].len());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.size
+    }
+
+    /// Test whether two sets refer to the same content in memory.
+    ///
+    /// This is true if the two sides are references to the same set,
+    /// or if the two sets refer to the same root node.
+    ///
+    /// This would return true if you're comparing a set to itself, or
+    /// if you're comparing a set to a fresh clone of itself.
+    ///
+    /// Time: O(1)
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        std::ptr::eq(self, other) || PoolRef::ptr_eq(&self.root, &other.root)
+    }
+
+    /// Get a reference to the memory pool used by this set.
+    ///
+    /// Note that if you didn't specifically construct it with a pool, you'll
+    /// get back a reference to a pool of size 0.
+    #[cfg(feature = "pool")]
+    pub fn pool(&self) -> &HashSetPool<A> {
+        &self.pool
+    }
+
+    /// Construct an empty hash set using the provided hasher.
+    #[inline]
+    #[must_use]
+    pub fn with_hasher<RS>(hasher: RS) -> Self
+    where
+        Ref<S>: From<RS>,
+    {
+        let pool = HashSetPool::default();
+        let root = PoolRef::default(&pool.0);
+        HashSet {
+            size: 0,
+            pool,
+            root,
+            hasher: From::from(hasher),
+        }
+    }
+
+    /// Construct an empty hash set using the provided memory pool and hasher.
+    #[cfg(feature = "pool")]
+    #[inline]
+    #[must_use]
+    pub fn with_pool_hasher<RS>(pool: &HashSetPool<A>, hasher: RS) -> Self
+    where
+        Ref<S>: From<RS>,
+    {
+        let root = PoolRef::default(&pool.0);
+        HashSet {
+            size: 0,
+            pool: pool.clone(),
+            root,
+            hasher: From::from(hasher),
+        }
+    }
+
+    /// Get a reference to the set's [`BuildHasher`][BuildHasher].
+    ///
+    /// [BuildHasher]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html
+    #[must_use]
+    pub fn hasher(&self) -> &Ref<S> {
+        &self.hasher
+    }
+
+    /// Construct an empty hash set using the same hasher as the current hash set.
+    #[inline]
+    #[must_use]
+    pub fn new_from<A1>(&self) -> HashSet<A1, S>
+    where
+        A1: Hash + Eq + Clone,
+    {
+        let pool = HashSetPool::default();
+        let root = PoolRef::default(&pool.0);
+        HashSet {
+            size: 0,
+            pool,
+            root,
+            hasher: self.hasher.clone(),
+        }
+    }
+
+    /// Discard all elements from the set.
+    ///
+    /// This leaves you with an empty set, and all elements that
+    /// were previously inside it are dropped.
+    ///
+    /// Time: O(n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::HashSet;
+    /// let mut set = hashset![1, 2, 3];
+    /// set.clear();
+    /// assert!(set.is_empty());
+    /// ```
+    pub fn clear(&mut self) {
+        if !self.is_empty() {
+            self.root = PoolRef::default(&self.pool.0);
+            self.size = 0;
+        }
+    }
+
+    /// Get an iterator over the values in a hash set.
+    ///
+    /// Please note that the order is consistent between sets using
+    /// the same hasher, but no other ordering guarantee is offered.
+    /// Items will not come out in insertion order or sort order.
+    /// They will, however, come out in the same order every time for
+    /// the same set.
+    #[must_use]
+    pub fn iter(&self) -> Iter<'_, A> {
+        Iter {
+            it: NodeIter::new(&self.root, self.size),
+        }
+    }
+}
+
+impl<A, S> HashSet<A, S>
+where
+    A: Hash + Eq,
+    S: BuildHasher,
+{
+    fn test_eq(&self, other: &Self) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+        let mut seen = collections::HashSet::new();
+        for value in self.iter() {
+            if !other.contains(value) {
+                return false;
+            }
+            seen.insert(value);
+        }
+        for value in other.iter() {
+            if !seen.contains(&value) {
+                return false;
+            }
+        }
+        true
+    }
+
+    /// Test if a value is part of a set.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn contains<BA>(&self, a: &BA) -> bool
+    where
+        BA: Hash + Eq + ?Sized,
+        A: Borrow<BA>,
+    {
+        self.root.get(hash_key(&*self.hasher, a), 0, a).is_some()
+    }
+
+    /// Test whether a set is a subset of another set, meaning that
+    /// all values in our set must also be in the other set.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn is_subset<RS>(&self, other: RS) -> bool
+    where
+        RS: Borrow<Self>,
+    {
+        let o = other.borrow();
+        self.iter().all(|a| o.contains(a))
+    }
+
+    /// Test whether a set is a proper subset of another set, meaning
+    /// that all values in our set must also be in the other set. A
+    /// proper subset must also be smaller than the other set.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn is_proper_subset<RS>(&self, other: RS) -> bool
+    where
+        RS: Borrow<Self>,
+    {
+        self.len() != other.borrow().len() && self.is_subset(other)
+    }
+}
+
+impl<A, S> HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher,
+{
+    /// Insert a value into a set.
+    ///
+    /// Time: O(log n)
+    #[inline]
+    pub fn insert(&mut self, a: A) -> Option<A> {
+        let hash = hash_key(&*self.hasher, &a);
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        match root.insert(&self.pool.0, hash, 0, Value(a)) {
+            None => {
+                self.size += 1;
+                None
+            }
+            Some(Value(old_value)) => Some(old_value),
+        }
+    }
+
+    /// Remove a value from a set if it exists.
+    ///
+    /// Time: O(log n)
+    pub fn remove<BA>(&mut self, a: &BA) -> Option<A>
+    where
+        BA: Hash + Eq + ?Sized,
+        A: Borrow<BA>,
+    {
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        let result = root.remove(&self.pool.0, hash_key(&*self.hasher, a), 0, a);
+        if result.is_some() {
+            self.size -= 1;
+        }
+        result.map(|v| v.0)
+    }
+
+    /// Construct a new set from the current set with the given value
+    /// added.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashset::HashSet;
+    /// # use std::sync::Arc;
+    /// let set = hashset![123];
+    /// assert_eq!(
+    ///   set.update(456),
+    ///   hashset![123, 456]
+    /// );
+    /// ```
+    #[must_use]
+    pub fn update(&self, a: A) -> Self {
+        let mut out = self.clone();
+        out.insert(a);
+        out
+    }
+
+    /// Construct a new set with the given value removed if it's in
+    /// the set.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn without<BA>(&self, a: &BA) -> Self
+    where
+        BA: Hash + Eq + ?Sized,
+        A: Borrow<BA>,
+    {
+        let mut out = self.clone();
+        out.remove(a);
+        out
+    }
+
+    /// Filter out values from a set which don't satisfy a predicate.
+    ///
+    /// This is slightly more efficient than filtering using an
+    /// iterator, in that it doesn't need to rehash the retained
+    /// values, but it still needs to reconstruct the entire tree
+    /// structure of the set.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::HashSet;
+    /// let mut set = hashset![1, 2, 3];
+    /// set.retain(|v| *v > 1);
+    /// let expected = hashset![2, 3];
+    /// assert_eq!(expected, set);
+    /// ```
+    pub fn retain<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&A) -> bool,
+    {
+        let old_root = self.root.clone();
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        for (value, hash) in NodeIter::new(&old_root, self.size) {
+            if !f(value) && root.remove(&self.pool.0, hash, 0, value).is_some() {
+                self.size -= 1;
+            }
+        }
+    }
+
+    /// Construct the union of two sets.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashset::HashSet;
+    /// let set1 = hashset!{1, 2};
+    /// let set2 = hashset!{2, 3};
+    /// let expected = hashset!{1, 2, 3};
+    /// assert_eq!(expected, set1.union(set2));
+    /// ```
+    #[must_use]
+    pub fn union(self, other: Self) -> Self {
+        let (mut to_mutate, to_consume) = if self.len() >= other.len() {
+            (self, other)
+        } else {
+            (other, self)
+        };
+        for value in to_consume {
+            to_mutate.insert(value);
+        }
+        to_mutate
+    }
+
+    /// Construct the union of multiple sets.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn unions<I>(i: I) -> Self
+    where
+        I: IntoIterator<Item = Self>,
+        S: Default,
+    {
+        i.into_iter().fold(Self::default(), Self::union)
+    }
+
+    /// Construct the symmetric difference between two sets.
+    ///
+    /// This is an alias for the
+    /// [`symmetric_difference`][symmetric_difference] method.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashset::HashSet;
+    /// let set1 = hashset!{1, 2};
+    /// let set2 = hashset!{2, 3};
+    /// let expected = hashset!{1, 3};
+    /// assert_eq!(expected, set1.difference(set2));
+    /// ```
+    ///
+    /// [symmetric_difference]: #method.symmetric_difference
+    #[must_use]
+    pub fn difference(self, other: Self) -> Self {
+        self.symmetric_difference(other)
+    }
+
+    /// Construct the symmetric difference between two sets.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashset::HashSet;
+    /// let set1 = hashset!{1, 2};
+    /// let set2 = hashset!{2, 3};
+    /// let expected = hashset!{1, 3};
+    /// assert_eq!(expected, set1.symmetric_difference(set2));
+    /// ```
+    #[must_use]
+    pub fn symmetric_difference(mut self, other: Self) -> Self {
+        for value in other {
+            if self.remove(&value).is_none() {
+                self.insert(value);
+            }
+        }
+        self
+    }
+
+    /// Construct the relative complement between two sets, that is the set
+    /// of values in `self` that do not occur in `other`.
+    ///
+    /// Time: O(m log n) where m is the size of the other set
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let set1 = ordset!{1, 2};
+    /// let set2 = ordset!{2, 3};
+    /// let expected = ordset!{1};
+    /// assert_eq!(expected, set1.relative_complement(set2));
+    /// ```
+    #[must_use]
+    pub fn relative_complement(mut self, other: Self) -> Self {
+        for value in other {
+            let _ = self.remove(&value);
+        }
+        self
+    }
+
+    /// Construct the intersection of two sets.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::hashset::HashSet;
+    /// let set1 = hashset!{1, 2};
+    /// let set2 = hashset!{2, 3};
+    /// let expected = hashset!{2};
+    /// assert_eq!(expected, set1.intersection(set2));
+    /// ```
+    #[must_use]
+    pub fn intersection(self, other: Self) -> Self {
+        let mut out = self.new_from();
+        for value in other {
+            if self.contains(&value) {
+                out.insert(value);
+            }
+        }
+        out
+    }
+}
+
+// Core traits
+
+impl<A, S> Clone for HashSet<A, S>
+where
+    A: Clone,
+{
+    /// Clone a set.
+    ///
+    /// Time: O(1)
+    #[inline]
+    fn clone(&self) -> Self {
+        HashSet {
+            hasher: self.hasher.clone(),
+            pool: self.pool.clone(),
+            root: self.root.clone(),
+            size: self.size,
+        }
+    }
+}
+
+impl<A, S> PartialEq for HashSet<A, S>
+where
+    A: Hash + Eq,
+    S: BuildHasher + Default,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.test_eq(other)
+    }
+}
+
+impl<A, S> Eq for HashSet<A, S>
+where
+    A: Hash + Eq,
+    S: BuildHasher + Default,
+{
+}
+
+impl<A, S> PartialOrd for HashSet<A, S>
+where
+    A: Hash + Eq + Clone + PartialOrd,
+    S: BuildHasher + Default,
+{
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        if Ref::ptr_eq(&self.hasher, &other.hasher) {
+            return self.iter().partial_cmp(other.iter());
+        }
+        self.iter().partial_cmp(other.iter())
+    }
+}
+
+impl<A, S> Ord for HashSet<A, S>
+where
+    A: Hash + Eq + Clone + Ord,
+    S: BuildHasher + Default,
+{
+    fn cmp(&self, other: &Self) -> Ordering {
+        if Ref::ptr_eq(&self.hasher, &other.hasher) {
+            return self.iter().cmp(other.iter());
+        }
+        self.iter().cmp(other.iter())
+    }
+}
+
+impl<A, S> Hash for HashSet<A, S>
+where
+    A: Hash + Eq,
+    S: BuildHasher + Default,
+{
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        for i in self.iter() {
+            i.hash(state);
+        }
+    }
+}
+
+impl<A, S> Default for HashSet<A, S>
+where
+    S: BuildHasher + Default,
+{
+    fn default() -> Self {
+        let pool = HashSetPool::default();
+        let root = PoolRef::default(&pool.0);
+        HashSet {
+            hasher: Ref::<S>::default(),
+            pool,
+            root,
+            size: 0,
+        }
+    }
+}
+
+impl<A, S> Add for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher,
+{
+    type Output = HashSet<A, S>;
+
+    fn add(self, other: Self) -> Self::Output {
+        self.union(other)
+    }
+}
+
+impl<A, S> Mul for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher,
+{
+    type Output = HashSet<A, S>;
+
+    fn mul(self, other: Self) -> Self::Output {
+        self.intersection(other)
+    }
+}
+
+impl<'a, A, S> Add for &'a HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher,
+{
+    type Output = HashSet<A, S>;
+
+    fn add(self, other: Self) -> Self::Output {
+        self.clone().union(other.clone())
+    }
+}
+
+impl<'a, A, S> Mul for &'a HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher,
+{
+    type Output = HashSet<A, S>;
+
+    fn mul(self, other: Self) -> Self::Output {
+        self.clone().intersection(other.clone())
+    }
+}
+
+impl<A, S> Sum for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn sum<I>(it: I) -> Self
+    where
+        I: Iterator<Item = Self>,
+    {
+        it.fold(Self::default(), |a, b| a + b)
+    }
+}
+
+impl<A, S, R> Extend<R> for HashSet<A, S>
+where
+    A: Hash + Eq + Clone + From<R>,
+    S: BuildHasher,
+{
+    fn extend<I>(&mut self, iter: I)
+    where
+        I: IntoIterator<Item = R>,
+    {
+        for value in iter {
+            self.insert(From::from(value));
+        }
+    }
+}
+
+#[cfg(not(has_specialisation))]
+impl<A, S> Debug for HashSet<A, S>
+where
+    A: Hash + Eq + Debug,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        f.debug_set().entries(self.iter()).finish()
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<A, S> Debug for HashSet<A, S>
+where
+    A: Hash + Eq + Debug,
+    S: BuildHasher,
+{
+    default fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        f.debug_set().entries(self.iter()).finish()
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<A, S> Debug for HashSet<A, S>
+where
+    A: Hash + Eq + Debug + Ord,
+    S: BuildHasher,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        f.debug_set().entries(self.iter()).finish()
+    }
+}
+
+// Iterators
+
+/// An iterator over the elements of a set.
+pub struct Iter<'a, A> {
+    it: NodeIter<'a, Value<A>>,
+}
+
+impl<'a, A> Iterator for Iter<'a, A>
+where
+    A: 'a,
+{
+    type Item = &'a A;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|(v, _)| &v.0)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
+
+impl<'a, A> FusedIterator for Iter<'a, A> {}
+
+/// A consuming iterator over the elements of a set.
+pub struct ConsumingIter<A>
+where
+    A: Hash + Eq + Clone,
+{
+    it: NodeDrain<Value<A>>,
+}
+
+impl<A> Iterator for ConsumingIter<A>
+where
+    A: Hash + Eq + Clone,
+{
+    type Item = A;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|(v, _)| v.0)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<A> ExactSizeIterator for ConsumingIter<A> where A: Hash + Eq + Clone {}
+
+impl<A> FusedIterator for ConsumingIter<A> where A: Hash + Eq + Clone {}
+
+// Iterator conversions
+
+impl<A, RA, S> FromIterator<RA> for HashSet<A, S>
+where
+    A: Hash + Eq + Clone + From<RA>,
+    S: BuildHasher + Default,
+{
+    fn from_iter<T>(i: T) -> Self
+    where
+        T: IntoIterator<Item = RA>,
+    {
+        let mut set = Self::default();
+        for value in i {
+            set.insert(From::from(value));
+        }
+        set
+    }
+}
+
+impl<'a, A, S> IntoIterator for &'a HashSet<A, S>
+where
+    A: Hash + Eq,
+    S: BuildHasher,
+{
+    type Item = &'a A;
+    type IntoIter = Iter<'a, A>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<A, S> IntoIterator for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher,
+{
+    type Item = A;
+    type IntoIter = ConsumingIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ConsumingIter {
+            it: NodeDrain::new(&self.pool.0, self.root, self.size),
+        }
+    }
+}
+
+// Conversions
+
+impl<'s, 'a, A, OA, SA, SB> From<&'s HashSet<&'a A, SA>> for HashSet<OA, SB>
+where
+    A: ToOwned<Owned = OA> + Hash + Eq + ?Sized,
+    OA: Borrow<A> + Hash + Eq + Clone,
+    SA: BuildHasher,
+    SB: BuildHasher + Default,
+{
+    fn from(set: &HashSet<&A, SA>) -> Self {
+        set.iter().map(|a| (*a).to_owned()).collect()
+    }
+}
+
+impl<'a, A, S> From<&'a [A]> for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(slice: &'a [A]) -> Self {
+        slice.iter().cloned().collect()
+    }
+}
+
+impl<A, S> From<Vec<A>> for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(vec: Vec<A>) -> Self {
+        vec.into_iter().collect()
+    }
+}
+
+impl<'a, A, S> From<&'a Vec<A>> for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(vec: &Vec<A>) -> Self {
+        vec.iter().cloned().collect()
+    }
+}
+
+impl<A, S> From<Vector<A>> for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(vector: Vector<A>) -> Self {
+        vector.into_iter().collect()
+    }
+}
+
+impl<'a, A, S> From<&'a Vector<A>> for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(vector: &Vector<A>) -> Self {
+        vector.iter().cloned().collect()
+    }
+}
+
+impl<A, S> From<collections::HashSet<A>> for HashSet<A, S>
+where
+    A: Eq + Hash + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(hash_set: collections::HashSet<A>) -> Self {
+        hash_set.into_iter().collect()
+    }
+}
+
+impl<'a, A, S> From<&'a collections::HashSet<A>> for HashSet<A, S>
+where
+    A: Eq + Hash + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(hash_set: &collections::HashSet<A>) -> Self {
+        hash_set.iter().cloned().collect()
+    }
+}
+
+impl<'a, A, S> From<&'a BTreeSet<A>> for HashSet<A, S>
+where
+    A: Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(btree_set: &BTreeSet<A>) -> Self {
+        btree_set.iter().cloned().collect()
+    }
+}
+
+impl<A, S> From<OrdSet<A>> for HashSet<A, S>
+where
+    A: Ord + Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(ordset: OrdSet<A>) -> Self {
+        ordset.into_iter().collect()
+    }
+}
+
+impl<'a, A, S> From<&'a OrdSet<A>> for HashSet<A, S>
+where
+    A: Ord + Hash + Eq + Clone,
+    S: BuildHasher + Default,
+{
+    fn from(ordset: &OrdSet<A>) -> Self {
+        ordset.into_iter().cloned().collect()
+    }
+}
+
+// Proptest
+#[cfg(any(test, feature = "proptest"))]
+#[doc(hidden)]
+pub mod proptest {
+    #[deprecated(
+        since = "14.3.0",
+        note = "proptest strategies have moved to im::proptest"
+    )]
+    pub use crate::proptest::hash_set;
+}
+
+#[cfg(test)]
+mod test {
+    use super::proptest::*;
+    use super::*;
+    use crate::test::LolHasher;
+    use ::proptest::num::i16;
+    use ::proptest::proptest;
+    use std::hash::BuildHasherDefault;
+
+    #[test]
+    fn insert_failing() {
+        let mut set: HashSet<i16, BuildHasherDefault<LolHasher>> = Default::default();
+        set.insert(14658);
+        assert_eq!(1, set.len());
+        set.insert(-19198);
+        assert_eq!(2, set.len());
+    }
+
+    #[test]
+    fn match_strings_with_string_slices() {
+        let mut set: HashSet<String> = From::from(&hashset!["foo", "bar"]);
+        set = set.without("bar");
+        assert!(!set.contains("bar"));
+        set.remove("foo");
+        assert!(!set.contains("foo"));
+    }
+
+    #[test]
+    fn macro_allows_trailing_comma() {
+        let set1 = hashset! {"foo", "bar"};
+        let set2 = hashset! {
+            "foo",
+            "bar",
+        };
+        assert_eq!(set1, set2);
+    }
+
+    #[test]
+    fn issue_60_drain_iterator_memory_corruption() {
+        use crate::test::MetroHashBuilder;
+        for i in 0..1000 {
+            let mut lhs = vec![0, 1, 2];
+            lhs.sort_unstable();
+
+            let hasher = Ref::from(MetroHashBuilder::new(i));
+            let mut iset: HashSet<_, MetroHashBuilder> = HashSet::with_hasher(hasher.clone());
+            for &i in &lhs {
+                iset.insert(i);
+            }
+
+            let mut rhs: Vec<_> = iset.clone().into_iter().collect();
+            rhs.sort_unstable();
+
+            if lhs != rhs {
+                println!("iteration: {}", i);
+                println!("seed: {}", hasher.seed());
+                println!("lhs: {}: {:?}", lhs.len(), &lhs);
+                println!("rhs: {}: {:?}", rhs.len(), &rhs);
+                panic!();
+            }
+        }
+    }
+
+    proptest! {
+        #[test]
+        fn proptest_a_set(ref s in hash_set(".*", 10..100)) {
+            assert!(s.len() < 100);
+            assert!(s.len() >= 10);
+        }
+    }
+}
diff --git a/vendor/im-rc/src/iter.rs b/vendor/im-rc/src/iter.rs
new file mode 100644
index 000000000..2327b8dd5
--- /dev/null
+++ b/vendor/im-rc/src/iter.rs
@@ -0,0 +1,42 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! Iterators over immutable data.
+
+/// Create an iterator of values using a function to update an owned state
+/// value.
+///
+/// The function is called with the current state as its argument, and should
+/// return an [`Option`][std::option::Option] of a tuple of the next value to
+/// yield from the iterator and the updated state. If the function returns
+/// [`None`][std::option::Option::None], the iterator ends.
+///
+/// # Examples
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::iter::unfold;
+/// # use im::vector::Vector;
+/// # use std::iter::FromIterator;
+/// // Create an infinite stream of numbers, starting at 0.
+/// let mut it = unfold(0, |i| Some((i, i + 1)));
+///
+/// // Make a list out of its first five elements.
+/// let numbers = Vector::from_iter(it.take(5));
+/// assert_eq!(numbers, vector![0, 1, 2, 3, 4]);
+/// ```
+///
+/// [std::option::Option]: https://doc.rust-lang.org/std/option/enum.Option.html
+/// [std::option::Option::None]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None
+pub fn unfold<F, S, A>(value: S, f: F) -> impl Iterator<Item = A>
+where
+    F: Fn(S) -> Option<(A, S)>,
+{
+    let mut value = Some(value);
+    std::iter::from_fn(move || {
+        f(value.take().unwrap()).map(|(next, state)| {
+            value = Some(state);
+            next
+        })
+    })
+}
diff --git a/vendor/im-rc/src/lib.rs b/vendor/im-rc/src/lib.rs
new file mode 100644
index 000000000..fa7a0a9eb
--- /dev/null
+++ b/vendor/im-rc/src/lib.rs
@@ -0,0 +1,507 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! # Immutable Data Structures for Rust
+//!
+//! This library implements several of the more commonly useful immutable data
+//! structures for Rust.
+//!
+//! ## What are immutable data structures?
+//!
+//! Immutable data structures are data structures which can be copied and
+//! modified efficiently without altering the original. The most uncomplicated
+//! example of this is the venerable [cons list][cons-list]. This crate offers a
+//! selection of more modern and flexible data structures with similar
+//! properties, tuned for the needs of Rust developers.
+//!
+//! Briefly, the following data structures are provided:
+//!
+//! * [Vectors][vector::Vector] based on [RRB trees][rrb-tree]
+//! * [Hash maps][hashmap::HashMap]/[sets][hashset::HashSet] based on [hash
+//!   array mapped tries][hamt]
+//! * [Ordered maps][ordmap::OrdMap]/[sets][ordset::OrdSet] based on
+//!   [B-trees][b-tree]
+//!
+//! ## Why Would I Want This?
+//!
+//! While immutable data structures can be a game changer for other
+//! programming languages, the most obvious benefit - avoiding the
+//! accidental mutation of data - is already handled so well by Rust's
+//! type system that it's just not something a Rust programmer needs
+//! to worry about even when using data structures that would send a
+//! conscientious Clojure programmer into a panic.
+//!
+//! Immutable data structures offer other benefits, though, some of
+//! which are useful even in a language like Rust. The most prominent
+//! is *structural sharing*, which means that if two data structures
+//! are mostly copies of each other, most of the memory they take up
+//! will be shared between them. This implies that making copies of an
+//! immutable data structure is cheap: it's really only a matter of
+//! copying a pointer and increasing a reference counter, where in the
+//! case of [`Vec`][std::vec::Vec] you have to allocate the same
+//! amount of memory all over again and make a copy of every element
+//! it contains. For immutable data structures, extra memory isn't
+//! allocated until you modify either the copy or the original, and
+//! then only the memory needed to record the difference.
+//!
+//! Another goal of this library has been the idea that you shouldn't
+//! even have to think about what data structure to use in any given
+//! situation, until the point where you need to start worrying about
+//! optimisation - which, in practice, often never comes. Beyond the
+//! shape of your data (ie. whether to use a list or a map), it should
+//! be fine not to think too carefully about data structures - you can
+//! just pick the one that has the right shape and it should have
+//! acceptable performance characteristics for every operation you
+//! might need. Specialised data structures will always be faster at
+//! what they've been specialised for, but `im` aims to provide the
+//! data structures which deliver the least chance of accidentally
+//! using them for the wrong thing.
+//!
+//! For instance, [`Vec`][std::vec::Vec] beats everything at memory
+//! usage, indexing and operations that happen at the back of the
+//! list, but is terrible at insertion and removal, and gets worse the
+//! closer to the front of the list you get.
+//! [`VecDeque`][std::collections::VecDeque] adds a little bit of
+//! complexity in order to make operations at the front as efficient
+//! as operations at the back, but is still bad at insertion and
+//! especially concatenation. [`Vector`][vector::Vector] adds another
+//! bit of complexity, and could never match [`Vec`][std::vec::Vec] at
+//! what it's best at, but in return every operation you can throw at
+//! it can be completed in a reasonable amount of time - even normally
+//! expensive operations like copying and especially concatenation are
+//! reasonably cheap when using a [`Vector`][vector::Vector].
+//!
+//! It should be noted, however, that because of its simplicity,
+//! [`Vec`][std::vec::Vec] actually beats [`Vector`][vector::Vector] even at its
+//! strongest operations at small sizes, just because modern CPUs are
+//! hyperoptimised for things like copying small chunks of contiguous memory -
+//! you actually need to go past a certain size (usually in the vicinity of
+//! several hundred elements) before you get to the point where
+//! [`Vec`][std::vec::Vec] isn't always going to be the fastest choice.
+//! [`Vector`][vector::Vector] attempts to overcome this by actually just being
+//! an array at very small sizes, and being able to switch efficiently to the
+//! full data structure when it grows large enough. Thus,
+//! [`Vector`][vector::Vector] will actually be equivalent to
+//! [Vec][std::vec::Vec] until it grows past the size of a single chunk.
+//!
+//! The maps - [`HashMap`][hashmap::HashMap] and
+//! [`OrdMap`][ordmap::OrdMap] - generally perform similarly to their
+//! equivalents in the standard library, but tend to run a bit slower
+//! on the basic operations ([`HashMap`][hashmap::HashMap] is almost
+//! neck and neck with its counterpart, while
+//! [`OrdMap`][ordmap::OrdMap] currently tends to run 2-3x slower). On
+//! the other hand, they offer the cheap copy and structural sharing
+//! between copies that you'd expect from immutable data structures.
+//!
+//! In conclusion, the aim of this library is to provide a safe
+//! default choice for the most common kinds of data structures,
+//! allowing you to defer careful thinking about the right data
+//! structure for the job until you need to start looking for
+//! optimisations - and you may find, especially for larger data sets,
+//! that immutable data structures are still the right choice.
+//!
+//! ## Values
+//!
+//! Because we need to make copies of shared nodes in these data structures
+//! before updating them, the values you store in them must implement
+//! [`Clone`][std::clone::Clone].  For primitive values that implement
+//! [`Copy`][std::marker::Copy], such as numbers, everything is fine: this is
+//! the case for which the data structures are optimised, and performance is
+//! going to be great.
+//!
+//! On the other hand, if you want to store values for which cloning is
+//! expensive, or values that don't implement [`Clone`][std::clone::Clone], you
+//! need to wrap them in [`Rc`][std::rc::Rc] or [`Arc`][std::sync::Arc]. Thus,
+//! if you have a complex structure `BigBlobOfData` and you want to store a list
+//! of them as a `Vector<BigBlobOfData>`, you should instead use a
+//! `Vector<Rc<BigBlobOfData>>`, which is going to save you not only the time
+//! spent cloning the big blobs of data, but also the memory spent keeping
+//! multiple copies of it around, as [`Rc`][std::rc::Rc] keeps a single
+//! reference counted copy around instead.
+//!
+//! If you're storing smaller values that aren't
+//! [`Copy`][std::marker::Copy]able, you'll need to exercise judgement: if your
+//! values are going to be very cheap to clone, as would be the case for short
+//! [`String`][std::string::String]s or small [`Vec`][std::vec::Vec]s, you're
+//! probably better off storing them directly without wrapping them in an
+//! [`Rc`][std::rc::Rc], because, like the [`Rc`][std::rc::Rc], they're just
+//! pointers to some data on the heap, and that data isn't expensive to clone -
+//! you might actually lose more performance from the extra redirection of
+//! wrapping them in an [`Rc`][std::rc::Rc] than you would from occasionally
+//! cloning them.
+//!
+//! ### When does cloning happen?
+//!
+//! So when will your values actually be cloned? The easy answer is only if you
+//! [`clone`][std::clone::Clone::clone] the data structure itself, and then only
+//! lazily as you change it. Values are stored in tree nodes inside the data
+//! structure, each node of which contains up to 64 values. When you
+//! [`clone`][std::clone::Clone::clone] a data structure, nothing is actually
+//! copied - it's just the reference count on the root node that's incremented,
+//! to indicate that it's shared between two data structures. It's only when you
+//! actually modify one of the shared data structures that nodes are cloned:
+//! when you make a change somewhere in the tree, the node containing the change
+//! needs to be cloned, and then its parent nodes need to be updated to contain
+//! the new child node instead of the old version, and so they're cloned as
+//! well.
+//!
+//! We can call this "lazy" cloning - if you make two copies of a data structure
+//! and you never change either of them, there's never any need to clone the
+//! data they contain. It's only when you start making changes that cloning
+//! starts to happen, and then only on the specific tree nodes that are part of
+//! the change. Note that the implications of lazily cloning the data structure
+//! extend to memory usage as well as the CPU workload of copying the data
+//! around - cloning an immutable data structure means both copies share the
+//! same allocated memory, until you start making changes.
+//!
+//! Most crucially, if you never clone the data structure, the data inside it is
+//! also never cloned, and in this case it acts just like a mutable data
+//! structure, with minimal performance differences (but still non-zero, as we
+//! still have to check for shared nodes).
+//!
+//! ## Data Structures
+//!
+//! We'll attempt to provide a comprehensive guide to the available
+//! data structures below.
+//!
+//! ### Performance Notes
+//!
+//! "Big O notation" is the standard way of talking about the time
+//! complexity of data structure operations. If you're not familiar
+//! with big O notation, here's a quick cheat sheet:
+//!
+//! *O(1)* means an operation runs in constant time: it will take the
+//! same time to complete regardless of the size of the data
+//! structure.
+//!
+//! *O(n)* means an operation runs in linear time: if you double the
+//! size of your data structure, the operation will take twice as long
+//! to complete; if you quadruple the size, it will take four times as
+//! long, etc.
+//!
+//! *O(log n)* means an operation runs in logarithmic time: for
+//! *log<sub>2</sub>*, if you double the size of your data structure,
+//! the operation will take one step longer to complete; if you
+//! quadruple the size, it will need two steps more; and so on.
+//! However, the data structures in this library generally run in
+//! *log<sub>64</sub>* time, meaning you have to make your data
+//! structure 64 times bigger to need one extra step, and 4096 times
+//! bigger to need two steps. This means that, while they still count
+//! as O(log n), operations on all but really large data sets will run
+//! at near enough to O(1) that you won't usually notice.
+//!
+//! *O(n log n)* is the most expensive operation you'll see in this
+//! library: it means that for every one of the *n* elements in your
+//! data structure, you have to perform *log n* operations. In our
+//! case, as noted above, this is often close enough to O(n) that it's
+//! not usually as bad as it sounds, but even O(n) isn't cheap and the
+//! cost still increases logarithmically, if slowly, as the size of
+//! your data increases. O(n log n) basically means "are you sure you
+//! need to do this?"
+//!
+//! *O(1)** means 'amortised O(1),' which means that an operation
+//! usually runs in constant time but will occasionally be more
+//! expensive: for instance,
+//! [`Vector::push_back`][vector::Vector::push_back], if called in
+//! sequence, will be O(1) most of the time but every 64th time it
+//! will be O(log n), as it fills up its tail chunk and needs to
+//! insert it into the tree. Please note that the O(1) with the
+//! asterisk attached is not a common notation; it's just a convention
+//! I've used in these docs to save myself from having to type
+//! 'amortised' everywhere.
+//!
+//! ### Lists
+//!
+//! Lists are sequences of single elements which maintain the order in
+//! which you inserted them. The only list in this library is
+//! [`Vector`][vector::Vector], which offers the best all round
+//! performance characteristics: it's pretty good at everything, even
+//! if there's always another kind of list that's better at something.
+//!
+//! | Type | Algorithm | Constraints | Order | Push | Pop | Split | Append | Lookup |
+//! | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+//! | [`Vector<A>`][vector::Vector] | [RRB tree][rrb-tree] | [`Clone`][std::clone::Clone] | insertion | O(1)\* | O(1)\* | O(log n) | O(log n) | O(log n) |
+//!
+//! ### Maps
+//!
+//! Maps are mappings of keys to values, where the most common read
+//! operation is to find the value associated with a given key. Maps
+//! may or may not have a defined order. Any given key can only occur
+//! once inside a map, and setting a key to a different value will
+//! overwrite the previous value.
+//!
+//! | Type | Algorithm | Key Constraints | Order | Insert | Remove | Lookup |
+//! | --- | --- | --- | --- | --- | --- | --- |
+//! | [`HashMap<K, V>`][hashmap::HashMap] | [HAMT][hamt] | [`Clone`][std::clone::Clone] + [`Hash`][std::hash::Hash] + [`Eq`][std::cmp::Eq] | undefined | O(log n) | O(log n) | O(log n) |
+//! | [`OrdMap<K, V>`][ordmap::OrdMap] | [B-tree][b-tree] | [`Clone`][std::clone::Clone] + [`Ord`][std::cmp::Ord] | sorted | O(log n) | O(log n) | O(log n) |
+//!
+//! ### Sets
+//!
+//! Sets are collections of unique values, and may or may not have a
+//! defined order. Their crucial property is that any given value can
+//! only exist once in a given set.
+//!
+//! | Type | Algorithm | Constraints | Order | Insert | Remove | Lookup |
+//! | --- | --- | --- | --- | --- | --- | --- |
+//! | [`HashSet<A>`][hashset::HashSet] | [HAMT][hamt] | [`Clone`][std::clone::Clone] + [`Hash`][std::hash::Hash] + [`Eq`][std::cmp::Eq] | undefined | O(log n) | O(log n) | O(log n) |
+//! | [`OrdSet<A>`][ordset::OrdSet] | [B-tree][b-tree] | [`Clone`][std::clone::Clone] + [`Ord`][std::cmp::Ord] | sorted | O(log n) | O(log n) | O(log n) |
+//!
+//! ## In-place Mutation
+//!
+//! All of these data structures support in-place copy-on-write
+//! mutation, which means that if you're the sole user of a data
+//! structure, you can update it in place without taking the
+//! performance hit of making a copy of the data structure before
+//! modifying it (this is about an order of magnitude faster than
+//! immutable operations, almost as fast as
+//! [`std::collections`][std::collections]'s mutable data structures).
+//!
+//! Thanks to [`Rc`][std::rc::Rc]'s reference counting, we are able to
+//! determine whether a node in a data structure is being shared with
+//! other data structures, or whether it's safe to mutate it in place.
+//! When it's shared, we'll automatically make a copy of the node
+//! before modifying it. The consequence of this is that cloning a
+//! data structure becomes a lazy operation: the initial clone is
+//! instant, and as you modify the cloned data structure it will clone
+//! chunks only where you change them, so that if you change the
+//! entire thing you will eventually have performed a full clone.
+//!
+//! This also gives us a couple of other optimisations for free:
+//! implementations of immutable data structures in other languages
+//! often have the idea of local mutation, like Clojure's transients
+//! or Haskell's `ST` monad - a managed scope where you can treat an
+//! immutable data structure like a mutable one, gaining a
+//! considerable amount of performance because you no longer need to
+//! copy your changed nodes for every operation, just the first time
+//! you hit a node that's sharing structure. In Rust, we don't need to
+//! think about this kind of managed scope, it's all taken care of
+//! behind the scenes because of our low level access to the garbage
+//! collector (which, in our case, is just a simple
+//! [`Rc`][std::rc::Rc]).
+//!
+//! ## Thread Safety
+//!
+//! The data structures in the `im` crate are thread safe, through
+//! [`Arc`][std::sync::Arc]. This comes with a slight performance impact, so
+//! that if you prioritise speed over thread safety, you may want to use the
+//! `im-rc` crate instead, which is identical to `im` except that it uses
+//! [`Rc`][std::rc::Rc] instead of [`Arc`][std::sync::Arc], implying that the
+//! data structures in `im-rc` do not implement [`Send`][std::marker::Send] and
+//! [`Sync`][std::marker::Sync]. This yields approximately a 20-25% increase in
+//! general performance.
+//!
+//! ## Feature Flags
+//!
+//! `im` comes with optional support for the following crates through Cargo
+//! feature flags. You can enable them in your `Cargo.toml` file like this:
+//!
+//! ```no_compile
+//! [dependencies]
+//! im = { version = "*", features = ["proptest", "serde"] }
+//! ```
+//!
+//! | Feature | Description |
+//! | ------- | ----------- |
+//! | [`pool`](https://crates.io/crates/refpool) | Constructors and pool types for [`refpool`](https://crates.io/crates/refpool) memory pools (only available in `im-rc`) |
+//! | [`proptest`](https://crates.io/crates/proptest) | Strategies for all `im` datatypes under a `proptest` namespace, eg. `im::vector::proptest::vector()` |
+//! | [`quickcheck`](https://crates.io/crates/quickcheck) | [`quickcheck::Arbitrary`](https://docs.rs/quickcheck/latest/quickcheck/trait.Arbitrary.html) implementations for all `im` datatypes (not available in `im-rc`) |
+//! | [`rayon`](https://crates.io/crates/rayon) | parallel iterator implementations for [`Vector`][vector::Vector] (not available in `im-rc`) |
+//! | [`serde`](https://crates.io/crates/serde) | [`Serialize`](https://docs.rs/serde/latest/serde/trait.Serialize.html) and [`Deserialize`](https://docs.rs/serde/latest/serde/trait.Deserialize.html) implementations for all `im` datatypes |
+//! | [`arbitrary`](https://crates.io/crates/arbitrary/) | [`arbitrary::Arbitrary`](https://docs.rs/arbitrary/latest/arbitrary/trait.Arbitrary.html) implementations for all `im` datatypes |
+//!
+//! [std::collections]: https://doc.rust-lang.org/std/collections/index.html
+//! [std::collections::VecDeque]: https://doc.rust-lang.org/std/collections/struct.VecDeque.html
+//! [std::vec::Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html
+//! [std::string::String]: https://doc.rust-lang.org/std/string/struct.String.html
+//! [std::rc::Rc]: https://doc.rust-lang.org/std/rc/struct.Rc.html
+//! [std::sync::Arc]: https://doc.rust-lang.org/std/sync/struct.Arc.html
+//! [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
+//! [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html
+//! [std::clone::Clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html
+//! [std::clone::Clone::clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html#tymethod.clone
+//! [std::marker::Copy]: https://doc.rust-lang.org/std/marker/trait.Copy.html
+//! [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html
+//! [std::marker::Send]: https://doc.rust-lang.org/std/marker/trait.Send.html
+//! [std::marker::Sync]: https://doc.rust-lang.org/std/marker/trait.Sync.html
+//! [hashmap::HashMap]: ./struct.HashMap.html
+//! [hashset::HashSet]: ./struct.HashSet.html
+//! [ordmap::OrdMap]: ./struct.OrdMap.html
+//! [ordset::OrdSet]: ./struct.OrdSet.html
+//! [vector::Vector]: ./struct.Vector.html
+//! [vector::Vector::push_back]: ./vector/enum.Vector.html#method.push_back
+//! [rrb-tree]: https://infoscience.epfl.ch/record/213452/files/rrbvector.pdf
+//! [hamt]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie
+//! [b-tree]: https://en.wikipedia.org/wiki/B-tree
+//! [cons-list]: https://en.wikipedia.org/wiki/Cons#Lists
+
+#![forbid(rust_2018_idioms)]
+#![deny(unsafe_code, nonstandard_style)]
+#![warn(unreachable_pub, missing_docs)]
+#![cfg_attr(has_specialisation, feature(specialization))]
+
+#[cfg(test)]
+#[macro_use]
+extern crate pretty_assertions;
+
+mod config;
+mod nodes;
+mod sort;
+mod sync;
+
+#[macro_use]
+mod util;
+
+#[macro_use]
+mod ord;
+pub use crate::ord::map as ordmap;
+pub use crate::ord::set as ordset;
+
+#[macro_use]
+mod hash;
+pub use crate::hash::map as hashmap;
+pub use crate::hash::set as hashset;
+
+#[macro_use]
+pub mod vector;
+
+pub mod iter;
+
+#[cfg(any(test, feature = "proptest"))]
+pub mod proptest;
+
+#[cfg(any(test, feature = "serde"))]
+#[doc(hidden)]
+pub mod ser;
+
+#[cfg(feature = "arbitrary")]
+#[doc(hidden)]
+pub mod arbitrary;
+
+#[cfg(all(threadsafe, feature = "quickcheck"))]
+#[doc(hidden)]
+pub mod quickcheck;
+
+#[cfg(any(threadsafe, not(feature = "pool")))]
+mod fakepool;
+
+#[cfg(all(threadsafe, feature = "pool"))]
+compile_error!(
+    "The `pool` feature is not threadsafe but you've enabled it on a threadsafe version of `im`."
+);
+
+pub use crate::hashmap::HashMap;
+pub use crate::hashset::HashSet;
+pub use crate::ordmap::OrdMap;
+pub use crate::ordset::OrdSet;
+#[doc(inline)]
+pub use crate::vector::Vector;
+
+#[cfg(test)]
+mod test;
+
+#[cfg(test)]
+mod tests;
+
+/// Update a value inside multiple levels of data structures.
+///
+/// This macro takes a [`Vector`][Vector], [`OrdMap`][OrdMap] or [`HashMap`][HashMap],
+/// a key or a series of keys, and a value, and returns the data structure with the
+/// new value at the location described by the keys.
+///
+/// If one of the keys in the path doesn't exist, the macro will panic.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use std::sync::Arc;
+/// # fn main() {
+/// let vec_inside_vec = vector![vector![1, 2, 3], vector![4, 5, 6]];
+///
+/// let expected = vector![vector![1, 2, 3], vector![4, 5, 1337]];
+///
+/// assert_eq!(expected, update_in![vec_inside_vec, 1 => 2, 1337]);
+/// # }
+/// ```
+///
+/// [Vector]: ../vector/enum.Vector.html
+/// [HashMap]: ../hashmap/struct.HashMap.html
+/// [OrdMap]: ../ordmap/struct.OrdMap.html
+#[macro_export]
+macro_rules! update_in {
+    ($target:expr, $path:expr => $($tail:tt) => *, $value:expr ) => {{
+        let inner = $target.get($path).expect("update_in! macro: key not found in target");
+        $target.update($path, update_in!(inner, $($tail) => *, $value))
+    }};
+
+    ($target:expr, $path:expr, $value:expr) => {
+        $target.update($path, $value)
+    };
+}
+
+/// Get a value inside multiple levels of data structures.
+///
+/// This macro takes a [`Vector`][Vector], [`OrdMap`][OrdMap] or [`HashMap`][HashMap],
+/// along with a key or a series of keys, and returns the value at the location inside
+/// the data structure described by the key sequence, or `None` if any of the keys didn't
+/// exist.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use std::sync::Arc;
+/// # fn main() {
+/// let vec_inside_vec = vector![vector![1, 2, 3], vector![4, 5, 6]];
+///
+/// assert_eq!(Some(&6), get_in![vec_inside_vec, 1 => 2]);
+/// # }
+/// ```
+///
+/// [Vector]: ../vector/enum.Vector.html
+/// [HashMap]: ../hashmap/struct.HashMap.html
+/// [OrdMap]: ../ordmap/struct.OrdMap.html
+#[macro_export]
+macro_rules! get_in {
+    ($target:expr, $path:expr => $($tail:tt) => * ) => {{
+        $target.get($path).and_then(|v| get_in!(v, $($tail) => *))
+    }};
+
+    ($target:expr, $path:expr) => {
+        $target.get($path)
+    };
+}
+
+#[cfg(test)]
+mod lib_test {
+    #[test]
+    fn update_in() {
+        let vector = vector![1, 2, 3, 4, 5];
+        assert_eq!(vector![1, 2, 23, 4, 5], update_in!(vector, 2, 23));
+        let hashmap = hashmap![1 => 1, 2 => 2, 3 => 3];
+        assert_eq!(
+            hashmap![1 => 1, 2 => 23, 3 => 3],
+            update_in!(hashmap, 2, 23)
+        );
+        let ordmap = ordmap![1 => 1, 2 => 2, 3 => 3];
+        assert_eq!(ordmap![1 => 1, 2 => 23, 3 => 3], update_in!(ordmap, 2, 23));
+
+        let vecs = vector![vector![1, 2, 3], vector![4, 5, 6], vector![7, 8, 9]];
+        let vecs_target = vector![vector![1, 2, 3], vector![4, 5, 23], vector![7, 8, 9]];
+        assert_eq!(vecs_target, update_in!(vecs, 1 => 2, 23));
+    }
+
+    #[test]
+    fn get_in() {
+        let vector = vector![1, 2, 3, 4, 5];
+        assert_eq!(Some(&3), get_in!(vector, 2));
+        let hashmap = hashmap![1 => 1, 2 => 2, 3 => 3];
+        assert_eq!(Some(&2), get_in!(hashmap, &2));
+        let ordmap = ordmap![1 => 1, 2 => 2, 3 => 3];
+        assert_eq!(Some(&2), get_in!(ordmap, &2));
+
+        let vecs = vector![vector![1, 2, 3], vector![4, 5, 6], vector![7, 8, 9]];
+        assert_eq!(Some(&6), get_in!(vecs, 1 => 2));
+    }
+}
diff --git a/vendor/im-rc/src/nodes/btree.rs b/vendor/im-rc/src/nodes/btree.rs
new file mode 100644
index 000000000..84f63fa96
--- /dev/null
+++ b/vendor/im-rc/src/nodes/btree.rs
@@ -0,0 +1,1368 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use std::borrow::Borrow;
+use std::cmp::Ordering;
+use std::mem;
+use std::ops::{Bound, RangeBounds};
+
+use sized_chunks::Chunk;
+use typenum::{Add1, Unsigned};
+
+use crate::config::OrdChunkSize as NodeSize;
+use crate::util::{Pool, PoolClone, PoolDefault, PoolRef};
+
+use self::Insert::*;
+use self::InsertAction::*;
+
+pub(crate) const NODE_SIZE: usize = NodeSize::USIZE;
+const MEDIAN: usize = (NODE_SIZE + 1) >> 1;
+
+pub trait BTreeValue {
+    type Key;
+    fn ptr_eq(&self, other: &Self) -> bool;
+    fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize>
+    where
+        BK: Ord + ?Sized,
+        Self: Sized,
+        Self::Key: Borrow<BK>;
+    fn search_value(slice: &[Self], value: &Self) -> Result<usize, usize>
+    where
+        Self: Sized;
+    fn cmp_keys<BK>(&self, other: &BK) -> Ordering
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>;
+    fn cmp_values(&self, other: &Self) -> Ordering;
+}
+
+pub(crate) struct Node<A> {
+    keys: Chunk<A, NodeSize>,
+    children: Chunk<Option<PoolRef<Node<A>>>, Add1<NodeSize>>,
+}
+
+#[cfg(feature = "pool")]
+#[allow(unsafe_code)]
+unsafe fn cast_uninit<A>(target: &mut A) -> &mut mem::MaybeUninit<A> {
+    &mut *(target as *mut A as *mut mem::MaybeUninit<A>)
+}
+
+#[allow(unsafe_code)]
+impl<A> PoolDefault for Node<A> {
+    #[cfg(feature = "pool")]
+    unsafe fn default_uninit(target: &mut mem::MaybeUninit<Self>) {
+        let ptr: *mut Self = target.as_mut_ptr();
+        Chunk::default_uninit(cast_uninit(&mut (*ptr).keys));
+        Chunk::default_uninit(cast_uninit(&mut (*ptr).children));
+        (*ptr).children.push_back(None);
+    }
+}
+
+#[allow(unsafe_code)]
+impl<A> PoolClone for Node<A>
+where
+    A: Clone,
+{
+    #[cfg(feature = "pool")]
+    unsafe fn clone_uninit(&self, target: &mut mem::MaybeUninit<Self>) {
+        self.keys
+            .clone_uninit(cast_uninit(&mut (*target.as_mut_ptr()).keys));
+        self.children
+            .clone_uninit(cast_uninit(&mut (*target.as_mut_ptr()).children));
+    }
+}
+
+pub(crate) enum Insert<A> {
+    Added,
+    Replaced(A),
+    Split(Node<A>, A, Node<A>),
+}
+
+enum InsertAction<A> {
+    AddedAction,
+    ReplacedAction(A),
+    InsertAt,
+    InsertSplit(Node<A>, A, Node<A>),
+}
+
+pub(crate) enum Remove<A> {
+    NoChange,
+    Removed(A),
+    Update(A, Node<A>),
+}
+
+enum Boundary {
+    Lowest,
+    Highest,
+}
+
+enum RemoveAction {
+    DeleteAt(usize),
+    PullUp(Boundary, usize, usize),
+    Merge(usize),
+    StealFromLeft(usize),
+    StealFromRight(usize),
+    MergeFirst(usize),
+    ContinueDown(usize),
+}
+
+impl<A> Clone for Node<A>
+where
+    A: Clone,
+{
+    fn clone(&self) -> Self {
+        Node {
+            keys: self.keys.clone(),
+            children: self.children.clone(),
+        }
+    }
+}
+
+impl<A> Default for Node<A> {
+    fn default() -> Self {
+        Node {
+            keys: Chunk::new(),
+            children: Chunk::unit(None),
+        }
+    }
+}
+
+impl<A> Node<A> {
+    #[inline]
+    fn has_room(&self) -> bool {
+        self.keys.len() < NODE_SIZE
+    }
+
+    #[inline]
+    fn too_small(&self) -> bool {
+        self.keys.len() < MEDIAN
+    }
+
+    #[inline]
+    pub(crate) fn unit(value: A) -> Self {
+        Node {
+            keys: Chunk::unit(value),
+            children: Chunk::pair(None, None),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn new_from_split(
+        pool: &Pool<Node<A>>,
+        left: Node<A>,
+        median: A,
+        right: Node<A>,
+    ) -> Self {
+        Node {
+            keys: Chunk::unit(median),
+            children: Chunk::pair(
+                Some(PoolRef::new(pool, left)),
+                Some(PoolRef::new(pool, right)),
+            ),
+        }
+    }
+
+    pub(crate) fn min(&self) -> Option<&A> {
+        match self.children.first().unwrap() {
+            None => self.keys.first(),
+            Some(ref child) => child.min(),
+        }
+    }
+
+    pub(crate) fn max(&self) -> Option<&A> {
+        match self.children.last().unwrap() {
+            None => self.keys.last(),
+            Some(ref child) => child.max(),
+        }
+    }
+}
+
+impl<A: BTreeValue> Node<A> {
+    fn child_contains<BK>(&self, index: usize, key: &BK) -> bool
+    where
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if let Some(Some(ref child)) = self.children.get(index) {
+            child.lookup(key).is_some()
+        } else {
+            false
+        }
+    }
+
+    pub(crate) fn lookup<BK>(&self, key: &BK) -> Option<&A>
+    where
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return None;
+        }
+        // Perform a binary search, resulting in either a match or
+        // the index of the first higher key, meaning we search the
+        // child to the left of it.
+        match A::search_key(&self.keys, key) {
+            Ok(index) => Some(&self.keys[index]),
+            Err(index) => match self.children[index] {
+                None => None,
+                Some(ref node) => node.lookup(key),
+            },
+        }
+    }
+
+    pub(crate) fn lookup_mut<BK>(&mut self, pool: &Pool<Node<A>>, key: &BK) -> Option<&mut A>
+    where
+        A: Clone,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return None;
+        }
+        // Perform a binary search, resulting in either a match or
+        // the index of the first higher key, meaning we search the
+        // child to the left of it.
+        match A::search_key(&self.keys, key) {
+            Ok(index) => Some(&mut self.keys[index]),
+            Err(index) => match self.children[index] {
+                None => None,
+                Some(ref mut child_ref) => {
+                    let child = PoolRef::make_mut(pool, child_ref);
+                    child.lookup_mut(pool, key)
+                }
+            },
+        }
+    }
+
+    pub(crate) fn lookup_prev<'a, BK>(&'a self, key: &BK) -> Option<&A>
+    where
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return None;
+        }
+        match A::search_key(&self.keys, key) {
+            Ok(index) => Some(&self.keys[index]),
+            Err(index) => match self.children[index] {
+                None if index == 0 => None,
+                None => self.keys.get(index - 1).map(|_| &self.keys[index - 1]),
+                Some(ref node) => node.lookup_prev(key),
+            },
+        }
+    }
+
+    pub(crate) fn lookup_next<'a, BK>(&'a self, key: &BK) -> Option<&A>
+    where
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return None;
+        }
+        match A::search_key(&self.keys, key) {
+            Ok(index) => Some(&self.keys[index]),
+            Err(index) => match self.children[index] {
+                None => self.keys.get(index).map(|_| &self.keys[index]),
+                Some(ref node) => node.lookup_next(key),
+            },
+        }
+    }
+
+    pub(crate) fn lookup_prev_mut<'a, BK>(
+        &'a mut self,
+        pool: &Pool<Node<A>>,
+        key: &BK,
+    ) -> Option<&mut A>
+    where
+        A: Clone,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return None;
+        }
+        match A::search_key(&self.keys, key) {
+            Ok(index) => Some(&mut self.keys[index]),
+            Err(index) => match self.children[index] {
+                None if index == 0 => None,
+                None => match self.keys.get(index - 1) {
+                    Some(_) => Some(&mut self.keys[index - 1]),
+                    None => None,
+                },
+                Some(ref mut node) => PoolRef::make_mut(pool, node).lookup_prev_mut(pool, key),
+            },
+        }
+    }
+
+    pub(crate) fn lookup_next_mut<'a, BK>(
+        &'a mut self,
+        pool: &Pool<Node<A>>,
+        key: &BK,
+    ) -> Option<&mut A>
+    where
+        A: Clone,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return None;
+        }
+        match A::search_key(&self.keys, key) {
+            Ok(index) => Some(&mut self.keys[index]),
+            Err(index) => match self.children[index] {
+                None => match self.keys.get(index) {
+                    Some(_) => Some(&mut self.keys[index]),
+                    None => None,
+                },
+                Some(ref mut node) => PoolRef::make_mut(pool, node).lookup_next_mut(pool, key),
+            },
+        }
+    }
+
+    pub(crate) fn path_first<'a, BK>(
+        &'a self,
+        mut path: Vec<(&'a Node<A>, usize)>,
+    ) -> Vec<(&'a Node<A>, usize)>
+    where
+        A: 'a,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return Vec::new();
+        }
+        match self.children[0] {
+            None => {
+                path.push((self, 0));
+                path
+            }
+            Some(ref node) => {
+                path.push((self, 0));
+                node.path_first(path)
+            }
+        }
+    }
+
+    pub(crate) fn path_last<'a, BK>(
+        &'a self,
+        mut path: Vec<(&'a Node<A>, usize)>,
+    ) -> Vec<(&'a Node<A>, usize)>
+    where
+        A: 'a,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return Vec::new();
+        }
+        let end = self.children.len() - 1;
+        match self.children[end] {
+            None => {
+                path.push((self, end - 1));
+                path
+            }
+            Some(ref node) => {
+                path.push((self, end));
+                node.path_last(path)
+            }
+        }
+    }
+
+    pub(crate) fn path_next<'a, BK>(
+        &'a self,
+        key: &BK,
+        mut path: Vec<(&'a Node<A>, usize)>,
+    ) -> Vec<(&'a Node<A>, usize)>
+    where
+        A: 'a,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return Vec::new();
+        }
+        match A::search_key(&self.keys, key) {
+            Ok(index) => {
+                path.push((self, index));
+                path
+            }
+            Err(index) => match self.children[index] {
+                None => match self.keys.get(index) {
+                    Some(_) => {
+                        path.push((self, index));
+                        path
+                    }
+                    None => {
+                        // go back up to find next
+                        while let Some((node, idx)) = path.last() {
+                            if node.keys.len() == *idx {
+                                path.pop();
+                            } else {
+                                break;
+                            }
+                        }
+                        path
+                    }
+                },
+                Some(ref node) => {
+                    path.push((self, index));
+                    node.path_next(key, path)
+                }
+            },
+        }
+    }
+
+    pub(crate) fn path_prev<'a, BK>(
+        &'a self,
+        key: &BK,
+        mut path: Vec<(&'a Node<A>, usize)>,
+    ) -> Vec<(&'a Node<A>, usize)>
+    where
+        A: 'a,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        if self.keys.is_empty() {
+            return Vec::new();
+        }
+        match A::search_key(&self.keys, key) {
+            Ok(index) => {
+                path.push((self, index));
+                path
+            }
+            Err(index) => match self.children[index] {
+                None if index == 0 => {
+                    // go back up to find prev
+                    while let Some((_, idx)) = path.last_mut() {
+                        if *idx == 0 {
+                            path.pop();
+                        } else {
+                            *idx -= 1;
+                            break;
+                        }
+                    }
+                    path
+                }
+                None => {
+                    path.push((self, index - 1));
+                    path
+                }
+                Some(ref node) => {
+                    path.push((self, index));
+                    node.path_prev(key, path)
+                }
+            },
+        }
+    }
+
+    fn split(
+        &mut self,
+        pool: &Pool<Node<A>>,
+        value: A,
+        ins_left: Option<Node<A>>,
+        ins_right: Option<Node<A>>,
+    ) -> Insert<A> {
+        let left_child = ins_left.map(|node| PoolRef::new(pool, node));
+        let right_child = ins_right.map(|node| PoolRef::new(pool, node));
+        let index = A::search_value(&self.keys, &value).unwrap_err();
+        let mut left_keys;
+        let mut left_children;
+        let mut right_keys;
+        let mut right_children;
+        let median;
+        match index.cmp(&MEDIAN) {
+            Ordering::Less => {
+                self.children[index] = left_child;
+
+                left_keys = Chunk::from_front(&mut self.keys, index);
+                left_keys.push_back(value);
+                left_keys.drain_from_front(&mut self.keys, MEDIAN - index - 1);
+
+                left_children = Chunk::from_front(&mut self.children, index + 1);
+                left_children.push_back(right_child);
+                left_children.drain_from_front(&mut self.children, MEDIAN - index - 1);
+
+                median = self.keys.pop_front();
+
+                right_keys = Chunk::drain_from(&mut self.keys);
+                right_children = Chunk::drain_from(&mut self.children);
+            }
+            Ordering::Greater => {
+                self.children[index] = left_child;
+
+                left_keys = Chunk::from_front(&mut self.keys, MEDIAN);
+                left_children = Chunk::from_front(&mut self.children, MEDIAN + 1);
+
+                median = self.keys.pop_front();
+
+                right_keys = Chunk::from_front(&mut self.keys, index - MEDIAN - 1);
+                right_keys.push_back(value);
+                right_keys.append(&mut self.keys);
+
+                right_children = Chunk::from_front(&mut self.children, index - MEDIAN);
+                right_children.push_back(right_child);
+                right_children.append(&mut self.children);
+            }
+            Ordering::Equal => {
+                left_keys = Chunk::from_front(&mut self.keys, MEDIAN);
+                left_children = Chunk::from_front(&mut self.children, MEDIAN);
+                left_children.push_back(left_child);
+
+                median = value;
+
+                right_keys = Chunk::drain_from(&mut self.keys);
+                right_children = Chunk::drain_from(&mut self.children);
+                right_children[0] = right_child;
+            }
+        }
+
+        debug_assert!(left_keys.len() == MEDIAN);
+        debug_assert!(left_children.len() == MEDIAN + 1);
+        debug_assert!(right_keys.len() == MEDIAN);
+        debug_assert!(right_children.len() == MEDIAN + 1);
+
+        Split(
+            Node {
+                keys: left_keys,
+                children: left_children,
+            },
+            median,
+            Node {
+                keys: right_keys,
+                children: right_children,
+            },
+        )
+    }
+
+    fn merge(middle: A, left: Node<A>, mut right: Node<A>) -> Node<A> {
+        let mut keys = left.keys;
+        keys.push_back(middle);
+        keys.append(&mut right.keys);
+        let mut children = left.children;
+        children.append(&mut right.children);
+        Node { keys, children }
+    }
+
+    fn pop_min(&mut self) -> (A, Option<PoolRef<Node<A>>>) {
+        let value = self.keys.pop_front();
+        let child = self.children.pop_front();
+        (value, child)
+    }
+
+    fn pop_max(&mut self) -> (A, Option<PoolRef<Node<A>>>) {
+        let value = self.keys.pop_back();
+        let child = self.children.pop_back();
+        (value, child)
+    }
+
+    fn push_min(&mut self, child: Option<PoolRef<Node<A>>>, value: A) {
+        self.keys.push_front(value);
+        self.children.push_front(child);
+    }
+
+    fn push_max(&mut self, child: Option<PoolRef<Node<A>>>, value: A) {
+        self.keys.push_back(value);
+        self.children.push_back(child);
+    }
+
+    pub(crate) fn insert(&mut self, pool: &Pool<Node<A>>, value: A) -> Insert<A>
+    where
+        A: Clone,
+    {
+        if self.keys.is_empty() {
+            self.keys.push_back(value);
+            self.children.push_back(None);
+            return Insert::Added;
+        }
+        let (median, left, right) = match A::search_value(&self.keys, &value) {
+            // Key exists in node
+            Ok(index) => {
+                return Insert::Replaced(mem::replace(&mut self.keys[index], value));
+            }
+            // Key is adjacent to some key in node
+            Err(index) => {
+                let has_room = self.has_room();
+                let action = match self.children[index] {
+                    // No child at location, this is the target node.
+                    None => InsertAt,
+                    // Child at location, pass it on.
+                    Some(ref mut child_ref) => {
+                        let child = PoolRef::make_mut(pool, child_ref);
+                        match child.insert(pool, value.clone()) {
+                            Insert::Added => AddedAction,
+                            Insert::Replaced(value) => ReplacedAction(value),
+                            Insert::Split(left, median, right) => InsertSplit(left, median, right),
+                        }
+                    }
+                };
+                match action {
+                    ReplacedAction(value) => return Insert::Replaced(value),
+                    AddedAction => {
+                        return Insert::Added;
+                    }
+                    InsertAt => {
+                        if has_room {
+                            self.keys.insert(index, value);
+                            self.children.insert(index + 1, None);
+                            return Insert::Added;
+                        } else {
+                            (value, None, None)
+                        }
+                    }
+                    InsertSplit(left, median, right) => {
+                        if has_room {
+                            self.children[index] = Some(PoolRef::new(pool, left));
+                            self.keys.insert(index, median);
+                            self.children
+                                .insert(index + 1, Some(PoolRef::new(pool, right)));
+                            return Insert::Added;
+                        } else {
+                            (median, Some(left), Some(right))
+                        }
+                    }
+                }
+            }
+        };
+        self.split(pool, median, left, right)
+    }
+
+    pub(crate) fn remove<BK>(&mut self, pool: &Pool<Node<A>>, key: &BK) -> Remove<A>
+    where
+        A: Clone,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        let index = A::search_key(&self.keys, key);
+        self.remove_index(pool, index, Ok(key))
+    }
+
+    fn remove_target<BK>(
+        &mut self,
+        pool: &Pool<Node<A>>,
+        target: Result<&BK, Boundary>,
+    ) -> Remove<A>
+    where
+        A: Clone,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        let index = match target {
+            Ok(key) => A::search_key(&self.keys, key),
+            Err(Boundary::Lowest) => Err(0),
+            Err(Boundary::Highest) => Err(self.keys.len()),
+        };
+        self.remove_index(pool, index, target)
+    }
+
+    fn remove_index<BK>(
+        &mut self,
+        pool: &Pool<Node<A>>,
+        index: Result<usize, usize>,
+        target: Result<&BK, Boundary>,
+    ) -> Remove<A>
+    where
+        A: Clone,
+        BK: Ord + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        let action = match index {
+            // Key exists in node, remove it.
+            Ok(index) => {
+                match (&self.children[index], &self.children[index + 1]) {
+                    // If we're a leaf, just delete the entry.
+                    (&None, &None) => RemoveAction::DeleteAt(index),
+                    // First consider pulling either predecessor (from left) or successor (from right).
+                    // otherwise just merge the two small children.
+                    (&Some(ref left), &Some(ref right)) => {
+                        if !left.too_small() {
+                            RemoveAction::PullUp(Boundary::Highest, index, index)
+                        } else if !right.too_small() {
+                            RemoveAction::PullUp(Boundary::Lowest, index, index + 1)
+                        } else {
+                            RemoveAction::Merge(index)
+                        }
+                    }
+                    _ => unreachable!("Branch missing children"),
+                }
+            }
+            // Target is adjacent to some key in node
+            Err(index) => match self.children[index] {
+                // We're deading with a leaf node
+                None => match target {
+                    // No child at location means key isn't in map.
+                    Ok(_key) => return Remove::NoChange,
+                    // Looking for the lowest or highest key
+                    Err(Boundary::Lowest) => RemoveAction::DeleteAt(0),
+                    Err(Boundary::Highest) => RemoveAction::DeleteAt(self.keys.len() - 1),
+                },
+                // Child at location, but it's at minimum capacity.
+                Some(ref child) if child.too_small() => {
+                    let left = if index > 0 {
+                        self.children.get(index - 1)
+                    } else {
+                        None
+                    }; // index is usize and can't be negative, best make sure it never is.
+                    match (left, self.children.get(index + 1)) {
+                        // If it has a left sibling with capacity, steal a key from it.
+                        (Some(&Some(ref old_left)), _) if !old_left.too_small() => {
+                            RemoveAction::StealFromLeft(index)
+                        }
+                        // If it has a right sibling with capacity, same as above.
+                        (_, Some(&Some(ref old_right))) if !old_right.too_small() => {
+                            RemoveAction::StealFromRight(index)
+                        }
+                        // If it has neither, we'll have to merge it with a sibling.
+                        // If we have a right sibling, we'll merge with that.
+                        (_, Some(&Some(_))) => RemoveAction::MergeFirst(index),
+                        // If we have a left sibling, we'll merge with that.
+                        (Some(&Some(_)), _) => RemoveAction::MergeFirst(index - 1),
+                        // If none of the above, we're in a bad state.
+                        _ => unreachable!(),
+                    }
+                }
+                // Child at location, and it's big enough, we can recurse down.
+                Some(_) => RemoveAction::ContinueDown(index),
+            },
+        };
+        match action {
+            RemoveAction::DeleteAt(index) => {
+                let pair = self.keys.remove(index);
+                self.children.remove(index);
+                Remove::Removed(pair)
+            }
+            RemoveAction::PullUp(boundary, pull_to, child_index) => {
+                let children = &mut self.children;
+                let mut update = None;
+                let value;
+                if let Some(&mut Some(ref mut child_ref)) = children.get_mut(child_index) {
+                    let child = PoolRef::make_mut(pool, child_ref);
+                    match child.remove_target(pool, Err(boundary)) {
+                        Remove::NoChange => unreachable!(),
+                        Remove::Removed(pulled_value) => {
+                            value = self.keys.set(pull_to, pulled_value);
+                        }
+                        Remove::Update(pulled_value, new_child) => {
+                            value = self.keys.set(pull_to, pulled_value);
+                            update = Some(new_child);
+                        }
+                    }
+                } else {
+                    unreachable!()
+                }
+                if let Some(new_child) = update {
+                    children[child_index] = Some(PoolRef::new(pool, new_child));
+                }
+                Remove::Removed(value)
+            }
+            RemoveAction::Merge(index) => {
+                let left = self.children.remove(index).unwrap();
+                let right = mem::replace(&mut self.children[index], None).unwrap();
+                let value = self.keys.remove(index);
+                let mut merged_child = Node::merge(
+                    value,
+                    PoolRef::unwrap_or_clone(left),
+                    PoolRef::unwrap_or_clone(right),
+                );
+                let (removed, new_child) = match merged_child.remove_target(pool, target) {
+                    Remove::NoChange => unreachable!(),
+                    Remove::Removed(removed) => (removed, merged_child),
+                    Remove::Update(removed, updated_child) => (removed, updated_child),
+                };
+                if self.keys.is_empty() {
+                    // If we've depleted the root node, the merged child becomes the root.
+                    Remove::Update(removed, new_child)
+                } else {
+                    self.children[index] = Some(PoolRef::new(pool, new_child));
+                    Remove::Removed(removed)
+                }
+            }
+            RemoveAction::StealFromLeft(index) => {
+                let mut update = None;
+                let out_value;
+                {
+                    let mut children = self.children.as_mut_slice()[index - 1..=index]
+                        .iter_mut()
+                        .map(|n| n.as_mut().unwrap());
+                    let left = PoolRef::make_mut(pool, children.next().unwrap());
+                    let child = PoolRef::make_mut(pool, children.next().unwrap());
+                    // Prepare the rebalanced node.
+                    child.push_min(
+                        left.children.last().unwrap().clone(),
+                        self.keys[index - 1].clone(),
+                    );
+                    match child.remove_target(pool, target) {
+                        Remove::NoChange => {
+                            // Key wasn't there, we need to revert the steal.
+                            child.pop_min();
+                            return Remove::NoChange;
+                        }
+                        Remove::Removed(value) => {
+                            // If we did remove something, we complete the rebalancing.
+                            let (left_value, _) = left.pop_max();
+                            self.keys[index - 1] = left_value;
+                            out_value = value;
+                        }
+                        Remove::Update(value, new_child) => {
+                            // If we did remove something, we complete the rebalancing.
+                            let (left_value, _) = left.pop_max();
+                            self.keys[index - 1] = left_value;
+                            update = Some(new_child);
+                            out_value = value;
+                        }
+                    }
+                }
+                if let Some(new_child) = update {
+                    self.children[index] = Some(PoolRef::new(pool, new_child));
+                }
+                Remove::Removed(out_value)
+            }
+            RemoveAction::StealFromRight(index) => {
+                let mut update = None;
+                let out_value;
+                {
+                    let mut children = self.children.as_mut_slice()[index..index + 2]
+                        .iter_mut()
+                        .map(|n| n.as_mut().unwrap());
+                    let child = PoolRef::make_mut(pool, children.next().unwrap());
+                    let right = PoolRef::make_mut(pool, children.next().unwrap());
+                    // Prepare the rebalanced node.
+                    child.push_max(right.children[0].clone(), self.keys[index].clone());
+                    match child.remove_target(pool, target) {
+                        Remove::NoChange => {
+                            // Key wasn't there, we need to revert the steal.
+                            child.pop_max();
+                            return Remove::NoChange;
+                        }
+                        Remove::Removed(value) => {
+                            // If we did remove something, we complete the rebalancing.
+                            let (right_value, _) = right.pop_min();
+                            self.keys[index] = right_value;
+                            out_value = value;
+                        }
+                        Remove::Update(value, new_child) => {
+                            // If we did remove something, we complete the rebalancing.
+                            let (right_value, _) = right.pop_min();
+                            self.keys[index] = right_value;
+                            update = Some(new_child);
+                            out_value = value;
+                        }
+                    }
+                }
+                if let Some(new_child) = update {
+                    self.children[index] = Some(PoolRef::new(pool, new_child));
+                }
+                Remove::Removed(out_value)
+            }
+            RemoveAction::MergeFirst(index) => {
+                if let Ok(key) = target {
+                    // Bail early if we're looking for a not existing key
+                    match self.keys[index].cmp_keys(key) {
+                        Ordering::Less if !self.child_contains(index + 1, key) => {
+                            return Remove::NoChange
+                        }
+                        Ordering::Greater if !self.child_contains(index, key) => {
+                            return Remove::NoChange
+                        }
+                        _ => (),
+                    }
+                }
+                let left = self.children.remove(index).unwrap();
+                let right = mem::replace(&mut self.children[index], None).unwrap();
+                let middle = self.keys.remove(index);
+                let mut merged = Node::merge(
+                    middle,
+                    PoolRef::unwrap_or_clone(left),
+                    PoolRef::unwrap_or_clone(right),
+                );
+                let update;
+                let out_value;
+                match merged.remove_target(pool, target) {
+                    Remove::NoChange => {
+                        panic!("nodes::btree::Node::remove: caught an absent key too late while merging");
+                    }
+                    Remove::Removed(value) => {
+                        if self.keys.is_empty() {
+                            return Remove::Update(value, merged);
+                        }
+                        update = merged;
+                        out_value = value;
+                    }
+                    Remove::Update(value, new_child) => {
+                        if self.keys.is_empty() {
+                            return Remove::Update(value, new_child);
+                        }
+                        update = new_child;
+                        out_value = value;
+                    }
+                }
+                self.children[index] = Some(PoolRef::new(pool, update));
+                Remove::Removed(out_value)
+            }
+            RemoveAction::ContinueDown(index) => {
+                let mut update = None;
+                let out_value;
+                if let Some(&mut Some(ref mut child_ref)) = self.children.get_mut(index) {
+                    let child = PoolRef::make_mut(pool, child_ref);
+                    match child.remove_target(pool, target) {
+                        Remove::NoChange => return Remove::NoChange,
+                        Remove::Removed(value) => {
+                            out_value = value;
+                        }
+                        Remove::Update(value, new_child) => {
+                            update = Some(new_child);
+                            out_value = value;
+                        }
+                    }
+                } else {
+                    unreachable!()
+                }
+                if let Some(new_child) = update {
+                    self.children[index] = Some(PoolRef::new(pool, new_child));
+                }
+                Remove::Removed(out_value)
+            }
+        }
+    }
+}
+
+// Iterator
+
+/// An iterator over an ordered set.
+pub struct Iter<'a, A> {
+    fwd_path: Vec<(&'a Node<A>, usize)>,
+    back_path: Vec<(&'a Node<A>, usize)>,
+    pub(crate) remaining: usize,
+}
+
+impl<'a, A: BTreeValue> Iter<'a, A> {
+    pub(crate) fn new<R, BK>(root: &'a Node<A>, size: usize, range: R) -> Self
+    where
+        R: RangeBounds<BK>,
+        A::Key: Borrow<BK>,
+        BK: Ord + ?Sized,
+    {
+        let fwd_path = match range.start_bound() {
+            Bound::Included(key) => root.path_next(key, Vec::new()),
+            Bound::Excluded(key) => {
+                let mut path = root.path_next(key, Vec::new());
+                if let Some(value) = Self::get(&path) {
+                    if value.cmp_keys(key) == Ordering::Equal {
+                        Self::step_forward(&mut path);
+                    }
+                }
+                path
+            }
+            Bound::Unbounded => root.path_first(Vec::new()),
+        };
+        let back_path = match range.end_bound() {
+            Bound::Included(key) => root.path_prev(key, Vec::new()),
+            Bound::Excluded(key) => {
+                let mut path = root.path_prev(key, Vec::new());
+                if let Some(value) = Self::get(&path) {
+                    if value.cmp_keys(key) == Ordering::Equal {
+                        Self::step_back(&mut path);
+                    }
+                }
+                path
+            }
+            Bound::Unbounded => root.path_last(Vec::new()),
+        };
+        Iter {
+            fwd_path,
+            back_path,
+            remaining: size,
+        }
+    }
+
+    fn get(path: &[(&'a Node<A>, usize)]) -> Option<&'a A> {
+        match path.last() {
+            Some((node, index)) => Some(&node.keys[*index]),
+            None => None,
+        }
+    }
+
+    fn step_forward(path: &mut Vec<(&'a Node<A>, usize)>) -> Option<&'a A> {
+        match path.pop() {
+            Some((node, index)) => {
+                let index = index + 1;
+                match node.children[index] {
+                    // Child between current and next key -> step down
+                    Some(ref child) => {
+                        path.push((node, index));
+                        path.push((child, 0));
+                        let mut node = child;
+                        while let Some(ref left_child) = node.children[0] {
+                            path.push((left_child, 0));
+                            node = left_child;
+                        }
+                        Some(&node.keys[0])
+                    }
+                    None => match node.keys.get(index) {
+                        // Yield next key
+                        value @ Some(_) => {
+                            path.push((node, index));
+                            value
+                        }
+                        // No more keys -> exhausted level, step up and yield
+                        None => loop {
+                            match path.pop() {
+                                None => {
+                                    return None;
+                                }
+                                Some((node, index)) => {
+                                    if let value @ Some(_) = node.keys.get(index) {
+                                        path.push((node, index));
+                                        return value;
+                                    }
+                                }
+                            }
+                        },
+                    },
+                }
+            }
+            None => None,
+        }
+    }
+
+    fn step_back(path: &mut Vec<(&'a Node<A>, usize)>) -> Option<&'a A> {
+        match path.pop() {
+            Some((node, index)) => match node.children[index] {
+                Some(ref child) => {
+                    path.push((node, index));
+                    let mut end = child.keys.len() - 1;
+                    path.push((child, end));
+                    let mut node = child;
+                    while let Some(ref right_child) = node.children[end + 1] {
+                        end = right_child.keys.len() - 1;
+                        path.push((right_child, end));
+                        node = right_child;
+                    }
+                    Some(&node.keys[end])
+                }
+                None => {
+                    if index == 0 {
+                        loop {
+                            match path.pop() {
+                                None => {
+                                    return None;
+                                }
+                                Some((node, index)) => {
+                                    if index > 0 {
+                                        let index = index - 1;
+                                        path.push((node, index));
+                                        return Some(&node.keys[index]);
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        let index = index - 1;
+                        path.push((node, index));
+                        Some(&node.keys[index])
+                    }
+                }
+            },
+            None => None,
+        }
+    }
+}
+
+impl<'a, A: 'a + BTreeValue> Iterator for Iter<'a, A> {
+    type Item = &'a A;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match Iter::get(&self.fwd_path) {
+            None => None,
+            Some(value) => match Iter::get(&self.back_path) {
+                Some(last_value) if value.cmp_values(last_value) == Ordering::Greater => None,
+                None => None,
+                Some(_) => {
+                    Iter::step_forward(&mut self.fwd_path);
+                    self.remaining -= 1;
+                    Some(value)
+                }
+            },
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        // (0, Some(self.remaining))
+        (0, None)
+    }
+}
+
+impl<'a, A: 'a + BTreeValue> DoubleEndedIterator for Iter<'a, A> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        match Iter::get(&self.back_path) {
+            None => None,
+            Some(value) => match Iter::get(&self.fwd_path) {
+                Some(last_value) if value.cmp_values(last_value) == Ordering::Less => None,
+                None => None,
+                Some(_) => {
+                    Iter::step_back(&mut self.back_path);
+                    self.remaining -= 1;
+                    Some(value)
+                }
+            },
+        }
+    }
+}
+
+// Consuming iterator
+
+enum ConsumingIterItem<A> {
+    Consider(Node<A>),
+    Yield(A),
+}
+
+/// A consuming iterator over an ordered set.
+pub struct ConsumingIter<A> {
+    fwd_last: Option<A>,
+    fwd_stack: Vec<ConsumingIterItem<A>>,
+    back_last: Option<A>,
+    back_stack: Vec<ConsumingIterItem<A>>,
+    remaining: usize,
+}
+
+impl<A: Clone> ConsumingIter<A> {
+    pub(crate) fn new(root: &Node<A>, total: usize) -> Self {
+        ConsumingIter {
+            fwd_last: None,
+            fwd_stack: vec![ConsumingIterItem::Consider(root.clone())],
+            back_last: None,
+            back_stack: vec![ConsumingIterItem::Consider(root.clone())],
+            remaining: total,
+        }
+    }
+
+    fn push_node(stack: &mut Vec<ConsumingIterItem<A>>, maybe_node: Option<PoolRef<Node<A>>>) {
+        if let Some(node) = maybe_node {
+            stack.push(ConsumingIterItem::Consider(PoolRef::unwrap_or_clone(node)))
+        }
+    }
+
+    fn push(stack: &mut Vec<ConsumingIterItem<A>>, mut node: Node<A>) {
+        for _n in 0..node.keys.len() {
+            ConsumingIter::push_node(stack, node.children.pop_back());
+            stack.push(ConsumingIterItem::Yield(node.keys.pop_back()));
+        }
+        ConsumingIter::push_node(stack, node.children.pop_back());
+    }
+
+    fn push_fwd(&mut self, node: Node<A>) {
+        ConsumingIter::push(&mut self.fwd_stack, node)
+    }
+
+    fn push_node_back(&mut self, maybe_node: Option<PoolRef<Node<A>>>) {
+        if let Some(node) = maybe_node {
+            self.back_stack
+                .push(ConsumingIterItem::Consider(PoolRef::unwrap_or_clone(node)))
+        }
+    }
+
+    fn push_back(&mut self, mut node: Node<A>) {
+        for _i in 0..node.keys.len() {
+            self.push_node_back(node.children.pop_front());
+            self.back_stack
+                .push(ConsumingIterItem::Yield(node.keys.pop_front()));
+        }
+        self.push_node_back(node.children.pop_back());
+    }
+}
+
+impl<A> Iterator for ConsumingIter<A>
+where
+    A: BTreeValue + Clone,
+{
+    type Item = A;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.fwd_stack.pop() {
+                None => {
+                    self.remaining = 0;
+                    return None;
+                }
+                Some(ConsumingIterItem::Consider(node)) => self.push_fwd(node),
+                Some(ConsumingIterItem::Yield(value)) => {
+                    if let Some(ref last) = self.back_last {
+                        if value.cmp_values(last) != Ordering::Less {
+                            self.fwd_stack.clear();
+                            self.back_stack.clear();
+                            self.remaining = 0;
+                            return None;
+                        }
+                    }
+                    self.remaining -= 1;
+                    self.fwd_last = Some(value.clone());
+                    return Some(value);
+                }
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.remaining, Some(self.remaining))
+    }
+}
+
+impl<A> DoubleEndedIterator for ConsumingIter<A>
+where
+    A: BTreeValue + Clone,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.back_stack.pop() {
+                None => {
+                    self.remaining = 0;
+                    return None;
+                }
+                Some(ConsumingIterItem::Consider(node)) => self.push_back(node),
+                Some(ConsumingIterItem::Yield(value)) => {
+                    if let Some(ref last) = self.fwd_last {
+                        if value.cmp_values(last) != Ordering::Greater {
+                            self.fwd_stack.clear();
+                            self.back_stack.clear();
+                            self.remaining = 0;
+                            return None;
+                        }
+                    }
+                    self.remaining -= 1;
+                    self.back_last = Some(value.clone());
+                    return Some(value);
+                }
+            }
+        }
+    }
+}
+
+impl<A: BTreeValue + Clone> ExactSizeIterator for ConsumingIter<A> {}
+
+// DiffIter
+
+/// An iterator over the differences between two ordered sets.
+pub struct DiffIter<'a, A> {
+    old_stack: Vec<IterItem<'a, A>>,
+    new_stack: Vec<IterItem<'a, A>>,
+}
+
+/// A description of a difference between two ordered sets.
+#[derive(PartialEq, Eq, Debug)]
+pub enum DiffItem<'a, A> {
+    /// This value has been added to the new set.
+    Add(&'a A),
+    /// This value has been changed between the two sets.
+    Update {
+        /// The old value.
+        old: &'a A,
+        /// The new value.
+        new: &'a A,
+    },
+    /// This value has been removed from the new set.
+    Remove(&'a A),
+}
+
+enum IterItem<'a, A> {
+    Consider(&'a Node<A>),
+    Yield(&'a A),
+}
+
+impl<'a, A: 'a> DiffIter<'a, A> {
+    pub(crate) fn new(old: &'a Node<A>, new: &'a Node<A>) -> Self {
+        DiffIter {
+            old_stack: if old.keys.is_empty() {
+                Vec::new()
+            } else {
+                vec![IterItem::Consider(old)]
+            },
+            new_stack: if new.keys.is_empty() {
+                Vec::new()
+            } else {
+                vec![IterItem::Consider(new)]
+            },
+        }
+    }
+
+    fn push_node(stack: &mut Vec<IterItem<'a, A>>, maybe_node: &'a Option<PoolRef<Node<A>>>) {
+        if let Some(ref node) = *maybe_node {
+            stack.push(IterItem::Consider(node))
+        }
+    }
+
+    fn push(stack: &mut Vec<IterItem<'a, A>>, node: &'a Node<A>) {
+        for n in 0..node.keys.len() {
+            let i = node.keys.len() - n;
+            Self::push_node(stack, &node.children[i]);
+            stack.push(IterItem::Yield(&node.keys[i - 1]));
+        }
+        Self::push_node(stack, &node.children[0]);
+    }
+}
+
+impl<'a, A> Iterator for DiffIter<'a, A>
+where
+    A: 'a + BTreeValue + PartialEq,
+{
+    type Item = DiffItem<'a, A>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match (self.old_stack.pop(), self.new_stack.pop()) {
+                (None, None) => return None,
+                (None, Some(new)) => match new {
+                    IterItem::Consider(new) => Self::push(&mut self.new_stack, new),
+                    IterItem::Yield(new) => return Some(DiffItem::Add(new)),
+                },
+                (Some(old), None) => match old {
+                    IterItem::Consider(old) => Self::push(&mut self.old_stack, old),
+                    IterItem::Yield(old) => return Some(DiffItem::Remove(old)),
+                },
+                (Some(old), Some(new)) => match (old, new) {
+                    (IterItem::Consider(old), IterItem::Consider(new)) => {
+                        if !std::ptr::eq(old, new) {
+                            match old.keys[0].cmp_values(&new.keys[0]) {
+                                Ordering::Less => {
+                                    Self::push(&mut self.old_stack, old);
+                                    self.new_stack.push(IterItem::Consider(new));
+                                }
+                                Ordering::Greater => {
+                                    self.old_stack.push(IterItem::Consider(old));
+                                    Self::push(&mut self.new_stack, new);
+                                }
+                                Ordering::Equal => {
+                                    Self::push(&mut self.old_stack, old);
+                                    Self::push(&mut self.new_stack, new);
+                                }
+                            }
+                        }
+                    }
+                    (IterItem::Consider(old), IterItem::Yield(new)) => {
+                        Self::push(&mut self.old_stack, old);
+                        self.new_stack.push(IterItem::Yield(new));
+                    }
+                    (IterItem::Yield(old), IterItem::Consider(new)) => {
+                        self.old_stack.push(IterItem::Yield(old));
+                        Self::push(&mut self.new_stack, new);
+                    }
+                    (IterItem::Yield(old), IterItem::Yield(new)) => match old.cmp_values(new) {
+                        Ordering::Less => {
+                            self.new_stack.push(IterItem::Yield(new));
+                            return Some(DiffItem::Remove(old));
+                        }
+                        Ordering::Equal => {
+                            if old != new {
+                                return Some(DiffItem::Update { old, new });
+                            }
+                        }
+                        Ordering::Greater => {
+                            self.old_stack.push(IterItem::Yield(old));
+                            return Some(DiffItem::Add(new));
+                        }
+                    },
+                },
+            }
+        }
+    }
+}
diff --git a/vendor/im-rc/src/nodes/hamt.rs b/vendor/im-rc/src/nodes/hamt.rs
new file mode 100644
index 000000000..945068be3
--- /dev/null
+++ b/vendor/im-rc/src/nodes/hamt.rs
@@ -0,0 +1,726 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use std::borrow::Borrow;
+use std::fmt;
+use std::hash::{BuildHasher, Hash, Hasher};
+use std::iter::FusedIterator;
+use std::slice::{Iter as SliceIter, IterMut as SliceIterMut};
+use std::{mem, ptr};
+
+use bitmaps::Bits;
+use sized_chunks::sparse_chunk::{Iter as ChunkIter, IterMut as ChunkIterMut, SparseChunk};
+use typenum::{Pow, Unsigned, U2};
+
+use crate::config::HashLevelSize;
+use crate::util::{clone_ref, Pool, PoolClone, PoolDefault, PoolRef, Ref};
+
+pub(crate) type HashWidth = <U2 as Pow<HashLevelSize>>::Output;
+pub(crate) type HashBits = <HashWidth as Bits>::Store; // a uint of HASH_SIZE bits
+pub(crate) const HASH_SHIFT: usize = HashLevelSize::USIZE;
+pub(crate) const HASH_WIDTH: usize = HashWidth::USIZE;
+pub(crate) const HASH_MASK: HashBits = (HASH_WIDTH - 1) as HashBits;
+
+pub(crate) fn hash_key<K: Hash + ?Sized, S: BuildHasher>(bh: &S, key: &K) -> HashBits {
+    let mut hasher = bh.build_hasher();
+    key.hash(&mut hasher);
+    hasher.finish() as HashBits
+}
+
+#[inline]
+fn mask(hash: HashBits, shift: usize) -> HashBits {
+    hash >> shift & HASH_MASK
+}
+
+pub trait HashValue {
+    type Key: Eq;
+
+    fn extract_key(&self) -> &Self::Key;
+    fn ptr_eq(&self, other: &Self) -> bool;
+}
+
+#[derive(Clone)]
+pub(crate) struct Node<A> {
+    data: SparseChunk<Entry<A>, HashWidth>,
+}
+
+#[allow(unsafe_code)]
+impl<A> PoolDefault for Node<A> {
+    #[cfg(feature = "pool")]
+    unsafe fn default_uninit(target: &mut mem::MaybeUninit<Self>) {
+        SparseChunk::default_uninit(
+            target
+                .as_mut_ptr()
+                .cast::<mem::MaybeUninit<SparseChunk<Entry<A>, HashWidth>>>()
+                .as_mut()
+                .unwrap(),
+        )
+    }
+}
+
+#[allow(unsafe_code)]
+impl<A> PoolClone for Node<A>
+where
+    A: Clone,
+{
+    #[cfg(feature = "pool")]
+    unsafe fn clone_uninit(&self, target: &mut mem::MaybeUninit<Self>) {
+        self.data.clone_uninit(
+            target
+                .as_mut_ptr()
+                .cast::<mem::MaybeUninit<SparseChunk<Entry<A>, HashWidth>>>()
+                .as_mut()
+                .unwrap(),
+        )
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct CollisionNode<A> {
+    hash: HashBits,
+    data: Vec<A>,
+}
+
+pub(crate) enum Entry<A> {
+    Value(A, HashBits),
+    Collision(Ref<CollisionNode<A>>),
+    Node(PoolRef<Node<A>>),
+}
+
+impl<A: Clone> Clone for Entry<A> {
+    fn clone(&self) -> Self {
+        match self {
+            Entry::Value(value, hash) => Entry::Value(value.clone(), *hash),
+            Entry::Collision(coll) => Entry::Collision(coll.clone()),
+            Entry::Node(node) => Entry::Node(node.clone()),
+        }
+    }
+}
+
+impl<A> Entry<A> {
+    fn is_value(&self) -> bool {
+        matches!(self, Entry::Value(_, _))
+    }
+
+    fn unwrap_value(self) -> A {
+        match self {
+            Entry::Value(a, _) => a,
+            _ => panic!("nodes::hamt::Entry::unwrap_value: unwrapped a non-value"),
+        }
+    }
+
+    fn from_node(pool: &Pool<Node<A>>, node: Node<A>) -> Self {
+        Entry::Node(PoolRef::new(pool, node))
+    }
+}
+
+impl<A> From<CollisionNode<A>> for Entry<A> {
+    fn from(node: CollisionNode<A>) -> Self {
+        Entry::Collision(Ref::new(node))
+    }
+}
+
+impl<A> Default for Node<A> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<A> Node<A> {
+    #[inline]
+    pub(crate) fn new() -> Self {
+        Node {
+            data: SparseChunk::new(),
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    #[inline]
+    pub(crate) fn unit(index: usize, value: Entry<A>) -> Self {
+        Node {
+            data: SparseChunk::unit(index, value),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn pair(index1: usize, value1: Entry<A>, index2: usize, value2: Entry<A>) -> Self {
+        Node {
+            data: SparseChunk::pair(index1, value1, index2, value2),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn single_child(pool: &Pool<Node<A>>, index: usize, node: Self) -> Self {
+        Node {
+            data: SparseChunk::unit(index, Entry::from_node(pool, node)),
+        }
+    }
+
+    fn pop(&mut self) -> Entry<A> {
+        self.data.pop().unwrap()
+    }
+}
+
+impl<A: HashValue> Node<A> {
+    fn merge_values(
+        pool: &Pool<Node<A>>,
+        value1: A,
+        hash1: HashBits,
+        value2: A,
+        hash2: HashBits,
+        shift: usize,
+    ) -> Self {
+        let index1 = mask(hash1, shift) as usize;
+        let index2 = mask(hash2, shift) as usize;
+        if index1 != index2 {
+            // Both values fit on the same level.
+            Node::pair(
+                index1,
+                Entry::Value(value1, hash1),
+                index2,
+                Entry::Value(value2, hash2),
+            )
+        } else if shift + HASH_SHIFT >= HASH_WIDTH {
+            // If we're at the bottom, we've got a collision.
+            Node::unit(
+                index1,
+                Entry::from(CollisionNode::new(hash1, value1, value2)),
+            )
+        } else {
+            // Pass the values down a level.
+            let node = Node::merge_values(pool, value1, hash1, value2, hash2, shift + HASH_SHIFT);
+            Node::single_child(pool, index1, node)
+        }
+    }
+
+    pub(crate) fn get<BK>(&self, hash: HashBits, shift: usize, key: &BK) -> Option<&A>
+    where
+        BK: Eq + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        let index = mask(hash, shift) as usize;
+        if let Some(entry) = self.data.get(index) {
+            match entry {
+                Entry::Value(ref value, _) => {
+                    if key == value.extract_key().borrow() {
+                        Some(value)
+                    } else {
+                        None
+                    }
+                }
+                Entry::Collision(ref coll) => coll.get(key),
+                Entry::Node(ref child) => child.get(hash, shift + HASH_SHIFT, key),
+            }
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn get_mut<BK>(
+        &mut self,
+        pool: &Pool<Node<A>>,
+        hash: HashBits,
+        shift: usize,
+        key: &BK,
+    ) -> Option<&mut A>
+    where
+        A: Clone,
+        BK: Eq + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        let index = mask(hash, shift) as usize;
+        if let Some(entry) = self.data.get_mut(index) {
+            match entry {
+                Entry::Value(ref mut value, _) => {
+                    if key == value.extract_key().borrow() {
+                        Some(value)
+                    } else {
+                        None
+                    }
+                }
+                Entry::Collision(ref mut coll_ref) => {
+                    let coll = Ref::make_mut(coll_ref);
+                    coll.get_mut(key)
+                }
+                Entry::Node(ref mut child_ref) => {
+                    let child = PoolRef::make_mut(pool, child_ref);
+                    child.get_mut(pool, hash, shift + HASH_SHIFT, key)
+                }
+            }
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn insert(
+        &mut self,
+        pool: &Pool<Node<A>>,
+        hash: HashBits,
+        shift: usize,
+        value: A,
+    ) -> Option<A>
+    where
+        A: Clone,
+    {
+        let index = mask(hash, shift) as usize;
+        if let Some(entry) = self.data.get_mut(index) {
+            let mut fallthrough = false;
+            // Value is here
+            match entry {
+                // Update value or create a subtree
+                Entry::Value(ref current, _) => {
+                    if current.extract_key() == value.extract_key() {
+                        // If we have a key match, fall through to the outer
+                        // level where we replace the current value. If we
+                        // don't, fall through to the inner level where we merge
+                        // some nodes.
+                        fallthrough = true;
+                    }
+                }
+                // There's already a collision here.
+                Entry::Collision(ref mut collision) => {
+                    let coll = Ref::make_mut(collision);
+                    return coll.insert(value);
+                }
+                Entry::Node(ref mut child_ref) => {
+                    // Child node
+                    let child = PoolRef::make_mut(pool, child_ref);
+                    return child.insert(pool, hash, shift + HASH_SHIFT, value);
+                }
+            }
+            if !fallthrough {
+                // If we get here, we're looking at a value entry that needs a merge.
+                // We're going to be unsafe and pry it out of the reference, trusting
+                // that we overwrite it with the merged node.
+                #[allow(unsafe_code)]
+                let old_entry = unsafe { ptr::read(entry) };
+                if shift + HASH_SHIFT >= HASH_WIDTH {
+                    // We're at the lowest level, need to set up a collision node.
+                    let coll = CollisionNode::new(hash, old_entry.unwrap_value(), value);
+                    #[allow(unsafe_code)]
+                    unsafe {
+                        ptr::write(entry, Entry::from(coll))
+                    };
+                } else if let Entry::Value(old_value, old_hash) = old_entry {
+                    let node = Node::merge_values(
+                        pool,
+                        old_value,
+                        old_hash,
+                        value,
+                        hash,
+                        shift + HASH_SHIFT,
+                    );
+                    #[allow(unsafe_code)]
+                    unsafe {
+                        ptr::write(entry, Entry::from_node(pool, node))
+                    };
+                } else {
+                    unreachable!()
+                }
+                return None;
+            }
+        }
+        // If we get here, either we found nothing at this index, in which case
+        // we insert a new entry, or we hit a value entry with the same key, in
+        // which case we replace it.
+        self.data
+            .insert(index, Entry::Value(value, hash))
+            .map(Entry::unwrap_value)
+    }
+
+    pub(crate) fn remove<BK>(
+        &mut self,
+        pool: &Pool<Node<A>>,
+        hash: HashBits,
+        shift: usize,
+        key: &BK,
+    ) -> Option<A>
+    where
+        A: Clone,
+        BK: Eq + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        let index = mask(hash, shift) as usize;
+        let mut new_node = None;
+        let mut removed = None;
+        if let Some(entry) = self.data.get_mut(index) {
+            match entry {
+                Entry::Value(ref value, _) => {
+                    if key != value.extract_key().borrow() {
+                        // Key wasn't in the map.
+                        return None;
+                    } // Otherwise, fall through to the removal.
+                }
+                Entry::Collision(ref mut coll_ref) => {
+                    let coll = Ref::make_mut(coll_ref);
+                    removed = coll.remove(key);
+                    if coll.len() == 1 {
+                        new_node = Some(coll.pop());
+                    } else {
+                        return removed;
+                    }
+                }
+                Entry::Node(ref mut child_ref) => {
+                    let child = PoolRef::make_mut(pool, child_ref);
+                    match child.remove(pool, hash, shift + HASH_SHIFT, key) {
+                        None => {
+                            return None;
+                        }
+                        Some(value) => {
+                            if child.len() == 1
+                                && child.data[child.data.first_index().unwrap()].is_value()
+                            {
+                                // If the child now contains only a single value node,
+                                // pull it up one level and discard the child.
+                                removed = Some(value);
+                                new_node = Some(child.pop());
+                            } else {
+                                return Some(value);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if let Some(node) = new_node {
+            self.data.insert(index, node);
+            return removed;
+        }
+        self.data.remove(index).map(Entry::unwrap_value)
+    }
+}
+
+impl<A: HashValue> CollisionNode<A> {
+    fn new(hash: HashBits, value1: A, value2: A) -> Self {
+        CollisionNode {
+            hash,
+            data: vec![value1, value2],
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    fn get<BK>(&self, key: &BK) -> Option<&A>
+    where
+        BK: Eq + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        for entry in &self.data {
+            if key == entry.extract_key().borrow() {
+                return Some(entry);
+            }
+        }
+        None
+    }
+
+    fn get_mut<BK>(&mut self, key: &BK) -> Option<&mut A>
+    where
+        BK: Eq + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        for entry in &mut self.data {
+            if key == entry.extract_key().borrow() {
+                return Some(entry);
+            }
+        }
+        None
+    }
+
+    fn insert(&mut self, value: A) -> Option<A> {
+        for item in &mut self.data {
+            if value.extract_key() == item.extract_key() {
+                return Some(mem::replace(item, value));
+            }
+        }
+        self.data.push(value);
+        None
+    }
+
+    fn remove<BK>(&mut self, key: &BK) -> Option<A>
+    where
+        BK: Eq + ?Sized,
+        A::Key: Borrow<BK>,
+    {
+        let mut loc = None;
+        for (index, item) in self.data.iter().enumerate() {
+            if key == item.extract_key().borrow() {
+                loc = Some(index);
+            }
+        }
+        if let Some(index) = loc {
+            Some(self.data.remove(index))
+        } else {
+            None
+        }
+    }
+
+    fn pop(&mut self) -> Entry<A> {
+        Entry::Value(self.data.pop().unwrap(), self.hash)
+    }
+}
+
+// Ref iterator
+
+pub(crate) struct Iter<'a, A> {
+    count: usize,
+    stack: Vec<ChunkIter<'a, Entry<A>, HashWidth>>,
+    current: ChunkIter<'a, Entry<A>, HashWidth>,
+    collision: Option<(HashBits, SliceIter<'a, A>)>,
+}
+
+impl<'a, A> Iter<'a, A>
+where
+    A: 'a,
+{
+    pub(crate) fn new(root: &'a Node<A>, size: usize) -> Self {
+        Iter {
+            count: size,
+            stack: Vec::with_capacity((HASH_WIDTH / HASH_SHIFT) + 1),
+            current: root.data.iter(),
+            collision: None,
+        }
+    }
+}
+
+impl<'a, A> Iterator for Iter<'a, A>
+where
+    A: 'a,
+{
+    type Item = (&'a A, HashBits);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.count == 0 {
+            return None;
+        }
+        if self.collision.is_some() {
+            if let Some((hash, ref mut coll)) = self.collision {
+                match coll.next() {
+                    None => {}
+                    Some(value) => {
+                        self.count -= 1;
+                        return Some((value, hash));
+                    }
+                }
+            }
+            self.collision = None;
+            return self.next();
+        }
+        match self.current.next() {
+            Some(Entry::Value(value, hash)) => {
+                self.count -= 1;
+                Some((value, *hash))
+            }
+            Some(Entry::Node(child)) => {
+                let current = mem::replace(&mut self.current, child.data.iter());
+                self.stack.push(current);
+                self.next()
+            }
+            Some(Entry::Collision(coll)) => {
+                self.collision = Some((coll.hash, coll.data.iter()));
+                self.next()
+            }
+            None => match self.stack.pop() {
+                None => None,
+                Some(iter) => {
+                    self.current = iter;
+                    self.next()
+                }
+            },
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.count, Some(self.count))
+    }
+}
+
+impl<'a, A> ExactSizeIterator for Iter<'a, A> where A: 'a {}
+
+impl<'a, A> FusedIterator for Iter<'a, A> where A: 'a {}
+
+// Mut ref iterator
+
+pub(crate) struct IterMut<'a, A> {
+    count: usize,
+    pool: Pool<Node<A>>,
+    stack: Vec<ChunkIterMut<'a, Entry<A>, HashWidth>>,
+    current: ChunkIterMut<'a, Entry<A>, HashWidth>,
+    collision: Option<(HashBits, SliceIterMut<'a, A>)>,
+}
+
+impl<'a, A> IterMut<'a, A>
+where
+    A: 'a,
+{
+    pub(crate) fn new(pool: &Pool<Node<A>>, root: &'a mut Node<A>, size: usize) -> Self {
+        IterMut {
+            count: size,
+            pool: pool.clone(),
+            stack: Vec::with_capacity((HASH_WIDTH / HASH_SHIFT) + 1),
+            current: root.data.iter_mut(),
+            collision: None,
+        }
+    }
+}
+
+impl<'a, A> Iterator for IterMut<'a, A>
+where
+    A: Clone + 'a,
+{
+    type Item = (&'a mut A, HashBits);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.count == 0 {
+            return None;
+        }
+        if self.collision.is_some() {
+            if let Some((hash, ref mut coll)) = self.collision {
+                match coll.next() {
+                    None => {}
+                    Some(value) => {
+                        self.count -= 1;
+                        return Some((value, hash));
+                    }
+                }
+            }
+            self.collision = None;
+            return self.next();
+        }
+        match self.current.next() {
+            Some(Entry::Value(value, hash)) => {
+                self.count -= 1;
+                Some((value, *hash))
+            }
+            Some(Entry::Node(child_ref)) => {
+                let child = PoolRef::make_mut(&self.pool, child_ref);
+                let current = mem::replace(&mut self.current, child.data.iter_mut());
+                self.stack.push(current);
+                self.next()
+            }
+            Some(Entry::Collision(coll_ref)) => {
+                let coll = Ref::make_mut(coll_ref);
+                self.collision = Some((coll.hash, coll.data.iter_mut()));
+                self.next()
+            }
+            None => match self.stack.pop() {
+                None => None,
+                Some(iter) => {
+                    self.current = iter;
+                    self.next()
+                }
+            },
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.count, Some(self.count))
+    }
+}
+
+impl<'a, A> ExactSizeIterator for IterMut<'a, A> where A: Clone + 'a {}
+
+impl<'a, A> FusedIterator for IterMut<'a, A> where A: Clone + 'a {}
+
+// Consuming iterator
+
+pub(crate) struct Drain<A>
+where
+    A: HashValue,
+{
+    count: usize,
+    pool: Pool<Node<A>>,
+    stack: Vec<PoolRef<Node<A>>>,
+    current: PoolRef<Node<A>>,
+    collision: Option<CollisionNode<A>>,
+}
+
+impl<A> Drain<A>
+where
+    A: HashValue,
+{
+    pub(crate) fn new(pool: &Pool<Node<A>>, root: PoolRef<Node<A>>, size: usize) -> Self {
+        Drain {
+            count: size,
+            pool: pool.clone(),
+            stack: vec![],
+            current: root,
+            collision: None,
+        }
+    }
+}
+
+impl<A> Iterator for Drain<A>
+where
+    A: HashValue + Clone,
+{
+    type Item = (A, HashBits);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.count == 0 {
+            return None;
+        }
+        if self.collision.is_some() {
+            if let Some(ref mut coll) = self.collision {
+                if let Some(value) = coll.data.pop() {
+                    self.count -= 1;
+                    return Some((value, coll.hash));
+                }
+            }
+            self.collision = None;
+            return self.next();
+        }
+        match PoolRef::make_mut(&self.pool, &mut self.current).data.pop() {
+            Some(Entry::Value(value, hash)) => {
+                self.count -= 1;
+                Some((value, hash))
+            }
+            Some(Entry::Collision(coll_ref)) => {
+                self.collision = Some(clone_ref(coll_ref));
+                self.next()
+            }
+            Some(Entry::Node(child)) => {
+                let parent = mem::replace(&mut self.current, child);
+                self.stack.push(parent);
+                self.next()
+            }
+            None => match self.stack.pop() {
+                None => None,
+                Some(parent) => {
+                    self.current = parent;
+                    self.next()
+                }
+            },
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.count, Some(self.count))
+    }
+}
+
+impl<A: HashValue> ExactSizeIterator for Drain<A> where A: Clone {}
+
+impl<A: HashValue> FusedIterator for Drain<A> where A: Clone {}
+
+impl<A: HashValue + fmt::Debug> fmt::Debug for Node<A> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        write!(f, "Node[ ")?;
+        for i in self.data.indices() {
+            write!(f, "{}: ", i)?;
+            match &self.data[i] {
+                Entry::Value(v, h) => write!(f, "{:?} :: {}, ", v, h)?,
+                Entry::Collision(c) => write!(f, "Coll{:?} :: {}", c.data, c.hash)?,
+                Entry::Node(n) => write!(f, "{:?}, ", n)?,
+            }
+        }
+        write!(f, " ]")
+    }
+}
diff --git a/vendor/im-rc/src/nodes/mod.rs b/vendor/im-rc/src/nodes/mod.rs
new file mode 100644
index 000000000..24e745504
--- /dev/null
+++ b/vendor/im-rc/src/nodes/mod.rs
@@ -0,0 +1,16 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+pub(crate) mod btree;
+pub(crate) mod hamt;
+pub(crate) mod rrb;
+
+pub(crate) mod chunk {
+    use crate::config::VectorChunkSize;
+    use sized_chunks as sc;
+    use typenum::Unsigned;
+
+    pub(crate) type Chunk<A> = sc::sized_chunk::Chunk<A, VectorChunkSize>;
+    pub(crate) const CHUNK_SIZE: usize = VectorChunkSize::USIZE;
+}
diff --git a/vendor/im-rc/src/nodes/rrb.rs b/vendor/im-rc/src/nodes/rrb.rs
new file mode 100644
index 000000000..8809b84b8
--- /dev/null
+++ b/vendor/im-rc/src/nodes/rrb.rs
@@ -0,0 +1,1101 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use std::mem::replace;
+use std::ops::Range;
+
+use crate::nodes::chunk::{Chunk, CHUNK_SIZE};
+use crate::util::{
+    Pool, PoolRef,
+    Side::{self, Left, Right},
+};
+use crate::vector::RRBPool;
+
+use self::Entry::*;
+
+pub(crate) const NODE_SIZE: usize = CHUNK_SIZE;
+
+#[derive(Debug)]
+enum Size {
+    Size(usize),
+    Table(PoolRef<Chunk<usize>>),
+}
+
+impl Clone for Size {
+    fn clone(&self) -> Self {
+        match *self {
+            Size::Size(size) => Size::Size(size),
+            Size::Table(ref table) => Size::Table(table.clone()),
+        }
+    }
+}
+
+impl Size {
+    fn size(&self) -> usize {
+        match self {
+            Size::Size(s) => *s,
+            Size::Table(sizes) => *sizes.last().unwrap_or(&0),
+        }
+    }
+
+    fn is_size(&self) -> bool {
+        match self {
+            Size::Size(_) => true,
+            Size::Table(_) => false,
+        }
+    }
+
+    fn table_from_size(pool: &Pool<Chunk<usize>>, level: usize, size: usize) -> Self {
+        let mut chunk = Chunk::new();
+        let mut remaining = size;
+        if let Some(child_size) = NODE_SIZE.checked_pow(level as u32) {
+            while remaining > child_size {
+                let next_value = chunk.last().unwrap_or(&0) + child_size;
+                chunk.push_back(next_value);
+                remaining -= child_size;
+            }
+        }
+        if remaining > 0 {
+            let next_value = chunk.last().unwrap_or(&0) + remaining;
+            chunk.push_back(next_value);
+        }
+        Size::Table(PoolRef::new(pool, chunk))
+    }
+
+    fn push(&mut self, pool: &Pool<Chunk<usize>>, side: Side, level: usize, value: usize) {
+        let size = match self {
+            Size::Size(ref mut size) => match side {
+                Left => *size,
+                Right => {
+                    *size += value;
+                    return;
+                }
+            },
+            Size::Table(ref mut size_ref) => {
+                let size_table = PoolRef::make_mut(pool, size_ref);
+                debug_assert!(size_table.len() < NODE_SIZE);
+                match side {
+                    Left => {
+                        for entry in size_table.iter_mut() {
+                            *entry += value;
+                        }
+                        size_table.push_front(value);
+                    }
+                    Right => {
+                        let prev = *(size_table.last().unwrap_or(&0));
+                        size_table.push_back(value + prev);
+                    }
+                }
+                return;
+            }
+        };
+        *self = Size::table_from_size(pool, level, size);
+        self.push(pool, side, level, value);
+    }
+
+    fn pop(&mut self, pool: &Pool<Chunk<usize>>, side: Side, level: usize, value: usize) {
+        let size = match self {
+            Size::Size(ref mut size) => match side {
+                Left => *size,
+                Right => {
+                    *size -= value;
+                    return;
+                }
+            },
+            Size::Table(ref mut size_ref) => {
+                let size_table = PoolRef::make_mut(pool, size_ref);
+                match side {
+                    Left => {
+                        let first = size_table.pop_front();
+                        debug_assert_eq!(value, first);
+                        for entry in size_table.iter_mut() {
+                            *entry -= value;
+                        }
+                    }
+                    Right => {
+                        let pop = size_table.pop_back();
+                        let last = size_table.last().unwrap_or(&0);
+                        debug_assert_eq!(value, pop - last);
+                    }
+                }
+                return;
+            }
+        };
+        *self = Size::table_from_size(pool, level, size);
+        self.pop(pool, side, level, value);
+    }
+
+    fn update(&mut self, pool: &Pool<Chunk<usize>>, index: usize, level: usize, value: isize) {
+        let size = match self {
+            Size::Size(ref size) => *size,
+            Size::Table(ref mut size_ref) => {
+                let size_table = PoolRef::make_mut(pool, size_ref);
+                for entry in size_table.iter_mut().skip(index) {
+                    *entry = (*entry as isize + value) as usize;
+                }
+                return;
+            }
+        };
+        *self = Size::table_from_size(pool, level, size);
+        self.update(pool, index, level, value);
+    }
+}
+
+pub(crate) enum PushResult<A> {
+    Full(A, usize),
+    Done,
+}
+
+pub(crate) enum PopResult<A> {
+    Done(A),
+    Drained(A),
+    Empty,
+}
+
+pub(crate) enum SplitResult {
+    Dropped(usize),
+    OutOfBounds,
+}
+
+// Invariants: Nodes only at level > 0, Values/Empty only at level = 0
+enum Entry<A> {
+    Nodes(Size, PoolRef<Chunk<Node<A>>>),
+    Values(PoolRef<Chunk<A>>),
+    Empty,
+}
+
+impl<A: Clone> Clone for Entry<A> {
+    fn clone(&self) -> Self {
+        match *self {
+            Nodes(ref size, ref nodes) => Nodes(size.clone(), nodes.clone()),
+            Values(ref values) => Values(values.clone()),
+            Empty => Empty,
+        }
+    }
+}
+
+impl<A: Clone> Entry<A> {
+    fn len(&self) -> usize {
+        match self {
+            Nodes(_, ref nodes) => nodes.len(),
+            Values(ref values) => values.len(),
+            Empty => 0,
+        }
+    }
+
+    fn is_full(&self) -> bool {
+        match self {
+            Nodes(_, ref nodes) => nodes.is_full(),
+            Values(ref values) => values.is_full(),
+            Empty => false,
+        }
+    }
+
+    fn unwrap_values(&self) -> &Chunk<A> {
+        match self {
+            Values(ref values) => values,
+            _ => panic!("rrb::Entry::unwrap_values: expected values, found nodes"),
+        }
+    }
+
+    fn unwrap_nodes(&self) -> &Chunk<Node<A>> {
+        match self {
+            Nodes(_, ref nodes) => nodes,
+            _ => panic!("rrb::Entry::unwrap_nodes: expected nodes, found values"),
+        }
+    }
+
+    fn unwrap_values_mut(&mut self, pool: &RRBPool<A>) -> &mut Chunk<A> {
+        match self {
+            Values(ref mut values) => PoolRef::make_mut(&pool.value_pool, values),
+            _ => panic!("rrb::Entry::unwrap_values_mut: expected values, found nodes"),
+        }
+    }
+
+    fn unwrap_nodes_mut(&mut self, pool: &RRBPool<A>) -> &mut Chunk<Node<A>> {
+        match self {
+            Nodes(_, ref mut nodes) => PoolRef::make_mut(&pool.node_pool, nodes),
+            _ => panic!("rrb::Entry::unwrap_nodes_mut: expected nodes, found values"),
+        }
+    }
+
+    fn values(self) -> Chunk<A> {
+        match self {
+            Values(values) => PoolRef::unwrap_or_clone(values),
+            _ => panic!("rrb::Entry::values: expected values, found nodes"),
+        }
+    }
+
+    fn nodes(self) -> Chunk<Node<A>> {
+        match self {
+            Nodes(_, nodes) => PoolRef::unwrap_or_clone(nodes),
+            _ => panic!("rrb::Entry::nodes: expected nodes, found values"),
+        }
+    }
+
+    fn is_empty_node(&self) -> bool {
+        matches!(self, Empty)
+    }
+}
+
+// Node
+
+pub(crate) struct Node<A> {
+    children: Entry<A>,
+}
+
+impl<A: Clone> Clone for Node<A> {
+    fn clone(&self) -> Self {
+        Node {
+            children: self.children.clone(),
+        }
+    }
+}
+
+impl<A: Clone> Default for Node<A> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<A: Clone> Node<A> {
+    pub(crate) fn new() -> Self {
+        Node { children: Empty }
+    }
+
+    pub(crate) fn parent(pool: &RRBPool<A>, level: usize, children: Chunk<Self>) -> Self {
+        let size = {
+            let mut size = Size::Size(0);
+            let mut it = children.iter().peekable();
+            loop {
+                match it.next() {
+                    None => break,
+                    Some(child) => {
+                        if size.is_size()
+                            && !child.is_completely_dense(level - 1)
+                            && it.peek().is_some()
+                        {
+                            size = Size::table_from_size(&pool.size_pool, level, size.size());
+                        }
+                        size.push(&pool.size_pool, Right, level, child.len())
+                    }
+                }
+            }
+            size
+        };
+        Node {
+            children: Nodes(size, PoolRef::new(&pool.node_pool, children)),
+        }
+    }
+
+    pub(crate) fn clear_node(&mut self) {
+        self.children = Empty;
+    }
+
+    pub(crate) fn from_chunk(pool: &RRBPool<A>, level: usize, chunk: PoolRef<Chunk<A>>) -> Self {
+        let node = Node {
+            children: Values(chunk),
+        };
+        node.elevate(pool, level)
+    }
+
+    pub(crate) fn single_parent(pool: &RRBPool<A>, node: Self) -> Self {
+        let size = if node.is_dense() {
+            Size::Size(node.len())
+        } else {
+            let size_table = Chunk::unit(node.len());
+            Size::Table(PoolRef::new(&pool.size_pool, size_table))
+        };
+        let children = PoolRef::new(&pool.node_pool, Chunk::unit(node));
+        Node {
+            children: Nodes(size, children),
+        }
+    }
+
+    pub(crate) fn join_dense(pool: &RRBPool<A>, left: Self, right: Self) -> Self {
+        let left_len = left.len();
+        let right_len = right.len();
+        Node {
+            children: {
+                let children = PoolRef::new(&pool.node_pool, Chunk::pair(left, right));
+                Nodes(Size::Size(left_len + right_len), children)
+            },
+        }
+    }
+
+    pub(crate) fn elevate(self, pool: &RRBPool<A>, level_increment: usize) -> Self {
+        if level_increment > 0 {
+            Self::single_parent(pool, self.elevate(pool, level_increment - 1))
+        } else {
+            self
+        }
+    }
+
+    pub(crate) fn join_branches(self, pool: &RRBPool<A>, right: Self, level: usize) -> Self {
+        let left_len = self.len();
+        let right_len = right.len();
+        let size = if self.is_completely_dense(level) && right.is_dense() {
+            Size::Size(left_len + right_len)
+        } else {
+            let size_table = Chunk::pair(left_len, left_len + right_len);
+            Size::Table(PoolRef::new(&pool.size_pool, size_table))
+        };
+        Node {
+            children: {
+                let children = Chunk::pair(self, right);
+                Nodes(size, PoolRef::new(&pool.node_pool, children))
+            },
+        }
+    }
+
+    pub(crate) fn len(&self) -> usize {
+        match self.children {
+            Entry::Nodes(Size::Size(size), _) => size,
+            Entry::Nodes(Size::Table(ref size_table), _) => *(size_table.last().unwrap_or(&0)),
+            Entry::Values(ref values) => values.len(),
+            Entry::Empty => 0,
+        }
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub(crate) fn is_single(&self) -> bool {
+        self.children.len() == 1
+    }
+
+    pub(crate) fn is_full(&self) -> bool {
+        self.children.is_full()
+    }
+
+    #[allow(dead_code)] // this is only used by tests
+    pub(crate) fn number_of_children(&self) -> usize {
+        self.children.len()
+    }
+
+    pub(crate) fn first_child(&self) -> &Self {
+        self.children.unwrap_nodes().first().unwrap()
+    }
+
+    /// True if the node is dense and so doesn't have a size table
+    fn is_dense(&self) -> bool {
+        !matches!(self.children, Entry::Nodes(Size::Table(_), _))
+    }
+
+    /// True if the node and its children are dense and at capacity
+    // TODO can use this technique to quickly test if a Size::Table
+    // should be converted back to a Size::Size
+    fn is_completely_dense(&self, level: usize) -> bool {
+        // Size of a full node is NODE_SIZE at level 0, NODE_SIZE² at
+        // level 1, etc.
+        if let Some(expected_size) = NODE_SIZE.checked_pow(level as u32 + 1) {
+            self.size() == expected_size
+        } else {
+            // We overflowed a usize, there's no way we can be completely dense as we know the size
+            // fits in a usize.
+            false
+        }
+    }
+
+    #[inline]
+    fn size(&self) -> usize {
+        match self.children {
+            Entry::Nodes(ref size, _) => size.size(),
+            Entry::Values(ref values) => values.len(),
+            Entry::Empty => 0,
+        }
+    }
+
+    #[inline]
+    fn push_size(&mut self, pool: &RRBPool<A>, side: Side, level: usize, value: usize) {
+        if let Entry::Nodes(ref mut size, _) = self.children {
+            size.push(&pool.size_pool, side, level, value)
+        }
+    }
+
+    #[inline]
+    fn pop_size(&mut self, pool: &RRBPool<A>, side: Side, level: usize, value: usize) {
+        if let Entry::Nodes(ref mut size, _) = self.children {
+            size.pop(&pool.size_pool, side, level, value)
+        }
+    }
+
+    #[inline]
+    fn update_size(&mut self, pool: &RRBPool<A>, index: usize, level: usize, value: isize) {
+        if let Entry::Nodes(ref mut size, _) = self.children {
+            size.update(&pool.size_pool, index, level, value)
+        }
+    }
+
+    fn size_up_to(&self, level: usize, index: usize) -> usize {
+        if let Entry::Nodes(ref size, _) = self.children {
+            if index == 0 {
+                0
+            } else {
+                match size {
+                    Size::Table(ref size_table) => size_table[index - 1],
+                    Size::Size(_) => index * NODE_SIZE.pow(level as u32),
+                }
+            }
+        } else {
+            index
+        }
+    }
+
+    fn index_in(&self, level: usize, index: usize) -> Option<usize> {
+        let mut target_idx = if let Some(child_size) = NODE_SIZE.checked_pow(level as u32) {
+            index / child_size
+        } else {
+            0
+        };
+        if target_idx >= self.children.len() {
+            return None;
+        }
+        if let Entry::Nodes(Size::Table(ref size_table), _) = self.children {
+            while size_table[target_idx] <= index {
+                target_idx += 1;
+                if target_idx >= size_table.len() {
+                    return None;
+                }
+            }
+        }
+        Some(target_idx)
+    }
+
+    pub(crate) fn index(&self, level: usize, index: usize) -> &A {
+        if level == 0 {
+            &self.children.unwrap_values()[index]
+        } else {
+            let target_idx = self.index_in(level, index).unwrap();
+            self.children.unwrap_nodes()[target_idx]
+                .index(level - 1, index - self.size_up_to(level, target_idx))
+        }
+    }
+
+    pub(crate) fn index_mut(&mut self, pool: &RRBPool<A>, level: usize, index: usize) -> &mut A {
+        if level == 0 {
+            &mut self.children.unwrap_values_mut(pool)[index]
+        } else {
+            let target_idx = self.index_in(level, index).unwrap();
+            let offset = index - self.size_up_to(level, target_idx);
+            let child = &mut self.children.unwrap_nodes_mut(pool)[target_idx];
+            child.index_mut(pool, level - 1, offset)
+        }
+    }
+
+    pub(crate) fn lookup_chunk(
+        &self,
+        level: usize,
+        base: usize,
+        index: usize,
+    ) -> (Range<usize>, *const Chunk<A>) {
+        if level == 0 {
+            (
+                base..(base + self.children.len()),
+                self.children.unwrap_values() as *const Chunk<A>,
+            )
+        } else {
+            let target_idx = self.index_in(level, index).unwrap();
+            let offset = self.size_up_to(level, target_idx);
+            let child_base = base + offset;
+            let children = self.children.unwrap_nodes();
+            let child = &children[target_idx];
+            child.lookup_chunk(level - 1, child_base, index - offset)
+        }
+    }
+
+    pub(crate) fn lookup_chunk_mut(
+        &mut self,
+        pool: &RRBPool<A>,
+        level: usize,
+        base: usize,
+        index: usize,
+    ) -> (Range<usize>, *mut Chunk<A>) {
+        if level == 0 {
+            (
+                base..(base + self.children.len()),
+                self.children.unwrap_values_mut(pool) as *mut Chunk<A>,
+            )
+        } else {
+            let target_idx = self.index_in(level, index).unwrap();
+            let offset = self.size_up_to(level, target_idx);
+            let child_base = base + offset;
+            let children = self.children.unwrap_nodes_mut(pool);
+            let child = &mut children[target_idx];
+            child.lookup_chunk_mut(pool, level - 1, child_base, index - offset)
+        }
+    }
+
+    fn push_child_node(&mut self, pool: &RRBPool<A>, side: Side, child: Node<A>) {
+        let children = self.children.unwrap_nodes_mut(pool);
+        match side {
+            Left => children.push_front(child),
+            Right => children.push_back(child),
+        }
+    }
+
+    fn pop_child_node(&mut self, pool: &RRBPool<A>, side: Side) -> Node<A> {
+        let children = self.children.unwrap_nodes_mut(pool);
+        match side {
+            Left => children.pop_front(),
+            Right => children.pop_back(),
+        }
+    }
+
+    pub(crate) fn push_chunk(
+        &mut self,
+        pool: &RRBPool<A>,
+        level: usize,
+        side: Side,
+        mut chunk: PoolRef<Chunk<A>>,
+    ) -> PushResult<PoolRef<Chunk<A>>> {
+        if chunk.is_empty() {
+            return PushResult::Done;
+        }
+        let is_full = self.is_full();
+        if level == 0 {
+            if self.children.is_empty_node() {
+                self.push_size(pool, side, level, chunk.len());
+                self.children = Values(chunk);
+                PushResult::Done
+            } else {
+                let values = self.children.unwrap_values_mut(pool);
+                if values.len() + chunk.len() <= NODE_SIZE {
+                    let chunk = PoolRef::make_mut(&pool.value_pool, &mut chunk);
+                    match side {
+                        Side::Left => {
+                            chunk.append(values);
+                            values.append(chunk);
+                        }
+                        Side::Right => values.append(chunk),
+                    }
+                    PushResult::Done
+                } else {
+                    PushResult::Full(chunk, 0)
+                }
+            }
+        } else if level == 1 {
+            // If rightmost existing node has any room, merge as much as
+            // possible over from the new node.
+            let num_drained = match side {
+                Side::Right => {
+                    if let Entry::Nodes(ref mut size, ref mut children) = self.children {
+                        let rightmost = PoolRef::make_mut(&pool.node_pool, children)
+                            .last_mut()
+                            .unwrap();
+                        let old_size = rightmost.len();
+                        let chunk = PoolRef::make_mut(&pool.value_pool, &mut chunk);
+                        let values = rightmost.children.unwrap_values_mut(pool);
+                        let to_drain = chunk.len().min(NODE_SIZE - values.len());
+                        values.drain_from_front(chunk, to_drain);
+                        size.pop(&pool.size_pool, Side::Right, level, old_size);
+                        size.push(&pool.size_pool, Side::Right, level, values.len());
+                        to_drain
+                    } else {
+                        0
+                    }
+                }
+                Side::Left => {
+                    if let Entry::Nodes(ref mut size, ref mut children) = self.children {
+                        let leftmost = PoolRef::make_mut(&pool.node_pool, children)
+                            .first_mut()
+                            .unwrap();
+                        let old_size = leftmost.len();
+                        let chunk = PoolRef::make_mut(&pool.value_pool, &mut chunk);
+                        let values = leftmost.children.unwrap_values_mut(pool);
+                        let to_drain = chunk.len().min(NODE_SIZE - values.len());
+                        values.drain_from_back(chunk, to_drain);
+                        size.pop(&pool.size_pool, Side::Left, level, old_size);
+                        size.push(&pool.size_pool, Side::Left, level, values.len());
+                        to_drain
+                    } else {
+                        0
+                    }
+                }
+            };
+            if is_full {
+                PushResult::Full(chunk, num_drained)
+            } else {
+                // If the chunk is empty after being drained, there might be
+                // more space in existing chunks. To keep the middle dense, we
+                // do not add it here.
+                if !chunk.is_empty() {
+                    if side == Left && chunk.len() < NODE_SIZE {
+                        if let Entry::Nodes(ref mut size, _) = self.children {
+                            if let Size::Size(value) = *size {
+                                *size = Size::table_from_size(&pool.size_pool, level, value);
+                            }
+                        }
+                    }
+                    self.push_size(pool, side, level, chunk.len());
+                    self.push_child_node(pool, side, Node::from_chunk(pool, 0, chunk));
+                }
+                PushResult::Done
+            }
+        } else {
+            let chunk_size = chunk.len();
+            let index = match side {
+                Right => self.children.len() - 1,
+                Left => 0,
+            };
+            let new_child = {
+                let children = self.children.unwrap_nodes_mut(pool);
+                let child = &mut children[index];
+                match child.push_chunk(pool, level - 1, side, chunk) {
+                    PushResult::Done => None,
+                    PushResult::Full(chunk, num_drained) => {
+                        // Our chunk was too large for `child`, so it could not
+                        // be pushed there. However, exactly `num_drained`
+                        // elements were added to the child. We need to reflect
+                        // that change in the size field of the node.
+                        match side {
+                            Right => match self.children {
+                                Entry::Nodes(Size::Table(ref mut sizes), _) => {
+                                    let sizes = PoolRef::make_mut(&pool.size_pool, sizes);
+                                    sizes[index] += num_drained;
+                                }
+                                Entry::Nodes(Size::Size(ref mut size), _) => {
+                                    *size += num_drained;
+                                }
+                                Entry::Values(_) | Entry::Empty => (),
+                            },
+                            Left => {
+                                self.update_size(pool, 0, level, num_drained as isize);
+                            }
+                        }
+                        if is_full {
+                            return PushResult::Full(chunk, 0);
+                        } else {
+                            Some(Node::from_chunk(pool, level - 1, chunk))
+                        }
+                    }
+                }
+            };
+            match new_child {
+                None => {
+                    self.update_size(pool, index, level, chunk_size as isize);
+                    PushResult::Done
+                }
+                Some(child) => {
+                    if side == Left && chunk_size < NODE_SIZE {
+                        if let Entry::Nodes(ref mut size, _) = self.children {
+                            if let Size::Size(value) = *size {
+                                *size = Size::table_from_size(&pool.size_pool, level, value);
+                            }
+                        }
+                    }
+                    self.push_size(pool, side, level, child.len());
+                    self.push_child_node(pool, side, child);
+                    PushResult::Done
+                }
+            }
+        }
+    }
+
+    pub(crate) fn pop_chunk(
+        &mut self,
+        pool: &RRBPool<A>,
+        level: usize,
+        side: Side,
+    ) -> PopResult<PoolRef<Chunk<A>>> {
+        if self.is_empty() {
+            return PopResult::Empty;
+        }
+        if level == 0 {
+            // should only get here if the tree is just one leaf node
+            match replace(&mut self.children, Empty) {
+                Values(chunk) => PopResult::Drained(chunk),
+                Empty => panic!("rrb::Node::pop_chunk: non-empty tree with Empty leaf"),
+                Nodes(_, _) => panic!("rrb::Node::pop_chunk: branch node at leaf"),
+            }
+        } else if level == 1 {
+            let child_node = self.pop_child_node(pool, side);
+            self.pop_size(pool, side, level, child_node.len());
+            let chunk = match child_node.children {
+                Values(ref chunk) => chunk.clone(),
+                Empty => panic!("rrb::Node::pop_chunk: non-empty tree with Empty leaf"),
+                Nodes(_, _) => panic!("rrb::Node::pop_chunk: branch node at leaf"),
+            };
+            if self.is_empty() {
+                PopResult::Drained(chunk)
+            } else {
+                PopResult::Done(chunk)
+            }
+        } else {
+            let index = match side {
+                Right => self.children.len() - 1,
+                Left => 0,
+            };
+            let mut drained = false;
+            let chunk = {
+                let children = self.children.unwrap_nodes_mut(pool);
+                let child = &mut children[index];
+                match child.pop_chunk(pool, level - 1, side) {
+                    PopResult::Empty => return PopResult::Empty,
+                    PopResult::Done(chunk) => chunk,
+                    PopResult::Drained(chunk) => {
+                        drained = true;
+                        chunk
+                    }
+                }
+            };
+            if drained {
+                self.pop_size(pool, side, level, chunk.len());
+                self.pop_child_node(pool, side);
+                if self.is_empty() {
+                    PopResult::Drained(chunk)
+                } else {
+                    PopResult::Done(chunk)
+                }
+            } else {
+                self.update_size(pool, index, level, -(chunk.len() as isize));
+                PopResult::Done(chunk)
+            }
+        }
+    }
+
+    pub(crate) fn split(
+        &mut self,
+        pool: &RRBPool<A>,
+        level: usize,
+        drop_side: Side,
+        index: usize,
+    ) -> SplitResult {
+        if index == 0 && drop_side == Side::Left {
+            // Dropped nothing
+            return SplitResult::Dropped(0);
+        }
+        if level > 0 && index == 0 && drop_side == Side::Right {
+            // Dropped everything
+            let dropped = if let Entry::Nodes(ref size, _) = self.children {
+                size.size()
+            } else {
+                panic!("leaf node at non-leaf level!");
+            };
+            self.children = Entry::Empty;
+            return SplitResult::Dropped(dropped);
+        }
+        let mut dropped;
+        if level == 0 {
+            let len = self.children.len();
+            if index >= len {
+                return SplitResult::OutOfBounds;
+            }
+            let children = self.children.unwrap_values_mut(pool);
+            match drop_side {
+                Side::Left => children.drop_left(index),
+                Side::Right => children.drop_right(index),
+            }
+            SplitResult::Dropped(match drop_side {
+                Left => index,
+                Right => len - index,
+            })
+        } else if let Some(target_idx) = self.index_in(level, index) {
+            let size_up_to = self.size_up_to(level, target_idx);
+            let (size, children) =
+                if let Entry::Nodes(ref mut size, ref mut children) = self.children {
+                    (size, PoolRef::make_mut(&pool.node_pool, children))
+                } else {
+                    unreachable!()
+                };
+            let child_gone = 0 == {
+                let child_node = &mut children[target_idx];
+                match child_node.split(pool, level - 1, drop_side, index - size_up_to) {
+                    SplitResult::OutOfBounds => return SplitResult::OutOfBounds,
+                    SplitResult::Dropped(amount) => dropped = amount,
+                }
+                child_node.len()
+            };
+            match drop_side {
+                Left => {
+                    let mut drop_from = target_idx;
+                    if child_gone {
+                        drop_from += 1;
+                    }
+                    children.drop_left(drop_from);
+                    if let Size::Size(value) = *size {
+                        *size = Size::table_from_size(&pool.size_pool, level, value);
+                    }
+                    let size_table = if let Size::Table(ref mut size_ref) = size {
+                        PoolRef::make_mut(&pool.size_pool, size_ref)
+                    } else {
+                        unreachable!()
+                    };
+                    let dropped_size = if target_idx > 0 {
+                        size_table[target_idx - 1]
+                    } else {
+                        0
+                    };
+                    dropped += dropped_size;
+                    size_table.drop_left(drop_from);
+                    for i in size_table.iter_mut() {
+                        *i -= dropped;
+                    }
+                }
+                Right => {
+                    let at_last = target_idx == children.len() - 1;
+                    let mut drop_from = target_idx + 1;
+                    if child_gone {
+                        drop_from -= 1;
+                    }
+                    if drop_from < children.len() {
+                        children.drop_right(drop_from);
+                    }
+                    match size {
+                        Size::Size(ref mut size) if at_last => {
+                            *size -= dropped;
+                        }
+                        Size::Size(ref mut size) => {
+                            let size_per_child = NODE_SIZE.pow(level as u32);
+                            let remainder = (target_idx + 1) * size_per_child;
+                            let new_size = remainder - dropped;
+                            if new_size < *size {
+                                dropped = *size - new_size;
+                                *size = new_size;
+                            } else {
+                                unreachable!(
+                                    "this means node is empty, should be caught at start of method"
+                                );
+                            }
+                        }
+                        Size::Table(ref mut size_ref) => {
+                            let size_table = PoolRef::make_mut(&pool.size_pool, size_ref);
+                            let dropped_size =
+                                size_table[size_table.len() - 1] - size_table[target_idx];
+                            if drop_from < size_table.len() {
+                                size_table.drop_right(drop_from);
+                            }
+                            if !child_gone {
+                                size_table[target_idx] -= dropped;
+                            }
+                            dropped += dropped_size;
+                        }
+                    }
+                }
+            }
+            SplitResult::Dropped(dropped)
+        } else {
+            SplitResult::OutOfBounds
+        }
+    }
+
+    fn merge_leaves(pool: &RRBPool<A>, mut left: Self, mut right: Self) -> Self {
+        if left.children.is_empty_node() {
+            // Left is empty, just use right
+            Self::single_parent(pool, right)
+        } else if right.children.is_empty_node() {
+            // Right is empty, just use left
+            Self::single_parent(pool, left)
+        } else {
+            {
+                let left_vals = left.children.unwrap_values_mut(pool);
+                let left_len = left_vals.len();
+                let right_vals = right.children.unwrap_values_mut(pool);
+                let right_len = right_vals.len();
+                if left_len + right_len <= NODE_SIZE {
+                    left_vals.append(right_vals);
+                } else {
+                    let count = right_len.min(NODE_SIZE - left_len);
+                    left_vals.drain_from_front(right_vals, count);
+                }
+            }
+            if right.is_empty() {
+                Self::single_parent(pool, left)
+            } else {
+                Self::join_dense(pool, left, right)
+            }
+        }
+    }
+
+    fn merge_rebalance(
+        pool: &RRBPool<A>,
+        level: usize,
+        left: Self,
+        middle: Self,
+        right: Self,
+    ) -> Self {
+        let left_nodes = left.children.nodes().into_iter();
+        let middle_nodes = middle.children.nodes().into_iter();
+        let right_nodes = right.children.nodes().into_iter();
+        let mut subtree_still_balanced = true;
+        let mut next_leaf = Chunk::new();
+        let mut next_node = Chunk::new();
+        let mut next_subtree = Chunk::new();
+        let mut root = Chunk::new();
+
+        for subtree in left_nodes.chain(middle_nodes).chain(right_nodes) {
+            if subtree.is_empty() {
+                continue;
+            }
+            if subtree.is_completely_dense(level) && subtree_still_balanced {
+                root.push_back(subtree);
+                continue;
+            }
+            subtree_still_balanced = false;
+
+            if level == 1 {
+                for value in subtree.children.values() {
+                    next_leaf.push_back(value);
+                    if next_leaf.is_full() {
+                        let new_node =
+                            Node::from_chunk(pool, 0, PoolRef::new(&pool.value_pool, next_leaf));
+                        next_subtree.push_back(new_node);
+                        next_leaf = Chunk::new();
+                        if next_subtree.is_full() {
+                            let new_subtree = Node::parent(pool, level, next_subtree);
+                            root.push_back(new_subtree);
+                            next_subtree = Chunk::new();
+                        }
+                    }
+                }
+            } else {
+                for node in subtree.children.nodes() {
+                    next_node.push_back(node);
+                    if next_node.is_full() {
+                        let new_node = Node::parent(pool, level - 1, next_node);
+                        next_subtree.push_back(new_node);
+                        next_node = Chunk::new();
+                        if next_subtree.is_full() {
+                            let new_subtree = Node::parent(pool, level, next_subtree);
+                            root.push_back(new_subtree);
+                            next_subtree = Chunk::new();
+                        }
+                    }
+                }
+            }
+        }
+        if !next_leaf.is_empty() {
+            let new_node = Node::from_chunk(pool, 0, PoolRef::new(&pool.value_pool, next_leaf));
+            next_subtree.push_back(new_node);
+        }
+        if !next_node.is_empty() {
+            let new_node = Node::parent(pool, level - 1, next_node);
+            next_subtree.push_back(new_node);
+        }
+        if !next_subtree.is_empty() {
+            let new_subtree = Node::parent(pool, level, next_subtree);
+            root.push_back(new_subtree);
+        }
+        Node::parent(pool, level + 1, root)
+    }
+
+    pub(crate) fn merge(pool: &RRBPool<A>, mut left: Self, mut right: Self, level: usize) -> Self {
+        if level == 0 {
+            Self::merge_leaves(pool, left, right)
+        } else {
+            let merged = {
+                if level == 1 {
+                    // We're going to rebalance all the leaves anyway, there's
+                    // no need for a middle at level 1
+                    Node::parent(pool, 0, Chunk::new())
+                } else {
+                    let left_last =
+                        if let Entry::Nodes(ref mut size, ref mut children) = left.children {
+                            let node = PoolRef::make_mut(&pool.node_pool, children).pop_back();
+                            if !node.is_empty() {
+                                size.pop(&pool.size_pool, Side::Right, level, node.len());
+                            }
+                            node
+                        } else {
+                            panic!("expected nodes, found entries or empty");
+                        };
+                    let right_first =
+                        if let Entry::Nodes(ref mut size, ref mut children) = right.children {
+                            let node = PoolRef::make_mut(&pool.node_pool, children).pop_front();
+                            if !node.is_empty() {
+                                size.pop(&pool.size_pool, Side::Left, level, node.len());
+                            }
+                            node
+                        } else {
+                            panic!("expected nodes, found entries or empty");
+                        };
+                    Self::merge(pool, left_last, right_first, level - 1)
+                }
+            };
+            Self::merge_rebalance(pool, level, left, merged, right)
+        }
+    }
+
+    #[cfg(any(test, feature = "debug"))]
+    pub(crate) fn assert_invariants(&self, level: usize) -> usize {
+        // Verifies that the size table matches reality.
+        match self.children {
+            Entry::Empty => 0,
+            Entry::Values(ref values) => {
+                // An empty value node is pointless and should never occur.
+                assert_ne!(0, values.len());
+                // Value nodes should only occur at level 0.
+                assert_eq!(0, level);
+                values.len()
+            }
+            Entry::Nodes(ref size, ref children) => {
+                // A parent node with no children should never occur.
+                assert_ne!(0, children.len());
+                // Parent nodes should never occur at level 0.
+                assert_ne!(0, level);
+                let mut lengths = Vec::new();
+                let should_be_dense = matches!(size, Size::Size(_));
+                for (index, child) in children.iter().enumerate() {
+                    let len = child.assert_invariants(level - 1);
+                    if should_be_dense && index < children.len() - 1 {
+                        // Assert that non-end nodes without size tables are full.
+                        assert_eq!(len, NODE_SIZE.pow(level as u32));
+                    }
+                    lengths.push(len);
+                }
+                match size {
+                    Size::Size(size) => {
+                        let total: usize = lengths.iter().sum();
+                        assert_eq!(*size, total);
+                    }
+                    Size::Table(ref table) => {
+                        assert_eq!(table.iter().len(), children.len());
+                        for (index, current) in table.iter().enumerate() {
+                            let expected: usize = lengths.iter().take(index + 1).sum();
+                            assert_eq!(expected, *current);
+                        }
+                    }
+                }
+                lengths.iter().sum()
+            }
+        }
+    }
+
+    // pub fn print<W>(&self, f: &mut W, indent: usize, level: usize) -> Result<(), fmt::Error>
+    // where
+    //     W: fmt::Write,
+    //     A: fmt::Debug,
+    // {
+    //     print_indent(f, indent)?;
+    //     if level == 0 {
+    //         if self.children.is_empty_node() {
+    //             writeln!(f, "Leaf: EMPTY")
+    //         } else {
+    //             writeln!(f, "Leaf: {:?}", self.children.unwrap_values())
+    //         }
+    //     } else {
+    //         match &self.children {
+    //             Entry::Nodes(size, children) => {
+    //                 writeln!(f, "Node level {} size_table {:?}", level, size)?;
+    //                 for child in children.iter() {
+    //                     child.print(f, indent + 4, level - 1)?;
+    //                 }
+    //                 Ok(())
+    //             }
+    //             _ => unreachable!(),
+    //         }
+    //     }
+    // }
+}
+
+// fn print_indent<W>(f: &mut W, indent: usize) -> Result<(), fmt::Error>
+// where
+//     W: fmt::Write,
+// {
+//     for _i in 0..indent {
+//         write!(f, " ")?;
+//     }
+//     Ok(())
+// }
diff --git a/vendor/im-rc/src/ord/map.rs b/vendor/im-rc/src/ord/map.rs
new file mode 100644
index 000000000..ad87932dc
--- /dev/null
+++ b/vendor/im-rc/src/ord/map.rs
@@ -0,0 +1,2649 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! An ordered map.
+//!
+//! An immutable ordered map implemented as a [B-tree] [1].
+//!
+//! Most operations on this type of map are O(log n). A
+//! [`HashMap`][hashmap::HashMap] is usually a better choice for
+//! performance, but the `OrdMap` has the advantage of only requiring
+//! an [`Ord`][std::cmp::Ord] constraint on the key, and of being
+//! ordered, so that keys always come out from lowest to highest,
+//! where a [`HashMap`][hashmap::HashMap] has no guaranteed ordering.
+//!
+//! [1]: https://en.wikipedia.org/wiki/B-tree
+//! [hashmap::HashMap]: ../hashmap/struct.HashMap.html
+//! [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html
+
+use std::borrow::Borrow;
+use std::cmp::Ordering;
+use std::collections;
+use std::fmt::{Debug, Error, Formatter};
+use std::hash::{BuildHasher, Hash, Hasher};
+use std::iter::{FromIterator, Iterator, Sum};
+use std::mem;
+use std::ops::{Add, Index, IndexMut, RangeBounds};
+
+use crate::hashmap::HashMap;
+use crate::nodes::btree::{BTreeValue, Insert, Node, Remove};
+#[cfg(has_specialisation)]
+use crate::util::linear_search_by;
+use crate::util::{Pool, PoolRef};
+
+pub use crate::nodes::btree::{
+    ConsumingIter, DiffItem as NodeDiffItem, DiffIter as NodeDiffIter, Iter as RangedIter,
+};
+
+/// Construct a map from a sequence of key/value pairs.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::ordmap::OrdMap;
+/// # fn main() {
+/// assert_eq!(
+///   ordmap!{
+///     1 => 11,
+///     2 => 22,
+///     3 => 33
+///   },
+///   OrdMap::from(vec![(1, 11), (2, 22), (3, 33)])
+/// );
+/// # }
+/// ```
+#[macro_export]
+macro_rules! ordmap {
+    () => { $crate::ordmap::OrdMap::new() };
+
+    ( $( $key:expr => $value:expr ),* ) => {{
+        let mut map = $crate::ordmap::OrdMap::new();
+        $({
+            map.insert($key, $value);
+        })*;
+        map
+    }};
+}
+
+#[cfg(not(has_specialisation))]
+impl<K: Ord, V> BTreeValue for (K, V) {
+    type Key = K;
+
+    fn ptr_eq(&self, _other: &Self) -> bool {
+        false
+    }
+
+    fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize>
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        slice.binary_search_by(|value| Self::Key::borrow(&value.0).cmp(key))
+    }
+
+    fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> {
+        slice.binary_search_by(|value| value.0.cmp(&key.0))
+    }
+
+    fn cmp_keys<BK>(&self, other: &BK) -> Ordering
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        Self::Key::borrow(&self.0).cmp(other)
+    }
+
+    fn cmp_values(&self, other: &Self) -> Ordering {
+        self.0.cmp(&other.0)
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<K: Ord, V> BTreeValue for (K, V) {
+    type Key = K;
+
+    fn ptr_eq(&self, _other: &Self) -> bool {
+        false
+    }
+
+    default fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize>
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        slice.binary_search_by(|value| Self::Key::borrow(&value.0).cmp(key))
+    }
+
+    default fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> {
+        slice.binary_search_by(|value| value.0.cmp(&key.0))
+    }
+
+    fn cmp_keys<BK>(&self, other: &BK) -> Ordering
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        Self::Key::borrow(&self.0).cmp(other)
+    }
+
+    fn cmp_values(&self, other: &Self) -> Ordering {
+        self.0.cmp(&other.0)
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<K: Ord + Copy, V> BTreeValue for (K, V) {
+    fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize>
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        linear_search_by(slice, |value| Self::Key::borrow(&value.0).cmp(key))
+    }
+
+    fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> {
+        linear_search_by(slice, |value| value.0.cmp(&key.0))
+    }
+}
+
+def_pool!(OrdMapPool<K, V>, Node<(K, V)>);
+
+/// An ordered map.
+///
+/// An immutable ordered map implemented as a B-tree.
+///
+/// Most operations on this type of map are O(log n). A
+/// [`HashMap`][hashmap::HashMap] is usually a better choice for
+/// performance, but the `OrdMap` has the advantage of only requiring
+/// an [`Ord`][std::cmp::Ord] constraint on the key, and of being
+/// ordered, so that keys always come out from lowest to highest,
+/// where a [`HashMap`][hashmap::HashMap] has no guaranteed ordering.
+///
+/// [hashmap::HashMap]: ../hashmap/struct.HashMap.html
+/// [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html
+pub struct OrdMap<K, V> {
+    size: usize,
+    pool: OrdMapPool<K, V>,
+    root: PoolRef<Node<(K, V)>>,
+}
+
+impl<K, V> OrdMap<K, V> {
+    /// Construct an empty map.
+    #[must_use]
+    pub fn new() -> Self {
+        let pool = OrdMapPool::default();
+        let root = PoolRef::default(&pool.0);
+        OrdMap {
+            size: 0,
+            pool,
+            root,
+        }
+    }
+
+    /// Construct an empty map using a specific memory pool.
+    #[cfg(feature = "pool")]
+    #[must_use]
+    pub fn with_pool(pool: &OrdMapPool<K, V>) -> Self {
+        let root = PoolRef::default(&pool.0);
+        OrdMap {
+            size: 0,
+            pool: pool.clone(),
+            root,
+        }
+    }
+
+    /// Construct a map with a single mapping.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map = OrdMap::unit(123, "onetwothree");
+    /// assert_eq!(
+    ///   map.get(&123),
+    ///   Some(&"onetwothree")
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn unit(key: K, value: V) -> Self {
+        let pool = OrdMapPool::default();
+        let root = PoolRef::new(&pool.0, Node::unit((key, value)));
+        OrdMap {
+            size: 1,
+            pool,
+            root,
+        }
+    }
+
+    /// Test whether a map is empty.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// assert!(
+    ///   !ordmap!{1 => 2}.is_empty()
+    /// );
+    /// assert!(
+    ///   OrdMap::<i32, i32>::new().is_empty()
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Test whether two maps refer to the same content in memory.
+    ///
+    /// This is true if the two sides are references to the same map,
+    /// or if the two maps refer to the same root node.
+    ///
+    /// This would return true if you're comparing a map to itself, or
+    /// if you're comparing a map to a fresh clone of itself.
+    ///
+    /// Time: O(1)
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        std::ptr::eq(self, other) || PoolRef::ptr_eq(&self.root, &other.root)
+    }
+
+    /// Get the size of a map.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// assert_eq!(3, ordmap!{
+    ///   1 => 11,
+    ///   2 => 22,
+    ///   3 => 33
+    /// }.len());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.size
+    }
+
+    /// Get a reference to the memory pool used by this map.
+    ///
+    /// Note that if you didn't specifically construct it with a pool, you'll
+    /// get back a reference to a pool of size 0.
+    #[cfg(feature = "pool")]
+    pub fn pool(&self) -> &OrdMapPool<K, V> {
+        &self.pool
+    }
+
+    /// Discard all elements from the map.
+    ///
+    /// This leaves you with an empty map, and all elements that
+    /// were previously inside it are dropped.
+    ///
+    /// Time: O(n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::OrdMap;
+    /// let mut map = ordmap![1=>1, 2=>2, 3=>3];
+    /// map.clear();
+    /// assert!(map.is_empty());
+    /// ```
+    pub fn clear(&mut self) {
+        if !self.is_empty() {
+            self.root = PoolRef::default(&self.pool.0);
+            self.size = 0;
+        }
+    }
+}
+
+impl<K, V> OrdMap<K, V>
+where
+    K: Ord,
+{
+    /// Get the largest key in a map, along with its value. If the map
+    /// is empty, return `None`.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// assert_eq!(Some(&(3, 33)), ordmap!{
+    ///   1 => 11,
+    ///   2 => 22,
+    ///   3 => 33
+    /// }.get_max());
+    /// ```
+    #[must_use]
+    pub fn get_max(&self) -> Option<&(K, V)> {
+        self.root.max()
+    }
+
+    /// Get the smallest key in a map, along with its value. If the
+    /// map is empty, return `None`.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// assert_eq!(Some(&(1, 11)), ordmap!{
+    ///   1 => 11,
+    ///   2 => 22,
+    ///   3 => 33
+    /// }.get_min());
+    /// ```
+    #[must_use]
+    pub fn get_min(&self) -> Option<&(K, V)> {
+        self.root.min()
+    }
+
+    /// Get an iterator over the key/value pairs of a map.
+    #[must_use]
+    pub fn iter(&self) -> Iter<'_, K, V> {
+        Iter {
+            it: RangedIter::new(&self.root, self.size, ..),
+        }
+    }
+
+    /// Create an iterator over a range of key/value pairs.
+    #[must_use]
+    pub fn range<R, BK>(&self, range: R) -> Iter<'_, K, V>
+    where
+        R: RangeBounds<BK>,
+        K: Borrow<BK>,
+        BK: Ord + ?Sized,
+    {
+        Iter {
+            it: RangedIter::new(&self.root, self.size, range),
+        }
+    }
+
+    /// Get an iterator over a map's keys.
+    #[must_use]
+    pub fn keys(&self) -> Keys<'_, K, V> {
+        Keys { it: self.iter() }
+    }
+
+    /// Get an iterator over a map's values.
+    #[must_use]
+    pub fn values(&self) -> Values<'_, K, V> {
+        Values { it: self.iter() }
+    }
+
+    /// Get an iterator over the differences between this map and
+    /// another, i.e. the set of entries to add, update, or remove to
+    /// this map in order to make it equal to the other map.
+    ///
+    /// This function will avoid visiting nodes which are shared
+    /// between the two maps, meaning that even very large maps can be
+    /// compared quickly if most of their structure is shared.
+    ///
+    /// Time: O(n) (where n is the number of unique elements across
+    /// the two maps, minus the number of elements belonging to nodes
+    /// shared between them)
+    #[must_use]
+    pub fn diff<'a>(&'a self, other: &'a Self) -> DiffIter<'a, K, V> {
+        DiffIter {
+            it: NodeDiffIter::new(&self.root, &other.root),
+        }
+    }
+
+    /// Get the value for a key from a map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map = ordmap!{123 => "lol"};
+    /// assert_eq!(
+    ///   map.get(&123),
+    ///   Some(&"lol")
+    /// );
+    /// ```
+    #[must_use]
+    pub fn get<BK>(&self, key: &BK) -> Option<&V>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.root.lookup(key).map(|(_, v)| v)
+    }
+
+    /// Get the key/value pair for a key from a map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map = ordmap!{123 => "lol"};
+    /// assert_eq!(
+    ///   map.get_key_value(&123),
+    ///   Some((&123, &"lol"))
+    /// );
+    /// ```
+    #[must_use]
+    pub fn get_key_value<BK>(&self, key: &BK) -> Option<(&K, &V)>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.root.lookup(key).map(|&(ref k, ref v)| (k, v))
+    }
+
+    /// Get the closest smaller entry in a map to a given key
+    /// as a mutable reference.
+    ///
+    /// If the map contains the given key, this is returned.
+    /// Otherwise, the closest key in the map smaller than the
+    /// given value is returned. If the smallest key in the map
+    /// is larger than the given key, `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::OrdMap;
+    /// let map = ordmap![1 => 1, 3 => 3, 5 => 5];
+    /// assert_eq!(Some((&3, &3)), map.get_prev(&4));
+    /// ```
+    #[must_use]
+    pub fn get_prev<BK>(&self, key: &BK) -> Option<(&K, &V)>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.root.lookup_prev(key).map(|(k, v)| (k, v))
+    }
+
+    /// Get the closest larger entry in a map to a given key
+    /// as a mutable reference.
+    ///
+    /// If the set contains the given value, this is returned.
+    /// Otherwise, the closest value in the set larger than the
+    /// given value is returned. If the largest value in the set
+    /// is smaller than the given value, `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::OrdMap;
+    /// let map = ordmap![1 => 1, 3 => 3, 5 => 5];
+    /// assert_eq!(Some((&5, &5)), map.get_next(&4));
+    /// ```
+    #[must_use]
+    pub fn get_next<BK>(&self, key: &BK) -> Option<(&K, &V)>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.root.lookup_next(key).map(|(k, v)| (k, v))
+    }
+
+    /// Test for the presence of a key in a map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map = ordmap!{123 => "lol"};
+    /// assert!(
+    ///   map.contains_key(&123)
+    /// );
+    /// assert!(
+    ///   !map.contains_key(&321)
+    /// );
+    /// ```
+    #[must_use]
+    pub fn contains_key<BK>(&self, k: &BK) -> bool
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.get(k).is_some()
+    }
+
+    /// Test whether a map is a submap of another map, meaning that
+    /// all keys in our map must also be in the other map, with the
+    /// same values.
+    ///
+    /// Use the provided function to decide whether values are equal.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn is_submap_by<B, RM, F>(&self, other: RM, mut cmp: F) -> bool
+    where
+        F: FnMut(&V, &B) -> bool,
+        RM: Borrow<OrdMap<K, B>>,
+    {
+        self.iter()
+            .all(|(k, v)| other.borrow().get(k).map(|ov| cmp(v, ov)).unwrap_or(false))
+    }
+
+    /// Test whether a map is a proper submap of another map, meaning
+    /// that all keys in our map must also be in the other map, with
+    /// the same values. To be a proper submap, ours must also contain
+    /// fewer keys than the other map.
+    ///
+    /// Use the provided function to decide whether values are equal.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn is_proper_submap_by<B, RM, F>(&self, other: RM, cmp: F) -> bool
+    where
+        F: FnMut(&V, &B) -> bool,
+        RM: Borrow<OrdMap<K, B>>,
+    {
+        self.len() != other.borrow().len() && self.is_submap_by(other, cmp)
+    }
+
+    /// Test whether a map is a submap of another map, meaning that
+    /// all keys in our map must also be in the other map, with the
+    /// same values.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 2 => 2};
+    /// let map2 = ordmap!{1 => 1, 2 => 2, 3 => 3};
+    /// assert!(map1.is_submap(map2));
+    /// ```
+    #[must_use]
+    pub fn is_submap<RM>(&self, other: RM) -> bool
+    where
+        V: PartialEq,
+        RM: Borrow<Self>,
+    {
+        self.is_submap_by(other.borrow(), PartialEq::eq)
+    }
+
+    /// Test whether a map is a proper submap of another map, meaning
+    /// that all keys in our map must also be in the other map, with
+    /// the same values. To be a proper submap, ours must also contain
+    /// fewer keys than the other map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 2 => 2};
+    /// let map2 = ordmap!{1 => 1, 2 => 2, 3 => 3};
+    /// assert!(map1.is_proper_submap(map2));
+    ///
+    /// let map3 = ordmap!{1 => 1, 2 => 2};
+    /// let map4 = ordmap!{1 => 1, 2 => 2};
+    /// assert!(!map3.is_proper_submap(map4));
+    /// ```
+    #[must_use]
+    pub fn is_proper_submap<RM>(&self, other: RM) -> bool
+    where
+        V: PartialEq,
+        RM: Borrow<Self>,
+    {
+        self.is_proper_submap_by(other.borrow(), PartialEq::eq)
+    }
+}
+
+impl<K, V> OrdMap<K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    /// Get a mutable reference to the value for a key from a map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let mut map = ordmap!{123 => "lol"};
+    /// if let Some(value) = map.get_mut(&123) {
+    ///     *value = "omg";
+    /// }
+    /// assert_eq!(
+    ///   map.get(&123),
+    ///   Some(&"omg")
+    /// );
+    /// ```
+    #[must_use]
+    pub fn get_mut<BK>(&mut self, key: &BK) -> Option<&mut V>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        root.lookup_mut(&self.pool.0, key).map(|(_, v)| v)
+    }
+
+    /// Get the closest smaller entry in a map to a given key
+    /// as a mutable reference.
+    ///
+    /// If the map contains the given key, this is returned.
+    /// Otherwise, the closest key in the map smaller than the
+    /// given value is returned. If the smallest key in the map
+    /// is larger than the given key, `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::OrdMap;
+    /// let mut map = ordmap![1 => 1, 3 => 3, 5 => 5];
+    /// if let Some((key, value)) = map.get_prev_mut(&4) {
+    ///     *value = 4;
+    /// }
+    /// assert_eq!(ordmap![1 => 1, 3 => 4, 5 => 5], map);
+    /// ```
+    #[must_use]
+    pub fn get_prev_mut<BK>(&mut self, key: &BK) -> Option<(&K, &mut V)>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        let pool = &self.pool.0;
+        PoolRef::make_mut(pool, &mut self.root)
+            .lookup_prev_mut(pool, key)
+            .map(|(ref k, ref mut v)| (k, v))
+    }
+
+    /// Get the closest larger entry in a map to a given key
+    /// as a mutable reference.
+    ///
+    /// If the set contains the given value, this is returned.
+    /// Otherwise, the closest value in the set larger than the
+    /// given value is returned. If the largest value in the set
+    /// is smaller than the given value, `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::OrdMap;
+    /// let mut map = ordmap![1 => 1, 3 => 3, 5 => 5];
+    /// if let Some((key, value)) = map.get_next_mut(&4) {
+    ///     *value = 4;
+    /// }
+    /// assert_eq!(ordmap![1 => 1, 3 => 3, 5 => 4], map);
+    /// ```
+    #[must_use]
+    pub fn get_next_mut<BK>(&mut self, key: &BK) -> Option<(&K, &mut V)>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        let pool = &self.pool.0;
+        PoolRef::make_mut(pool, &mut self.root)
+            .lookup_next_mut(pool, key)
+            .map(|(ref k, ref mut v)| (k, v))
+    }
+
+    /// Insert a key/value mapping into a map.
+    ///
+    /// This is a copy-on-write operation, so that the parts of the
+    /// map's structure which are shared with other maps will be
+    /// safely copied before mutating.
+    ///
+    /// If the map already has a mapping for the given key, the
+    /// previous value is overwritten.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let mut map = ordmap!{};
+    /// map.insert(123, "123");
+    /// map.insert(456, "456");
+    /// assert_eq!(
+    ///   map,
+    ///   ordmap!{123 => "123", 456 => "456"}
+    /// );
+    /// ```
+    ///
+    /// [insert]: #method.insert
+    #[inline]
+    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
+        let new_root = {
+            let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+            match root.insert(&self.pool.0, (key, value)) {
+                Insert::Replaced((_, old_value)) => return Some(old_value),
+                Insert::Added => {
+                    self.size += 1;
+                    return None;
+                }
+                Insert::Split(left, median, right) => PoolRef::new(
+                    &self.pool.0,
+                    Node::new_from_split(&self.pool.0, left, median, right),
+                ),
+            }
+        };
+        self.size += 1;
+        self.root = new_root;
+        None
+    }
+
+    /// Remove a key/value mapping from a map if it exists.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let mut map = ordmap!{123 => "123", 456 => "456"};
+    /// map.remove(&123);
+    /// map.remove(&456);
+    /// assert!(map.is_empty());
+    /// ```
+    ///
+    /// [remove]: #method.remove
+    #[inline]
+    pub fn remove<BK>(&mut self, k: &BK) -> Option<V>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.remove_with_key(k).map(|(_, v)| v)
+    }
+
+    /// Remove a key/value pair from a map, if it exists, and return
+    /// the removed key and value.
+    ///
+    /// Time: O(log n)
+    pub fn remove_with_key<BK>(&mut self, k: &BK) -> Option<(K, V)>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        let (new_root, removed_value) = {
+            let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+            match root.remove(&self.pool.0, k) {
+                Remove::NoChange => return None,
+                Remove::Removed(pair) => {
+                    self.size -= 1;
+                    return Some(pair);
+                }
+                Remove::Update(pair, root) => (PoolRef::new(&self.pool.0, root), Some(pair)),
+            }
+        };
+        self.size -= 1;
+        self.root = new_root;
+        removed_value
+    }
+
+    /// Construct a new map by inserting a key/value mapping into a
+    /// map.
+    ///
+    /// If the map already has a mapping for the given key, the
+    /// previous value is overwritten.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map = ordmap!{};
+    /// assert_eq!(
+    ///   map.update(123, "123"),
+    ///   ordmap!{123 => "123"}
+    /// );
+    /// ```
+    #[must_use]
+    pub fn update(&self, key: K, value: V) -> Self {
+        let mut out = self.clone();
+        out.insert(key, value);
+        out
+    }
+
+    /// Construct a new map by inserting a key/value mapping into a
+    /// map.
+    ///
+    /// If the map already has a mapping for the given key, we call
+    /// the provided function with the old value and the new value,
+    /// and insert the result as the new value.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn update_with<F>(self, k: K, v: V, f: F) -> Self
+    where
+        F: FnOnce(V, V) -> V,
+    {
+        self.update_with_key(k, v, |_, v1, v2| f(v1, v2))
+    }
+
+    /// Construct a new map by inserting a key/value mapping into a
+    /// map.
+    ///
+    /// If the map already has a mapping for the given key, we call
+    /// the provided function with the key, the old value and the new
+    /// value, and insert the result as the new value.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn update_with_key<F>(self, k: K, v: V, f: F) -> Self
+    where
+        F: FnOnce(&K, V, V) -> V,
+    {
+        match self.extract_with_key(&k) {
+            None => self.update(k, v),
+            Some((_, v2, m)) => {
+                let out_v = f(&k, v2, v);
+                m.update(k, out_v)
+            }
+        }
+    }
+
+    /// Construct a new map by inserting a key/value mapping into a
+    /// map, returning the old value for the key as well as the new
+    /// map.
+    ///
+    /// If the map already has a mapping for the given key, we call
+    /// the provided function with the key, the old value and the new
+    /// value, and insert the result as the new value.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn update_lookup_with_key<F>(self, k: K, v: V, f: F) -> (Option<V>, Self)
+    where
+        F: FnOnce(&K, &V, V) -> V,
+    {
+        match self.extract_with_key(&k) {
+            None => (None, self.update(k, v)),
+            Some((_, v2, m)) => {
+                let out_v = f(&k, &v2, v);
+                (Some(v2), m.update(k, out_v))
+            }
+        }
+    }
+
+    /// Update the value for a given key by calling a function with
+    /// the current value and overwriting it with the function's
+    /// return value.
+    ///
+    /// The function gets an [`Option<V>`][std::option::Option] and
+    /// returns the same, so that it can decide to delete a mapping
+    /// instead of updating the value, and decide what to do if the
+    /// key isn't in the map.
+    ///
+    /// Time: O(log n)
+    ///
+    /// [std::option::Option]: https://doc.rust-lang.org/std/option/enum.Option.html
+    #[must_use]
+    pub fn alter<F>(&self, f: F, k: K) -> Self
+    where
+        F: FnOnce(Option<V>) -> Option<V>,
+    {
+        let pop = self.extract_with_key(&k);
+        match (f(pop.as_ref().map(|&(_, ref v, _)| v.clone())), pop) {
+            (None, None) => self.clone(),
+            (Some(v), None) => self.update(k, v),
+            (None, Some((_, _, m))) => m,
+            (Some(v), Some((_, _, m))) => m.update(k, v),
+        }
+    }
+
+    /// Remove a key/value pair from a map, if it exists.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn without<BK>(&self, k: &BK) -> Self
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.extract(k)
+            .map(|(_, m)| m)
+            .unwrap_or_else(|| self.clone())
+    }
+
+    /// Remove a key/value pair from a map, if it exists, and return
+    /// the removed value as well as the updated list.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn extract<BK>(&self, k: &BK) -> Option<(V, Self)>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        self.extract_with_key(k).map(|(_, v, m)| (v, m))
+    }
+
+    /// Remove a key/value pair from a map, if it exists, and return
+    /// the removed key and value as well as the updated list.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn extract_with_key<BK>(&self, k: &BK) -> Option<(K, V, Self)>
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        let mut out = self.clone();
+        let result = out.remove_with_key(k);
+        result.map(|(k, v)| (k, v, out))
+    }
+
+    /// Construct the union of two maps, keeping the values in the
+    /// current map when keys exist in both maps.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 3};
+    /// let map2 = ordmap!{2 => 2, 3 => 4};
+    /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 3};
+    /// assert_eq!(expected, map1.union(map2));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn union(self, other: Self) -> Self {
+        let (mut to_mutate, to_consume) = if self.len() >= other.len() {
+            (self, other)
+        } else {
+            (other, self)
+        };
+        for (k, v) in to_consume {
+            to_mutate.entry(k).or_insert(v);
+        }
+        to_mutate
+    }
+
+    /// Construct the union of two maps, using a function to decide
+    /// what to do with the value when a key is in both maps.
+    ///
+    /// The function is called when a value exists in both maps, and
+    /// receives the value from the current map as its first argument,
+    /// and the value from the other map as the second. It should
+    /// return the value to be inserted in the resulting map.
+    ///
+    /// Time: O(n log n)
+    #[inline]
+    #[must_use]
+    pub fn union_with<F>(self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(V, V) -> V,
+    {
+        self.union_with_key(other, |_, v1, v2| f(v1, v2))
+    }
+
+    /// Construct the union of two maps, using a function to decide
+    /// what to do with the value when a key is in both maps.
+    ///
+    /// The function is called when a value exists in both maps, and
+    /// receives a reference to the key as its first argument, the
+    /// value from the current map as the second argument, and the
+    /// value from the other map as the third argument. It should
+    /// return the value to be inserted in the resulting map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 4};
+    /// let map2 = ordmap!{2 => 2, 3 => 5};
+    /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 9};
+    /// assert_eq!(expected, map1.union_with_key(
+    ///     map2,
+    ///     |key, left, right| left + right
+    /// ));
+    /// ```
+    #[must_use]
+    pub fn union_with_key<F>(self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(&K, V, V) -> V,
+    {
+        if self.len() >= other.len() {
+            self.union_with_key_inner(other, f)
+        } else {
+            other.union_with_key_inner(self, |key, other_value, self_value| {
+                f(key, self_value, other_value)
+            })
+        }
+    }
+
+    fn union_with_key_inner<F>(mut self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(&K, V, V) -> V,
+    {
+        for (key, right_value) in other {
+            match self.remove(&key) {
+                None => {
+                    self.insert(key, right_value);
+                }
+                Some(left_value) => {
+                    let final_value = f(&key, left_value, right_value);
+                    self.insert(key, final_value);
+                }
+            }
+        }
+        self
+    }
+
+    /// Construct the union of a sequence of maps, selecting the value
+    /// of the leftmost when a key appears in more than one map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 3};
+    /// let map2 = ordmap!{2 => 2};
+    /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 3};
+    /// assert_eq!(expected, OrdMap::unions(vec![map1, map2]));
+    /// ```
+    #[must_use]
+    pub fn unions<I>(i: I) -> Self
+    where
+        I: IntoIterator<Item = Self>,
+    {
+        i.into_iter().fold(Self::default(), Self::union)
+    }
+
+    /// Construct the union of a sequence of maps, using a function to
+    /// decide what to do with the value when a key is in more than
+    /// one map.
+    ///
+    /// The function is called when a value exists in multiple maps,
+    /// and receives the value from the current map as its first
+    /// argument, and the value from the next map as the second. It
+    /// should return the value to be inserted in the resulting map.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn unions_with<I, F>(i: I, f: F) -> Self
+    where
+        I: IntoIterator<Item = Self>,
+        F: Fn(V, V) -> V,
+    {
+        i.into_iter()
+            .fold(Self::default(), |a, b| a.union_with(b, &f))
+    }
+
+    /// Construct the union of a sequence of maps, using a function to
+    /// decide what to do with the value when a key is in more than
+    /// one map.
+    ///
+    /// The function is called when a value exists in multiple maps,
+    /// and receives a reference to the key as its first argument, the
+    /// value from the current map as the second argument, and the
+    /// value from the next map as the third argument. It should
+    /// return the value to be inserted in the resulting map.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn unions_with_key<I, F>(i: I, f: F) -> Self
+    where
+        I: IntoIterator<Item = Self>,
+        F: Fn(&K, V, V) -> V,
+    {
+        i.into_iter()
+            .fold(Self::default(), |a, b| a.union_with_key(b, &f))
+    }
+
+    /// Construct the symmetric difference between two maps by discarding keys
+    /// which occur in both maps.
+    ///
+    /// This is an alias for the
+    /// [`symmetric_difference`][symmetric_difference] method.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 4};
+    /// let map2 = ordmap!{2 => 2, 3 => 5};
+    /// let expected = ordmap!{1 => 1, 2 => 2};
+    /// assert_eq!(expected, map1.difference(map2));
+    /// ```
+    ///
+    /// [symmetric_difference]: #method.symmetric_difference
+    #[inline]
+    #[must_use]
+    pub fn difference(self, other: Self) -> Self {
+        self.symmetric_difference(other)
+    }
+
+    /// Construct the symmetric difference between two maps by discarding keys
+    /// which occur in both maps.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 4};
+    /// let map2 = ordmap!{2 => 2, 3 => 5};
+    /// let expected = ordmap!{1 => 1, 2 => 2};
+    /// assert_eq!(expected, map1.symmetric_difference(map2));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn symmetric_difference(self, other: Self) -> Self {
+        self.symmetric_difference_with_key(other, |_, _, _| None)
+    }
+
+    /// Construct the symmetric difference between two maps by using a function
+    /// to decide what to do if a key occurs in both.
+    ///
+    /// This is an alias for the
+    /// [`symmetric_difference_with`][symmetric_difference_with] method.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// [symmetric_difference_with]: #method.symmetric_difference_with
+    #[inline]
+    #[must_use]
+    pub fn difference_with<F>(self, other: Self, f: F) -> Self
+    where
+        F: FnMut(V, V) -> Option<V>,
+    {
+        self.symmetric_difference_with(other, f)
+    }
+
+    /// Construct the symmetric difference between two maps by using a function
+    /// to decide what to do if a key occurs in both.
+    ///
+    /// Time: O(n log n)
+    #[inline]
+    #[must_use]
+    pub fn symmetric_difference_with<F>(self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(V, V) -> Option<V>,
+    {
+        self.symmetric_difference_with_key(other, |_, a, b| f(a, b))
+    }
+
+    /// Construct the symmetric difference between two maps by using a function
+    /// to decide what to do if a key occurs in both. The function
+    /// receives the key as well as both values.
+    ///
+    /// This is an alias for the
+    /// [`symmetric_difference_with_key`][symmetric_difference_with_key]
+    /// method.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 4};
+    /// let map2 = ordmap!{2 => 2, 3 => 5};
+    /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 9};
+    /// assert_eq!(expected, map1.difference_with_key(
+    ///     map2,
+    ///     |key, left, right| Some(left + right)
+    /// ));
+    /// ```
+    /// [symmetric_difference_with_key]: #method.symmetric_difference_with_key
+    #[must_use]
+    pub fn difference_with_key<F>(self, other: Self, f: F) -> Self
+    where
+        F: FnMut(&K, V, V) -> Option<V>,
+    {
+        self.symmetric_difference_with_key(other, f)
+    }
+
+    /// Construct the symmetric difference between two maps by using a function
+    /// to decide what to do if a key occurs in both. The function
+    /// receives the key as well as both values.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 4};
+    /// let map2 = ordmap!{2 => 2, 3 => 5};
+    /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 9};
+    /// assert_eq!(expected, map1.symmetric_difference_with_key(
+    ///     map2,
+    ///     |key, left, right| Some(left + right)
+    /// ));
+    /// ```
+    #[must_use]
+    pub fn symmetric_difference_with_key<F>(mut self, other: Self, mut f: F) -> Self
+    where
+        F: FnMut(&K, V, V) -> Option<V>,
+    {
+        let mut out = Self::default();
+        for (key, right_value) in other {
+            match self.remove(&key) {
+                None => {
+                    out.insert(key, right_value);
+                }
+                Some(left_value) => {
+                    if let Some(final_value) = f(&key, left_value, right_value) {
+                        out.insert(key, final_value);
+                    }
+                }
+            }
+        }
+        out.union(self)
+    }
+
+    /// Construct the relative complement between two maps by discarding keys
+    /// which occur in `other`.
+    ///
+    /// Time: O(m log n) where m is the size of the other map
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 3 => 4};
+    /// let map2 = ordmap!{2 => 2, 3 => 5};
+    /// let expected = ordmap!{1 => 1};
+    /// assert_eq!(expected, map1.relative_complement(map2));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn relative_complement(mut self, other: Self) -> Self {
+        for (key, _) in other {
+            let _ = self.remove(&key);
+        }
+        self
+    }
+
+    /// Construct the intersection of two maps, keeping the values
+    /// from the current map.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 2 => 2};
+    /// let map2 = ordmap!{2 => 3, 3 => 4};
+    /// let expected = ordmap!{2 => 2};
+    /// assert_eq!(expected, map1.intersection(map2));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn intersection(self, other: Self) -> Self {
+        self.intersection_with_key(other, |_, v, _| v)
+    }
+
+    /// Construct the intersection of two maps, calling a function
+    /// with both values for each key and using the result as the
+    /// value for the key.
+    ///
+    /// Time: O(n log n)
+    #[inline]
+    #[must_use]
+    pub fn intersection_with<B, C, F>(self, other: OrdMap<K, B>, mut f: F) -> OrdMap<K, C>
+    where
+        B: Clone,
+        C: Clone,
+        F: FnMut(V, B) -> C,
+    {
+        self.intersection_with_key(other, |_, v1, v2| f(v1, v2))
+    }
+
+    /// Construct the intersection of two maps, calling a function
+    /// with the key and both values for each key and using the result
+    /// as the value for the key.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordmap::OrdMap;
+    /// let map1 = ordmap!{1 => 1, 2 => 2};
+    /// let map2 = ordmap!{2 => 3, 3 => 4};
+    /// let expected = ordmap!{2 => 5};
+    /// assert_eq!(expected, map1.intersection_with_key(
+    ///     map2,
+    ///     |key, left, right| left + right
+    /// ));
+    /// ```
+    #[must_use]
+    pub fn intersection_with_key<B, C, F>(mut self, other: OrdMap<K, B>, mut f: F) -> OrdMap<K, C>
+    where
+        B: Clone,
+        C: Clone,
+        F: FnMut(&K, V, B) -> C,
+    {
+        let mut out = OrdMap::<K, C>::default();
+        for (key, right_value) in other {
+            match self.remove(&key) {
+                None => (),
+                Some(left_value) => {
+                    let result = f(&key, left_value, right_value);
+                    out.insert(key, result);
+                }
+            }
+        }
+        out
+    }
+
+    /// Split a map into two, with the left hand map containing keys
+    /// which are smaller than `split`, and the right hand map
+    /// containing keys which are larger than `split`.
+    ///
+    /// The `split` mapping is discarded.
+    #[must_use]
+    pub fn split<BK>(&self, split: &BK) -> (Self, Self)
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        let (l, _, r) = self.split_lookup(split);
+        (l, r)
+    }
+
+    /// Split a map into two, with the left hand map containing keys
+    /// which are smaller than `split`, and the right hand map
+    /// containing keys which are larger than `split`.
+    ///
+    /// Returns both the two maps and the value of `split`.
+    #[must_use]
+    pub fn split_lookup<BK>(&self, split: &BK) -> (Self, Option<V>, Self)
+    where
+        BK: Ord + ?Sized,
+        K: Borrow<BK>,
+    {
+        // TODO this is atrociously slow, got to be a better way
+        self.iter()
+            .fold((ordmap![], None, ordmap![]), |(l, m, r), (k, v)| {
+                match k.borrow().cmp(split) {
+                    Ordering::Less => (l.update(k.clone(), v.clone()), m, r),
+                    Ordering::Equal => (l, Some(v.clone()), r),
+                    Ordering::Greater => (l, m, r.update(k.clone(), v.clone())),
+                }
+            })
+    }
+
+    /// Construct a map with only the `n` smallest keys from a given
+    /// map.
+    #[must_use]
+    pub fn take(&self, n: usize) -> Self {
+        self.iter()
+            .take(n)
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect()
+    }
+
+    /// Construct a map with the `n` smallest keys removed from a
+    /// given map.
+    #[must_use]
+    pub fn skip(&self, n: usize) -> Self {
+        self.iter()
+            .skip(n)
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect()
+    }
+
+    /// Remove the smallest key from a map, and return its value as
+    /// well as the updated map.
+    #[must_use]
+    pub fn without_min(&self) -> (Option<V>, Self) {
+        let (pop, next) = self.without_min_with_key();
+        (pop.map(|(_, v)| v), next)
+    }
+
+    /// Remove the smallest key from a map, and return that key, its
+    /// value as well as the updated map.
+    #[must_use]
+    pub fn without_min_with_key(&self) -> (Option<(K, V)>, Self) {
+        match self.get_min() {
+            None => (None, self.clone()),
+            Some((k, _)) => {
+                let (key, value, next) = self.extract_with_key(k).unwrap();
+                (Some((key, value)), next)
+            }
+        }
+    }
+
+    /// Remove the largest key from a map, and return its value as
+    /// well as the updated map.
+    #[must_use]
+    pub fn without_max(&self) -> (Option<V>, Self) {
+        let (pop, next) = self.without_max_with_key();
+        (pop.map(|(_, v)| v), next)
+    }
+
+    /// Remove the largest key from a map, and return that key, its
+    /// value as well as the updated map.
+    #[must_use]
+    pub fn without_max_with_key(&self) -> (Option<(K, V)>, Self) {
+        match self.get_max() {
+            None => (None, self.clone()),
+            Some((k, _)) => {
+                let (key, value, next) = self.extract_with_key(k).unwrap();
+                (Some((key, value)), next)
+            }
+        }
+    }
+
+    /// Get the [`Entry`][Entry] for a key in the map for in-place manipulation.
+    ///
+    /// Time: O(log n)
+    ///
+    /// [Entry]: enum.Entry.html
+    #[must_use]
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
+        if self.contains_key(&key) {
+            Entry::Occupied(OccupiedEntry { map: self, key })
+        } else {
+            Entry::Vacant(VacantEntry { map: self, key })
+        }
+    }
+}
+
+// Entries
+
+/// A handle for a key and its associated value.
+pub enum Entry<'a, K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    /// An entry which exists in the map.
+    Occupied(OccupiedEntry<'a, K, V>),
+    /// An entry which doesn't exist in the map.
+    Vacant(VacantEntry<'a, K, V>),
+}
+
+impl<'a, K, V> Entry<'a, K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    /// Insert the default value provided if there was no value
+    /// already, and return a mutable reference to the value.
+    pub fn or_insert(self, default: V) -> &'a mut V {
+        self.or_insert_with(|| default)
+    }
+
+    /// Insert the default value from the provided function if there
+    /// was no value already, and return a mutable reference to the
+    /// value.
+    pub fn or_insert_with<F>(self, default: F) -> &'a mut V
+    where
+        F: FnOnce() -> V,
+    {
+        match self {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(default()),
+        }
+    }
+
+    /// Insert a default value if there was no value already, and
+    /// return a mutable reference to the value.
+    pub fn or_default(self) -> &'a mut V
+    where
+        V: Default,
+    {
+        self.or_insert_with(Default::default)
+    }
+
+    /// Get the key for this entry.
+    #[must_use]
+    pub fn key(&self) -> &K {
+        match self {
+            Entry::Occupied(entry) => entry.key(),
+            Entry::Vacant(entry) => entry.key(),
+        }
+    }
+
+    /// Call the provided function to modify the value if the value
+    /// exists.
+    pub fn and_modify<F>(mut self, f: F) -> Self
+    where
+        F: FnOnce(&mut V),
+    {
+        match &mut self {
+            Entry::Occupied(ref mut entry) => f(entry.get_mut()),
+            Entry::Vacant(_) => (),
+        }
+        self
+    }
+}
+
+/// An entry for a mapping that already exists in the map.
+pub struct OccupiedEntry<'a, K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    map: &'a mut OrdMap<K, V>,
+    key: K,
+}
+
+impl<'a, K, V> OccupiedEntry<'a, K, V>
+where
+    K: 'a + Ord + Clone,
+    V: 'a + Clone,
+{
+    /// Get the key for this entry.
+    #[must_use]
+    pub fn key(&self) -> &K {
+        &self.key
+    }
+
+    /// Remove this entry from the map and return the removed mapping.
+    pub fn remove_entry(self) -> (K, V) {
+        self.map
+            .remove_with_key(&self.key)
+            .expect("ordmap::OccupiedEntry::remove_entry: key has vanished!")
+    }
+
+    /// Get the current value.
+    #[must_use]
+    pub fn get(&self) -> &V {
+        self.map.get(&self.key).unwrap()
+    }
+
+    /// Get a mutable reference to the current value.
+    #[must_use]
+    pub fn get_mut(&mut self) -> &mut V {
+        self.map.get_mut(&self.key).unwrap()
+    }
+
+    /// Convert this entry into a mutable reference.
+    #[must_use]
+    pub fn into_mut(self) -> &'a mut V {
+        self.map.get_mut(&self.key).unwrap()
+    }
+
+    /// Overwrite the current value.
+    pub fn insert(&mut self, value: V) -> V {
+        mem::replace(self.get_mut(), value)
+    }
+
+    /// Remove this entry from the map and return the removed value.
+    pub fn remove(self) -> V {
+        self.remove_entry().1
+    }
+}
+
+/// An entry for a mapping that does not already exist in the map.
+pub struct VacantEntry<'a, K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    map: &'a mut OrdMap<K, V>,
+    key: K,
+}
+
+impl<'a, K, V> VacantEntry<'a, K, V>
+where
+    K: 'a + Ord + Clone,
+    V: 'a + Clone,
+{
+    /// Get the key for this entry.
+    #[must_use]
+    pub fn key(&self) -> &K {
+        &self.key
+    }
+
+    /// Convert this entry into its key.
+    #[must_use]
+    pub fn into_key(self) -> K {
+        self.key
+    }
+
+    /// Insert a value into this entry.
+    pub fn insert(self, value: V) -> &'a mut V {
+        self.map.insert(self.key.clone(), value);
+        // TODO insert_mut ought to return this reference
+        self.map.get_mut(&self.key).unwrap()
+    }
+}
+
+// Core traits
+
+impl<K, V> Clone for OrdMap<K, V> {
+    /// Clone a map.
+    ///
+    /// Time: O(1)
+    #[inline]
+    fn clone(&self) -> Self {
+        OrdMap {
+            size: self.size,
+            pool: self.pool.clone(),
+            root: self.root.clone(),
+        }
+    }
+}
+
+#[cfg(not(has_specialisation))]
+impl<K, V> PartialEq for OrdMap<K, V>
+where
+    K: Ord + PartialEq,
+    V: PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.len() == other.len() && self.diff(other).next().is_none()
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V> PartialEq for OrdMap<K, V>
+where
+    K: Ord + PartialEq,
+    V: PartialEq,
+{
+    default fn eq(&self, other: &Self) -> bool {
+        self.len() == other.len() && self.diff(other).next().is_none()
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V> PartialEq for OrdMap<K, V>
+where
+    K: Ord + Eq,
+    V: Eq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        PoolRef::ptr_eq(&self.root, &other.root)
+            || (self.len() == other.len() && self.diff(other).next().is_none())
+    }
+}
+
+impl<K: Ord + Eq, V: Eq> Eq for OrdMap<K, V> {}
+
+impl<K, V> PartialOrd for OrdMap<K, V>
+where
+    K: Ord,
+    V: PartialOrd,
+{
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.iter().partial_cmp(other.iter())
+    }
+}
+
+impl<K, V> Ord for OrdMap<K, V>
+where
+    K: Ord,
+    V: Ord,
+{
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.iter().cmp(other.iter())
+    }
+}
+
+impl<K, V> Hash for OrdMap<K, V>
+where
+    K: Ord + Hash,
+    V: Hash,
+{
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        for i in self.iter() {
+            i.hash(state);
+        }
+    }
+}
+
+impl<K, V> Default for OrdMap<K, V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a, K, V> Add for &'a OrdMap<K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    type Output = OrdMap<K, V>;
+
+    fn add(self, other: Self) -> Self::Output {
+        self.clone().union(other.clone())
+    }
+}
+
+impl<K, V> Add for OrdMap<K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    type Output = OrdMap<K, V>;
+
+    fn add(self, other: Self) -> Self::Output {
+        self.union(other)
+    }
+}
+
+impl<K, V> Sum for OrdMap<K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    fn sum<I>(it: I) -> Self
+    where
+        I: Iterator<Item = Self>,
+    {
+        it.fold(Self::default(), |a, b| a + b)
+    }
+}
+
+impl<K, V, RK, RV> Extend<(RK, RV)> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<RK>,
+    V: Clone + From<RV>,
+{
+    fn extend<I>(&mut self, iter: I)
+    where
+        I: IntoIterator<Item = (RK, RV)>,
+    {
+        for (key, value) in iter {
+            self.insert(From::from(key), From::from(value));
+        }
+    }
+}
+
+impl<'a, BK, K, V> Index<&'a BK> for OrdMap<K, V>
+where
+    BK: Ord + ?Sized,
+    K: Ord + Borrow<BK>,
+{
+    type Output = V;
+
+    fn index(&self, key: &BK) -> &Self::Output {
+        match self.root.lookup(key) {
+            None => panic!("OrdMap::index: invalid key"),
+            Some(&(_, ref value)) => value,
+        }
+    }
+}
+
+impl<'a, BK, K, V> IndexMut<&'a BK> for OrdMap<K, V>
+where
+    BK: Ord + ?Sized,
+    K: Ord + Clone + Borrow<BK>,
+    V: Clone,
+{
+    fn index_mut(&mut self, key: &BK) -> &mut Self::Output {
+        let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+        match root.lookup_mut(&self.pool.0, key) {
+            None => panic!("OrdMap::index: invalid key"),
+            Some(&mut (_, ref mut value)) => value,
+        }
+    }
+}
+
+impl<K, V> Debug for OrdMap<K, V>
+where
+    K: Ord + Debug,
+    V: Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let mut d = f.debug_map();
+        for (k, v) in self.iter() {
+            d.entry(k, v);
+        }
+        d.finish()
+    }
+}
+
+// Iterators
+
+/// An iterator over the key/value pairs of a map.
+pub struct Iter<'a, K, V> {
+    it: RangedIter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for Iter<'a, K, V>
+where
+    (K, V): 'a + BTreeValue,
+{
+    type Item = (&'a K, &'a V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|(k, v)| (k, v))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.it.remaining, Some(self.it.remaining))
+    }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V>
+where
+    (K, V): 'a + BTreeValue,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.it.next_back().map(|(k, v)| (k, v))
+    }
+}
+
+impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> where (K, V): 'a + BTreeValue {}
+
+/// An iterator over the differences between two maps.
+pub struct DiffIter<'a, K, V> {
+    it: NodeDiffIter<'a, (K, V)>,
+}
+
+/// A description of a difference between two ordered maps.
+#[derive(PartialEq, Eq, Debug)]
+pub enum DiffItem<'a, K, V> {
+    /// This value has been added to the new map.
+    Add(&'a K, &'a V),
+    /// This value has been changed between the two maps.
+    Update {
+        /// The old value.
+        old: (&'a K, &'a V),
+        /// The new value.
+        new: (&'a K, &'a V),
+    },
+    /// This value has been removed from the new map.
+    Remove(&'a K, &'a V),
+}
+
+impl<'a, K, V> Iterator for DiffIter<'a, K, V>
+where
+    (K, V): 'a + BTreeValue + PartialEq,
+{
+    type Item = DiffItem<'a, K, V>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|item| match item {
+            NodeDiffItem::Add((k, v)) => DiffItem::Add(k, v),
+            NodeDiffItem::Update {
+                old: (oldk, oldv),
+                new: (newk, newv),
+            } => DiffItem::Update {
+                old: (oldk, oldv),
+                new: (newk, newv),
+            },
+            NodeDiffItem::Remove((k, v)) => DiffItem::Remove(k, v),
+        })
+    }
+}
+
+/// An iterator ove the keys of a map.
+pub struct Keys<'a, K, V> {
+    it: Iter<'a, K, V>,
+}
+
+impl<'a, K, V> Iterator for Keys<'a, K, V>
+where
+    K: 'a + Ord,
+    V: 'a,
+{
+    type Item = &'a K;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|(k, _)| k)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V>
+where
+    K: 'a + Ord,
+    V: 'a,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.it.next_back().map(|(k, _)| k)
+    }
+}
+
+impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V>
+where
+    K: 'a + Ord,
+    V: 'a,
+{
+}
+
+/// An iterator over the values of a map.
+pub struct Values<'a, K, V> {
+    it: Iter<'a, K, V>,
+}
+
+impl<'a, K, V> Iterator for Values<'a, K, V>
+where
+    K: 'a + Ord,
+    V: 'a,
+{
+    type Item = &'a V;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|(_, v)| v)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V>
+where
+    K: 'a + Ord,
+    V: 'a,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.it.next_back().map(|(_, v)| v)
+    }
+}
+
+impl<'a, K, V> ExactSizeIterator for Values<'a, K, V>
+where
+    K: 'a + Ord,
+    V: 'a,
+{
+}
+
+impl<K, V, RK, RV> FromIterator<(RK, RV)> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<RK>,
+    V: Clone + From<RV>,
+{
+    fn from_iter<T>(i: T) -> Self
+    where
+        T: IntoIterator<Item = (RK, RV)>,
+    {
+        let mut m = OrdMap::default();
+        for (k, v) in i {
+            m.insert(From::from(k), From::from(v));
+        }
+        m
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a OrdMap<K, V>
+where
+    K: Ord,
+{
+    type Item = (&'a K, &'a V);
+    type IntoIter = Iter<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<K, V> IntoIterator for OrdMap<K, V>
+where
+    K: Ord + Clone,
+    V: Clone,
+{
+    type Item = (K, V);
+    type IntoIter = ConsumingIter<(K, V)>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ConsumingIter::new(&self.root, self.size)
+    }
+}
+
+// Conversions
+
+impl<K, V> AsRef<OrdMap<K, V>> for OrdMap<K, V> {
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
+impl<'m, 'k, 'v, K, V, OK, OV> From<&'m OrdMap<&'k K, &'v V>> for OrdMap<OK, OV>
+where
+    K: Ord + ToOwned<Owned = OK> + ?Sized,
+    V: ToOwned<Owned = OV> + ?Sized,
+    OK: Ord + Clone + Borrow<K>,
+    OV: Clone + Borrow<V>,
+{
+    fn from(m: &OrdMap<&K, &V>) -> Self {
+        m.iter()
+            .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
+            .collect()
+    }
+}
+
+impl<'a, K, V, RK, RV, OK, OV> From<&'a [(RK, RV)]> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<OK>,
+    V: Clone + From<OV>,
+    OK: Borrow<RK>,
+    OV: Borrow<RV>,
+    RK: ToOwned<Owned = OK>,
+    RV: ToOwned<Owned = OV>,
+{
+    fn from(m: &'a [(RK, RV)]) -> OrdMap<K, V> {
+        m.iter()
+            .map(|&(ref k, ref v)| (k.to_owned(), v.to_owned()))
+            .collect()
+    }
+}
+
+impl<K, V, RK, RV> From<Vec<(RK, RV)>> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<RK>,
+    V: Clone + From<RV>,
+{
+    fn from(m: Vec<(RK, RV)>) -> OrdMap<K, V> {
+        m.into_iter().collect()
+    }
+}
+
+impl<'a, K: Ord, V, RK, RV, OK, OV> From<&'a Vec<(RK, RV)>> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<OK>,
+    V: Clone + From<OV>,
+    OK: Borrow<RK>,
+    OV: Borrow<RV>,
+    RK: ToOwned<Owned = OK>,
+    RV: ToOwned<Owned = OV>,
+{
+    fn from(m: &'a Vec<(RK, RV)>) -> OrdMap<K, V> {
+        m.iter()
+            .map(|&(ref k, ref v)| (k.to_owned(), v.to_owned()))
+            .collect()
+    }
+}
+
+impl<K: Ord, V, RK: Eq + Hash, RV> From<collections::HashMap<RK, RV>> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<RK>,
+    V: Clone + From<RV>,
+{
+    fn from(m: collections::HashMap<RK, RV>) -> OrdMap<K, V> {
+        m.into_iter().collect()
+    }
+}
+
+impl<'a, K, V, OK, OV, RK, RV> From<&'a collections::HashMap<RK, RV>> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<OK>,
+    V: Clone + From<OV>,
+    OK: Borrow<RK>,
+    OV: Borrow<RV>,
+    RK: Hash + Eq + ToOwned<Owned = OK>,
+    RV: ToOwned<Owned = OV>,
+{
+    fn from(m: &'a collections::HashMap<RK, RV>) -> OrdMap<K, V> {
+        m.iter()
+            .map(|(k, v)| (k.to_owned(), v.to_owned()))
+            .collect()
+    }
+}
+
+impl<K: Ord, V, RK, RV> From<collections::BTreeMap<RK, RV>> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<RK>,
+    V: Clone + From<RV>,
+{
+    fn from(m: collections::BTreeMap<RK, RV>) -> OrdMap<K, V> {
+        m.into_iter().collect()
+    }
+}
+
+impl<'a, K: Ord, V, RK, RV, OK, OV> From<&'a collections::BTreeMap<RK, RV>> for OrdMap<K, V>
+where
+    K: Ord + Clone + From<OK>,
+    V: Clone + From<OV>,
+    OK: Borrow<RK>,
+    OV: Borrow<RV>,
+    RK: Ord + ToOwned<Owned = OK>,
+    RV: ToOwned<Owned = OV>,
+{
+    fn from(m: &'a collections::BTreeMap<RK, RV>) -> OrdMap<K, V> {
+        m.iter()
+            .map(|(k, v)| (k.to_owned(), v.to_owned()))
+            .collect()
+    }
+}
+
+impl<K: Ord + Hash + Eq + Clone, V: Clone, S: BuildHasher> From<HashMap<K, V, S>> for OrdMap<K, V> {
+    fn from(m: HashMap<K, V, S>) -> Self {
+        m.into_iter().collect()
+    }
+}
+
+impl<'a, K: Ord + Hash + Eq + Clone, V: Clone, S: BuildHasher> From<&'a HashMap<K, V, S>>
+    for OrdMap<K, V>
+{
+    fn from(m: &'a HashMap<K, V, S>) -> Self {
+        m.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
+    }
+}
+
+// Proptest
+#[cfg(any(test, feature = "proptest"))]
+#[doc(hidden)]
+pub mod proptest {
+    #[deprecated(
+        since = "14.3.0",
+        note = "proptest strategies have moved to im::proptest"
+    )]
+    pub use crate::proptest::ord_map;
+}
+
+// Tests
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::proptest::*;
+    use crate::test::is_sorted;
+    use ::proptest::num::{i16, usize};
+    use ::proptest::{bool, collection, proptest};
+
+    #[test]
+    fn iterates_in_order() {
+        let map = ordmap! {
+            2 => 22,
+            1 => 11,
+            3 => 33,
+            8 => 88,
+            9 => 99,
+            4 => 44,
+            5 => 55,
+            7 => 77,
+            6 => 66
+        };
+        let mut it = map.iter();
+        assert_eq!(it.next(), Some((&1, &11)));
+        assert_eq!(it.next(), Some((&2, &22)));
+        assert_eq!(it.next(), Some((&3, &33)));
+        assert_eq!(it.next(), Some((&4, &44)));
+        assert_eq!(it.next(), Some((&5, &55)));
+        assert_eq!(it.next(), Some((&6, &66)));
+        assert_eq!(it.next(), Some((&7, &77)));
+        assert_eq!(it.next(), Some((&8, &88)));
+        assert_eq!(it.next(), Some((&9, &99)));
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    fn into_iter() {
+        let map = ordmap! {
+            2 => 22,
+            1 => 11,
+            3 => 33,
+            8 => 88,
+            9 => 99,
+            4 => 44,
+            5 => 55,
+            7 => 77,
+            6 => 66
+        };
+        let mut vec = vec![];
+        for (k, v) in map {
+            assert_eq!(k * 11, v);
+            vec.push(k)
+        }
+        assert_eq!(vec, vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    }
+
+    #[test]
+    fn deletes_correctly() {
+        let map = ordmap! {
+            2 => 22,
+            1 => 11,
+            3 => 33,
+            8 => 88,
+            9 => 99,
+            4 => 44,
+            5 => 55,
+            7 => 77,
+            6 => 66
+        };
+        assert_eq!(map.extract(&11), None);
+        let (popped, less) = map.extract(&5).unwrap();
+        assert_eq!(popped, 55);
+        let mut it = less.iter();
+        assert_eq!(it.next(), Some((&1, &11)));
+        assert_eq!(it.next(), Some((&2, &22)));
+        assert_eq!(it.next(), Some((&3, &33)));
+        assert_eq!(it.next(), Some((&4, &44)));
+        assert_eq!(it.next(), Some((&6, &66)));
+        assert_eq!(it.next(), Some((&7, &77)));
+        assert_eq!(it.next(), Some((&8, &88)));
+        assert_eq!(it.next(), Some((&9, &99)));
+        assert_eq!(it.next(), None);
+    }
+
+    #[test]
+    fn debug_output() {
+        assert_eq!(
+            format!("{:?}", ordmap! { 3 => 4, 5 => 6, 1 => 2 }),
+            "{1: 2, 3: 4, 5: 6}"
+        );
+    }
+
+    #[test]
+    fn equality2() {
+        let v1 = "1".to_string();
+        let v2 = "1".to_string();
+        assert_eq!(v1, v2);
+        let p1 = Vec::<String>::new();
+        let p2 = Vec::<String>::new();
+        assert_eq!(p1, p2);
+        let c1 = OrdMap::unit(v1, p1);
+        let c2 = OrdMap::unit(v2, p2);
+        assert_eq!(c1, c2);
+    }
+
+    #[test]
+    fn insert_remove_single_mut() {
+        let mut m = OrdMap::new();
+        m.insert(0, 0);
+        assert_eq!(OrdMap::unit(0, 0), m);
+        m.remove(&0);
+        assert_eq!(OrdMap::new(), m);
+    }
+
+    #[test]
+    fn double_ended_iterator_1() {
+        let m = ordmap! {1 => 1, 2 => 2, 3 => 3, 4 => 4};
+        let mut it = m.iter();
+        assert_eq!(Some((&1, &1)), it.next());
+        assert_eq!(Some((&4, &4)), it.next_back());
+        assert_eq!(Some((&2, &2)), it.next());
+        assert_eq!(Some((&3, &3)), it.next_back());
+        assert_eq!(None, it.next());
+    }
+
+    #[test]
+    fn double_ended_iterator_2() {
+        let m = ordmap! {1 => 1, 2 => 2, 3 => 3, 4 => 4};
+        let mut it = m.iter();
+        assert_eq!(Some((&1, &1)), it.next());
+        assert_eq!(Some((&4, &4)), it.next_back());
+        assert_eq!(Some((&2, &2)), it.next());
+        assert_eq!(Some((&3, &3)), it.next_back());
+        assert_eq!(None, it.next_back());
+    }
+
+    #[test]
+    fn safe_mutation() {
+        let v1 = (0..131_072).map(|i| (i, i)).collect::<OrdMap<_, _>>();
+        let mut v2 = v1.clone();
+        v2.insert(131_000, 23);
+        assert_eq!(Some(&23), v2.get(&131_000));
+        assert_eq!(Some(&131_000), v1.get(&131_000));
+    }
+
+    #[test]
+    fn index_operator() {
+        let mut map = ordmap! {1 => 2, 3 => 4, 5 => 6};
+        assert_eq!(4, map[&3]);
+        map[&3] = 8;
+        assert_eq!(ordmap! {1 => 2, 3 => 8, 5 => 6}, map);
+    }
+
+    #[test]
+    fn entry_api() {
+        let mut map = ordmap! {"bar" => 5};
+        map.entry("foo").and_modify(|v| *v += 5).or_insert(1);
+        assert_eq!(1, map[&"foo"]);
+        map.entry("foo").and_modify(|v| *v += 5).or_insert(1);
+        assert_eq!(6, map[&"foo"]);
+        map.entry("bar").and_modify(|v| *v += 5).or_insert(1);
+        assert_eq!(10, map[&"bar"]);
+        assert_eq!(
+            10,
+            match map.entry("bar") {
+                Entry::Occupied(entry) => entry.remove(),
+                _ => panic!(),
+            }
+        );
+        assert!(!map.contains_key(&"bar"));
+    }
+
+    #[test]
+    fn match_string_keys_with_string_slices() {
+        let mut map: OrdMap<String, i32> =
+            From::from(&ordmap! { "foo" => &1, "bar" => &2, "baz" => &3 });
+        assert_eq!(Some(&1), map.get("foo"));
+        map = map.without("foo");
+        assert_eq!(Some(3), map.remove("baz"));
+        map["bar"] = 8;
+        assert_eq!(8, map["bar"]);
+    }
+
+    #[test]
+    fn ranged_iter() {
+        let map: OrdMap<i32, i32> = ordmap![1=>2, 2=>3, 3=>4, 4=>5, 5=>6, 7=>8];
+        let range: Vec<(i32, i32)> = map.range(..).map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (7, 8)], range);
+        let range: Vec<(i32, i32)> = map.range(..).rev().map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(7, 8), (5, 6), (4, 5), (3, 4), (2, 3), (1, 2)], range);
+        let range: Vec<(i32, i32)> = map.range(2..5).map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(2, 3), (3, 4), (4, 5)], range);
+        let range: Vec<(i32, i32)> = map.range(2..5).rev().map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(4, 5), (3, 4), (2, 3)], range);
+        let range: Vec<(i32, i32)> = map.range(3..).map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(3, 4), (4, 5), (5, 6), (7, 8)], range);
+        let range: Vec<(i32, i32)> = map.range(3..).rev().map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(7, 8), (5, 6), (4, 5), (3, 4)], range);
+        let range: Vec<(i32, i32)> = map.range(..4).map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(1, 2), (2, 3), (3, 4)], range);
+        let range: Vec<(i32, i32)> = map.range(..4).rev().map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(3, 4), (2, 3), (1, 2)], range);
+        let range: Vec<(i32, i32)> = map.range(..=3).map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(1, 2), (2, 3), (3, 4)], range);
+        let range: Vec<(i32, i32)> = map.range(..=3).rev().map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(3, 4), (2, 3), (1, 2)], range);
+        let range: Vec<(i32, i32)> = map.range(..6).map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)], range);
+        let range: Vec<(i32, i32)> = map.range(..=6).map(|(k, v)| (*k, *v)).collect();
+        assert_eq!(vec![(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)], range);
+    }
+
+    #[test]
+    fn range_iter_big() {
+        use crate::nodes::btree::NODE_SIZE;
+        use std::ops::Bound::Included;
+        const N: usize = NODE_SIZE * NODE_SIZE * 5; // enough for a sizeable 3 level tree
+
+        let data = (1usize..N).filter(|i| i % 2 == 0).map(|i| (i, ()));
+        let bmap = data
+            .clone()
+            .collect::<std::collections::BTreeMap<usize, ()>>();
+        let omap = data.collect::<OrdMap<usize, ()>>();
+
+        for i in (0..NODE_SIZE * 5).chain(N - NODE_SIZE * 5..=N + 1) {
+            assert_eq!(omap.range(i..).count(), bmap.range(i..).count());
+            assert_eq!(omap.range(..i).count(), bmap.range(..i).count());
+            assert_eq!(omap.range(i..i + 7).count(), bmap.range(i..i + 7).count());
+            assert_eq!(omap.range(i..=i + 7).count(), bmap.range(i..=i + 7).count());
+            assert_eq!(
+                omap.range((Included(i), Included(i + 7))).count(),
+                bmap.range((Included(i), Included(i + 7))).count(),
+            );
+        }
+    }
+
+    #[test]
+    fn issue_124() {
+        let mut map = OrdMap::new();
+        let contents = include_str!("test-fixtures/issue_124.txt");
+        for line in contents.lines() {
+            if line.starts_with("insert ") {
+                map.insert(line[7..].parse::<u32>().unwrap(), 0);
+            } else if line.starts_with("remove ") {
+                map.remove(&line[7..].parse::<u32>().unwrap());
+            }
+        }
+    }
+
+    proptest! {
+        #[test]
+        fn length(ref input in collection::btree_map(i16::ANY, i16::ANY, 0..1000)) {
+            let map: OrdMap<i32, i32> = OrdMap::from(input.clone());
+            assert_eq!(input.len(), map.len());
+        }
+
+        #[test]
+        fn order(ref input in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) {
+            let map: OrdMap<i32, i32> = OrdMap::from(input.clone());
+            assert!(is_sorted(map.keys()));
+        }
+
+        #[test]
+        fn overwrite_values(ref vec in collection::vec((i16::ANY, i16::ANY), 1..1000), index_rand in usize::ANY, new_val in i16::ANY) {
+            let index = vec[index_rand % vec.len()].0;
+            let map1 = OrdMap::from_iter(vec.clone());
+            let map2 = map1.update(index, new_val);
+            for (k, v) in map2 {
+                if k == index {
+                    assert_eq!(v, new_val);
+                } else {
+                    match map1.get(&k) {
+                        None => panic!("map1 didn't have key {:?}", k),
+                        Some(other_v) => {
+                            assert_eq!(v, *other_v);
+                        }
+                    }
+                }
+            }
+        }
+
+        #[test]
+        fn delete_values(ref vec in collection::vec((usize::ANY, usize::ANY), 1..1000), index_rand in usize::ANY) {
+            let index = vec[index_rand % vec.len()].0;
+            let map1: OrdMap<usize, usize> = OrdMap::from_iter(vec.clone());
+            let map2 = map1.without(&index);
+            assert_eq!(map1.len(), map2.len() + 1);
+            for k in map2.keys() {
+                assert_ne!(*k, index);
+            }
+        }
+
+        #[test]
+        fn insert_and_delete_values(
+            ref input in ord_map(0usize..64, 0usize..64, 1..1000),
+            ref ops in collection::vec((bool::ANY, usize::ANY, usize::ANY), 1..1000)
+        ) {
+            let mut map = input.clone();
+            let mut tree: collections::BTreeMap<usize, usize> = input.iter().map(|(k, v)| (*k, *v)).collect();
+            for (ins, key, val) in ops {
+                if *ins {
+                    tree.insert(*key, *val);
+                    map = map.update(*key, *val)
+                } else {
+                    tree.remove(key);
+                    map = map.without(key)
+                }
+            }
+            assert!(map.iter().map(|(k, v)| (*k, *v)).eq(tree.iter().map(|(k, v)| (*k, *v))));
+        }
+
+        #[test]
+        fn proptest_works(ref m in ord_map(0..9999, ".*", 10..100)) {
+            assert!(m.len() < 100);
+            assert!(m.len() >= 10);
+        }
+
+        #[test]
+        fn insert_and_length(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) {
+            let mut map: OrdMap<i16, i16> = OrdMap::new();
+            for (k, v) in m.iter() {
+                map = map.update(*k, *v)
+            }
+            assert_eq!(m.len(), map.len());
+        }
+
+        #[test]
+        fn from_iterator(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) {
+            let map: OrdMap<i16, i16> =
+                FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            assert_eq!(m.len(), map.len());
+        }
+
+        #[test]
+        fn iterate_over(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) {
+            let map: OrdMap<i16, i16> =
+                FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            assert_eq!(m.len(), map.iter().count());
+        }
+
+        #[test]
+        fn equality(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) {
+            let map1: OrdMap<i16, i16> =
+                FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            let map2: OrdMap<i16, i16> =
+                FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            assert_eq!(map1, map2);
+        }
+
+        #[test]
+        fn lookup(ref m in ord_map(i16::ANY, i16::ANY, 0..1000)) {
+            let map: OrdMap<i16, i16> =
+                FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            for (k, v) in m.iter() {
+                assert_eq!(Some(*v), map.get(k).cloned());
+            }
+        }
+
+        #[test]
+        fn remove(ref m in ord_map(i16::ANY, i16::ANY, 0..1000)) {
+            let mut map: OrdMap<i16, i16> =
+                FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+            for k in m.keys() {
+                let l = map.len();
+                assert_eq!(m.get(k).cloned(), map.get(k).cloned());
+                map = map.without(k);
+                assert_eq!(None, map.get(k));
+                assert_eq!(l - 1, map.len());
+            }
+        }
+
+        #[test]
+        fn insert_mut(ref m in ord_map(i16::ANY, i16::ANY, 0..1000)) {
+            let mut mut_map = OrdMap::new();
+            let mut map = OrdMap::new();
+            for (k, v) in m.iter() {
+                map = map.update(*k, *v);
+                mut_map.insert(*k, *v);
+            }
+            assert_eq!(map, mut_map);
+        }
+
+        #[test]
+        fn remove_mut(ref orig in ord_map(i16::ANY, i16::ANY, 0..1000)) {
+            let mut map = orig.clone();
+            for key in orig.keys() {
+                let len = map.len();
+                assert_eq!(orig.get(key), map.get(key));
+                assert_eq!(orig.get(key).cloned(), map.remove(key));
+                assert_eq!(None, map.get(key));
+                assert_eq!(len - 1, map.len());
+            }
+        }
+
+        #[test]
+        fn remove_alien(ref orig in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) {
+            let mut map = OrdMap::<i16, i16>::from(orig.clone());
+            for key in orig.keys() {
+                let len = map.len();
+                assert_eq!(orig.get(key), map.get(key));
+                assert_eq!(orig.get(key).cloned(), map.remove(key));
+                assert_eq!(None, map.get(key));
+                assert_eq!(len - 1, map.len());
+            }
+        }
+
+        #[test]
+        fn delete_and_reinsert(
+            ref input in collection::hash_map(i16::ANY, i16::ANY, 1..1000),
+            index_rand in usize::ANY
+        ) {
+            let index = *input.keys().nth(index_rand % input.len()).unwrap();
+            let map1 = OrdMap::from_iter(input.clone());
+            let (val, map2): (i16, _) = map1.extract(&index).unwrap();
+            let map3 = map2.update(index, val);
+            for key in map2.keys() {
+                assert!(*key != index);
+            }
+            assert_eq!(map1.len(), map2.len() + 1);
+            assert_eq!(map1, map3);
+        }
+
+        #[test]
+        fn exact_size_iterator(ref m in ord_map(i16::ANY, i16::ANY, 1..1000)) {
+            let mut should_be = m.len();
+            let mut it = m.iter();
+            loop {
+                assert_eq!(should_be, it.len());
+                match it.next() {
+                    None => break,
+                    Some(_) => should_be -= 1,
+                }
+            }
+            assert_eq!(0, it.len());
+        }
+
+        #[test]
+        fn diff_all_values(a in collection::vec((usize::ANY, usize::ANY), 1..1000), b in collection::vec((usize::ANY, usize::ANY), 1..1000)) {
+            let a: OrdMap<usize, usize> = OrdMap::from(a);
+            let b: OrdMap<usize, usize> = OrdMap::from(b);
+
+            let diff: Vec<_> = a.diff(&b).collect();
+            let union = b.clone().union(a.clone());
+            let expected: Vec<_> = union.iter().filter_map(|(k, v)| {
+                if a.contains_key(k) {
+                    if b.contains_key(k) {
+                        let old = a.get(k).unwrap();
+                        if old != v	{
+                            Some(DiffItem::Update {
+                                old: (k, old),
+                                new: (k, v),
+                            })
+                        } else {
+                            None
+                        }
+                    } else {
+                        Some(DiffItem::Remove(k, v))
+                    }
+                } else {
+                    Some(DiffItem::Add(k, v))
+                }
+            }).collect();
+            assert_eq!(expected, diff);
+        }
+    }
+}
diff --git a/vendor/im-rc/src/ord/mod.rs b/vendor/im-rc/src/ord/mod.rs
new file mode 100644
index 000000000..27a56a5e2
--- /dev/null
+++ b/vendor/im-rc/src/ord/mod.rs
@@ -0,0 +1,8 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#[macro_use]
+pub mod map;
+#[macro_use]
+pub mod set;
diff --git a/vendor/im-rc/src/ord/set.rs b/vendor/im-rc/src/ord/set.rs
new file mode 100644
index 000000000..60ad6adcc
--- /dev/null
+++ b/vendor/im-rc/src/ord/set.rs
@@ -0,0 +1,1243 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! An ordered set.
+//!
+//! An immutable ordered set implemented as a [B-tree] [1].
+//!
+//! Most operations on this type of set are O(log n). A
+//! [`HashSet`][hashset::HashSet] is usually a better choice for
+//! performance, but the `OrdSet` has the advantage of only requiring
+//! an [`Ord`][std::cmp::Ord] constraint on its values, and of being
+//! ordered, so values always come out from lowest to highest, where a
+//! [`HashSet`][hashset::HashSet] has no guaranteed ordering.
+//!
+//! [1]: https://en.wikipedia.org/wiki/B-tree
+//! [hashset::HashSet]: ./struct.HashSet.html
+//! [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html
+
+use std::borrow::Borrow;
+use std::cmp::Ordering;
+use std::collections;
+use std::fmt::{Debug, Error, Formatter};
+use std::hash::{BuildHasher, Hash, Hasher};
+use std::iter::{FromIterator, IntoIterator, Sum};
+use std::ops::{Add, Deref, Mul, RangeBounds};
+
+use crate::hashset::HashSet;
+use crate::nodes::btree::{
+    BTreeValue, ConsumingIter as ConsumingNodeIter, DiffIter as NodeDiffIter, Insert,
+    Iter as NodeIter, Node, Remove,
+};
+#[cfg(has_specialisation)]
+use crate::util::linear_search_by;
+use crate::util::{Pool, PoolRef};
+
+pub use crate::nodes::btree::DiffItem;
+
+/// Construct a set from a sequence of values.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::ordset::OrdSet;
+/// # fn main() {
+/// assert_eq!(
+///   ordset![1, 2, 3],
+///   OrdSet::from(vec![1, 2, 3])
+/// );
+/// # }
+/// ```
+#[macro_export]
+macro_rules! ordset {
+    () => { $crate::ordset::OrdSet::new() };
+
+    ( $($x:expr),* ) => {{
+        let mut l = $crate::ordset::OrdSet::new();
+        $(
+            l.insert($x);
+        )*
+            l
+    }};
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+struct Value<A>(A);
+
+impl<A> Deref for Value<A> {
+    type Target = A;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+// FIXME lacking specialisation, we can't simply implement `BTreeValue`
+// for `A`, we have to use the `Value<A>` indirection.
+#[cfg(not(has_specialisation))]
+impl<A: Ord> BTreeValue for Value<A> {
+    type Key = A;
+
+    fn ptr_eq(&self, _other: &Self) -> bool {
+        false
+    }
+
+    fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize>
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        slice.binary_search_by(|value| Self::Key::borrow(value).cmp(key))
+    }
+
+    fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> {
+        slice.binary_search_by(|value| value.cmp(key))
+    }
+
+    fn cmp_keys<BK>(&self, other: &BK) -> Ordering
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        Self::Key::borrow(self).cmp(other)
+    }
+
+    fn cmp_values(&self, other: &Self) -> Ordering {
+        self.cmp(other)
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<A: Ord> BTreeValue for Value<A> {
+    type Key = A;
+
+    fn ptr_eq(&self, _other: &Self) -> bool {
+        false
+    }
+
+    default fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize>
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        slice.binary_search_by(|value| Self::Key::borrow(value).cmp(key))
+    }
+
+    default fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> {
+        slice.binary_search_by(|value| value.cmp(key))
+    }
+
+    fn cmp_keys<BK>(&self, other: &BK) -> Ordering
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        Self::Key::borrow(self).cmp(other)
+    }
+
+    fn cmp_values(&self, other: &Self) -> Ordering {
+        self.cmp(other)
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<A: Ord + Copy> BTreeValue for Value<A> {
+    fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize>
+    where
+        BK: Ord + ?Sized,
+        Self::Key: Borrow<BK>,
+    {
+        linear_search_by(slice, |value| Self::Key::borrow(value).cmp(key))
+    }
+
+    fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> {
+        linear_search_by(slice, |value| value.cmp(key))
+    }
+}
+
+def_pool!(OrdSetPool<A>, Node<Value<A>>);
+
+/// An ordered set.
+///
+/// An immutable ordered set implemented as a [B-tree] [1].
+///
+/// Most operations on this type of set are O(log n). A
+/// [`HashSet`][hashset::HashSet] is usually a better choice for
+/// performance, but the `OrdSet` has the advantage of only requiring
+/// an [`Ord`][std::cmp::Ord] constraint on its values, and of being
+/// ordered, so values always come out from lowest to highest, where a
+/// [`HashSet`][hashset::HashSet] has no guaranteed ordering.
+///
+/// [1]: https://en.wikipedia.org/wiki/B-tree
+/// [hashset::HashSet]: ./struct.HashSet.html
+/// [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html
+pub struct OrdSet<A> {
+    size: usize,
+    pool: OrdSetPool<A>,
+    root: PoolRef<Node<Value<A>>>,
+}
+
+impl<A> OrdSet<A> {
+    /// Construct an empty set.
+    #[must_use]
+    pub fn new() -> Self {
+        let pool = OrdSetPool::default();
+        let root = PoolRef::default(&pool.0);
+        OrdSet {
+            size: 0,
+            pool,
+            root,
+        }
+    }
+
+    /// Construct an empty set using a specific memory pool.
+    #[cfg(feature = "pool")]
+    #[must_use]
+    pub fn with_pool(pool: &OrdSetPool<A>) -> Self {
+        let root = PoolRef::default(&pool.0);
+        OrdSet {
+            size: 0,
+            pool: pool.clone(),
+            root,
+        }
+    }
+
+    /// Construct a set with a single value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let set = OrdSet::unit(123);
+    /// assert!(set.contains(&123));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn unit(a: A) -> Self {
+        let pool = OrdSetPool::default();
+        let root = PoolRef::new(&pool.0, Node::unit(Value(a)));
+        OrdSet {
+            size: 1,
+            pool,
+            root,
+        }
+    }
+
+    /// Test whether a set is empty.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// assert!(
+    ///   !ordset![1, 2, 3].is_empty()
+    /// );
+    /// assert!(
+    ///   OrdSet::<i32>::new().is_empty()
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Get the size of a set.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// assert_eq!(3, ordset![1, 2, 3].len());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.size
+    }
+
+    /// Test whether two sets refer to the same content in memory.
+    ///
+    /// This is true if the two sides are references to the same set,
+    /// or if the two sets refer to the same root node.
+    ///
+    /// This would return true if you're comparing a set to itself, or
+    /// if you're comparing a set to a fresh clone of itself.
+    ///
+    /// Time: O(1)
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        std::ptr::eq(self, other) || PoolRef::ptr_eq(&self.root, &other.root)
+    }
+
+    /// Get a reference to the memory pool used by this set.
+    ///
+    /// Note that if you didn't specifically construct it with a pool, you'll
+    /// get back a reference to a pool of size 0.
+    #[cfg(feature = "pool")]
+    pub fn pool(&self) -> &OrdSetPool<A> {
+        &self.pool
+    }
+
+    /// Discard all elements from the set.
+    ///
+    /// This leaves you with an empty set, and all elements that
+    /// were previously inside it are dropped.
+    ///
+    /// Time: O(n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::OrdSet;
+    /// let mut set = ordset![1, 2, 3];
+    /// set.clear();
+    /// assert!(set.is_empty());
+    /// ```
+    pub fn clear(&mut self) {
+        if !self.is_empty() {
+            self.root = PoolRef::default(&self.pool.0);
+            self.size = 0;
+        }
+    }
+}
+
+impl<A> OrdSet<A>
+where
+    A: Ord,
+{
+    /// Get the smallest value in a set.
+    ///
+    /// If the set is empty, returns `None`.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn get_min(&self) -> Option<&A> {
+        self.root.min().map(Deref::deref)
+    }
+
+    /// Get the largest value in a set.
+    ///
+    /// If the set is empty, returns `None`.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn get_max(&self) -> Option<&A> {
+        self.root.max().map(Deref::deref)
+    }
+
+    /// Create an iterator over the contents of the set.
+    #[must_use]
+    pub fn iter(&self) -> Iter<'_, A> {
+        Iter {
+            it: NodeIter::new(&self.root, self.size, ..),
+        }
+    }
+
+    /// Create an iterator over a range inside the set.
+    #[must_use]
+    pub fn range<R, BA>(&self, range: R) -> RangedIter<'_, A>
+    where
+        R: RangeBounds<BA>,
+        A: Borrow<BA>,
+        BA: Ord + ?Sized,
+    {
+        RangedIter {
+            it: NodeIter::new(&self.root, self.size, range),
+        }
+    }
+
+    /// Get an iterator over the differences between this set and
+    /// another, i.e. the set of entries to add or remove to this set
+    /// in order to make it equal to the other set.
+    ///
+    /// This function will avoid visiting nodes which are shared
+    /// between the two sets, meaning that even very large sets can be
+    /// compared quickly if most of their structure is shared.
+    ///
+    /// Time: O(n) (where n is the number of unique elements across
+    /// the two sets, minus the number of elements belonging to nodes
+    /// shared between them)
+    #[must_use]
+    pub fn diff<'a>(&'a self, other: &'a Self) -> DiffIter<'_, A> {
+        DiffIter {
+            it: NodeDiffIter::new(&self.root, &other.root),
+        }
+    }
+
+    /// Test if a value is part of a set.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let mut set = ordset!{1, 2, 3};
+    /// assert!(set.contains(&1));
+    /// assert!(!set.contains(&4));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn contains<BA>(&self, a: &BA) -> bool
+    where
+        BA: Ord + ?Sized,
+        A: Borrow<BA>,
+    {
+        self.root.lookup(a).is_some()
+    }
+
+    /// Get the closest smaller value in a set to a given value.
+    ///
+    /// If the set contains the given value, this is returned.
+    /// Otherwise, the closest value in the set smaller than the
+    /// given value is returned. If the smallest value in the set
+    /// is larger than the given value, `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::OrdSet;
+    /// let set = ordset![1, 3, 5, 7, 9];
+    /// assert_eq!(Some(&5), set.get_prev(&6));
+    /// ```
+    #[must_use]
+    pub fn get_prev(&self, key: &A) -> Option<&A> {
+        self.root.lookup_prev(key).map(|v| &v.0)
+    }
+
+    /// Get the closest larger value in a set to a given value.
+    ///
+    /// If the set contains the given value, this is returned.
+    /// Otherwise, the closest value in the set larger than the
+    /// given value is returned. If the largest value in the set
+    /// is smaller than the given value, `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::OrdSet;
+    /// let set = ordset![1, 3, 5, 7, 9];
+    /// assert_eq!(Some(&5), set.get_next(&4));
+    /// ```
+    #[must_use]
+    pub fn get_next(&self, key: &A) -> Option<&A> {
+        self.root.lookup_next(key).map(|v| &v.0)
+    }
+
+    /// Test whether a set is a subset of another set, meaning that
+    /// all values in our set must also be in the other set.
+    ///
+    /// Time: O(n log m) where m is the size of the other set
+    #[must_use]
+    pub fn is_subset<RS>(&self, other: RS) -> bool
+    where
+        RS: Borrow<Self>,
+    {
+        let other = other.borrow();
+        if other.len() < self.len() {
+            return false;
+        }
+        self.iter().all(|a| other.contains(a))
+    }
+
+    /// Test whether a set is a proper subset of another set, meaning
+    /// that all values in our set must also be in the other set. A
+    /// proper subset must also be smaller than the other set.
+    ///
+    /// Time: O(n log m) where m is the size of the other set
+    #[must_use]
+    pub fn is_proper_subset<RS>(&self, other: RS) -> bool
+    where
+        RS: Borrow<Self>,
+    {
+        self.len() != other.borrow().len() && self.is_subset(other)
+    }
+}
+
+impl<A> OrdSet<A>
+where
+    A: Ord + Clone,
+{
+    /// Insert a value into a set.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let mut set = ordset!{};
+    /// set.insert(123);
+    /// set.insert(456);
+    /// assert_eq!(
+    ///   set,
+    ///   ordset![123, 456]
+    /// );
+    /// ```
+    #[inline]
+    pub fn insert(&mut self, a: A) -> Option<A> {
+        let new_root = {
+            let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+            match root.insert(&self.pool.0, Value(a)) {
+                Insert::Replaced(Value(old_value)) => return Some(old_value),
+                Insert::Added => {
+                    self.size += 1;
+                    return None;
+                }
+                Insert::Split(left, median, right) => PoolRef::new(
+                    &self.pool.0,
+                    Node::new_from_split(&self.pool.0, left, median, right),
+                ),
+            }
+        };
+        self.size += 1;
+        self.root = new_root;
+        None
+    }
+
+    /// Remove a value from a set.
+    ///
+    /// Time: O(log n)
+    #[inline]
+    pub fn remove<BA>(&mut self, a: &BA) -> Option<A>
+    where
+        BA: Ord + ?Sized,
+        A: Borrow<BA>,
+    {
+        let (new_root, removed_value) = {
+            let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+            match root.remove(&self.pool.0, a) {
+                Remove::Update(value, root) => (PoolRef::new(&self.pool.0, root), Some(value.0)),
+                Remove::Removed(value) => {
+                    self.size -= 1;
+                    return Some(value.0);
+                }
+                Remove::NoChange => return None,
+            }
+        };
+        self.size -= 1;
+        self.root = new_root;
+        removed_value
+    }
+
+    /// Remove the smallest value from a set.
+    ///
+    /// Time: O(log n)
+    pub fn remove_min(&mut self) -> Option<A> {
+        // FIXME implement this at the node level for better efficiency
+        let key = match self.get_min() {
+            None => return None,
+            Some(v) => v,
+        }
+        .clone();
+        self.remove(&key)
+    }
+
+    /// Remove the largest value from a set.
+    ///
+    /// Time: O(log n)
+    pub fn remove_max(&mut self) -> Option<A> {
+        // FIXME implement this at the node level for better efficiency
+        let key = match self.get_max() {
+            None => return None,
+            Some(v) => v,
+        }
+        .clone();
+        self.remove(&key)
+    }
+
+    /// Construct a new set from the current set with the given value
+    /// added.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let set = ordset![456];
+    /// assert_eq!(
+    ///   set.update(123),
+    ///   ordset![123, 456]
+    /// );
+    /// ```
+    #[must_use]
+    pub fn update(&self, a: A) -> Self {
+        let mut out = self.clone();
+        out.insert(a);
+        out
+    }
+
+    /// Construct a new set with the given value removed if it's in
+    /// the set.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn without<BA>(&self, a: &BA) -> Self
+    where
+        BA: Ord + ?Sized,
+        A: Borrow<BA>,
+    {
+        let mut out = self.clone();
+        out.remove(a);
+        out
+    }
+
+    /// Remove the smallest value from a set, and return that value as
+    /// well as the updated set.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn without_min(&self) -> (Option<A>, Self) {
+        match self.get_min() {
+            Some(v) => (Some(v.clone()), self.without(v)),
+            None => (None, self.clone()),
+        }
+    }
+
+    /// Remove the largest value from a set, and return that value as
+    /// well as the updated set.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn without_max(&self) -> (Option<A>, Self) {
+        match self.get_max() {
+            Some(v) => (Some(v.clone()), self.without(v)),
+            None => (None, self.clone()),
+        }
+    }
+
+    /// Construct the union of two sets.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let set1 = ordset!{1, 2};
+    /// let set2 = ordset!{2, 3};
+    /// let expected = ordset!{1, 2, 3};
+    /// assert_eq!(expected, set1.union(set2));
+    /// ```
+    #[must_use]
+    pub fn union(self, other: Self) -> Self {
+        let (mut to_mutate, to_consume) = if self.len() >= other.len() {
+            (self, other)
+        } else {
+            (other, self)
+        };
+        for value in to_consume {
+            to_mutate.insert(value);
+        }
+        to_mutate
+    }
+
+    /// Construct the union of multiple sets.
+    ///
+    /// Time: O(n log n)
+    #[must_use]
+    pub fn unions<I>(i: I) -> Self
+    where
+        I: IntoIterator<Item = Self>,
+    {
+        i.into_iter().fold(Self::default(), Self::union)
+    }
+
+    /// Construct the symmetric difference between two sets.
+    ///
+    /// This is an alias for the
+    /// [`symmetric_difference`][symmetric_difference] method.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let set1 = ordset!{1, 2};
+    /// let set2 = ordset!{2, 3};
+    /// let expected = ordset!{1, 3};
+    /// assert_eq!(expected, set1.difference(set2));
+    /// ```
+    ///
+    /// [symmetric_difference]: #method.symmetric_difference
+    #[must_use]
+    pub fn difference(self, other: Self) -> Self {
+        self.symmetric_difference(other)
+    }
+
+    /// Construct the symmetric difference between two sets.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let set1 = ordset!{1, 2};
+    /// let set2 = ordset!{2, 3};
+    /// let expected = ordset!{1, 3};
+    /// assert_eq!(expected, set1.symmetric_difference(set2));
+    /// ```
+    #[must_use]
+    pub fn symmetric_difference(mut self, other: Self) -> Self {
+        for value in other {
+            if self.remove(&value).is_none() {
+                self.insert(value);
+            }
+        }
+        self
+    }
+
+    /// Construct the relative complement between two sets, that is the set
+    /// of values in `self` that do not occur in `other`.
+    ///
+    /// Time: O(m log n) where m is the size of the other set
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let set1 = ordset!{1, 2};
+    /// let set2 = ordset!{2, 3};
+    /// let expected = ordset!{1};
+    /// assert_eq!(expected, set1.relative_complement(set2));
+    /// ```
+    #[must_use]
+    pub fn relative_complement(mut self, other: Self) -> Self {
+        for value in other {
+            let _ = self.remove(&value);
+        }
+        self
+    }
+
+    /// Construct the intersection of two sets.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::ordset::OrdSet;
+    /// let set1 = ordset!{1, 2};
+    /// let set2 = ordset!{2, 3};
+    /// let expected = ordset!{2};
+    /// assert_eq!(expected, set1.intersection(set2));
+    /// ```
+    #[must_use]
+    pub fn intersection(self, other: Self) -> Self {
+        let mut out = Self::default();
+        for value in other {
+            if self.contains(&value) {
+                out.insert(value);
+            }
+        }
+        out
+    }
+
+    /// Split a set into two, with the left hand set containing values
+    /// which are smaller than `split`, and the right hand set
+    /// containing values which are larger than `split`.
+    ///
+    /// The `split` value itself is discarded.
+    ///
+    /// Time: O(n)
+    #[must_use]
+    pub fn split<BA>(self, split: &BA) -> (Self, Self)
+    where
+        BA: Ord + ?Sized,
+        A: Borrow<BA>,
+    {
+        let (left, _, right) = self.split_member(split);
+        (left, right)
+    }
+
+    /// Split a set into two, with the left hand set containing values
+    /// which are smaller than `split`, and the right hand set
+    /// containing values which are larger than `split`.
+    ///
+    /// Returns a tuple of the two sets and a boolean which is true if
+    /// the `split` value existed in the original set, and false
+    /// otherwise.
+    ///
+    /// Time: O(n)
+    #[must_use]
+    pub fn split_member<BA>(self, split: &BA) -> (Self, bool, Self)
+    where
+        BA: Ord + ?Sized,
+        A: Borrow<BA>,
+    {
+        let mut left = Self::default();
+        let mut right = Self::default();
+        let mut present = false;
+        for value in self {
+            match value.borrow().cmp(split) {
+                Ordering::Less => {
+                    left.insert(value);
+                }
+                Ordering::Equal => {
+                    present = true;
+                }
+                Ordering::Greater => {
+                    right.insert(value);
+                }
+            }
+        }
+        (left, present, right)
+    }
+
+    /// Construct a set with only the `n` smallest values from a given
+    /// set.
+    ///
+    /// Time: O(n)
+    #[must_use]
+    pub fn take(&self, n: usize) -> Self {
+        self.iter().take(n).cloned().collect()
+    }
+
+    /// Construct a set with the `n` smallest values removed from a
+    /// given set.
+    ///
+    /// Time: O(n)
+    #[must_use]
+    pub fn skip(&self, n: usize) -> Self {
+        self.iter().skip(n).cloned().collect()
+    }
+}
+
+// Core traits
+
+impl<A> Clone for OrdSet<A> {
+    /// Clone a set.
+    ///
+    /// Time: O(1)
+    #[inline]
+    fn clone(&self) -> Self {
+        OrdSet {
+            size: self.size,
+            pool: self.pool.clone(),
+            root: self.root.clone(),
+        }
+    }
+}
+
+impl<A: Ord> PartialEq for OrdSet<A> {
+    fn eq(&self, other: &Self) -> bool {
+        PoolRef::ptr_eq(&self.root, &other.root)
+            || (self.len() == other.len() && self.diff(other).next().is_none())
+    }
+}
+
+impl<A: Ord + Eq> Eq for OrdSet<A> {}
+
+impl<A: Ord> PartialOrd for OrdSet<A> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.iter().partial_cmp(other.iter())
+    }
+}
+
+impl<A: Ord> Ord for OrdSet<A> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.iter().cmp(other.iter())
+    }
+}
+
+impl<A: Ord + Hash> Hash for OrdSet<A> {
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        for i in self.iter() {
+            i.hash(state);
+        }
+    }
+}
+
+impl<A> Default for OrdSet<A> {
+    fn default() -> Self {
+        OrdSet::new()
+    }
+}
+
+impl<A: Ord + Clone> Add for OrdSet<A> {
+    type Output = OrdSet<A>;
+
+    fn add(self, other: Self) -> Self::Output {
+        self.union(other)
+    }
+}
+
+impl<'a, A: Ord + Clone> Add for &'a OrdSet<A> {
+    type Output = OrdSet<A>;
+
+    fn add(self, other: Self) -> Self::Output {
+        self.clone().union(other.clone())
+    }
+}
+
+impl<A: Ord + Clone> Mul for OrdSet<A> {
+    type Output = OrdSet<A>;
+
+    fn mul(self, other: Self) -> Self::Output {
+        self.intersection(other)
+    }
+}
+
+impl<'a, A: Ord + Clone> Mul for &'a OrdSet<A> {
+    type Output = OrdSet<A>;
+
+    fn mul(self, other: Self) -> Self::Output {
+        self.clone().intersection(other.clone())
+    }
+}
+
+impl<A: Ord + Clone> Sum for OrdSet<A> {
+    fn sum<I>(it: I) -> Self
+    where
+        I: Iterator<Item = Self>,
+    {
+        it.fold(Self::new(), |a, b| a + b)
+    }
+}
+
+impl<A, R> Extend<R> for OrdSet<A>
+where
+    A: Ord + Clone + From<R>,
+{
+    fn extend<I>(&mut self, iter: I)
+    where
+        I: IntoIterator<Item = R>,
+    {
+        for value in iter {
+            self.insert(From::from(value));
+        }
+    }
+}
+
+impl<A: Ord + Debug> Debug for OrdSet<A> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        f.debug_set().entries(self.iter()).finish()
+    }
+}
+
+// Iterators
+
+/// An iterator over the elements of a set.
+pub struct Iter<'a, A> {
+    it: NodeIter<'a, Value<A>>,
+}
+
+impl<'a, A> Iterator for Iter<'a, A>
+where
+    A: 'a + Ord,
+{
+    type Item = &'a A;
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(Deref::deref)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.it.remaining, Some(self.it.remaining))
+    }
+}
+
+impl<'a, A> DoubleEndedIterator for Iter<'a, A>
+where
+    A: 'a + Ord,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.it.next_back().map(Deref::deref)
+    }
+}
+
+impl<'a, A> ExactSizeIterator for Iter<'a, A> where A: 'a + Ord {}
+
+/// A ranged iterator over the elements of a set.
+///
+/// The only difference from `Iter` is that this one doesn't implement
+/// `ExactSizeIterator` because we can't know the size of the range without first
+/// iterating over it to count.
+pub struct RangedIter<'a, A> {
+    it: NodeIter<'a, Value<A>>,
+}
+
+impl<'a, A> Iterator for RangedIter<'a, A>
+where
+    A: 'a + Ord,
+{
+    type Item = &'a A;
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(Deref::deref)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.it.size_hint()
+    }
+}
+
+impl<'a, A> DoubleEndedIterator for RangedIter<'a, A>
+where
+    A: 'a + Ord,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.it.next_back().map(Deref::deref)
+    }
+}
+
+/// A consuming iterator over the elements of a set.
+pub struct ConsumingIter<A> {
+    it: ConsumingNodeIter<Value<A>>,
+}
+
+impl<A> Iterator for ConsumingIter<A>
+where
+    A: Ord + Clone,
+{
+    type Item = A;
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|v| v.0)
+    }
+}
+
+/// An iterator over the difference between two sets.
+pub struct DiffIter<'a, A> {
+    it: NodeDiffIter<'a, Value<A>>,
+}
+
+impl<'a, A> Iterator for DiffIter<'a, A>
+where
+    A: Ord + PartialEq,
+{
+    type Item = DiffItem<'a, A>;
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        self.it.next().map(|item| match item {
+            DiffItem::Add(v) => DiffItem::Add(v.deref()),
+            DiffItem::Update { old, new } => DiffItem::Update {
+                old: old.deref(),
+                new: new.deref(),
+            },
+            DiffItem::Remove(v) => DiffItem::Remove(v.deref()),
+        })
+    }
+}
+
+impl<A, R> FromIterator<R> for OrdSet<A>
+where
+    A: Ord + Clone + From<R>,
+{
+    fn from_iter<T>(i: T) -> Self
+    where
+        T: IntoIterator<Item = R>,
+    {
+        let mut out = Self::new();
+        for item in i {
+            out.insert(From::from(item));
+        }
+        out
+    }
+}
+
+impl<'a, A> IntoIterator for &'a OrdSet<A>
+where
+    A: 'a + Ord,
+{
+    type Item = &'a A;
+    type IntoIter = Iter<'a, A>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<A> IntoIterator for OrdSet<A>
+where
+    A: Ord + Clone,
+{
+    type Item = A;
+    type IntoIter = ConsumingIter<A>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ConsumingIter {
+            it: ConsumingNodeIter::new(&self.root, self.size),
+        }
+    }
+}
+
+// Conversions
+
+impl<'s, 'a, A, OA> From<&'s OrdSet<&'a A>> for OrdSet<OA>
+where
+    A: ToOwned<Owned = OA> + Ord + ?Sized,
+    OA: Borrow<A> + Ord + Clone,
+{
+    fn from(set: &OrdSet<&A>) -> Self {
+        set.iter().map(|a| (*a).to_owned()).collect()
+    }
+}
+
+impl<'a, A> From<&'a [A]> for OrdSet<A>
+where
+    A: Ord + Clone,
+{
+    fn from(slice: &'a [A]) -> Self {
+        slice.iter().cloned().collect()
+    }
+}
+
+impl<A: Ord + Clone> From<Vec<A>> for OrdSet<A> {
+    fn from(vec: Vec<A>) -> Self {
+        vec.into_iter().collect()
+    }
+}
+
+impl<'a, A: Ord + Clone> From<&'a Vec<A>> for OrdSet<A> {
+    fn from(vec: &Vec<A>) -> Self {
+        vec.iter().cloned().collect()
+    }
+}
+
+impl<A: Eq + Hash + Ord + Clone> From<collections::HashSet<A>> for OrdSet<A> {
+    fn from(hash_set: collections::HashSet<A>) -> Self {
+        hash_set.into_iter().collect()
+    }
+}
+
+impl<'a, A: Eq + Hash + Ord + Clone> From<&'a collections::HashSet<A>> for OrdSet<A> {
+    fn from(hash_set: &collections::HashSet<A>) -> Self {
+        hash_set.iter().cloned().collect()
+    }
+}
+
+impl<A: Ord + Clone> From<collections::BTreeSet<A>> for OrdSet<A> {
+    fn from(btree_set: collections::BTreeSet<A>) -> Self {
+        btree_set.into_iter().collect()
+    }
+}
+
+impl<'a, A: Ord + Clone> From<&'a collections::BTreeSet<A>> for OrdSet<A> {
+    fn from(btree_set: &collections::BTreeSet<A>) -> Self {
+        btree_set.iter().cloned().collect()
+    }
+}
+
+impl<A: Hash + Eq + Ord + Clone, S: BuildHasher> From<HashSet<A, S>> for OrdSet<A> {
+    fn from(hashset: HashSet<A, S>) -> Self {
+        hashset.into_iter().collect()
+    }
+}
+
+impl<'a, A: Hash + Eq + Ord + Clone, S: BuildHasher> From<&'a HashSet<A, S>> for OrdSet<A> {
+    fn from(hashset: &HashSet<A, S>) -> Self {
+        hashset.into_iter().cloned().collect()
+    }
+}
+
+// Proptest
+#[cfg(any(test, feature = "proptest"))]
+#[doc(hidden)]
+pub mod proptest {
+    #[deprecated(
+        since = "14.3.0",
+        note = "proptest strategies have moved to im::proptest"
+    )]
+    pub use crate::proptest::ord_set;
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::proptest::*;
+    use ::proptest::proptest;
+
+    #[test]
+    fn match_strings_with_string_slices() {
+        let mut set: OrdSet<String> = From::from(&ordset!["foo", "bar"]);
+        set = set.without("bar");
+        assert!(!set.contains("bar"));
+        set.remove("foo");
+        assert!(!set.contains("foo"));
+    }
+
+    #[test]
+    fn ranged_iter() {
+        let set: OrdSet<i32> = ordset![1, 2, 3, 4, 5];
+        let range: Vec<i32> = set.range(..).cloned().collect();
+        assert_eq!(vec![1, 2, 3, 4, 5], range);
+        let range: Vec<i32> = set.range(..).rev().cloned().collect();
+        assert_eq!(vec![5, 4, 3, 2, 1], range);
+        let range: Vec<i32> = set.range(2..5).cloned().collect();
+        assert_eq!(vec![2, 3, 4], range);
+        let range: Vec<i32> = set.range(2..5).rev().cloned().collect();
+        assert_eq!(vec![4, 3, 2], range);
+        let range: Vec<i32> = set.range(3..).cloned().collect();
+        assert_eq!(vec![3, 4, 5], range);
+        let range: Vec<i32> = set.range(3..).rev().cloned().collect();
+        assert_eq!(vec![5, 4, 3], range);
+        let range: Vec<i32> = set.range(..4).cloned().collect();
+        assert_eq!(vec![1, 2, 3], range);
+        let range: Vec<i32> = set.range(..4).rev().cloned().collect();
+        assert_eq!(vec![3, 2, 1], range);
+        let range: Vec<i32> = set.range(..=3).cloned().collect();
+        assert_eq!(vec![1, 2, 3], range);
+        let range: Vec<i32> = set.range(..=3).rev().cloned().collect();
+        assert_eq!(vec![3, 2, 1], range);
+    }
+
+    proptest! {
+        #[test]
+        fn proptest_a_set(ref s in ord_set(".*", 10..100)) {
+            assert!(s.len() < 100);
+            assert!(s.len() >= 10);
+        }
+
+        #[test]
+        fn long_ranged_iter(max in 1..1000) {
+            let range = 0..max;
+            let expected: Vec<i32> = range.clone().collect();
+            let set: OrdSet<i32> = range.clone().collect::<OrdSet<_>>();
+            let result: Vec<i32> = set.range(..).cloned().collect();
+            assert_eq!(expected, result);
+
+            let expected: Vec<i32> = range.clone().rev().collect();
+            let set: OrdSet<i32> = range.collect::<OrdSet<_>>();
+            let result: Vec<i32> = set.range(..).rev().cloned().collect();
+            assert_eq!(expected, result);
+        }
+    }
+}
diff --git a/vendor/im-rc/src/ord/test-fixtures/issue_124.txt b/vendor/im-rc/src/ord/test-fixtures/issue_124.txt
new file mode 100644
index 000000000..51786177e
--- /dev/null
+++ b/vendor/im-rc/src/ord/test-fixtures/issue_124.txt
@@ -0,0 +1,3492 @@
+insert 1495
+insert 1568
+insert 1313
+insert 824
+insert 926
+insert 3031
+insert 872
+insert 1330
+insert 2356
+insert 298
+insert 1957
+insert 2133
+insert 3295
+insert 1139
+insert 2895
+insert 2442
+insert 553
+insert 2637
+insert 2571
+insert 352
+insert 1076
+insert 1611
+insert 902
+insert 480
+insert 1489
+insert 3223
+insert 169
+insert 2912
+insert 2276
+insert 1512
+insert 291
+insert 137
+insert 2917
+insert 2509
+insert 1729
+insert 62
+insert 1381
+insert 647
+insert 1647
+insert 2064
+insert 1847
+insert 1618
+insert 528
+insert 431
+insert 639
+insert 1910
+insert 1764
+insert 114
+insert 2872
+insert 2911
+insert 999
+insert 15
+insert 53
+insert 1924
+insert 2195
+insert 1134
+insert 269
+insert 2903
+insert 432
+insert 149
+insert 1241
+insert 3266
+insert 1975
+insert 2095
+insert 1384
+insert 2858
+insert 2814
+insert 2735
+insert 2779
+insert 991
+insert 1725
+insert 1804
+insert 959
+insert 1395
+insert 720
+insert 1758
+insert 1459
+insert 925
+insert 860
+insert 1035
+insert 1310
+insert 2892
+insert 3129
+insert 891
+insert 913
+insert 2136
+insert 45
+insert 255
+insert 2980
+insert 2918
+insert 2234
+insert 2845
+insert 2135
+insert 2818
+insert 978
+insert 2038
+insert 2251
+insert 14
+insert 333
+insert 649
+insert 1947
+insert 1768
+insert 3309
+insert 3063
+insert 788
+insert 65
+insert 833
+insert 1038
+insert 1966
+insert 1746
+insert 1595
+insert 2512
+insert 1543
+insert 1269
+insert 243
+insert 175
+insert 259
+insert 4
+insert 2715
+insert 297
+insert 2386
+insert 1060
+insert 2686
+insert 2400
+insert 2548
+insert 278
+insert 1890
+insert 1777
+insert 1424
+insert 2109
+insert 3307
+insert 1974
+insert 1985
+insert 3144
+insert 1186
+insert 1945
+insert 3184
+insert 1488
+insert 1707
+insert 2915
+insert 2995
+insert 2467
+insert 1791
+insert 1309
+insert 2916
+insert 1941
+insert 1824
+insert 1525
+insert 1626
+insert 1687
+insert 2333
+insert 2198
+insert 1237
+insert 2931
+insert 2764
+insert 2609
+insert 1202
+insert 1314
+insert 1556
+insert 1892
+insert 2329
+insert 2065
+insert 1559
+insert 2282
+insert 3279
+insert 1651
+insert 1610
+insert 2039
+insert 3269
+insert 1948
+insert 1663
+insert 1627
+insert 943
+insert 2313
+insert 1048
+insert 2399
+insert 2302
+insert 1022
+insert 946
+insert 2303
+insert 1085
+insert 108
+insert 2738
+insert 1311
+insert 844
+insert 1166
+insert 3198
+insert 1093
+insert 1192
+insert 1508
+insert 2471
+insert 2518
+insert 3209
+insert 1149
+insert 1743
+insert 1770
+insert 960
+insert 895
+insert 1806
+insert 1137
+insert 1654
+insert 1386
+insert 2727
+insert 1379
+insert 2572
+insert 128
+insert 2476
+insert 182
+insert 1037
+insert 605
+insert 2494
+insert 2561
+insert 941
+insert 2748
+insert 1448
+insert 2260
+insert 1273
+insert 2558
+insert 1198
+insert 1774
+insert 1740
+insert 1861
+insert 3049
+insert 2821
+insert 1341
+insert 1661
+insert 1506
+insert 1741
+insert 1811
+insert 1737
+insert 1693
+insert 1877
+insert 1756
+insert 1755
+insert 1553
+insert 1864
+insert 1734
+insert 1790
+insert 1753
+insert 2396
+insert 2531
+insert 1878
+insert 1809
+insert 2692
+insert 1854
+insert 1960
+insert 1999
+insert 2028
+insert 1879
+insert 1590
+insert 2521
+insert 3081
+insert 2665
+insert 1638
+insert 1667
+insert 1417
+insert 1876
+insert 3113
+insert 2757
+insert 2711
+insert 2587
+insert 1607
+insert 2568
+insert 2724
+insert 2685
+insert 2523
+insert 3151
+insert 1530
+insert 2454
+insert 2539
+insert 1356
+insert 1885
+insert 769
+insert 1982
+insert 3059
+insert 1232
+insert 2773
+insert 3270
+insert 2599
+insert 294
+insert 164
+insert 22
+insert 239
+insert 648
+insert 1679
+insert 644
+insert 398
+insert 455
+insert 443
+insert 1686
+insert 758
+insert 1720
+insert 1387
+insert 672
+insert 2569
+insert 2921
+insert 1228
+insert 1521
+insert 2115
+insert 2101
+insert 3035
+insert 2088
+insert 2094
+insert 1290
+insert 940
+insert 1303
+insert 2515
+insert 2863
+insert 1319
+insert 1315
+insert 2445
+insert 1949
+insert 2935
+insert 1992
+insert 1435
+insert 1413
+insert 1742
+insert 2769
+insert 2266
+insert 3290
+insert 3224
+insert 3171
+insert 2981
+insert 3200
+insert 3140
+insert 493
+insert 1299
+insert 338
+insert 1639
+insert 1463
+insert 730
+insert 1779
+insert 1918
+insert 2804
+insert 1476
+remove 432
+insert 296
+insert 1469
+insert 1364
+insert 1732
+insert 1908
+insert 2076
+insert 2489
+insert 2401
+insert 2560
+insert 2299
+insert 1451
+insert 3303
+insert 2174
+insert 2048
+insert 3293
+insert 2097
+insert 1705
+insert 1731
+insert 2296
+insert 2925
+insert 2932
+insert 1711
+insert 2397
+insert 2520
+insert 2742
+insert 1324
+insert 1160
+insert 1458
+insert 1439
+insert 3277
+insert 1374
+insert 1217
+insert 1218
+insert 2197
+insert 2185
+insert 1952
+insert 1798
+insert 1442
+insert 2601
+insert 2675
+insert 2283
+insert 12
+insert 567
+insert 638
+insert 1904
+insert 704
+insert 1447
+insert 1965
+insert 2728
+insert 2741
+insert 2441
+insert 2122
+insert 862
+insert 958
+insert 1955
+insert 850
+insert 2696
+insert 955
+insert 2867
+insert 2042
+insert 1925
+insert 2952
+insert 2265
+insert 1220
+insert 3289
+insert 2650
+insert 2215
+insert 2288
+insert 1373
+insert 2096
+insert 1167
+insert 830
+insert 829
+insert 1558
+insert 1189
+insert 2263
+insert 2341
+insert 2337
+insert 2270
+insert 3024
+insert 3182
+insert 1420
+insert 1557
+insert 1441
+insert 3037
+insert 3206
+insert 2913
+insert 1398
+insert 1392
+insert 1493
+insert 843
+insert 1287
+insert 2199
+insert 2838
+insert 2225
+insert 2181
+insert 736
+insert 2201
+insert 2907
+insert 808
+insert 712
+insert 2165
+insert 1219
+insert 1221
+insert 1715
+insert 1710
+insert 1700
+insert 2218
+insert 2187
+insert 1204
+insert 1709
+insert 2278
+insert 2698
+insert 1718
+insert 2240
+insert 2704
+insert 2340
+insert 1168
+insert 2256
+insert 2227
+insert 2203
+insert 2848
+insert 2305
+insert 1698
+insert 2647
+insert 2342
+insert 2275
+insert 1307
+insert 3062
+insert 2354
+insert 1312
+insert 3074
+insert 3060
+insert 1665
+insert 989
+insert 2591
+insert 3076
+insert 3136
+insert 3117
+insert 3123
+insert 234
+insert 6
+insert 698
+insert 719
+insert 3156
+insert 2358
+insert 2819
+insert 1793
+insert 3235
+insert 3000
+insert 28
+insert 3304
+insert 1856
+insert 1795
+insert 1733
+insert 1803
+insert 3127
+insert 1866
+insert 1642
+insert 1657
+insert 1723
+insert 2966
+insert 927
+insert 1055
+insert 3078
+insert 3201
+insert 3226
+insert 1014
+insert 3208
+insert 3262
+insert 2567
+insert 1430
+insert 2781
+insert 2425
+insert 1185
+insert 2385
+insert 1724
+insert 3181
+insert 2365
+insert 2361
+insert 1787
+insert 1410
+insert 1172
+insert 2746
+insert 2573
+insert 90
+insert 2268
+insert 2756
+insert 1304
+insert 1203
+insert 1860
+insert 841
+insert 1913
+insert 2284
+insert 2309
+insert 2946
+insert 1697
+remove 1975
+insert 2087
+insert 1921
+insert 3281
+insert 1894
+insert 1905
+insert 1206
+insert 1552
+insert 1179
+insert 2269
+insert 1606
+insert 1223
+insert 634
+insert 2594
+insert 1426
+insert 1164
+insert 1129
+insert 1019
+insert 897
+insert 2632
+insert 523
+insert 405
+insert 531
+insert 541
+insert 2285
+insert 1210
+insert 1212
+insert 2018
+insert 1524
+insert 1175
+insert 1857
+insert 1701
+insert 1712
+insert 1597
+insert 2737
+insert 363
+insert 3118
+insert 2006
+insert 2314
+insert 1205
+insert 1922
+insert 1293
+insert 1169
+insert 613
+insert 740
+insert 2678
+insert 655
+insert 385
+insert 1200
+insert 494
+insert 799
+insert 821
+insert 1282
+insert 2747
+insert 892
+insert 2656
+insert 1735
+insert 1766
+insert 2379
+insert 620
+insert 1776
+insert 1660
+insert 2999
+insert 3012
+insert 747
+insert 1797
+insert 1843
+insert 2074
+insert 1046
+insert 1194
+insert 136
+insert 551
+insert 147
+insert 41
+insert 429
+insert 198
+insert 272
+insert 459
+insert 2297
+insert 3174
+insert 1281
+insert 1274
+insert 1225
+insert 1780
+insert 1814
+insert 1726
+insert 1251
+insert 1305
+insert 1826
+insert 1859
+insert 1226
+insert 1187
+insert 2129
+insert 2853
+insert 3164
+insert 1497
+insert 2910
+insert 187
+insert 985
+insert 1414
+insert 2720
+insert 3299
+insert 2866
+insert 2850
+insert 1207
+insert 2308
+insert 879
+insert 2553
+insert 2554
+insert 1796
+insert 1802
+insert 1881
+insert 1738
+insert 1432
+insert 1317
+insert 2143
+insert 1747
+insert 2108
+insert 1406
+insert 3187
+insert 3065
+insert 3214
+insert 2364
+insert 2646
+insert 1942
+insert 25
+insert 162
+insert 469
+insert 511
+insert 370
+insert 377
+insert 3175
+insert 1609
+insert 2873
+insert 2802
+insert 3071
+insert 2623
+insert 2689
+insert 1358
+insert 2610
+insert 1903
+insert 2885
+insert 2036
+insert 2113
+insert 2784
+insert 2588
+insert 945
+insert 2744
+insert 190
+insert 2869
+insert 1505
+remove 2912
+insert 117
+insert 155
+insert 2723
+insert 1279
+insert 2801
+insert 2216
+insert 1736
+insert 688
+insert 3026
+insert 10
+insert 2771
+insert 2739
+insert 2162
+insert 546
+insert 1526
+insert 1501
+insert 1584
+insert 1541
+insert 1471
+insert 1548
+insert 508
+insert 2086
+insert 1858
+insert 2718
+insert 399
+insert 140
+insert 109
+insert 1869
+insert 560
+insert 1769
+insert 871
+insert 450
+insert 555
+insert 382
+insert 911
+insert 442
+insert 2236
+insert 2798
+insert 2069
+insert 795
+insert 931
+insert 1291
+insert 1275
+insert 576
+insert 2209
+insert 2212
+insert 2759
+insert 2248
+insert 2061
+insert 2224
+insert 2237
+insert 2525
+insert 2574
+insert 2244
+insert 2562
+insert 2196
+insert 3052
+insert 1266
+insert 1998
+insert 3020
+insert 3038
+insert 832
+insert 822
+insert 1359
+insert 2923
+insert 2063
+insert 2147
+insert 1976
+insert 1328
+insert 2976
+insert 1090
+insert 988
+insert 2761
+insert 1066
+insert 1719
+insert 126
+insert 151
+insert 1339
+insert 2158
+insert 1690
+insert 1692
+insert 2073
+insert 1829
+insert 1896
+insert 2005
+insert 2719
+insert 1376
+insert 2001
+insert 2057
+insert 2035
+insert 2924
+insert 1936
+insert 1461
+insert 2168
+insert 2245
+insert 1429
+insert 1409
+insert 2406
+insert 1318
+insert 1648
+insert 2843
+insert 3018
+insert 3011
+insert 3161
+insert 3028
+insert 2497
+insert 231
+insert 191
+insert 286
+insert 2188
+insert 2841
+insert 2228
+insert 2140
+insert 3133
+insert 1450
+insert 2103
+insert 1473
+insert 1487
+insert 3072
+insert 3093
+insert 3056
+insert 2894
+insert 1416
+insert 2897
+insert 2429
+insert 1956
+insert 1934
+insert 1940
+insert 1929
+insert 3084
+insert 2740
+insert 3298
+insert 3308
+insert 3247
+insert 2832
+insert 2163
+remove 2039
+insert 1899
+insert 1939
+insert 1399
+insert 1412
+insert 1365
+insert 2876
+insert 1897
+insert 2037
+insert 1930
+insert 1640
+insert 1931
+insert 3159
+insert 2899
+insert 2231
+insert 3147
+insert 2825
+insert 1243
+insert 1810
+insert 1872
+insert 3116
+insert 3165
+insert 2068
+insert 1874
+insert 2226
+insert 2250
+insert 2249
+insert 618
+insert 1370
+remove 1220
+insert 1354
+insert 1438
+insert 2213
+insert 1377
+insert 563
+insert 637
+insert 1933
+insert 734
+insert 761
+insert 29
+insert 2114
+insert 2194
+insert 2152
+insert 2217
+insert 314
+insert 440
+insert 393
+insert 670
+insert 785
+insert 2455
+insert 729
+insert 2271
+insert 2463
+insert 2481
+insert 2519
+insert 2488
+insert 1502
+insert 2485
+insert 2279
+insert 2638
+insert 656
+insert 574
+insert 2508
+insert 612
+insert 877
+insert 683
+insert 938
+insert 1298
+insert 1257
+insert 550
+insert 2117
+insert 2603
+insert 2702
+insert 2480
+insert 2941
+insert 2613
+insert 2281
+insert 1006
+insert 1016
+insert 2961
+insert 3033
+insert 1534
+insert 2962
+insert 2357
+insert 1216
+insert 1197
+insert 968
+insert 1002
+insert 1030
+insert 1003
+insert 1026
+insert 2708
+insert 2666
+insert 2542
+insert 2736
+insert 1870
+insert 2318
+insert 2344
+insert 3220
+insert 2635
+insert 3294
+insert 1183
+insert 2347
+insert 1396
+insert 2731
+insert 2164
+insert 2167
+insert 1411
+insert 2159
+insert 1694
+insert 1689
+insert 1714
+insert 1713
+insert 2373
+insert 2763
+insert 2820
+insert 3083
+insert 3030
+insert 3160
+insert 3010
+insert 3054
+insert 3112
+insert 3130
+insert 3095
+insert 3090
+insert 3158
+insert 3242
+insert 1691
+insert 3211
+insert 2418
+insert 1666
+insert 971
+insert 1695
+insert 1634
+insert 888
+insert 2794
+insert 2532
+insert 2887
+insert 2797
+insert 1316
+insert 2125
+insert 1696
+insert 1888
+insert 1706
+insert 1231
+insert 1234
+insert 2050
+insert 1235
+insert 2102
+insert 218
+insert 228
+insert 2461
+insert 3291
+insert 3267
+insert 1708
+insert 1721
+insert 1704
+insert 2792
+insert 2782
+insert 83
+insert 2906
+insert 1981
+insert 1245
+insert 1326
+insert 2622
+insert 2254
+insert 184
+insert 2750
+insert 2618
+insert 2679
+insert 2778
+insert 2628
+insert 855
+insert 2092
+insert 2118
+insert 1347
+insert 1527
+insert 2575
+insert 2119
+insert 2098
+insert 537
+insert 1623
+insert 2402
+insert 2054
+insert 193
+insert 1180
+insert 1378
+insert 1483
+insert 1188
+insert 2099
+insert 1184
+insert 1480
+insert 233
+insert 170
+insert 268
+insert 220
+insert 2261
+insert 1425
+insert 1932
+insert 1938
+insert 3047
+insert 1440
+insert 3105
+insert 3039
+insert 1443
+insert 1978
+insert 1996
+insert 1542
+insert 1547
+insert 1423
+insert 180
+insert 1585
+insert 1431
+insert 1586
+insert 2100
+insert 1444
+insert 2107
+insert 2896
+insert 1445
+insert 2743
+insert 1109
+insert 2751
+insert 2315
+insert 2634
+insert 1446
+insert 3288
+insert 1835
+insert 253
+insert 1504
+insert 371
+insert 504
+insert 204
+insert 2617
+insert 2388
+insert 107
+insert 131
+insert 111
+insert 1523
+insert 2909
+insert 1703
+insert 1717
+insert 1566
+insert 1151
+insert 1116
+insert 3172
+insert 2605
+insert 2641
+insert 1227
+insert 1230
+insert 1256
+insert 2725
+insert 1588
+insert 1529
+insert 1173
+insert 3142
+insert 3125
+insert 1581
+insert 578
+insert 3228
+insert 3239
+insert 599
+insert 759
+insert 3016
+insert 3025
+insert 619
+insert 653
+insert 626
+insert 2768
+insert 754
+insert 3231
+insert 3260
+insert 791
+insert 756
+insert 2405
+insert 2404
+insert 1474
+insert 1213
+insert 1211
+insert 2019
+insert 3077
+insert 3087
+insert 2555
+insert 1699
+insert 1464
+insert 2687
+insert 1578
+insert 1975
+insert 1490
+insert 1478
+insert 573
+insert 592
+insert 1655
+insert 1652
+insert 1669
+insert 1649
+insert 1092
+insert 1122
+insert 1153
+insert 2734
+insert 1676
+insert 1871
+insert 1131
+insert 2730
+insert 2729
+insert 1222
+insert 1196
+insert 2733
+insert 2793
+insert 1421
+insert 2672
+insert 1633
+insert 1472
+insert 2749
+insert 1477
+insert 1460
+insert 3050
+insert 1491
+insert 3114
+insert 2378
+insert 1427
+insert 1419
+insert 1722
+insert 1580
+insert 1449
+insert 1484
+insert 1053
+insert 1485
+insert 3085
+insert 2153
+insert 3002
+insert 2023
+insert 3008
+insert 2280
+insert 3003
+insert 2958
+insert 2972
+insert 3015
+insert 2803
+insert 3045
+insert 2127
+insert 2971
+insert 1437
+insert 1494
+insert 1486
+insert 3032
+insert 2809
+remove 1627
+insert 1428
+insert 775
+insert 5
+insert 3064
+insert 3107
+insert 3115
+insert 3138
+insert 3128
+insert 3111
+insert 1032
+insert 3075
+remove 298
+insert 3145
+insert 1572
+insert 186
+insert 1039
+insert 1086
+insert 236
+insert 1052
+insert 1385
+insert 252
+insert 1133
+insert 1108
+insert 928
+insert 1369
+insert 2116
+insert 2934
+insert 203
+insert 1113
+insert 2619
+insert 275
+insert 1844
+insert 1165
+insert 1868
+insert 194
+insert 254
+remove 297
+insert 2104
+insert 1603
+insert 2963
+insert 1672
+insert 3004
+insert 1683
+insert 1057
+insert 1807
+insert 2978
+insert 2004
+insert 1452
+insert 1482
+insert 2112
+insert 1436
+insert 1433
+insert 1602
+insert 1422
+insert 1575
+insert 1560
+insert 2649
+insert 1454
+insert 2658
+insert 2621
+insert 1702
+insert 1583
+insert 1467
+insert 1140
+insert 1229
+insert 1121
+insert 987
+insert 980
+insert 1174
+insert 1475
+insert 1615
+insert 1190
+insert 1619
+insert 1265
+insert 1621
+insert 1616
+insert 1492
+remove 1430
+insert 2905
+insert 1224
+insert 1538
+insert 1023
+insert 2807
+insert 1848
+insert 2659
+insert 1496
+insert 2710
+insert 1132
+insert 1154
+insert 1887
+insert 2593
+insert 1875
+remove 1429
+insert 1163
+insert 2983
+insert 2968
+insert 1587
+insert 222
+insert 283
+insert 263
+remove 1428
+insert 535
+insert 547
+insert 470
+insert 457
+insert 518
+insert 199
+insert 1263
+insert 1084
+insert 526
+insert 933
+insert 889
+remove 1437
+insert 246
+insert 530
+insert 903
+remove 2489
+insert 2682
+insert 2914
+insert 1716
+insert 2688
+insert 1332
+insert 2690
+insert 2722
+insert 2657
+insert 2908
+insert 1345
+insert 1582
+insert 2969
+insert 2612
+insert 213
+insert 225
+insert 1401
+insert 1340
+insert 1889
+insert 2017
+insert 961
+insert 1042
+insert 1873
+insert 2790
+insert 224
+insert 1177
+insert 202
+insert 1372
+insert 185
+insert 1520
+insert 1346
+insert 211
+insert 181
+insert 2745
+insert 2726
+insert 2870
+insert 1214
+insert 2940
+insert 2653
+insert 2219
+insert 2813
+insert 1532
+insert 2890
+insert 1195
+insert 1128
+insert 468
+insert 1592
+insert 1144
+remove 1219
+insert 3183
+insert 2774
+insert 1622
+insert 1141
+insert 3285
+insert 2274
+insert 2680
+insert 1161
+insert 1158
+insert 279
+insert 1613
+insert 142
+insert 1510
+insert 100
+insert 467
+insert 106
+insert 367
+insert 1546
+insert 1867
+insert 851
+insert 918
+insert 1845
+insert 1176
+insert 1178
+insert 1193
+insert 1884
+insert 2663
+insert 1617
+insert 1614
+insert 461
+insert 1783
+insert 2721
+insert 1851
+insert 3255
+insert 1517
+insert 237
+insert 1535
+insert 1973
+insert 2880
+insert 2883
+insert 1928
+remove 1424
+insert 2991
+insert 2202
+insert 1574
+insert 2206
+insert 538
+insert 1573
+insert 96
+insert 3
+insert 32
+insert 13
+insert 98
+insert 121
+insert 30
+insert 66
+insert 127
+insert 118
+insert 2732
+remove 1166
+insert 113
+insert 628
+insert 2246
+insert 1567
+insert 1688
+insert 1579
+insert 3014
+insert 2223
+insert 2145
+insert 2232
+insert 2190
+insert 2053
+insert 1882
+insert 381
+insert 3170
+insert 2651
+insert 3148
+insert 1805
+insert 543
+insert 406
+insert 517
+insert 454
+insert 1664
+insert 2806
+insert 1886
+insert 1865
+insert 3135
+insert 3179
+insert 2156
+insert 1628
+insert 1636
+insert 1819
+insert 2151
+insert 1968
+insert 2009
+insert 2134
+insert 3237
+insert 2886
+insert 2262
+insert 2957
+insert 2959
+insert 1972
+insert 31
+insert 842
+insert 2193
+insert 2106
+insert 2755
+insert 2645
+insert 2091
+insert 3001
+insert 2901
+insert 1678
+insert 2144
+insert 2891
+insert 1728
+insert 1645
+insert 1745
+insert 3166
+insert 1662
+insert 1366
+insert 2105
+insert 1612
+insert 2882
+insert 2528
+insert 1987
+insert 1599
+insert 229
+insert 1284
+insert 1156
+insert 1296
+insert 1297
+insert 2570
+insert 2078
+insert 2307
+insert 2565
+insert 2847
+insert 1343
+insert 1323
+insert 2900
+insert 2902
+insert 2089
+insert 1259
+insert 1288
+insert 2912
+insert 1252
+insert 256
+insert 232
+insert 230
+insert 2888
+insert 2684
+insert 2111
+insert 2090
+insert 2693
+insert 240
+insert 2898
+insert 295
+insert 2893
+insert 2264
+insert 2884
+insert 2705
+insert 2859
+insert 2904
+insert 2222
+insert 2889
+insert 389
+insert 1397
+insert 1407
+insert 1862
+insert 1250
+insert 1969
+insert 1375
+insert 1404
+insert 2433
+insert 2436
+insert 2948
+insert 1402
+insert 1320
+insert 1271
+insert 2453
+insert 2439
+insert 1300
+insert 2421
+insert 2110
+insert 2430
+insert 2121
+insert 2205
+insert 1353
+insert 509
+insert 515
+insert 1249
+insert 2919
+insert 2960
+insert 1389
+insert 139
+insert 542
+insert 2026
+insert 2039
+insert 2586
+insert 2581
+insert 2137
+insert 2936
+insert 2412
+insert 2431
+insert 2393
+insert 2362
+insert 2484
+insert 2440
+insert 2413
+insert 2468
+insert 2556
+insert 1898
+insert 1624
+insert 766
+insert 1608
+insert 1600
+insert 669
+insert 659
+insert 658
+insert 328
+insert 3221
+insert 3194
+insert 144
+insert 477
+insert 372
+insert 426
+insert 145
+insert 310
+insert 423
+insert 621
+insert 641
+insert 725
+insert 738
+insert 2093
+insert 2590
+insert 2499
+insert 1919
+insert 329
+insert 311
+insert 2580
+insert 2221
+insert 2833
+insert 2243
+insert 1564
+insert 2258
+insert 1917
+insert 2239
+insert 1901
+insert 2235
+insert 2701
+insert 2992
+insert 2752
+insert 395
+insert 2047
+insert 1967
+insert 1962
+insert 353
+insert 391
+insert 339
+insert 2211
+insert 419
+insert 409
+insert 2230
+insert 2247
+insert 2189
+insert 2229
+insert 907
+insert 957
+insert 1604
+insert 859
+insert 848
+insert 1838
+insert 883
+insert 1620
+insert 3213
+insert 456
+insert 2438
+insert 444
+insert 402
+insert 414
+insert 331
+insert 2448
+insert 400
+insert 284
+insert 421
+insert 365
+insert 280
+insert 208
+insert 2290
+insert 1596
+insert 1570
+insert 1594
+insert 1550
+remove 1490
+insert 1348
+insert 1344
+insert 1390
+insert 1511
+insert 1342
+insert 1306
+insert 1264
+insert 1286
+insert 2977
+insert 1371
+insert 1408
+insert 1544
+insert 1238
+insert 1242
+insert 2852
+insert 1605
+insert 1625
+insert 1334
+insert 1327
+insert 1576
+insert 2949
+insert 1565
+insert 3034
+insert 1589
+insert 2945
+insert 2973
+insert 2975
+insert 1637
+insert 2422
+insert 2860
+insert 2056
+insert 2045
+insert 2811
+insert 2812
+insert 2289
+insert 2041
+insert 2207
+insert 2920
+insert 1632
+insert 1394
+insert 3199
+insert 3287
+insert 3305
+insert 1368
+remove 3116
+insert 2021
+insert 3280
+insert 1964
+insert 2161
+insert 3273
+insert 1986
+insert 2022
+insert 2130
+insert 3240
+insert 3261
+insert 2040
+insert 3272
+insert 1883
+insert 1577
+insert 1555
+insert 1828
+insert 2055
+insert 2072
+insert 2257
+insert 2259
+insert 2070
+insert 2238
+insert 1591
+insert 2180
+insert 2120
+insert 2182
+insert 1360
+insert 2506
+insert 1382
+insert 2510
+insert 2220
+insert 1355
+insert 2141
+insert 1337
+insert 2437
+insert 2469
+insert 2443
+insert 1863
+insert 2166
+insert 2585
+insert 2139
+insert 2522
+insert 2331
+insert 2503
+insert 2210
+insert 2175
+insert 11
+insert 1515
+insert 119
+insert 1519
+insert 1593
+insert 201
+insert 258
+insert 1601
+insert 205
+insert 2176
+insert 1403
+insert 1598
+insert 1522
+insert 1514
+insert 1466
+insert 3274
+insert 1561
+insert 1393
+insert 2157
+insert 1503
+insert 910
+insert 924
+insert 861
+insert 388
+insert 3205
+insert 407
+insert 932
+insert 195
+insert 942
+insert 241
+insert 922
+insert 2024
+insert 864
+insert 1627
+insert 271
+insert 265
+insert 2376
+insert 247
+insert 2077
+insert 2277
+insert 3202
+insert 2267
+insert 2464
+insert 2446
+insert 1367
+insert 1380
+insert 2301
+insert 1405
+insert 2348
+insert 418
+insert 396
+insert 413
+insert 1363
+insert 1294
+insert 3229
+insert 3217
+remove 1411
+insert 2540
+insert 2633
+insert 1388
+insert 2577
+insert 2557
+insert 1272
+insert 2502
+insert 2516
+insert 2564
+insert 2559
+insert 2434
+insert 1953
+insert 2664
+insert 1837
+insert 2677
+insert 1827
+insert 2625
+insert 2667
+insert 2369
+insert 2360
+insert 1880
+insert 2387
+insert 335
+insert 2416
+insert 2643
+remove 1312
+insert 2410
+insert 2420
+insert 2411
+insert 2368
+insert 2374
+insert 2375
+insert 2417
+insert 2383
+insert 2395
+insert 1350
+insert 1260
+insert 1244
+insert 2123
+insert 1509
+insert 2584
+insert 2582
+insert 2578
+insert 1911
+insert 2479
+insert 2566
+insert 2346
+insert 2292
+insert 691
+insert 1277
+insert 882
+insert 846
+insert 2287
+insert 849
+insert 866
+insert 55
+insert 2526
+insert 869
+insert 827
+insert 1171
+insert 1533
+insert 350
+insert 46
+insert 135
+insert 2615
+insert 1528
+insert 1554
+insert 1539
+insert 1468
+insert 3185
+insert 1182
+insert 1479
+remove 1495
+insert 1507
+insert 1518
+insert 384
+insert 1301
+insert 1240
+insert 1254
+insert 112
+insert 75
+insert 72
+remove 1494
+insert 138
+insert 89
+insert 2840
+insert 200
+insert 1191
+insert 168
+insert 167
+insert 890
+insert 944
+insert 920
+insert 868
+insert 839
+insert 1146
+insert 1012
+insert 2255
+insert 2815
+insert 1563
+insert 2579
+insert 1545
+insert 2583
+insert 3089
+insert 1785
+insert 2273
+remove 1370
+insert 1739
+insert 3098
+insert 192
+insert 2242
+insert 172
+insert 3091
+insert 935
+insert 221
+insert 251
+insert 178
+insert 1751
+insert 369
+insert 929
+insert 82
+insert 436
+insert 276
+insert 244
+insert 387
+remove 2216
+insert 410
+insert 3053
+insert 1498
+insert 2826
+insert 366
+remove 1238
+insert 289
+insert 972
+insert 1761
+insert 441
+insert 361
+insert 401
+insert 2306
+insert 2390
+insert 2291
+insert 1199
+insert 982
+insert 270
+remove 1399
+insert 1551
+remove 1346
+insert 2169
+insert 986
+insert 394
+insert 3116
+insert 2272
+insert 3119
+insert 1494
+insert 3236
+insert 916
+insert 896
+insert 3152
+insert 3248
+insert 2132
+insert 2131
+insert 2155
+insert 1338
+insert 1043
+insert 954
+insert 3167
+insert 1562
+insert 3134
+insert 1571
+insert 898
+insert 1540
+insert 930
+insert 949
+insert 863
+insert 507
+insert 923
+insert 840
+insert 914
+insert 899
+insert 2184
+insert 2204
+insert 2128
+insert 2160
+insert 2173
+insert 2191
+insert 2171
+insert 2177
+insert 2179
+insert 1549
+insert 1569
+insert 1500
+remove 1389
+insert 1823
+insert 1812
+remove 1371
+remove 1375
+insert 1792
+insert 831
+insert 1831
+insert 1516
+insert 1822
+insert 1846
+insert 125
+insert 1799
+insert 129
+insert 1825
+insert 1836
+insert 210
+insert 188
+insert 1499
+insert 174
+insert 99
+insert 1833
+insert 1028
+insert 1024
+insert 1362
+insert 217
+insert 952
+insert 838
+insert 835
+insert 886
+insert 904
+insert 1041
+insert 1047
+insert 124
+insert 179
+insert 134
+insert 173
+insert 209
+insert 215
+insert 901
+insert 19
+insert 141
+remove 1387
+insert 177
+insert 160
+insert 157
+insert 998
+insert 16
+insert 1789
+insert 1748
+insert 1784
+insert 1818
+insert 908
+insert 950
+insert 939
+insert 936
+insert 1531
+insert 919
+insert 905
+insert 937
+insert 582
+insert 664
+insert 597
+insert 906
+insert 549
+insert 506
+insert 575
+insert 479
+insert 947
+insert 76
+insert 577
+insert 56
+insert 51
+insert 623
+insert 652
+remove 1364
+insert 1537
+remove 1396
+insert 1434
+insert 1415
+insert 1346
+insert 1399
+insert 1335
+insert 1513
+remove 1403
+insert 1536
+remove 1409
+remove 1366
+insert 1391
+remove 1287
+insert 1280
+remove 1503
+remove 1406
+insert 1383
+insert 2549
+insert 2538
+insert 2495
+insert 1268
+remove 1390
+insert 2527
+remove 1493
+remove 1394
+insert 1255
+remove 1315
+remove 1311
+insert 1276
+insert 1331
+remove 1317
+insert 1400
+remove 1354
+insert 1322
+insert 1357
+insert 1481
+remove 1405
+insert 285
+insert 288
+insert 261
+insert 640
+insert 632
+insert 525
+insert 266
+insert 962
+insert 629
+insert 378
+insert 380
+remove 1359
+insert 1351
+insert 587
+insert 368
+insert 376
+insert 1333
+insert 1050
+insert 1040
+insert 337
+insert 1352
+insert 3196
+insert 1997
+insert 326
+remove 2228
+insert 17
+insert 320
+insert 86
+remove 1502
+insert 1135
+remove 1298
+insert 132
+insert 156
+insert 1361
+insert 1215
+insert 2775
+insert 122
+insert 2816
+insert 2800
+insert 2799
+insert 1208
+insert 1285
+insert 1329
+insert 1201
+insert 1951
+insert 2786
+insert 2783
+insert 2822
+insert 2827
+insert 2805
+insert 2956
+insert 2862
+insert 2988
+insert 953
+insert 2791
+insert 2844
+insert 2777
+insert 2846
+insert 2785
+insert 2951
+insert 430
+insert 375
+insert 104
+insert 154
+insert 427
+insert 373
+insert 1025
+insert 146
+insert 379
+insert 894
+insert 867
+insert 969
+insert 159
+insert 887
+insert 876
+insert 176
+insert 1027
+insert 1119
+insert 994
+insert 917
+insert 1349
+insert 153
+insert 1033
+insert 875
+insert 0
+insert 1336
+insert 912
+remove 1357
+insert 501
+insert 206
+insert 1029
+insert 1081
+insert 152
+insert 1115
+insert 545
+insert 1044
+insert 1145
+insert 909
+insert 472
+insert 1056
+insert 845
+insert 881
+insert 1112
+insert 915
+insert 536
+insert 383
+insert 544
+insert 163
+insert 558
+remove 1343
+insert 1292
+insert 103
+insert 1321
+insert 554
+insert 825
+insert 559
+insert 539
+insert 242
+insert 556
+insert 235
+insert 245
+insert 133
+insert 374
+insert 161
+insert 34
+insert 1143
+insert 1136
+insert 1059
+insert 1087
+insert 1155
+insert 143
+insert 158
+insert 123
+insert 115
+insert 166
+insert 893
+insert 94
+insert 71
+insert 88
+insert 18
+remove 1314
+insert 238
+insert 260
+insert 1130
+insert 984
+insert 1152
+insert 1079
+insert 557
+insert 223
+insert 207
+insert 257
+insert 281
+insert 292
+insert 532
+insert 197
+insert 274
+insert 497
+insert 2655
+insert 267
+insert 686
+insert 212
+insert 854
+insert 880
+insert 325
+insert 673
+insert 216
+insert 196
+insert 7
+insert 782
+insert 2669
+insert 63
+insert 744
+insert 1
+insert 277
+insert 214
+insert 364
+insert 148
+insert 57
+remove 1274
+insert 727
+insert 787
+insert 772
+insert 20
+insert 293
+insert 773
+insert 1010
+insert 183
+insert 873
+insert 617
+insert 836
+insert 878
+insert 451
+insert 313
+insert 607
+insert 1102
+insert 386
+insert 424
+insert 404
+insert 650
+insert 826
+insert 1162
+insert 794
+insert 334
+insert 101
+insert 345
+insert 110
+insert 865
+insert 226
+insert 667
+insert 1088
+insert 651
+insert 273
+insert 870
+insert 852
+insert 189
+insert 1045
+insert 1031
+insert 102
+insert 347
+insert 54
+remove 1345
+insert 354
+insert 631
+insert 1159
+insert 837
+insert 150
+insert 105
+insert 583
+insert 657
+insert 606
+insert 624
+insert 2
+insert 9
+insert 601
+insert 248
+insert 360
+insert 663
+insert 777
+insert 315
+insert 615
+insert 765
+insert 750
+insert 593
+insert 595
+insert 548
+insert 979
+insert 1049
+insert 1157
+insert 1148
+insert 322
+insert 332
+insert 1051
+insert 1013
+insert 349
+insert 552
+insert 390
+insert 974
+insert 1080
+insert 392
+insert 1325
+remove 1328
+insert 1054
+insert 1034
+insert 478
+insert 287
+insert 1302
+insert 805
+insert 492
+insert 24
+insert 529
+insert 533
+insert 165
+insert 79
+insert 584
+insert 884
+insert 815
+insert 776
+insert 534
+insert 49
+insert 524
+insert 874
+insert 264
+insert 482
+insert 495
+insert 505
+insert 810
+insert 885
+insert 64
+insert 1364
+insert 726
+insert 858
+insert 249
+insert 757
+insert 743
+insert 358
+insert 921
+insert 521
+insert 739
+insert 857
+insert 318
+insert 282
+insert 951
+insert 1246
+insert 745
+insert 26
+insert 21
+insert 58
+remove 1352
+insert 302
+insert 1270
+insert 1058
+insert 8
+insert 803
+insert 316
+insert 770
+insert 262
+insert 27
+insert 611
+insert 1289
+insert 73
+insert 23
+insert 856
+insert 527
+insert 52
+insert 1253
+insert 760
+insert 120
+insert 807
+insert 643
+insert 116
+insert 362
+insert 646
+insert 668
+insert 642
+insert 227
+insert 1104
+insert 680
+insert 812
+insert 793
+insert 823
+insert 717
+insert 755
+insert 1781
+insert 1065
+insert 636
+insert 290
+insert 767
+insert 1261
+insert 1283
+insert 1295
+remove 1351
+remove 1341
+remove 1339
+insert 1262
+insert 397
+insert 408
+insert 445
+insert 746
+insert 437
+insert 710
+insert 723
+insert 403
+insert 715
+insert 434
+insert 514
+insert 681
+insert 540
+insert 463
+insert 490
+insert 438
+insert 806
+insert 420
+insert 741
+insert 714
+insert 692
+insert 458
+insert 447
+insert 448
+insert 753
+insert 412
+insert 728
+insert 718
+remove 1296
+remove 1276
+insert 735
+insert 1209
+insert 1036
+insert 1124
+insert 722
+insert 748
+insert 742
+insert 724
+insert 1181
+insert 751
+insert 733
+insert 416
+insert 1170
+insert 446
+insert 2881
+remove 1358
+remove 1288
+insert 449
+insert 40
+insert 33
+insert 130
+insert 1456
+insert 1418
+remove 1489
+insert 1455
+insert 1453
+remove 1473
+remove 1478
+remove 1484
+insert 2154
+insert 1470
+insert 1462
+remove 1487
+insert 1909
+insert 1914
+insert 1465
+insert 1853
+remove 1410
+insert 2252
+remove 1483
+remove 1467
+remove 1316
+insert 948
+insert 1296
+insert 1750
+insert 171
+insert 1238
+insert 749
+insert 697
+insert 219
+insert 721
+insert 828
+insert 2327
+insert 737
+insert 1760
+insert 1775
+insert 1782
+insert 685
+insert 1778
+insert 731
+insert 2352
+insert 706
+insert 1762
+insert 679
+insert 732
+insert 1767
+insert 2325
+insert 2208
+insert 1788
+insert 1772
+insert 1771
+insert 1765
+insert 752
+insert 674
+insert 690
+insert 2353
+insert 1980
+insert 2142
+insert 2286
+insert 2200
+insert 1954
+insert 2338
+insert 453
+insert 411
+insert 2339
+insert 2192
+insert 1749
+insert 2334
+insert 1993
+insert 2015
+insert 428
+insert 2322
+insert 433
+insert 2178
+insert 1727
+remove 1488
+remove 1363
+insert 1916
+insert 2335
+insert 1311
+remove 1461
+insert 2332
+insert 2319
+insert 2930
+insert 1278
+insert 2753
+insert 1754
+insert 2321
+insert 2851
+insert 2214
+insert 2172
+insert 2170
+insert 1314
+remove 1283
+insert 1786
+insert 250
+remove 1355
+insert 1317
+insert 1958
+remove 1325
+insert 2839
+insert 1074
+insert 1752
+insert 2124
+remove 2259
+insert 1457
+insert 1487
+insert 2146
+insert 2138
+remove 2257
+insert 2150
+insert 2241
+insert 1937
+insert 2148
+insert 1730
+insert 1308
+insert 1239
+remove 1165
+insert 2183
+insert 1920
+insert 834
+insert 764
+insert 853
+remove 2258
+insert 2233
+insert 1842
+insert 1943
+insert 847
+insert 783
+insert 1935
+insert 816
+insert 2186
+insert 2126
+insert 2149
+insert 792
+insert 1927
+insert 1315
+insert 1912
+remove 1280
+insert 1902
+insert 1915
+insert 820
+remove 1324
+insert 1923
+insert 1390
+insert 813
+insert 695
+insert 817
+insert 1926
+insert 1895
+insert 705
+insert 1389
+insert 790
+insert 682
+remove 1491
+insert 786
+insert 796
+insert 804
+insert 800
+insert 1950
+insert 811
+insert 771
+insert 435
+insert 452
+insert 464
+insert 432
+insert 784
+insert 900
+remove 1957
+insert 417
+insert 425
+insert 2695
+insert 2796
+insert 415
+insert 48
+insert 801
+insert 802
+insert 1069
+insert 603
+insert 460
+insert 422
+insert 439
+insert 774
+remove 1448
+insert 779
+insert 579
+insert 809
+insert 762
+insert 778
+insert 798
+insert 622
+insert 797
+insert 819
+insert 814
+insert 565
+insert 780
+insert 600
+insert 781
+insert 789
+insert 763
+insert 768
+insert 818
+remove 1408
+insert 1794
+insert 2350
+insert 581
+insert 2384
+insert 590
+insert 2349
+insert 466
+insert 2351
+insert 2394
+insert 608
+insert 598
+insert 519
+insert 633
+insert 485
+insert 627
+insert 2293
+insert 2253
+insert 2817
+insert 2366
+insert 500
+insert 2600
+insert 2627
+insert 2310
+remove 980
+insert 1110
+insert 1757
+insert 512
+insert 568
+insert 462
+insert 498
+remove 1342
+insert 2808
+insert 496
+insert 1258
+insert 1120
+insert 1150
+insert 91
+insert 1316
+insert 47
+insert 1312
+insert 1324
+insert 513
+insert 499
+insert 481
+insert 465
+insert 483
+insert 474
+insert 487
+insert 491
+insert 522
+insert 502
+insert 934
+remove 1300
+insert 510
+remove 1297
+remove 1273
+insert 1946
+insert 476
+insert 97
+insert 1138
+insert 503
+insert 1357
+insert 489
+insert 1147
+insert 42
+insert 1267
+insert 1248
+remove 1329
+insert 486
+insert 520
+insert 1082
+remove 1272
+insert 1068
+remove 1360
+insert 50
+remove 987
+remove 1364
+remove 1314
+insert 1283
+insert 1280
+insert 84
+remove 1344
+remove 1318
+insert 1341
+insert 59
+insert 471
+insert 1077
+insert 473
+insert 1070
+remove 1299
+remove 1315
+remove 1282
+insert 1276
+insert 3132
+remove 1347
+insert 3124
+insert 516
+insert 488
+remove 1362
+insert 300
+insert 1891
+insert 312
+insert 1118
+insert 475
+insert 359
+insert 1362
+insert 309
+insert 1067
+insert 1830
+insert 3027
+insert 2052
+insert 1816
+insert 2027
+insert 1098
+insert 1855
+insert 1078
+insert 1817
+insert 484
+insert 1142
+remove 962
+insert 1062
+insert 2563
+insert 1839
+insert 2576
+insert 1072
+insert 1107
+insert 992
+insert 1020
+insert 355
+insert 343
+insert 1094
+insert 1064
+insert 1125
+insert 1808
+insert 1236
+insert 1071
+insert 1103
+insert 1233
+insert 1840
+insert 1850
+remove 1235
+insert 1089
+insert 1815
+insert 1763
+insert 976
+insert 1773
+insert 1091
+insert 1018
+insert 1083
+insert 1075
+insert 1114
+insert 35
+insert 1123
+insert 1106
+insert 1834
+insert 1017
+insert 1117
+remove 1269
+insert 1111
+insert 1247
+insert 993
+insert 604
+insert 1849
+insert 1820
+insert 1105
+insert 2336
+insert 1095
+insert 569
+insert 2320
+insert 341
+insert 3249
+insert 983
+insert 308
+insert 306
+insert 2551
+insert 564
+remove 1311
+insert 1011
+insert 2311
+insert 1841
+insert 2871
+insert 2865
+insert 610
+insert 2828
+insert 609
+insert 2829
+insert 2834
+insert 2837
+insert 2836
+insert 321
+insert 2861
+insert 2324
+insert 2875
+insert 995
+insert 585
+insert 570
+insert 616
+insert 1906
+insert 1900
+insert 2874
+insert 2312
+insert 2787
+insert 80
+insert 2372
+insert 970
+insert 588
+insert 95
+insert 1126
+insert 324
+insert 602
+insert 571
+insert 589
+insert 561
+insert 586
+insert 342
+insert 61
+insert 2835
+insert 36
+insert 2879
+insert 2856
+insert 317
+insert 39
+insert 572
+insert 1009
+insert 654
+insert 625
+insert 2857
+insert 2830
+insert 2854
+insert 2345
+insert 2878
+insert 614
+insert 1073
+insert 1096
+insert 580
+remove 674
+insert 1005
+remove 681
+insert 635
+insert 1007
+insert 2491
+insert 2606
+insert 298
+remove 706
+insert 356
+insert 645
+insert 2595
+remove 698
+remove 692
+insert 2624
+insert 630
+insert 2642
+remove 668
+insert 2864
+insert 37
+insert 3245
+insert 2849
+insert 980
+insert 2877
+insert 2868
+insert 977
+insert 2316
+insert 2842
+insert 67
+remove 659
+insert 2500
+insert 336
+insert 81
+insert 3192
+remove 720
+remove 1164
+insert 3244
+insert 2824
+insert 2543
+insert 2295
+insert 703
+insert 2328
+insert 348
+insert 323
+insert 2823
+insert 2855
+insert 566
+insert 562
+insert 2831
+insert 2654
+insert 330
+insert 596
+insert 2700
+insert 981
+insert 346
+insert 299
+insert 591
+insert 38
+insert 1970
+remove 1268
+insert 2355
+insert 2507
+insert 2079
+insert 43
+insert 74
+insert 301
+insert 357
+insert 327
+insert 351
+insert 1990
+insert 2323
+insert 297
+insert 2300
+insert 594
+insert 2330
+insert 344
+insert 965
+insert 967
+insert 307
+insert 304
+insert 340
+insert 3241
+insert 3284
+insert 2673
+remove 1090
+insert 319
+insert 87
+insert 2699
+insert 305
+insert 85
+insert 3283
+insert 77
+insert 1008
+insert 93
+insert 2671
+insert 2530
+insert 684
+insert 78
+insert 303
+insert 2661
+insert 674
+insert 707
+insert 3169
+remove 1234
+remove 1104
+insert 2020
+insert 996
+insert 68
+insert 92
+insert 69
+insert 963
+insert 70
+insert 1977
+insert 2033
+insert 2524
+insert 1004
+insert 2450
+insert 60
+insert 701
+insert 44
+insert 671
+insert 1097
+insert 1099
+insert 720
+insert 962
+insert 1021
+insert 702
+insert 997
+insert 2709
+insert 2462
+remove 1096
+insert 2370
+insert 2298
+insert 2676
+remove 1199
+insert 2414
+insert 687
+insert 2080
+remove 1095
+insert 706
+insert 1100
+insert 1101
+insert 2668
+insert 1127
+insert 2046
+insert 2060
+insert 2044
+remove 1110
+insert 699
+insert 2714
+insert 2472
+insert 2014
+remove 1120
+insert 3234
+insert 2428
+insert 3250
+insert 1994
+insert 700
+insert 3233
+insert 964
+insert 2998
+insert 3193
+insert 2011
+insert 709
+insert 2030
+insert 3257
+insert 3264
+insert 3216
+insert 1000
+insert 3276
+insert 2717
+insert 2660
+insert 975
+remove 1087
+insert 3278
+insert 2533
+insert 3268
+insert 990
+insert 1001
+insert 2487
+insert 973
+insert 2034
+remove 1111
+insert 2517
+insert 1063
+insert 3306
+insert 696
+insert 1061
+insert 2552
+remove 1119
+insert 2432
+insert 2707
+insert 2326
+insert 716
+insert 660
+remove 1122
+insert 3271
+insert 2424
+insert 3013
+insert 3238
+insert 3258
+insert 692
+insert 3203
+insert 2294
+insert 1979
+insert 2997
+insert 2391
+insert 2029
+insert 1630
+insert 956
+insert 2505
+insert 3215
+insert 1641
+insert 3302
+insert 2367
+insert 676
+insert 2381
+insert 666
+insert 675
+insert 1015
+remove 1112
+insert 2071
+insert 3043
+insert 3301
+insert 2475
+insert 698
+insert 2031
+insert 3048
+insert 2644
+insert 2419
+insert 2059
+insert 2550
+insert 3046
+insert 2067
+insert 3312
+insert 3296
+insert 3006
+insert 2965
+insert 2460
+insert 2652
+insert 2758
+insert 677
+insert 1959
+insert 713
+insert 2359
+insert 2694
+insert 2674
+insert 2703
+insert 1684
+insert 2713
+insert 1653
+insert 2964
+insert 2389
+insert 3086
+insert 3204
+insert 3021
+insert 2639
+insert 2616
+insert 3246
+insert 3195
+insert 2795
+insert 3036
+insert 3207
+insert 2630
+insert 1682
+insert 2670
+insert 2085
+insert 3297
+insert 711
+insert 2712
+insert 2477
+insert 2681
+insert 659
+insert 2706
+insert 2683
+insert 3219
+insert 3282
+insert 3101
+insert 3109
+insert 2049
+insert 2007
+insert 3094
+insert 2716
+insert 2451
+insert 2922
+insert 2081
+insert 1629
+insert 2075
+insert 2483
+insert 2025
+insert 2691
+insert 693
+insert 2602
+insert 2513
+insert 2662
+insert 681
+insert 662
+insert 678
+insert 2986
+insert 3292
+insert 2492
+insert 3251
+insert 661
+insert 1988
+insert 2032
+insert 689
+insert 708
+insert 2944
+insert 694
+insert 2697
+insert 2604
+insert 2620
+insert 2435
+insert 3029
+insert 2970
+insert 2974
+insert 2607
+insert 2766
+insert 3061
+insert 3103
+insert 1674
+insert 1673
+insert 2648
+insert 3009
+insert 2051
+insert 1852
+insert 2082
+insert 2008
+insert 3079
+insert 1971
+insert 3212
+insert 2084
+insert 1656
+insert 665
+insert 1685
+insert 2990
+insert 2984
+insert 2942
+insert 2536
+insert 3190
+insert 2062
+insert 3188
+insert 3073
+insert 3102
+insert 3096
+insert 2987
+insert 3092
+insert 2760
+insert 2631
+insert 2066
+insert 2943
+insert 2926
+insert 2950
+insert 2058
+insert 2589
+insert 2598
+insert 3131
+insert 3120
+insert 1832
+insert 2363
+insert 2083
+insert 2933
+insert 2967
+insert 3082
+insert 3100
+insert 2415
+insert 2776
+insert 1983
+insert 1813
+insert 3099
+insert 2493
+insert 2597
+insert 2537
+insert 2010
+insert 1643
+insert 3191
+insert 2989
+insert 2937
+insert 3149
+insert 3057
+insert 2013
+insert 2929
+insert 3176
+insert 2636
+insert 3163
+remove 1163
+insert 1984
+insert 2000
+insert 2608
+insert 2043
+insert 3137
+insert 3189
+insert 3263
+insert 2994
+insert 2498
+insert 2596
+insert 1800
+insert 3259
+insert 1759
+insert 2762
+insert 3023
+insert 3017
+insert 2955
+insert 2592
+insert 2511
+insert 3005
+insert 3097
+insert 3121
+insert 2629
+insert 2534
+insert 2927
+insert 2544
+insert 3055
+insert 2640
+insert 1821
+insert 3300
+insert 3153
+insert 2954
+insert 3275
+insert 3227
+insert 3168
+insert 3225
+insert 1801
+insert 1744
+insert 3154
+insert 3143
+insert 2452
+insert 2614
+insert 3044
+insert 2611
+insert 2409
+insert 2407
+insert 3070
+insert 2545
+insert 2953
+insert 3243
+insert 2947
+insert 2626
+insert 2398
+insert 2392
+insert 3222
+insert 3108
+insert 2377
+insert 3177
+insert 3150
+insert 2490
+insert 2456
+insert 2478
+insert 3155
+insert 2535
+insert 2501
+insert 2380
+insert 3232
+insert 1670
+remove 1129
+insert 2985
+insert 2408
+insert 2473
+insert 3122
+insert 1991
+insert 3067
+insert 1963
+insert 2423
+insert 2928
+insert 2458
+insert 2382
+insert 2993
+insert 3019
+insert 2489
+insert 3139
+insert 3068
+insert 3088
+insert 1961
+insert 2003
+insert 3146
+insert 3066
+insert 3173
+insert 3162
+insert 2016
+insert 2486
+insert 3042
+insert 1995
+insert 2444
+insert 2457
+insert 3069
+insert 3157
+insert 3186
+insert 2939
+insert 1646
+insert 2470
+insert 2982
+insert 2547
+insert 2780
+insert 3265
+insert 3178
+insert 1681
+insert 2788
+insert 3218
+insert 2012
+insert 3253
+insert 3252
+insert 1668
+insert 2789
+insert 3041
+insert 2938
+insert 2754
+insert 2002
+insert 1644
+insert 2343
+insert 3180
+insert 1675
+insert 3230
+insert 1631
+insert 2504
+insert 2767
+insert 3126
+insert 3254
+insert 3310
+insert 2466
+insert 3141
+insert 2770
+insert 3311
+insert 1907
+insert 3286
+insert 3110
+insert 3051
+insert 1957
+insert 2772
+insert 1944
+insert 1989
+insert 3256
+insert 2529
+insert 2317
+insert 3040
+insert 1658
+insert 1893
+insert 3104
+insert 2810
+insert 2482
+insert 2979
+insert 3058
+insert 2474
+insert 1671
+insert 1659
+insert 3007
+insert 2541
+insert 966
+insert 2459
+insert 2546
+insert 1677
+insert 2496
+insert 1635
+insert 1650
+insert 1680
+insert 2403
+insert 3106
+insert 2426
+insert 3080
+insert 2447
+insert 3022
+insert 3210
+insert 2304
+insert 2996
+insert 2465
+insert 2449
+insert 2371
+insert 2765
+insert 2514
+insert 3197
+insert 2427
+remove 1086
diff --git a/vendor/im-rc/src/proptest.rs b/vendor/im-rc/src/proptest.rs
new file mode 100644
index 000000000..9180ef273
--- /dev/null
+++ b/vendor/im-rc/src/proptest.rs
@@ -0,0 +1,164 @@
+//! Proptest strategies.
+//!
+//! These are only available when using the `proptest` feature flag.
+
+use crate::{HashMap, HashSet, OrdMap, OrdSet, Vector};
+use ::proptest::collection::vec;
+use ::proptest::strategy::{BoxedStrategy, Strategy, ValueTree};
+use std::hash::Hash;
+use std::iter::FromIterator;
+use std::ops::Range;
+
+/// A strategy for generating a [`Vector`][Vector] of a certain size.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// # use ::proptest::proptest;
+/// proptest! {
+///     #[test]
+///     fn proptest_a_vector(ref l in vector(".*", 10..100)) {
+///         assert!(l.len() < 100);
+///         assert!(l.len() >= 10);
+///     }
+/// }
+/// ```
+///
+/// [Vector]: ../struct.Vector.html
+pub fn vector<A: Strategy + 'static>(
+    element: A,
+    size: Range<usize>,
+) -> BoxedStrategy<Vector<<A::Tree as ValueTree>::Value>>
+where
+    <A::Tree as ValueTree>::Value: Clone,
+{
+    vec(element, size).prop_map(Vector::from_iter).boxed()
+}
+
+/// A strategy for an [`OrdMap`][OrdMap] of a given size.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// # use ::proptest::proptest;
+/// proptest! {
+///     #[test]
+///     fn proptest_works(ref m in ord_map(0..9999, ".*", 10..100)) {
+///         assert!(m.len() < 100);
+///         assert!(m.len() >= 10);
+///     }
+/// }
+/// ```
+///
+/// [OrdMap]: ../struct.OrdMap.html
+pub fn ord_map<K: Strategy + 'static, V: Strategy + 'static>(
+    key: K,
+    value: V,
+    size: Range<usize>,
+) -> BoxedStrategy<OrdMap<<K::Tree as ValueTree>::Value, <V::Tree as ValueTree>::Value>>
+where
+    <K::Tree as ValueTree>::Value: Ord + Clone,
+    <V::Tree as ValueTree>::Value: Clone,
+{
+    ::proptest::collection::vec((key, value), size.clone())
+        .prop_map(OrdMap::from)
+        .prop_filter("OrdMap minimum size".to_owned(), move |m| {
+            m.len() >= size.start
+        })
+        .boxed()
+}
+
+/// A strategy for an [`OrdSet`][OrdSet] of a given size.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// # use ::proptest::proptest;
+/// proptest! {
+///     #[test]
+///     fn proptest_a_set(ref s in ord_set(".*", 10..100)) {
+///         assert!(s.len() < 100);
+///         assert!(s.len() >= 10);
+///     }
+/// }
+/// ```
+///
+/// [OrdSet]: ../struct.OrdSet.html
+pub fn ord_set<A: Strategy + 'static>(
+    element: A,
+    size: Range<usize>,
+) -> BoxedStrategy<OrdSet<<A::Tree as ValueTree>::Value>>
+where
+    <A::Tree as ValueTree>::Value: Ord + Clone,
+{
+    ::proptest::collection::vec(element, size.clone())
+        .prop_map(OrdSet::from)
+        .prop_filter("OrdSet minimum size".to_owned(), move |s| {
+            s.len() >= size.start
+        })
+        .boxed()
+}
+
+/// A strategy for a [`HashMap`][HashMap] of a given size.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// # use ::proptest::proptest;
+/// proptest! {
+///     #[test]
+///     fn proptest_works(ref m in hash_map(0..9999, ".*", 10..100)) {
+///         assert!(m.len() < 100);
+///         assert!(m.len() >= 10);
+///     }
+/// }
+/// ```
+///
+/// [HashMap]: ../struct.HashMap.html
+pub fn hash_map<K: Strategy + 'static, V: Strategy + 'static>(
+    key: K,
+    value: V,
+    size: Range<usize>,
+) -> BoxedStrategy<HashMap<<K::Tree as ValueTree>::Value, <V::Tree as ValueTree>::Value>>
+where
+    <K::Tree as ValueTree>::Value: Hash + Eq + Clone,
+    <V::Tree as ValueTree>::Value: Clone,
+{
+    ::proptest::collection::vec((key, value), size.clone())
+        .prop_map(HashMap::from)
+        .prop_filter("Map minimum size".to_owned(), move |m| {
+            m.len() >= size.start
+        })
+        .boxed()
+}
+
+/// A strategy for a [`HashSet`][HashSet] of a given size.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// # use ::proptest::proptest;
+/// proptest! {
+///     #[test]
+///     fn proptest_a_set(ref s in hash_set(".*", 10..100)) {
+///         assert!(s.len() < 100);
+///         assert!(s.len() >= 10);
+///     }
+/// }
+/// ```
+///
+/// [HashSet]: ../struct.HashSet.html
+pub fn hash_set<A: Strategy + 'static>(
+    element: A,
+    size: Range<usize>,
+) -> BoxedStrategy<HashSet<<A::Tree as ValueTree>::Value>>
+where
+    <A::Tree as ValueTree>::Value: Hash + Eq + Clone,
+{
+    ::proptest::collection::vec(element, size.clone())
+        .prop_map(HashSet::from)
+        .prop_filter("HashSet minimum size".to_owned(), move |s| {
+            s.len() >= size.start
+        })
+        .boxed()
+}
diff --git a/vendor/im-rc/src/quickcheck.rs b/vendor/im-rc/src/quickcheck.rs
new file mode 100644
index 000000000..3faade751
--- /dev/null
+++ b/vendor/im-rc/src/quickcheck.rs
@@ -0,0 +1,43 @@
+use crate::{HashMap, HashSet, OrdMap, OrdSet, Vector};
+use ::quickcheck::{Arbitrary, Gen};
+use std::hash::{BuildHasher, Hash};
+use std::iter::FromIterator;
+
+impl<A: Arbitrary + Sync + Clone> Arbitrary for Vector<A> {
+    fn arbitrary(g: &mut Gen) -> Self {
+        Vector::from_iter(Vec::<A>::arbitrary(g))
+    }
+}
+
+impl<K: Ord + Clone + Arbitrary + Sync, V: Clone + Arbitrary + Sync> Arbitrary for OrdMap<K, V> {
+    fn arbitrary(g: &mut Gen) -> Self {
+        OrdMap::from_iter(Vec::<(K, V)>::arbitrary(g))
+    }
+}
+
+impl<A: Ord + Clone + Arbitrary + Sync> Arbitrary for OrdSet<A> {
+    fn arbitrary(g: &mut Gen) -> Self {
+        OrdSet::from_iter(Vec::<A>::arbitrary(g))
+    }
+}
+
+impl<A, S> Arbitrary for HashSet<A, S>
+where
+    A: Hash + Eq + Arbitrary + Sync,
+    S: BuildHasher + Default + Send + Sync + 'static,
+{
+    fn arbitrary(g: &mut Gen) -> Self {
+        HashSet::from_iter(Vec::<A>::arbitrary(g))
+    }
+}
+
+impl<K, V, S> Arbitrary for HashMap<K, V, S>
+where
+    K: Hash + Eq + Arbitrary + Sync,
+    V: Arbitrary + Sync,
+    S: BuildHasher + Default + Send + Sync + 'static,
+{
+    fn arbitrary(g: &mut Gen) -> Self {
+        HashMap::from(Vec::<(K, V)>::arbitrary(g))
+    }
+}
diff --git a/vendor/im-rc/src/ser.rs b/vendor/im-rc/src/ser.rs
new file mode 100644
index 000000000..d9a35e5f3
--- /dev/null
+++ b/vendor/im-rc/src/ser.rs
@@ -0,0 +1,293 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use serde::de::{Deserialize, Deserializer, MapAccess, SeqAccess, Visitor};
+use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
+use std::fmt;
+use std::hash::{BuildHasher, Hash};
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+use crate::hashmap::HashMap;
+use crate::hashset::HashSet;
+use crate::ordmap::OrdMap;
+use crate::ordset::OrdSet;
+use crate::vector::Vector;
+
+struct SeqVisitor<'de, S, A>
+where
+    S: From<Vec<A>>,
+    A: Deserialize<'de>,
+{
+    phantom_s: PhantomData<S>,
+    phantom_a: PhantomData<A>,
+    phantom_lifetime: PhantomData<&'de ()>,
+}
+
+impl<'de, S, A> SeqVisitor<'de, S, A>
+where
+    S: From<Vec<A>>,
+    A: Deserialize<'de>,
+{
+    pub(crate) fn new() -> SeqVisitor<'de, S, A> {
+        SeqVisitor {
+            phantom_s: PhantomData,
+            phantom_a: PhantomData,
+            phantom_lifetime: PhantomData,
+        }
+    }
+}
+
+impl<'de, S, A> Visitor<'de> for SeqVisitor<'de, S, A>
+where
+    S: From<Vec<A>>,
+    A: Deserialize<'de>,
+{
+    type Value = S;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a sequence")
+    }
+
+    fn visit_seq<Access>(self, mut access: Access) -> Result<Self::Value, Access::Error>
+    where
+        Access: SeqAccess<'de>,
+    {
+        let mut v: Vec<A> = match access.size_hint() {
+            None => Vec::new(),
+            Some(l) => Vec::with_capacity(l),
+        };
+        while let Some(i) = access.next_element()? {
+            v.push(i)
+        }
+        Ok(From::from(v))
+    }
+}
+
+struct MapVisitor<'de, S, K, V>
+where
+    S: From<Vec<(K, V)>>,
+    K: Deserialize<'de>,
+    V: Deserialize<'de>,
+{
+    phantom_s: PhantomData<S>,
+    phantom_k: PhantomData<K>,
+    phantom_v: PhantomData<V>,
+    phantom_lifetime: PhantomData<&'de ()>,
+}
+
+impl<'de, S, K, V> MapVisitor<'de, S, K, V>
+where
+    S: From<Vec<(K, V)>>,
+    K: Deserialize<'de>,
+    V: Deserialize<'de>,
+{
+    pub(crate) fn new() -> MapVisitor<'de, S, K, V> {
+        MapVisitor {
+            phantom_s: PhantomData,
+            phantom_k: PhantomData,
+            phantom_v: PhantomData,
+            phantom_lifetime: PhantomData,
+        }
+    }
+}
+
+impl<'de, S, K, V> Visitor<'de> for MapVisitor<'de, S, K, V>
+where
+    S: From<Vec<(K, V)>>,
+    K: Deserialize<'de>,
+    V: Deserialize<'de>,
+{
+    type Value = S;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a sequence")
+    }
+
+    fn visit_map<Access>(self, mut access: Access) -> Result<Self::Value, Access::Error>
+    where
+        Access: MapAccess<'de>,
+    {
+        let mut v: Vec<(K, V)> = match access.size_hint() {
+            None => Vec::new(),
+            Some(l) => Vec::with_capacity(l),
+        };
+        while let Some(i) = access.next_entry()? {
+            v.push(i)
+        }
+        Ok(From::from(v))
+    }
+}
+
+// Set
+
+impl<'de, A: Deserialize<'de> + Ord + Clone> Deserialize<'de> for OrdSet<A> {
+    fn deserialize<D>(des: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        des.deserialize_seq(SeqVisitor::new())
+    }
+}
+
+impl<A: Ord + Clone + Serialize> Serialize for OrdSet<A> {
+    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut s = ser.serialize_seq(Some(self.len()))?;
+        for i in self.iter() {
+            s.serialize_element(i.deref())?;
+        }
+        s.end()
+    }
+}
+
+// Map
+
+impl<'de, K: Deserialize<'de> + Ord + Clone, V: Deserialize<'de> + Clone> Deserialize<'de>
+    for OrdMap<K, V>
+{
+    fn deserialize<D>(des: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        des.deserialize_map(MapVisitor::<'de, OrdMap<K, V>, K, V>::new())
+    }
+}
+
+impl<K: Serialize + Ord + Clone, V: Serialize + Clone> Serialize for OrdMap<K, V> {
+    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut s = ser.serialize_map(Some(self.len()))?;
+        for (k, v) in self.iter() {
+            s.serialize_entry(k.deref(), v.deref())?;
+        }
+        s.end()
+    }
+}
+
+// HashMap
+
+impl<'de, K, V, S> Deserialize<'de> for HashMap<K, V, S>
+where
+    K: Deserialize<'de> + Hash + Eq + Clone,
+    V: Deserialize<'de> + Clone,
+    S: BuildHasher + Default,
+{
+    fn deserialize<D>(des: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        des.deserialize_map(MapVisitor::<'de, HashMap<K, V, S>, K, V>::new())
+    }
+}
+
+impl<K, V, S> Serialize for HashMap<K, V, S>
+where
+    K: Serialize + Hash + Eq + Clone,
+    V: Serialize + Clone,
+    S: BuildHasher + Default,
+{
+    fn serialize<Ser>(&self, ser: Ser) -> Result<Ser::Ok, Ser::Error>
+    where
+        Ser: Serializer,
+    {
+        let mut s = ser.serialize_map(Some(self.len()))?;
+        for (k, v) in self.iter() {
+            s.serialize_entry(k.deref(), v.deref())?;
+        }
+        s.end()
+    }
+}
+
+// HashSet
+
+impl<'de, A: Deserialize<'de> + Hash + Eq + Clone, S: BuildHasher + Default> Deserialize<'de>
+    for HashSet<A, S>
+{
+    fn deserialize<D>(des: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        des.deserialize_seq(SeqVisitor::new())
+    }
+}
+
+impl<A: Serialize + Hash + Eq + Clone, S: BuildHasher + Default> Serialize for HashSet<A, S> {
+    fn serialize<Ser>(&self, ser: Ser) -> Result<Ser::Ok, Ser::Error>
+    where
+        Ser: Serializer,
+    {
+        let mut s = ser.serialize_seq(Some(self.len()))?;
+        for i in self.iter() {
+            s.serialize_element(i.deref())?;
+        }
+        s.end()
+    }
+}
+
+// Vector
+
+impl<'de, A: Clone + Deserialize<'de>> Deserialize<'de> for Vector<A> {
+    fn deserialize<D>(des: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        des.deserialize_seq(SeqVisitor::<'de, Vector<A>, A>::new())
+    }
+}
+
+impl<A: Clone + Serialize> Serialize for Vector<A> {
+    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut s = ser.serialize_seq(Some(self.len()))?;
+        for i in self.iter() {
+            s.serialize_element(i.deref())?;
+        }
+        s.end()
+    }
+}
+
+// Tests
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::proptest::{hash_map, hash_set, ord_map, ord_set, vector};
+    use ::proptest::num::i32;
+    use ::proptest::proptest;
+    use serde_json::{from_str, to_string};
+
+    proptest! {
+        #[test]
+        fn ser_ordset(ref v in ord_set(i32::ANY, 0..100)) {
+            assert_eq!(v, &from_str::<OrdSet<i32>>(&to_string(&v).unwrap()).unwrap());
+        }
+
+        #[test]
+        fn ser_ordmap(ref v in ord_map(i32::ANY, i32::ANY, 0..100)) {
+            assert_eq!(v, &from_str::<OrdMap<i32, i32>>(&to_string(&v).unwrap()).unwrap());
+        }
+
+        #[test]
+        fn ser_hashmap(ref v in hash_map(i32::ANY, i32::ANY, 0..100)) {
+            assert_eq!(v, &from_str::<HashMap<i32, i32>>(&to_string(&v).unwrap()).unwrap());
+        }
+
+        #[test]
+        fn ser_hashset(ref v in hash_set(i32::ANY, 0..100)) {
+            assert_eq!(v, &from_str::<HashSet<i32>>(&to_string(&v).unwrap()).unwrap());
+        }
+
+        #[test]
+        fn ser_vector(ref v in vector(i32::ANY, 0..100)) {
+            assert_eq!(v, &from_str::<Vector<i32>>(&to_string(&v).unwrap()).unwrap());
+        }
+    }
+}
diff --git a/vendor/im-rc/src/sort.rs b/vendor/im-rc/src/sort.rs
new file mode 100644
index 000000000..6c980019a
--- /dev/null
+++ b/vendor/im-rc/src/sort.rs
@@ -0,0 +1,203 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use crate::vector::FocusMut;
+use rand_core::{RngCore, SeedableRng};
+use std::cmp::Ordering;
+use std::mem;
+
+fn gen_range<R: RngCore>(rng: &mut R, min: usize, max: usize) -> usize {
+    let range = max - min;
+    min + (rng.next_u64() as usize % range)
+}
+
+// Ported from the Java version at:
+//    http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf
+// There are a couple of modifications made here to make it more performant on the tree structure of
+// the Vector. Instead of moving of handling equal and nonequal items in a single pass we make two
+// additional passes to find the exact partition places. This allows us to split the focus into
+// three correctly sized parts for less than, equal to and greater than items. As a bonus this
+// doesn't need to reorder the equal items to the center of the vector.
+fn do_quicksort<A, F, R>(vector: FocusMut<'_, A>, cmp: &F, rng: &mut R)
+where
+    A: Clone,
+    F: Fn(&A, &A) -> Ordering,
+    R: RngCore,
+{
+    if vector.len() <= 1 {
+        return;
+    }
+
+    // We know there are at least 2 elements here
+    let pivot_index = gen_range(rng, 0, vector.len());
+    let (mut first, mut rest) = vector.split_at(1);
+
+    if pivot_index > 0 {
+        mem::swap(rest.index_mut(pivot_index - 1), first.index_mut(0));
+    }
+    // Pivot is now always in the first slice
+    let pivot_item = first.index(0);
+
+    // Find the exact place to put the pivot or pivot-equal items
+    let mut less_count = 0;
+    let mut equal_count = 0;
+
+    for index in 0..rest.len() {
+        let item = rest.index(index);
+        let comp = cmp(item, pivot_item);
+        match comp {
+            Ordering::Less => less_count += 1,
+            Ordering::Equal => equal_count += 1,
+            Ordering::Greater => {}
+        }
+    }
+
+    // If by accident we picked the minimum element as a pivot, we just call sort again with the
+    // rest of the vector.
+    if less_count == 0 {
+        do_quicksort(rest, cmp, rng);
+        return;
+    }
+
+    // We know here that there is at least one item before the pivot, so we move the minimum to the
+    // beginning part of the vector. First, however we swap the pivot to the start of the equal
+    // zone.
+    less_count -= 1;
+    equal_count += 1;
+    let first_item = first.index_mut(0);
+    mem::swap(first_item, rest.index_mut(less_count));
+    for index in 0..rest.len() {
+        if index == less_count {
+            // This is the position we swapped the pivot to. We can't move it from its position, and
+            // we know its not the minimum.
+            continue;
+        }
+        let rest_item = rest.index_mut(index);
+        if cmp(rest_item, first_item) == Ordering::Less {
+            mem::swap(first_item, rest_item);
+        }
+    }
+
+    // Split the vector up into less_than, equal to and greater than parts.
+    let (remaining, mut greater_focus) = rest.split_at(less_count + equal_count);
+    let (mut less_focus, mut equal_focus) = remaining.split_at(less_count);
+
+    let mut less_position = 0;
+    let mut equal_position = 0;
+    let mut greater_position = 0;
+
+    while less_position != less_focus.len() || greater_position != greater_focus.len() {
+        // At start of this loop, equal_position always points to an equal item
+        let mut equal_swap_side = None;
+        let equal_item = equal_focus.index(equal_position);
+
+        // Advance the less_position until we find an out of place item
+        while less_position != less_focus.len() {
+            let less_item = less_focus.index(less_position);
+            match cmp(less_item, equal_item) {
+                Ordering::Equal => {
+                    equal_swap_side = Some(Ordering::Less);
+                    break;
+                }
+                Ordering::Greater => {
+                    break;
+                }
+                _ => {}
+            }
+            less_position += 1;
+        }
+
+        // Advance the greater until we find an out of place item
+        while greater_position != greater_focus.len() {
+            let greater_item = greater_focus.index(greater_position);
+            match cmp(greater_item, equal_item) {
+                Ordering::Less => break,
+                Ordering::Equal => {
+                    equal_swap_side = Some(Ordering::Greater);
+                    break;
+                }
+                _ => {}
+            }
+            greater_position += 1;
+        }
+
+        if let Some(swap_side) = equal_swap_side {
+            // One of the sides is equal to the pivot, advance the pivot
+            let item = if swap_side == Ordering::Less {
+                less_focus.index_mut(less_position)
+            } else {
+                greater_focus.index_mut(greater_position)
+            };
+
+            // We are guaranteed not to hit the end of the equal focus
+            while cmp(item, equal_focus.index(equal_position)) == Ordering::Equal {
+                equal_position += 1;
+            }
+
+            // Swap the equal position and the desired side, it's important to note that only the
+            // equals focus is guaranteed to have made progress so we don't advance the side's index
+            mem::swap(item, equal_focus.index_mut(equal_position));
+        } else if less_position != less_focus.len() && greater_position != greater_focus.len() {
+            // Both sides are out of place and not equal to the pivot, this can only happen if there
+            // is a greater item in the lesser zone and a lesser item in the greater zone. The
+            // solution is to swap both sides and advance both side's indices.
+            debug_assert_ne!(
+                cmp(
+                    less_focus.index(less_position),
+                    equal_focus.index(equal_position)
+                ),
+                Ordering::Equal
+            );
+            debug_assert_ne!(
+                cmp(
+                    greater_focus.index(greater_position),
+                    equal_focus.index(equal_position)
+                ),
+                Ordering::Equal
+            );
+            mem::swap(
+                less_focus.index_mut(less_position),
+                greater_focus.index_mut(greater_position),
+            );
+            less_position += 1;
+            greater_position += 1;
+        }
+    }
+
+    // Now we have partitioned both sides correctly, we just have to recurse now
+    do_quicksort(less_focus, cmp, rng);
+    if !greater_focus.is_empty() {
+        do_quicksort(greater_focus, cmp, rng);
+    }
+}
+
+pub(crate) fn quicksort<A, F>(vector: FocusMut<'_, A>, cmp: &F)
+where
+    A: Clone,
+    F: Fn(&A, &A) -> Ordering,
+{
+    let mut rng = rand_xoshiro::Xoshiro256Plus::seed_from_u64(0);
+    do_quicksort(vector, cmp, &mut rng);
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::test::is_sorted;
+    use crate::vector::proptest::vector;
+    use ::proptest::num::i32;
+    use ::proptest::proptest;
+
+    proptest! {
+        #[test]
+        fn test_quicksort(ref input in vector(i32::ANY, 0..10000)) {
+            let mut vec = input.clone();
+            let len = vec.len();
+            if len > 1 {
+                quicksort(vec.focus_mut(), &Ord::cmp);
+            }
+            assert!(is_sorted(vec));
+        }
+    }
+}
diff --git a/vendor/im-rc/src/sync.rs b/vendor/im-rc/src/sync.rs
new file mode 100644
index 000000000..9b137555e
--- /dev/null
+++ b/vendor/im-rc/src/sync.rs
@@ -0,0 +1,69 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+pub(crate) use self::lock::Lock;
+
+#[cfg(threadsafe)]
+mod lock {
+    use std::sync::{Arc, Mutex, MutexGuard};
+
+    /// Thread safe lock: just wraps a `Mutex`.
+    pub(crate) struct Lock<A> {
+        lock: Arc<Mutex<A>>,
+    }
+
+    impl<A> Lock<A> {
+        pub(crate) fn new(value: A) -> Self {
+            Lock {
+                lock: Arc::new(Mutex::new(value)),
+            }
+        }
+
+        #[inline]
+        pub(crate) fn lock(&mut self) -> Option<MutexGuard<'_, A>> {
+            self.lock.lock().ok()
+        }
+    }
+
+    impl<A> Clone for Lock<A> {
+        fn clone(&self) -> Self {
+            Lock {
+                lock: self.lock.clone(),
+            }
+        }
+    }
+}
+
+#[cfg(not(threadsafe))]
+mod lock {
+    use std::cell::{RefCell, RefMut};
+    use std::rc::Rc;
+
+    /// Single threaded lock: a `RefCell` so we should safely panic if somehow
+    /// trying to access the stored data twice from the same thread.
+    pub(crate) struct Lock<A> {
+        lock: Rc<RefCell<A>>,
+    }
+
+    impl<A> Lock<A> {
+        pub(crate) fn new(value: A) -> Self {
+            Lock {
+                lock: Rc::new(RefCell::new(value)),
+            }
+        }
+
+        #[inline]
+        pub(crate) fn lock(&mut self) -> Option<RefMut<'_, A>> {
+            self.lock.try_borrow_mut().ok()
+        }
+    }
+
+    impl<A> Clone for Lock<A> {
+        fn clone(&self) -> Self {
+            Lock {
+                lock: self.lock.clone(),
+            }
+        }
+    }
+}
diff --git a/vendor/im-rc/src/test.rs b/vendor/im-rc/src/test.rs
new file mode 100644
index 000000000..9887d0138
--- /dev/null
+++ b/vendor/im-rc/src/test.rs
@@ -0,0 +1,86 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use metrohash::MetroHash64;
+use std::hash::{BuildHasher, Hasher};
+use std::marker::PhantomData;
+use typenum::{Unsigned, U64};
+
+pub(crate) fn is_sorted<A, I>(l: I) -> bool
+where
+    I: IntoIterator<Item = A>,
+    A: Ord,
+{
+    let mut it = l.into_iter().peekable();
+    loop {
+        match (it.next(), it.peek()) {
+            (_, None) => return true,
+            (Some(ref a), Some(b)) if a > b => return false,
+            _ => (),
+        }
+    }
+}
+
+pub(crate) struct LolHasher<N: Unsigned = U64> {
+    state: u64,
+    shift: usize,
+    size: PhantomData<N>,
+}
+
+impl<N: Unsigned> LolHasher<N> {
+    fn feed_me(&mut self, byte: u8) {
+        self.state ^= u64::from(byte) << self.shift;
+        self.shift += 8;
+        if self.shift >= 64 {
+            self.shift = 0;
+        }
+    }
+}
+
+impl<N: Unsigned> Hasher for LolHasher<N> {
+    fn write(&mut self, bytes: &[u8]) {
+        for byte in bytes {
+            self.feed_me(*byte)
+        }
+    }
+
+    fn finish(&self) -> u64 {
+        if N::USIZE == 64 {
+            self.state
+        } else {
+            self.state & ((1 << N::USIZE) - 1)
+        }
+    }
+}
+
+impl<N: Unsigned> Default for LolHasher<N> {
+    fn default() -> Self {
+        LolHasher {
+            state: 0,
+            shift: 0,
+            size: PhantomData,
+        }
+    }
+}
+
+pub(crate) struct MetroHashBuilder {
+    seed: u64,
+}
+
+impl MetroHashBuilder {
+    pub(crate) fn new(seed: u64) -> Self {
+        MetroHashBuilder { seed }
+    }
+
+    pub(crate) fn seed(&self) -> u64 {
+        self.seed
+    }
+}
+
+impl BuildHasher for MetroHashBuilder {
+    type Hasher = MetroHash64;
+    fn build_hasher(&self) -> Self::Hasher {
+        MetroHash64::with_seed(self.seed)
+    }
+}
diff --git a/vendor/im-rc/src/tests/hashset.rs b/vendor/im-rc/src/tests/hashset.rs
new file mode 100644
index 000000000..01df2be4e
--- /dev/null
+++ b/vendor/im-rc/src/tests/hashset.rs
@@ -0,0 +1,85 @@
+#![allow(clippy::unit_arg)]
+
+use std::collections::HashSet as NatSet;
+use std::fmt::{Debug, Error, Formatter, Write};
+use std::hash::Hash;
+
+use crate::HashSet;
+
+use proptest::proptest;
+use proptest_derive::Arbitrary;
+
+#[derive(Arbitrary, Debug)]
+enum Action<A> {
+    Insert(A),
+    Remove(A),
+}
+
+#[derive(Arbitrary)]
+struct Actions<A>(Vec<Action<A>>)
+where
+    A: Hash + Eq + Clone;
+
+impl<A> Debug for Actions<A>
+where
+    A: Hash + Eq + Debug + Clone,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let mut out = String::new();
+        let mut expected = NatSet::new();
+        writeln!(out, "let mut set = HashSet::new();")?;
+        for action in &self.0 {
+            match action {
+                Action::Insert(ref value) => {
+                    expected.insert(value.clone());
+                    writeln!(out, "set.insert({:?});", value)?;
+                }
+                Action::Remove(ref value) => {
+                    expected.remove(value);
+                    writeln!(out, "set.remove({:?});", value)?;
+                }
+            }
+        }
+        writeln!(
+            out,
+            "let expected = vec!{:?};",
+            expected.into_iter().collect::<Vec<_>>()
+        )?;
+        writeln!(out, "assert_eq!(HashSet::from(expected), set);")?;
+        write!(f, "{}", super::code_fmt(&out))
+    }
+}
+
+proptest! {
+    #[test]
+    fn comprehensive(actions: Actions<u8>) {
+        let mut set = HashSet::new();
+        let mut nat = NatSet::new();
+        for action in actions.0 {
+            match action {
+                Action::Insert(value) => {
+                    let len = nat.len() + if nat.contains(&value) {
+                        0
+                    } else {
+                        1
+                    };
+                    nat.insert(value);
+                    set.insert(value);
+                    assert_eq!(len, set.len());
+                }
+                Action::Remove(value) => {
+                    let len = nat.len() - if nat.contains(&value) {
+                        1
+                    } else {
+                        0
+                    };
+                    nat.remove(&value);
+                    set.remove(&value);
+                    assert_eq!(len, set.len());
+                }
+            }
+            assert_eq!(nat.len(), set.len());
+            assert_eq!(HashSet::from(nat.clone()), set);
+        }
+    }
+}
diff --git a/vendor/im-rc/src/tests/mod.rs b/vendor/im-rc/src/tests/mod.rs
new file mode 100644
index 000000000..cafea5f9f
--- /dev/null
+++ b/vendor/im-rc/src/tests/mod.rs
@@ -0,0 +1,24 @@
+mod hashset;
+mod ordset;
+mod vector;
+
+fn code_fmt(code: &str) -> String {
+    // use syntect::easy::HighlightLines;
+    // use syntect::highlighting::{Style, ThemeSet};
+    // use syntect::parsing::SyntaxSet;
+    // use syntect::util::{as_24_bit_terminal_escaped, LinesWithEndings};
+    //
+    // let ps = SyntaxSet::load_defaults_newlines();
+    // let ts = ThemeSet::load_defaults();
+    // let syntax = ps.find_syntax_by_extension("rs").unwrap();
+    // let mut h = HighlightLines::new(syntax, &ts.themes["base16-ocean.dark"]);
+    // let mut out = String::from("\n\n");
+    // for line in LinesWithEndings::from(&code) {
+    //     let ranges: Vec<(Style, &str)> = h.highlight(line, &ps);
+    //     let escaped = as_24_bit_terminal_escaped(&ranges[..], false);
+    //     out += &escaped;
+    // }
+    // out += "\n\x1b[0m";
+    // out
+    code.to_string()
+}
diff --git a/vendor/im-rc/src/tests/ordset.rs b/vendor/im-rc/src/tests/ordset.rs
new file mode 100644
index 000000000..15efec5c2
--- /dev/null
+++ b/vendor/im-rc/src/tests/ordset.rs
@@ -0,0 +1,85 @@
+#![allow(clippy::unit_arg)]
+
+use std::collections::BTreeSet;
+use std::fmt::{Debug, Error, Formatter, Write};
+
+use crate::OrdSet;
+
+use proptest::proptest;
+use proptest_derive::Arbitrary;
+
+#[derive(Arbitrary, Debug)]
+enum Action<A> {
+    Insert(A),
+    Remove(A),
+}
+
+#[derive(Arbitrary)]
+struct Actions<A>(Vec<Action<A>>)
+where
+    A: Ord + Clone;
+
+impl<A> Debug for Actions<A>
+where
+    A: Ord + Debug + Clone,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let mut out = String::new();
+        let mut expected = BTreeSet::new();
+        writeln!(out, "let mut set = OrdSet::new();")?;
+        for action in &self.0 {
+            match action {
+                Action::Insert(ref value) => {
+                    expected.insert(value.clone());
+                    writeln!(out, "set.insert({:?});", value)?;
+                }
+                Action::Remove(ref value) => {
+                    expected.remove(value);
+                    writeln!(out, "set.remove({:?});", value)?;
+                }
+            }
+        }
+        writeln!(
+            out,
+            "let expected = vec!{:?};",
+            expected.into_iter().collect::<Vec<_>>()
+        )?;
+        writeln!(out, "assert_eq!(OrdSet::from(expected), set);")?;
+        write!(f, "{}", super::code_fmt(&out))
+    }
+}
+
+proptest! {
+    #[test]
+    fn comprehensive(actions: Actions<u8>) {
+        let mut set = OrdSet::new();
+        let mut nat = BTreeSet::new();
+        for action in actions.0 {
+            match action {
+                Action::Insert(value) => {
+                    let len = nat.len() + if nat.contains(&value) {
+                        0
+                    } else {
+                        1
+                    };
+                    nat.insert(value);
+                    set.insert(value);
+                    assert_eq!(len, set.len());
+                }
+                Action::Remove(value) => {
+                    let len = nat.len() - if nat.contains(&value) {
+                        1
+                    } else {
+                        0
+                    };
+                    nat.remove(&value);
+                    set.remove(&value);
+                    assert_eq!(len, set.len());
+                }
+            }
+            assert_eq!(nat.len(), set.len());
+            assert_eq!(OrdSet::from(nat.clone()), set);
+            assert!(nat.iter().eq(set.iter()));
+        }
+    }
+}
diff --git a/vendor/im-rc/src/tests/vector.rs b/vendor/im-rc/src/tests/vector.rs
new file mode 100644
index 000000000..14e312ade
--- /dev/null
+++ b/vendor/im-rc/src/tests/vector.rs
@@ -0,0 +1,231 @@
+#![allow(clippy::unit_arg)]
+
+use std::fmt::{Debug, Error, Formatter, Write};
+
+use crate::Vector;
+
+use proptest::proptest;
+use proptest_derive::Arbitrary;
+
+#[derive(Arbitrary, Debug)]
+enum Action<A> {
+    PushFront(A),
+    PushBack(A),
+    PopFront,
+    PopBack,
+    Insert(usize, A),
+    Remove(usize),
+    JoinLeft(Vec<A>),
+    JoinRight(Vec<A>),
+    SplitLeft(usize),
+    SplitRight(usize),
+}
+
+#[derive(Arbitrary)]
+struct Actions<A>(Vec<Action<A>>)
+where
+    A: Clone;
+
+impl<A> Debug for Actions<A>
+where
+    A: Debug + Clone,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let mut out = String::new();
+        let mut expected = vec![];
+        writeln!(out, "let mut vec = Vector::new();")?;
+        for action in &self.0 {
+            match action {
+                Action::PushFront(ref value) => {
+                    expected.insert(0, value.clone());
+                    writeln!(out, "vec.push_front({:?});", value)?
+                }
+                Action::PushBack(ref value) => {
+                    expected.push(value.clone());
+                    writeln!(out, "vec.push_back({:?});", value)?
+                }
+                Action::PopFront => {
+                    if !expected.is_empty() {
+                        expected.remove(0);
+                    }
+                    writeln!(out, "vec.pop_front();")?
+                }
+                Action::PopBack => {
+                    expected.pop();
+                    writeln!(out, "vec.pop_back();")?
+                }
+                Action::Insert(ref index, ref value) => {
+                    let index = cap_index(expected.len(), *index);
+                    expected.insert(index, value.clone());
+                    writeln!(out, "vec.insert({:?}, {:?});", index, value)?
+                }
+                Action::Remove(ref index) => {
+                    if !expected.is_empty() {
+                        let index = cap_index(expected.len(), *index);
+                        expected.remove(index);
+                        writeln!(out, "vec.remove({:?})", index)?
+                    } else {
+                        continue;
+                    }
+                }
+                Action::JoinLeft(ref vec) => {
+                    let mut vec_new = vec.clone();
+                    vec_new.append(&mut expected);
+                    expected = vec_new;
+                    writeln!(
+                        out,
+                        "let mut vec_new = Vector::from(vec!{:?}); // size {:?}",
+                        vec,
+                        vec.len()
+                    )?;
+                    writeln!(out, "vec_new.append(vec);")?;
+                    writeln!(out, "vec = vec_new;")?
+                }
+                Action::JoinRight(ref vec) => {
+                    expected.append(&mut vec.clone());
+                    writeln!(
+                        out,
+                        "vec.append(Vector::from(vec!{:?})); // size {:?}",
+                        vec,
+                        vec.len()
+                    )?
+                }
+                Action::SplitLeft(ref index) => {
+                    let index = cap_index(expected.len(), *index);
+                    expected.truncate(index);
+                    writeln!(out, "vec.split_off({:?});", index)?
+                }
+                Action::SplitRight(ref index) => {
+                    let index = cap_index(expected.len(), *index);
+                    expected = expected.split_off(index);
+                    writeln!(out, "vec = vec.split_off({:?});", index)?
+                }
+            }
+            writeln!(out, "// len = {:?}", expected.len())?;
+        }
+        writeln!(out, "let expected = vec!{:?};", expected)?;
+        writeln!(out, "assert_eq!(Vector::from(expected), vec);")?;
+        write!(f, "{}", super::code_fmt(&out))
+    }
+}
+
+fn cap_index(len: usize, index: usize) -> usize {
+    if len == 0 {
+        0
+    } else {
+        index % len
+    }
+}
+
+proptest! {
+    #[test]
+    fn comprehensive(actions: Actions<u8>) {
+        let mut vec = Vector::new();
+        let mut nat = Vec::new();
+        vec.assert_invariants();
+        for action in actions.0 {
+            match action {
+                Action::PushFront(value) => {
+                    let len = vec.len();
+                    nat.insert(0, value);
+                    vec.push_front(value);
+                    assert_eq!(len + 1, vec.len());
+                }
+                Action::PushBack(value) => {
+                    let len = vec.len();
+                    nat.push(value);
+                    vec.push_back(value);
+                    assert_eq!(len + 1, vec.len());
+                }
+                Action::PopFront => {
+                    if vec.is_empty() {
+                        assert_eq!(None, vec.pop_front());
+                    } else {
+                        let len = vec.len();
+                        assert_eq!(nat.remove(0), vec.pop_front().unwrap());
+                        assert_eq!(len - 1, vec.len());
+                    }
+                }
+                Action::PopBack => {
+                    if vec.is_empty() {
+                        assert_eq!(None, vec.pop_back());
+                    } else {
+                        let len = vec.len();
+                        assert_eq!(nat.pop(), vec.pop_back());
+                        assert_eq!(len - 1, vec.len());
+                    }
+                }
+                Action::Insert(index, value) => {
+                    let index = cap_index(vec.len(), index);
+                    let len = vec.len();
+                    nat.insert(index, value);
+                    vec.insert(index, value);
+                    assert_eq!(len + 1, vec.len());
+                }
+                Action::Remove(index) => {
+                    if vec.is_empty() {
+                        continue;
+                    }
+                    let index = cap_index(vec.len(), index);
+                    let len = vec.len();
+                    assert_eq!(nat.remove(index), vec.remove(index));
+                    assert_eq!(len - 1, vec.len());
+                }
+                Action::JoinLeft(mut new_nat) => {
+                    let mut new_vec = new_nat.iter().cloned().collect::<Vector<_>>();
+                    let add_len = new_nat.len();
+                    let len = vec.len();
+                    new_vec.append(vec);
+                    vec = new_vec;
+                    new_nat.append(&mut nat);
+                    nat = new_nat;
+                    assert_eq!(len + add_len, vec.len());
+                }
+                Action::JoinRight(mut new_nat) => {
+                    let new_vec = new_nat.iter().cloned().collect::<Vector<_>>();
+                    let add_len = new_nat.len();
+                    let len = vec.len();
+                    vec.append(new_vec);
+                    nat.append(&mut new_nat);
+                    assert_eq!(len + add_len, vec.len());
+                }
+                Action::SplitLeft(index) => {
+                    let index = cap_index(vec.len(), index);
+                    let len = vec.len();
+                    let vec_right = vec.split_off(index);
+                    let nat_right = nat.split_off(index);
+                    assert_eq!(index, vec.len());
+                    assert_eq!(len - index, vec_right.len());
+                    assert_eq!(nat_right.iter().cloned().collect::<Vector<_>>(), vec_right);
+                }
+                Action::SplitRight(index) => {
+                    let index = cap_index(vec.len(), index);
+                    let len = vec.len();
+                    let vec_right = vec.split_off(index);
+                    let nat_right = nat.split_off(index);
+                    assert_eq!(index, vec.len());
+                    assert_eq!(len - index, vec_right.len());
+                    assert_eq!(nat.iter().cloned().collect::<Vector<_>>(), vec);
+                    vec = vec_right;
+                    nat = nat_right;
+                }
+            }
+            vec.assert_invariants();
+            assert_eq!(nat.len(),vec.len());
+            assert_eq!(nat.iter().cloned().collect::<Vector<_>>(), vec);
+        }
+    }
+}
+
+#[test]
+fn test_inserts() {
+    const N: usize = 2000;
+    let mut v = Vector::new();
+    for i in 0..N {
+        v.insert(v.len() / 2, i);
+    }
+    let mut rv: Vec<usize> = Vec::new();
+    rv.extend((0..N).skip(1).step_by(2));
+    rv.extend((0..N).step_by(2).rev());
+    assert_eq!(rv.iter().cloned().collect::<Vector<_>>(), v);
+}
diff --git a/vendor/im-rc/src/util.rs b/vendor/im-rc/src/util.rs
new file mode 100644
index 000000000..5451f156d
--- /dev/null
+++ b/vendor/im-rc/src/util.rs
@@ -0,0 +1,142 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// Every codebase needs a `util` module.
+
+use std::cmp::Ordering;
+use std::ops::{Bound, IndexMut, Range, RangeBounds};
+use std::ptr;
+
+#[cfg(feature = "pool")]
+pub(crate) use refpool::{PoolClone, PoolDefault};
+
+// The `Ref` type is an alias for either `Rc` or `Arc`, user's choice.
+
+// `Arc` without refpool
+#[cfg(all(threadsafe))]
+pub(crate) use crate::fakepool::{Arc as PoolRef, Pool, PoolClone, PoolDefault};
+
+// `Ref` == `Arc` when threadsafe
+#[cfg(threadsafe)]
+pub(crate) type Ref<A> = std::sync::Arc<A>;
+
+// `Rc` without refpool
+#[cfg(all(not(threadsafe), not(feature = "pool")))]
+pub(crate) use crate::fakepool::{Pool, PoolClone, PoolDefault, Rc as PoolRef};
+
+// `Rc` with refpool
+#[cfg(all(not(threadsafe), feature = "pool"))]
+pub(crate) type PoolRef<A> = refpool::PoolRef<A>;
+#[cfg(all(not(threadsafe), feature = "pool"))]
+pub(crate) type Pool<A> = refpool::Pool<A>;
+
+// `Ref` == `Rc` when not threadsafe
+#[cfg(not(threadsafe))]
+pub(crate) type Ref<A> = std::rc::Rc<A>;
+
+pub(crate) fn clone_ref<A>(r: Ref<A>) -> A
+where
+    A: Clone,
+{
+    Ref::try_unwrap(r).unwrap_or_else(|r| (*r).clone())
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub(crate) enum Side {
+    Left,
+    Right,
+}
+
+/// Swap two values of anything implementing `IndexMut`.
+///
+/// Like `slice::swap`, but more generic.
+#[allow(unsafe_code)]
+pub(crate) fn swap_indices<V>(vector: &mut V, a: usize, b: usize)
+where
+    V: IndexMut<usize>,
+    V::Output: Sized,
+{
+    if a == b {
+        return;
+    }
+    // so sorry, but there's no implementation for this in std that's
+    // sufficiently generic
+    let pa: *mut V::Output = &mut vector[a];
+    let pb: *mut V::Output = &mut vector[b];
+    unsafe {
+        ptr::swap(pa, pb);
+    }
+}
+
+#[allow(dead_code)]
+pub(crate) fn linear_search_by<'a, A, I, F>(iterable: I, mut cmp: F) -> Result<usize, usize>
+where
+    A: 'a,
+    I: IntoIterator<Item = &'a A>,
+    F: FnMut(&A) -> Ordering,
+{
+    let mut pos = 0;
+    for value in iterable {
+        match cmp(value) {
+            Ordering::Equal => return Ok(pos),
+            Ordering::Greater => return Err(pos),
+            Ordering::Less => {}
+        }
+        pos += 1;
+    }
+    Err(pos)
+}
+
+pub(crate) fn to_range<R>(range: &R, right_unbounded: usize) -> Range<usize>
+where
+    R: RangeBounds<usize>,
+{
+    let start_index = match range.start_bound() {
+        Bound::Included(i) => *i,
+        Bound::Excluded(i) => *i + 1,
+        Bound::Unbounded => 0,
+    };
+    let end_index = match range.end_bound() {
+        Bound::Included(i) => *i + 1,
+        Bound::Excluded(i) => *i,
+        Bound::Unbounded => right_unbounded,
+    };
+    start_index..end_index
+}
+
+macro_rules! def_pool {
+    ($name:ident<$($arg:tt),*>, $pooltype:ty) => {
+        /// A memory pool for the appropriate node type.
+        pub struct $name<$($arg,)*>(Pool<$pooltype>);
+
+        impl<$($arg,)*> $name<$($arg,)*> {
+            /// Create a new pool with the given size.
+            pub fn new(size: usize) -> Self {
+                Self(Pool::new(size))
+            }
+
+            /// Fill the pool with preallocated chunks.
+            pub fn fill(&self) {
+                self.0.fill();
+            }
+
+            ///Get the current size of the pool.
+            pub fn pool_size(&self) -> usize {
+                self.0.get_pool_size()
+            }
+        }
+
+        impl<$($arg,)*> Default for $name<$($arg,)*> {
+            fn default() -> Self {
+                Self::new($crate::config::POOL_SIZE)
+            }
+        }
+
+        impl<$($arg,)*> Clone for $name<$($arg,)*> {
+            fn clone(&self) -> Self {
+                Self(self.0.clone())
+            }
+        }
+    };
+}
diff --git a/vendor/im-rc/src/vector/focus.rs b/vendor/im-rc/src/vector/focus.rs
new file mode 100644
index 000000000..4fdba751a
--- /dev/null
+++ b/vendor/im-rc/src/vector/focus.rs
@@ -0,0 +1,909 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use std::mem::{replace, swap};
+use std::ops::{Range, RangeBounds};
+use std::ptr::null;
+use std::sync::atomic::{AtomicPtr, Ordering};
+
+use crate::nodes::chunk::Chunk;
+use crate::sync::Lock;
+use crate::util::{to_range, PoolRef, Ref};
+use crate::vector::{
+    Iter, IterMut, RRBPool, Rrb, Vector,
+    VectorInner::{Full, Inline, Single},
+};
+
+/// Focused indexing over a [`Vector`][Vector].
+///
+/// By remembering the last tree node accessed through an index lookup and the
+/// path we took to get there, we can speed up lookups for adjacent indices
+/// tremendously. Lookups on indices in the same node are instantaneous, and
+/// lookups on sibling nodes are also very fast.
+///
+/// A `Focus` can also be used as a restricted view into a vector, using the
+/// [`narrow`][narrow] and [`split_at`][split_at] methods.
+///
+/// # When should I use a `Focus` for better performance?
+///
+/// `Focus` is useful when you need to perform a large number of index lookups
+/// that are more likely than not to be close to each other. It's usually worth
+/// using a `Focus` in any situation where you're batching a lot of index
+/// lookups together, even if they're not obviously adjacent - there's likely
+/// to be some performance gain for even completely random access.
+///
+/// If you're just iterating forwards or backwards over the [`Vector`][Vector]
+/// in order, you're better off with a regular iterator, which, in fact, is
+/// implemented using a `Focus`, but provides a simpler interface.
+///
+/// If you're just doing a very small number of index lookups, the setup cost
+/// for the `Focus` is probably not worth it.
+///
+/// A `Focus` is never faster than an index lookup on a small [`Vector`][Vector]
+/// with a length below the internal RRB tree's branching factor of 64.
+///
+/// # Examples
+///
+/// This example is contrived, as the better way to iterate forwards or
+/// backwards over a vector is with an actual iterator. Even so, the version
+/// using a `Focus` should run nearly an order of magnitude faster than the
+/// version using index lookups at a length of 1000. It should also be noted
+/// that [`vector::Iter`][Iter] is actually implemented using a `Focus` behind
+/// the scenes, so the performance of the two should be identical.
+///
+/// ```rust
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::vector::Vector;
+/// # use std::iter::FromIterator;
+/// let mut vec: Vector<i64> = Vector::from_iter(0..1000);
+///
+/// // Summing a vector, the slow way:
+/// let mut sum = 0;
+/// for i in 0..1000 {
+///     sum += *vec.get(i).unwrap();
+/// }
+/// assert_eq!(499500, sum);
+///
+/// // Summing a vector faster using a Focus:
+/// let mut sum = 0;
+/// let mut focus = vec.focus();
+/// for i in 0..1000 {
+///     sum += *focus.get(i).unwrap();
+/// }
+/// assert_eq!(499500, sum);
+///
+/// // And the easy way, for completeness:
+/// let sum: i64 = vec.iter().sum();
+/// assert_eq!(499500, sum);
+/// ```
+///
+/// [Vector]: enum.Vector.html
+/// [Iter]: struct.Iter.html
+/// [narrow]: #method.narrow
+/// [split_at]: #method.split_at
+pub enum Focus<'a, A> {
+    #[doc(hidden)]
+    Single(&'a [A]),
+    #[doc(hidden)]
+    Full(TreeFocus<A>),
+}
+
+impl<'a, A> Focus<'a, A>
+where
+    A: Clone + 'a,
+{
+    /// Construct a `Focus` for a [`Vector`][Vector].
+    ///
+    /// [Vector]: enum.Vector.html
+    pub fn new(vector: &'a Vector<A>) -> Self {
+        match &vector.vector {
+            Inline(_, chunk) => Focus::Single(chunk),
+            Single(_, chunk) => Focus::Single(chunk),
+            Full(_, tree) => Focus::Full(TreeFocus::new(tree)),
+        }
+    }
+
+    /// Get the length of the focused [`Vector`][Vector].
+    ///
+    /// [Vector]: enum.Vector.html
+    pub fn len(&self) -> usize {
+        match self {
+            Focus::Single(chunk) => chunk.len(),
+            Focus::Full(tree) => tree.len(),
+        }
+    }
+
+    /// Test if the focused [`Vector`][Vector] is empty.
+    ///
+    /// [Vector]: enum.Vector.html
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Get a reference to the value at a given index.
+    pub fn get(&mut self, index: usize) -> Option<&A> {
+        match self {
+            Focus::Single(chunk) => chunk.get(index),
+            Focus::Full(tree) => tree.get(index),
+        }
+    }
+
+    /// Get a reference to the value at a given index.
+    ///
+    /// Panics if the index is out of bounds.
+    pub fn index(&mut self, index: usize) -> &A {
+        self.get(index).expect("index out of bounds")
+    }
+
+    /// Get the chunk for the given index.
+    ///
+    /// This gives you a reference to the leaf node that contains the index,
+    /// along with its start and end indices.
+    pub fn chunk_at(&mut self, index: usize) -> (Range<usize>, &[A]) {
+        let len = self.len();
+        if index >= len {
+            panic!("vector::Focus::chunk_at: index out of bounds");
+        }
+        match self {
+            Focus::Single(chunk) => (0..len, chunk),
+            Focus::Full(tree) => tree.get_chunk(index),
+        }
+    }
+
+    /// Narrow the focus onto a subslice of the vector.
+    ///
+    /// `Focus::narrow(range)` has the same effect as `&slice[range]`, without
+    /// actually modifying the underlying vector.
+    ///
+    /// Panics if the range isn't fully inside the current focus.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// # use std::iter::FromIterator;
+    /// let vec = Vector::from_iter(0..1000);
+    /// let narrowed = vec.focus().narrow(100..200);
+    /// let narrowed_vec = narrowed.into_iter().cloned().collect();
+    /// assert_eq!(Vector::from_iter(100..200), narrowed_vec);
+    /// ```
+    ///
+    /// [slice::split_at]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at
+    /// [Vector::split_at]: enum.Vector.html#method.split_at
+    pub fn narrow<R>(self, range: R) -> Self
+    where
+        R: RangeBounds<usize>,
+    {
+        let r = to_range(&range, self.len());
+        if r.start >= r.end || r.start >= self.len() {
+            panic!("vector::Focus::narrow: range out of bounds");
+        }
+        match self {
+            Focus::Single(chunk) => Focus::Single(&chunk[r]),
+            Focus::Full(tree) => Focus::Full(tree.narrow(r)),
+        }
+    }
+
+    /// Split the focus into two.
+    ///
+    /// Given an index `index`, consume the focus and produce two new foci, the
+    /// left onto indices `0..index`, and the right onto indices `index..N`
+    /// where `N` is the length of the current focus.
+    ///
+    /// Panics if the index is out of bounds.
+    ///
+    /// This is the moral equivalent of [`slice::split_at`][slice::split_at], in
+    /// that it leaves the underlying data structure unchanged, unlike
+    /// [`Vector::split_at`][Vector::split_at].
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// # use std::iter::FromIterator;
+    /// let vec = Vector::from_iter(0..1000);
+    /// let (left, right) = vec.focus().split_at(500);
+    /// let left_vec = left.into_iter().cloned().collect();
+    /// let right_vec = right.into_iter().cloned().collect();
+    /// assert_eq!(Vector::from_iter(0..500), left_vec);
+    /// assert_eq!(Vector::from_iter(500..1000), right_vec);
+    /// ```
+    ///
+    /// [slice::split_at]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at
+    /// [Vector::split_at]: enum.Vector.html#method.split_at
+    pub fn split_at(self, index: usize) -> (Self, Self) {
+        if index >= self.len() {
+            panic!("vector::Focus::split_at: index out of bounds");
+        }
+        match self {
+            Focus::Single(chunk) => {
+                let (left, right) = chunk.split_at(index);
+                (Focus::Single(left), Focus::Single(right))
+            }
+            Focus::Full(tree) => {
+                let (left, right) = tree.split_at(index);
+                (Focus::Full(left), Focus::Full(right))
+            }
+        }
+    }
+}
+
+impl<'a, A> IntoIterator for Focus<'a, A>
+where
+    A: Clone + 'a,
+{
+    type Item = &'a A;
+    type IntoIter = Iter<'a, A>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Iter::from_focus(self)
+    }
+}
+
+impl<'a, A> Clone for Focus<'a, A>
+where
+    A: Clone + 'a,
+{
+    fn clone(&self) -> Self {
+        match self {
+            Focus::Single(chunk) => Focus::Single(chunk),
+            Focus::Full(tree) => Focus::Full(tree.clone()),
+        }
+    }
+}
+
+pub struct TreeFocus<A> {
+    tree: Rrb<A>,
+    view: Range<usize>,
+    middle_range: Range<usize>,
+    target_range: Range<usize>,
+    target_ptr: *const Chunk<A>,
+}
+
+impl<A> Clone for TreeFocus<A> {
+    fn clone(&self) -> Self {
+        let tree = self.tree.clone();
+        TreeFocus {
+            view: self.view.clone(),
+            middle_range: self.middle_range.clone(),
+            target_range: 0..0,
+            target_ptr: null(),
+            tree,
+        }
+    }
+}
+
+#[allow(unsafe_code)]
+#[cfg(threadsafe)]
+unsafe impl<A: Send> Send for TreeFocus<A> {}
+#[allow(unsafe_code)]
+#[cfg(threadsafe)]
+unsafe impl<A: Sync> Sync for TreeFocus<A> {}
+
+#[inline]
+fn contains<A: Ord>(range: &Range<A>, index: &A) -> bool {
+    *index >= range.start && *index < range.end
+}
+
+impl<A> TreeFocus<A>
+where
+    A: Clone,
+{
+    fn new(tree: &Rrb<A>) -> Self {
+        let middle_start = tree.outer_f.len() + tree.inner_f.len();
+        let middle_end = middle_start + tree.middle.len();
+        TreeFocus {
+            tree: tree.clone(),
+            view: 0..tree.length,
+            middle_range: middle_start..middle_end,
+            target_range: 0..0,
+            target_ptr: null(),
+        }
+    }
+
+    fn len(&self) -> usize {
+        self.view.end - self.view.start
+    }
+
+    fn narrow(self, mut view: Range<usize>) -> Self {
+        view.start += self.view.start;
+        view.end += self.view.start;
+        TreeFocus {
+            view,
+            middle_range: self.middle_range.clone(),
+            target_range: 0..0,
+            target_ptr: null(),
+            tree: self.tree,
+        }
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let len = self.len();
+        let left = self.clone().narrow(0..index);
+        let right = self.narrow(index..len);
+        (left, right)
+    }
+
+    fn physical_index(&self, index: usize) -> usize {
+        debug_assert!(index < self.view.end);
+        self.view.start + index
+    }
+
+    fn logical_range(&self, range: &Range<usize>) -> Range<usize> {
+        (range.start - self.view.start)..(range.end - self.view.start)
+    }
+
+    fn set_focus(&mut self, index: usize) {
+        if index < self.middle_range.start {
+            let outer_len = self.tree.outer_f.len();
+            if index < outer_len {
+                self.target_range = 0..outer_len;
+                self.target_ptr = &*self.tree.outer_f;
+            } else {
+                self.target_range = outer_len..self.middle_range.start;
+                self.target_ptr = &*self.tree.inner_f;
+            }
+        } else if index >= self.middle_range.end {
+            let outer_start = self.middle_range.end + self.tree.inner_b.len();
+            if index < outer_start {
+                self.target_range = self.middle_range.end..outer_start;
+                self.target_ptr = &*self.tree.inner_b;
+            } else {
+                self.target_range = outer_start..self.tree.length;
+                self.target_ptr = &*self.tree.outer_b;
+            }
+        } else {
+            let tree_index = index - self.middle_range.start;
+            let (range, ptr) = self
+                .tree
+                .middle
+                .lookup_chunk(self.tree.middle_level, 0, tree_index);
+            self.target_range =
+                (range.start + self.middle_range.start)..(range.end + self.middle_range.start);
+            self.target_ptr = ptr;
+        }
+    }
+
+    #[allow(unsafe_code)]
+    fn get_focus(&self) -> &Chunk<A> {
+        unsafe { &*self.target_ptr }
+    }
+
+    pub fn get(&mut self, index: usize) -> Option<&A> {
+        if index >= self.len() {
+            return None;
+        }
+        let phys_index = self.physical_index(index);
+        if !contains(&self.target_range, &phys_index) {
+            self.set_focus(phys_index);
+        }
+        let target_phys_index = phys_index - self.target_range.start;
+        Some(&self.get_focus()[target_phys_index])
+    }
+
+    pub fn get_chunk(&mut self, index: usize) -> (Range<usize>, &[A]) {
+        let phys_index = self.physical_index(index);
+        if !contains(&self.target_range, &phys_index) {
+            self.set_focus(phys_index);
+        }
+        let mut slice: &[A] = self.get_focus().as_slice();
+        let mut left = 0;
+        let mut right = 0;
+        if self.target_range.start < self.view.start {
+            left = self.view.start - self.target_range.start;
+        }
+        if self.target_range.end > self.view.end {
+            right = self.target_range.end - self.view.end;
+        }
+        slice = &slice[left..(slice.len() - right)];
+        let phys_range = (self.target_range.start + left)..(self.target_range.end - right);
+        (self.logical_range(&phys_range), slice)
+    }
+}
+
+/// A mutable version of [`Focus`][Focus].
+///
+/// See [`Focus`][Focus] for more details.
+///
+/// You can only build one `FocusMut` at a time for a vector, effectively
+/// keeping a lock on the vector until you're done with the focus, which relies
+/// on the structure of the vector not changing while it exists.
+///
+/// ```rust,compile_fail
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::vector::Vector;
+/// # use std::iter::FromIterator;
+/// let mut vec = Vector::from_iter(0..1000);
+/// let focus1 = vec.focus_mut();
+/// // Fails here in 2015 edition because you're creating
+/// // two mutable references to the same thing.
+/// let focus2 = vec.focus_mut();
+/// // Fails here in 2018 edition because creating focus2
+/// // made focus1's lifetime go out of scope.
+/// assert_eq!(Some(&0), focus1.get(0));
+/// ```
+///
+/// On the other hand, you can split that one focus into multiple sub-focuses,
+/// which is safe because they can't overlap:
+///
+/// ```rust
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::vector::Vector;
+/// # use std::iter::FromIterator;
+/// let mut vec = Vector::from_iter(0..1000);
+/// let focus = vec.focus_mut();
+/// let (mut left, mut right) = focus.split_at(500);
+/// assert_eq!(Some(&0), left.get(0));
+/// assert_eq!(Some(&500), right.get(0));
+/// ```
+///
+/// These sub-foci also work as a lock on the vector, even if the focus they
+/// were created from goes out of scope.
+///
+/// ```rust,compile_fail
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::vector::Vector;
+/// # use std::iter::FromIterator;
+/// let mut vec = Vector::from_iter(0..1000);
+/// let (left, right) = {
+///     let focus = vec.focus_mut();
+///     focus.split_at(500)
+/// };
+/// // `left` and `right` are still in scope even if `focus` isn't, so we can't
+/// // create another focus:
+/// let focus2 = vec.focus_mut();
+/// assert_eq!(Some(&0), left.get(0));
+/// ```
+///
+/// [Focus]: enum.Focus.html
+pub enum FocusMut<'a, A> {
+    #[doc(hidden)]
+    Single(RRBPool<A>, &'a mut [A]),
+    #[doc(hidden)]
+    Full(RRBPool<A>, TreeFocusMut<'a, A>),
+}
+
+impl<'a, A> FocusMut<'a, A>
+where
+    A: Clone + 'a,
+{
+    /// Construct a `FocusMut` for a `Vector`.
+    pub fn new(vector: &'a mut Vector<A>) -> Self {
+        match &mut vector.vector {
+            Inline(pool, chunk) => FocusMut::Single(pool.clone(), chunk),
+            Single(pool, chunk) => FocusMut::Single(
+                pool.clone(),
+                PoolRef::make_mut(&pool.value_pool, chunk).as_mut_slice(),
+            ),
+            Full(pool, tree) => FocusMut::Full(pool.clone(), TreeFocusMut::new(tree)),
+        }
+    }
+
+    /// Get the length of the focused `Vector`.
+    pub fn len(&self) -> usize {
+        match self {
+            FocusMut::Single(_, chunk) => chunk.len(),
+            FocusMut::Full(_, tree) => tree.len(),
+        }
+    }
+
+    /// Test if the focused `Vector` is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Get a reference to the value at a given index.
+    pub fn get(&mut self, index: usize) -> Option<&A> {
+        self.get_mut(index).map(|r| &*r)
+    }
+
+    /// Get a mutable reference to the value at a given index.
+    pub fn get_mut(&mut self, index: usize) -> Option<&mut A> {
+        match self {
+            FocusMut::Single(_, chunk) => chunk.get_mut(index),
+            FocusMut::Full(pool, tree) => tree.get(pool, index),
+        }
+    }
+
+    /// Get a reference to the value at a given index.
+    ///
+    /// Panics if the index is out of bounds.
+    pub fn index(&mut self, index: usize) -> &A {
+        &*self.index_mut(index)
+    }
+
+    /// Get a mutable reference to the value at a given index.
+    ///
+    /// Panics if the index is out of bounds.
+    #[allow(clippy::should_implement_trait)] // would if I could
+    pub fn index_mut(&mut self, index: usize) -> &mut A {
+        self.get_mut(index).expect("index out of bounds")
+    }
+
+    /// Update the value at a given index.
+    ///
+    /// Returns `None` if the index is out of bounds, or the replaced value
+    /// otherwise.
+    pub fn set(&mut self, index: usize, value: A) -> Option<A> {
+        self.get_mut(index).map(|pos| replace(pos, value))
+    }
+
+    /// Swap the values at two given indices.
+    ///
+    /// Panics if either index is out of bounds.
+    ///
+    /// If the indices are equal, this function returns without doing anything.
+    pub fn swap(&mut self, a: usize, b: usize) {
+        if a == b {
+            return;
+        }
+        self.pair(a, b, |left, right| swap(left, right));
+    }
+
+    /// Lookup two indices simultaneously and run a function over them.
+    ///
+    /// Useful because the borrow checker won't let you have more than one
+    /// mutable reference into the same data structure at any given time.
+    ///
+    /// Panics if either index is out of bounds, or if they are the same index.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// # use std::iter::FromIterator;
+    /// let mut vec = vector![1, 2, 3, 4, 5];
+    /// vec.focus_mut().pair(1, 3, |a, b| *a += *b);
+    /// assert_eq!(vector![1, 6, 3, 4, 5], vec);
+    /// ```
+    #[allow(unsafe_code)]
+    pub fn pair<F, B>(&mut self, a: usize, b: usize, mut f: F) -> B
+    where
+        F: FnMut(&mut A, &mut A) -> B,
+    {
+        if a == b {
+            panic!("vector::FocusMut::pair: indices cannot be equal!");
+        }
+        let pa: *mut A = self.index_mut(a);
+        let pb: *mut A = self.index_mut(b);
+        unsafe { f(&mut *pa, &mut *pb) }
+    }
+
+    /// Lookup three indices simultaneously and run a function over them.
+    ///
+    /// Useful because the borrow checker won't let you have more than one
+    /// mutable reference into the same data structure at any given time.
+    ///
+    /// Panics if any index is out of bounds, or if any indices are equal.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// # use std::iter::FromIterator;
+    /// let mut vec = vector![1, 2, 3, 4, 5];
+    /// vec.focus_mut().triplet(0, 2, 4, |a, b, c| *a += *b + *c);
+    /// assert_eq!(vector![9, 2, 3, 4, 5], vec);
+    /// ```
+    #[allow(unsafe_code)]
+    pub fn triplet<F, B>(&mut self, a: usize, b: usize, c: usize, mut f: F) -> B
+    where
+        F: FnMut(&mut A, &mut A, &mut A) -> B,
+    {
+        if a == b || b == c || a == c {
+            panic!("vector::FocusMut::triplet: indices cannot be equal!");
+        }
+        let pa: *mut A = self.index_mut(a);
+        let pb: *mut A = self.index_mut(b);
+        let pc: *mut A = self.index_mut(c);
+        unsafe { f(&mut *pa, &mut *pb, &mut *pc) }
+    }
+
+    /// Get the chunk for the given index.
+    ///
+    /// This gives you a reference to the leaf node that contains the index,
+    /// along with its start and end indices.
+    pub fn chunk_at(&mut self, index: usize) -> (Range<usize>, &mut [A]) {
+        let len = self.len();
+        if index >= len {
+            panic!("vector::FocusMut::chunk_at: index out of bounds");
+        }
+        match self {
+            FocusMut::Single(_, chunk) => (0..len, chunk),
+            FocusMut::Full(pool, tree) => {
+                let (range, chunk) = tree.get_chunk(pool, index);
+                (range, chunk)
+            }
+        }
+    }
+
+    /// Narrow the focus onto a subslice of the vector.
+    ///
+    /// `FocusMut::narrow(range)` has the same effect as `&slice[range]`, without
+    /// actually modifying the underlying vector.
+    ///
+    /// Panics if the range isn't fully inside the current focus.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// # use std::iter::FromIterator;
+    /// let mut vec = Vector::from_iter(0..1000);
+    /// let narrowed = vec.focus_mut().narrow(100..200);
+    /// let narrowed_vec = narrowed.unmut().into_iter().cloned().collect();
+    /// assert_eq!(Vector::from_iter(100..200), narrowed_vec);
+    /// ```
+    ///
+    /// [slice::split_at]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at
+    /// [Vector::split_at]: enum.Vector.html#method.split_at
+    pub fn narrow<R>(self, range: R) -> Self
+    where
+        R: RangeBounds<usize>,
+    {
+        let r = to_range(&range, self.len());
+        if r.start > r.end || r.start > self.len() {
+            panic!("vector::FocusMut::narrow: range out of bounds");
+        }
+        match self {
+            FocusMut::Single(pool, chunk) => FocusMut::Single(pool, &mut chunk[r]),
+            FocusMut::Full(pool, tree) => FocusMut::Full(pool, tree.narrow(r)),
+        }
+    }
+
+    /// Split the focus into two.
+    ///
+    /// Given an index `index`, consume the focus and produce two new foci, the
+    /// left onto indices `0..index`, and the right onto indices `index..N`
+    /// where `N` is the length of the current focus.
+    ///
+    /// Panics if the index is out of bounds.
+    ///
+    /// This is the moral equivalent of [`slice::split_at`][slice::split_at], in
+    /// that it leaves the underlying data structure unchanged, unlike
+    /// [`Vector::split_at`][Vector::split_at].
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// # use std::iter::FromIterator;
+    /// let mut vec = Vector::from_iter(0..1000);
+    /// {
+    ///     let (left, right) = vec.focus_mut().split_at(500);
+    ///     for ptr in left {
+    ///         *ptr += 100;
+    ///     }
+    ///     for ptr in right {
+    ///         *ptr -= 100;
+    ///     }
+    /// }
+    /// let expected = Vector::from_iter(100..600)
+    ///              + Vector::from_iter(400..900);
+    /// assert_eq!(expected, vec);
+    /// ```
+    ///
+    /// [slice::split_at]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at
+    /// [Vector::split_at]: enum.Vector.html#method.split_at
+    #[allow(clippy::redundant_clone)]
+    pub fn split_at(self, index: usize) -> (Self, Self) {
+        if index > self.len() {
+            panic!("vector::FocusMut::split_at: index out of bounds");
+        }
+        match self {
+            FocusMut::Single(pool, chunk) => {
+                let (left, right) = chunk.split_at_mut(index);
+                (
+                    FocusMut::Single(pool.clone(), left),
+                    FocusMut::Single(pool, right),
+                )
+            }
+            FocusMut::Full(pool, tree) => {
+                let (left, right) = tree.split_at(index);
+                (
+                    FocusMut::Full(pool.clone(), left),
+                    FocusMut::Full(pool, right),
+                )
+            }
+        }
+    }
+
+    /// Convert a `FocusMut` into a `Focus`.
+    pub fn unmut(self) -> Focus<'a, A> {
+        match self {
+            FocusMut::Single(_, chunk) => Focus::Single(chunk),
+            FocusMut::Full(_, mut tree) => Focus::Full(TreeFocus {
+                tree: {
+                    let t = tree.tree.lock().unwrap();
+                    (*t).clone()
+                },
+                view: tree.view.clone(),
+                middle_range: tree.middle_range.clone(),
+                target_range: 0..0,
+                target_ptr: null(),
+            }),
+        }
+    }
+}
+
+impl<'a, A> IntoIterator for FocusMut<'a, A>
+where
+    A: Clone + 'a,
+{
+    type Item = &'a mut A;
+    type IntoIter = IterMut<'a, A>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IterMut::from_focus(self)
+    }
+}
+
+impl<'a, A> From<FocusMut<'a, A>> for Focus<'a, A>
+where
+    A: Clone + 'a,
+{
+    fn from(f: FocusMut<'a, A>) -> Self {
+        f.unmut()
+    }
+}
+
+pub struct TreeFocusMut<'a, A> {
+    tree: Lock<&'a mut Rrb<A>>,
+    view: Range<usize>,
+    middle_range: Range<usize>,
+    target_range: Range<usize>,
+    target_ptr: AtomicPtr<Chunk<A>>,
+}
+
+impl<'a, A> TreeFocusMut<'a, A>
+where
+    A: Clone + 'a,
+{
+    fn new(tree: &'a mut Rrb<A>) -> Self {
+        let middle_start = tree.outer_f.len() + tree.inner_f.len();
+        let middle_end = middle_start + tree.middle.len();
+        TreeFocusMut {
+            view: 0..tree.length,
+            tree: Lock::new(tree),
+            middle_range: middle_start..middle_end,
+            target_range: 0..0,
+            target_ptr: AtomicPtr::default(),
+        }
+    }
+
+    fn len(&self) -> usize {
+        self.view.end - self.view.start
+    }
+
+    fn narrow(self, mut view: Range<usize>) -> Self {
+        view.start += self.view.start;
+        view.end += self.view.start;
+        TreeFocusMut {
+            view,
+            middle_range: self.middle_range.clone(),
+            target_range: 0..0,
+            target_ptr: AtomicPtr::default(),
+            tree: self.tree,
+        }
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let len = self.len();
+        debug_assert!(index <= len);
+        #[allow(unsafe_code)]
+        let left = TreeFocusMut {
+            view: self.view.start..(self.view.start + index),
+            middle_range: self.middle_range.clone(),
+            target_range: 0..0,
+            target_ptr: AtomicPtr::default(),
+            tree: self.tree.clone(),
+        };
+        let right = TreeFocusMut {
+            view: (self.view.start + index)..(self.view.start + len),
+            middle_range: self.middle_range.clone(),
+            target_range: 0..0,
+            target_ptr: AtomicPtr::default(),
+            tree: self.tree,
+        };
+        (left, right)
+    }
+
+    fn physical_index(&self, index: usize) -> usize {
+        debug_assert!(index < self.view.end);
+        self.view.start + index
+    }
+
+    fn logical_range(&self, range: &Range<usize>) -> Range<usize> {
+        (range.start - self.view.start)..(range.end - self.view.start)
+    }
+
+    fn set_focus(&mut self, pool: &RRBPool<A>, index: usize) {
+        let mut tree = self
+            .tree
+            .lock()
+            .expect("im::vector::Focus::set_focus: unable to acquire exclusive lock on Vector");
+        if index < self.middle_range.start {
+            let outer_len = tree.outer_f.len();
+            if index < outer_len {
+                self.target_range = 0..outer_len;
+                self.target_ptr.store(
+                    PoolRef::make_mut(&pool.value_pool, &mut tree.outer_f),
+                    Ordering::Relaxed,
+                );
+            } else {
+                self.target_range = outer_len..self.middle_range.start;
+                self.target_ptr.store(
+                    PoolRef::make_mut(&pool.value_pool, &mut tree.inner_f),
+                    Ordering::Relaxed,
+                );
+            }
+        } else if index >= self.middle_range.end {
+            let outer_start = self.middle_range.end + tree.inner_b.len();
+            if index < outer_start {
+                self.target_range = self.middle_range.end..outer_start;
+                self.target_ptr.store(
+                    PoolRef::make_mut(&pool.value_pool, &mut tree.inner_b),
+                    Ordering::Relaxed,
+                );
+            } else {
+                self.target_range = outer_start..tree.length;
+                self.target_ptr.store(
+                    PoolRef::make_mut(&pool.value_pool, &mut tree.outer_b),
+                    Ordering::Relaxed,
+                );
+            }
+        } else {
+            let tree_index = index - self.middle_range.start;
+            let level = tree.middle_level;
+            let middle = Ref::make_mut(&mut tree.middle);
+            let (range, ptr) = middle.lookup_chunk_mut(pool, level, 0, tree_index);
+            self.target_range =
+                (range.start + self.middle_range.start)..(range.end + self.middle_range.start);
+            self.target_ptr.store(ptr, Ordering::Relaxed);
+        }
+    }
+
+    #[allow(unsafe_code)]
+    fn get_focus(&mut self) -> &mut Chunk<A> {
+        unsafe { &mut *self.target_ptr.load(Ordering::Relaxed) }
+    }
+
+    pub fn get(&mut self, pool: &RRBPool<A>, index: usize) -> Option<&mut A> {
+        if index >= self.len() {
+            return None;
+        }
+        let phys_index = self.physical_index(index);
+        if !contains(&self.target_range, &phys_index) {
+            self.set_focus(pool, phys_index);
+        }
+        let target_phys_index = phys_index - self.target_range.start;
+        Some(&mut self.get_focus()[target_phys_index])
+    }
+
+    pub fn get_chunk(&mut self, pool: &RRBPool<A>, index: usize) -> (Range<usize>, &mut [A]) {
+        let phys_index = self.physical_index(index);
+        if !contains(&self.target_range, &phys_index) {
+            self.set_focus(pool, phys_index);
+        }
+        let mut left = 0;
+        let mut right = 0;
+        if self.target_range.start < self.view.start {
+            left = self.view.start - self.target_range.start;
+        }
+        if self.target_range.end > self.view.end {
+            right = self.target_range.end - self.view.end;
+        }
+        let phys_range = (self.target_range.start + left)..(self.target_range.end - right);
+        let log_range = self.logical_range(&phys_range);
+        let slice_len = self.get_focus().len();
+        let slice = &mut (self.get_focus().as_mut_slice())[left..(slice_len - right)];
+        (log_range, slice)
+    }
+}
diff --git a/vendor/im-rc/src/vector/mod.rs b/vendor/im-rc/src/vector/mod.rs
new file mode 100644
index 000000000..a2ce0adf7
--- /dev/null
+++ b/vendor/im-rc/src/vector/mod.rs
@@ -0,0 +1,2745 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! A persistent vector.
+//!
+//! This is a sequence of elements in insertion order - if you need a
+//! list of things, any kind of list of things, this is what you're
+//! looking for.
+//!
+//! It's implemented as an [RRB vector][rrbpaper] with [smart
+//! head/tail chunking][chunkedseq]. In performance terms, this means
+//! that practically every operation is O(log n), except push/pop on
+//! both sides, which will be O(1) amortised, and O(log n) in the
+//! worst case. In practice, the push/pop operations will be
+//! blindingly fast, nearly on par with the native
+//! [`VecDeque`][VecDeque], and other operations will have decent, if
+//! not high, performance, but they all have more or less the same
+//! O(log n) complexity, so you don't need to keep their performance
+//! characteristics in mind - everything, even splitting and merging,
+//! is safe to use and never too slow.
+//!
+//! ## Performance Notes
+//!
+//! Because of the head/tail chunking technique, until you push a
+//! number of items above double the tree's branching factor (that's
+//! `self.len()` = 2 × *k* (where *k* = 64) = 128) on either side, the
+//! data structure is still just a handful of arrays, not yet an RRB
+//! tree, so you'll see performance and memory characteristics fairly
+//! close to [`Vec`][Vec] or [`VecDeque`][VecDeque].
+//!
+//! This means that the structure always preallocates four chunks of
+//! size *k* (*k* being the tree's branching factor), equivalent to a
+//! [`Vec`][Vec] with an initial capacity of 256. Beyond that, it will
+//! allocate tree nodes of capacity *k* as needed.
+//!
+//! In addition, vectors start out as single chunks, and only expand into the
+//! full data structure once you go past the chunk size. This makes them
+//! perform identically to [`Vec`][Vec] at small sizes.
+//!
+//! [rrbpaper]: https://infoscience.epfl.ch/record/213452/files/rrbvector.pdf
+//! [chunkedseq]: http://deepsea.inria.fr/pasl/chunkedseq.pdf
+//! [Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html
+//! [VecDeque]: https://doc.rust-lang.org/std/collections/struct.VecDeque.html
+
+use std::borrow::Borrow;
+use std::cmp::Ordering;
+use std::fmt::{Debug, Error, Formatter};
+use std::hash::{Hash, Hasher};
+use std::iter::Sum;
+use std::iter::{FromIterator, FusedIterator};
+use std::mem::{replace, swap};
+use std::ops::{Add, Index, IndexMut, RangeBounds};
+
+use sized_chunks::InlineArray;
+
+use crate::nodes::chunk::{Chunk, CHUNK_SIZE};
+use crate::nodes::rrb::{Node, PopResult, PushResult, SplitResult};
+use crate::sort;
+use crate::util::{clone_ref, swap_indices, to_range, Pool, PoolDefault, PoolRef, Ref, Side};
+
+use self::VectorInner::{Full, Inline, Single};
+
+mod focus;
+
+pub use self::focus::{Focus, FocusMut};
+
+mod pool;
+pub use self::pool::RRBPool;
+
+#[cfg(all(threadsafe, any(test, feature = "rayon")))]
+pub mod rayon;
+
+/// Construct a vector from a sequence of elements.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::vector::Vector;
+/// # fn main() {
+/// assert_eq!(
+///   vector![1, 2, 3],
+///   Vector::from(vec![1, 2, 3])
+/// );
+/// # }
+/// ```
+#[macro_export]
+macro_rules! vector {
+    () => { $crate::vector::Vector::new() };
+
+    ( $($x:expr),* ) => {{
+        let mut l = $crate::vector::Vector::new();
+        $(
+            l.push_back($x);
+        )*
+            l
+    }};
+
+    ( $($x:expr ,)* ) => {{
+        let mut l = $crate::vector::Vector::new();
+        $(
+            l.push_back($x);
+        )*
+            l
+    }};
+}
+
+/// A persistent vector.
+///
+/// This is a sequence of elements in insertion order - if you need a list of
+/// things, any kind of list of things, this is what you're looking for.
+///
+/// It's implemented as an [RRB vector][rrbpaper] with [smart head/tail
+/// chunking][chunkedseq]. In performance terms, this means that practically
+/// every operation is O(log n), except push/pop on both sides, which will be
+/// O(1) amortised, and O(log n) in the worst case. In practice, the push/pop
+/// operations will be blindingly fast, nearly on par with the native
+/// [`VecDeque`][VecDeque], and other operations will have decent, if not high,
+/// performance, but they all have more or less the same O(log n) complexity, so
+/// you don't need to keep their performance characteristics in mind -
+/// everything, even splitting and merging, is safe to use and never too slow.
+///
+/// ## Performance Notes
+///
+/// Because of the head/tail chunking technique, until you push a number of
+/// items above double the tree's branching factor (that's `self.len()` = 2 ×
+/// *k* (where *k* = 64) = 128) on either side, the data structure is still just
+/// a handful of arrays, not yet an RRB tree, so you'll see performance and
+/// memory characteristics similar to [`Vec`][Vec] or [`VecDeque`][VecDeque].
+///
+/// This means that the structure always preallocates four chunks of size *k*
+/// (*k* being the tree's branching factor), equivalent to a [`Vec`][Vec] with
+/// an initial capacity of 256. Beyond that, it will allocate tree nodes of
+/// capacity *k* as needed.
+///
+/// In addition, vectors start out as single chunks, and only expand into the
+/// full data structure once you go past the chunk size. This makes them
+/// perform identically to [`Vec`][Vec] at small sizes.
+///
+/// [rrbpaper]: https://infoscience.epfl.ch/record/213452/files/rrbvector.pdf
+/// [chunkedseq]: http://deepsea.inria.fr/pasl/chunkedseq.pdf
+/// [Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html
+/// [VecDeque]: https://doc.rust-lang.org/std/collections/struct.VecDeque.html
+pub struct Vector<A> {
+    vector: VectorInner<A>,
+}
+
+enum VectorInner<A> {
+    Inline(RRBPool<A>, InlineArray<A, Rrb<A>>),
+    Single(RRBPool<A>, PoolRef<Chunk<A>>),
+    Full(RRBPool<A>, Rrb<A>),
+}
+
+#[doc(hidden)]
+pub struct Rrb<A> {
+    length: usize,
+    middle_level: usize,
+    outer_f: PoolRef<Chunk<A>>,
+    inner_f: PoolRef<Chunk<A>>,
+    middle: Ref<Node<A>>,
+    inner_b: PoolRef<Chunk<A>>,
+    outer_b: PoolRef<Chunk<A>>,
+}
+
+impl<A> Clone for Rrb<A> {
+    fn clone(&self) -> Self {
+        Rrb {
+            length: self.length,
+            middle_level: self.middle_level,
+            outer_f: self.outer_f.clone(),
+            inner_f: self.inner_f.clone(),
+            middle: self.middle.clone(),
+            inner_b: self.inner_b.clone(),
+            outer_b: self.outer_b.clone(),
+        }
+    }
+}
+
+impl<A: Clone> Vector<A> {
+    /// Get a reference to the memory pool this `Vector` is using.
+    ///
+    /// Note that if you didn't specifically construct it with a pool, you'll
+    /// get back a reference to a pool of size 0.
+    #[cfg_attr(not(feature = "pool"), doc(hidden))]
+    pub fn pool(&self) -> &RRBPool<A> {
+        match self.vector {
+            Inline(ref pool, _) => pool,
+            Single(ref pool, _) => pool,
+            Full(ref pool, _) => pool,
+        }
+    }
+
+    /// True if a vector is a full inline or single chunk, ie. must be promoted
+    /// to grow further.
+    fn needs_promotion(&self) -> bool {
+        match &self.vector {
+            Inline(_, chunk) if chunk.is_full() => true,
+            Single(_, chunk) if chunk.is_full() => true,
+            _ => false,
+        }
+    }
+
+    /// Promote an inline to a single.
+    fn promote_inline(&mut self) {
+        if let Inline(pool, chunk) = &mut self.vector {
+            self.vector = Single(pool.clone(), PoolRef::new(&pool.value_pool, chunk.into()));
+        }
+    }
+
+    /// Promote a single to a full, with the single chunk becoming inner_f, or
+    /// promote an inline to a single.
+    fn promote_front(&mut self) {
+        self.vector = match &mut self.vector {
+            Inline(pool, chunk) => {
+                Single(pool.clone(), PoolRef::new(&pool.value_pool, chunk.into()))
+            }
+            Single(pool, chunk) => {
+                let chunk = chunk.clone();
+                Full(
+                    pool.clone(),
+                    Rrb {
+                        length: chunk.len(),
+                        middle_level: 0,
+                        outer_f: PoolRef::default(&pool.value_pool),
+                        inner_f: chunk,
+                        middle: Ref::new(Node::new()),
+                        inner_b: PoolRef::default(&pool.value_pool),
+                        outer_b: PoolRef::default(&pool.value_pool),
+                    },
+                )
+            }
+            Full(_, _) => return,
+        }
+    }
+
+    /// Promote a single to a full, with the single chunk becoming inner_b, or
+    /// promote an inline to a single.
+    fn promote_back(&mut self) {
+        self.vector = match &mut self.vector {
+            Inline(pool, chunk) => {
+                Single(pool.clone(), PoolRef::new(&pool.value_pool, chunk.into()))
+            }
+            Single(pool, chunk) => {
+                let chunk = chunk.clone();
+                Full(
+                    pool.clone(),
+                    Rrb {
+                        length: chunk.len(),
+                        middle_level: 0,
+                        outer_f: PoolRef::default(&pool.value_pool),
+                        inner_f: PoolRef::default(&pool.value_pool),
+                        middle: Ref::new(Node::new()),
+                        inner_b: chunk,
+                        outer_b: PoolRef::default(&pool.value_pool),
+                    },
+                )
+            }
+            Full(_, _) => return,
+        }
+    }
+
+    /// Construct an empty vector.
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            vector: Inline(RRBPool::default(), InlineArray::new()),
+        }
+    }
+
+    /// Construct an empty vector using a specific memory pool.
+    #[cfg(feature = "pool")]
+    #[must_use]
+    pub fn with_pool(pool: &RRBPool<A>) -> Self {
+        Self {
+            vector: Inline(pool.clone(), InlineArray::new()),
+        }
+    }
+
+    /// Get the length of a vector.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// assert_eq!(5, vector![1, 2, 3, 4, 5].len());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn len(&self) -> usize {
+        match &self.vector {
+            Inline(_, chunk) => chunk.len(),
+            Single(_, chunk) => chunk.len(),
+            Full(_, tree) => tree.length,
+        }
+    }
+
+    /// Test whether a vector is empty.
+    ///
+    /// Time: O(1)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let vec = vector!["Joe", "Mike", "Robert"];
+    /// assert_eq!(false, vec.is_empty());
+    /// assert_eq!(true, Vector::<i32>::new().is_empty());
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Test whether a vector is currently inlined.
+    ///
+    /// Vectors small enough that their contents could be stored entirely inside
+    /// the space of `std::mem::size_of::<Vector<A>>()` bytes are stored inline on
+    /// the stack instead of allocating any chunks. This method returns `true` if
+    /// this vector is currently inlined, or `false` if it currently has chunks allocated
+    /// on the heap.
+    ///
+    /// This may be useful in conjunction with [`ptr_eq()`][ptr_eq], which checks if
+    /// two vectors' heap allocations are the same, and thus will never return `true`
+    /// for inlined vectors.
+    ///
+    /// Time: O(1)
+    ///
+    /// [ptr_eq]: #method.ptr_eq
+    #[inline]
+    #[must_use]
+    pub fn is_inline(&self) -> bool {
+        matches!(&self.vector, Inline(_, _))
+    }
+
+    /// Test whether two vectors refer to the same content in memory.
+    ///
+    /// This uses the following rules to determine equality:
+    /// * If the two sides are references to the same vector, return true.
+    /// * If the two sides are single chunk vectors pointing to the same chunk, return true.
+    /// * If the two sides are full trees pointing to the same chunks, return true.
+    ///
+    /// This would return true if you're comparing a vector to itself, or
+    /// if you're comparing a vector to a fresh clone of itself. The exception to this is
+    /// if you've cloned an inline array (ie. an array with so few elements they can fit
+    /// inside the space a `Vector` allocates for its pointers, so there are no heap allocations
+    /// to compare).
+    ///
+    /// Time: O(1)
+    #[must_use]
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        fn cmp_chunk<A>(left: &PoolRef<Chunk<A>>, right: &PoolRef<Chunk<A>>) -> bool {
+            (left.is_empty() && right.is_empty()) || PoolRef::ptr_eq(left, right)
+        }
+
+        if std::ptr::eq(self, other) {
+            return true;
+        }
+
+        match (&self.vector, &other.vector) {
+            (Single(_, left), Single(_, right)) => cmp_chunk(left, right),
+            (Full(_, left), Full(_, right)) => {
+                cmp_chunk(&left.outer_f, &right.outer_f)
+                    && cmp_chunk(&left.inner_f, &right.inner_f)
+                    && cmp_chunk(&left.inner_b, &right.inner_b)
+                    && cmp_chunk(&left.outer_b, &right.outer_b)
+                    && ((left.middle.is_empty() && right.middle.is_empty())
+                        || Ref::ptr_eq(&left.middle, &right.middle))
+            }
+            _ => false,
+        }
+    }
+
+    /// Get an iterator over a vector.
+    ///
+    /// Time: O(1)
+    #[inline]
+    #[must_use]
+    pub fn iter(&self) -> Iter<'_, A> {
+        Iter::new(self)
+    }
+
+    /// Get a mutable iterator over a vector.
+    ///
+    /// Time: O(1)
+    #[inline]
+    #[must_use]
+    pub fn iter_mut(&mut self) -> IterMut<'_, A> {
+        IterMut::new(self)
+    }
+
+    /// Get an iterator over the leaf nodes of a vector.
+    ///
+    /// This returns an iterator over the [`Chunk`s][Chunk] at the leaves of the
+    /// RRB tree. These are useful for efficient parallelisation of work on
+    /// the vector, but should not be used for basic iteration.
+    ///
+    /// Time: O(1)
+    ///
+    /// [Chunk]: ../chunk/struct.Chunk.html
+    #[inline]
+    #[must_use]
+    pub fn leaves(&self) -> Chunks<'_, A> {
+        Chunks::new(self)
+    }
+
+    /// Get a mutable iterator over the leaf nodes of a vector.
+    //
+    /// This returns an iterator over the [`Chunk`s][Chunk] at the leaves of the
+    /// RRB tree. These are useful for efficient parallelisation of work on
+    /// the vector, but should not be used for basic iteration.
+    ///
+    /// Time: O(1)
+    ///
+    /// [Chunk]: ../chunk/struct.Chunk.html
+    #[inline]
+    #[must_use]
+    pub fn leaves_mut(&mut self) -> ChunksMut<'_, A> {
+        ChunksMut::new(self)
+    }
+
+    /// Construct a [`Focus`][Focus] for a vector.
+    ///
+    /// Time: O(1)
+    ///
+    /// [Focus]: enum.Focus.html
+    #[inline]
+    #[must_use]
+    pub fn focus(&self) -> Focus<'_, A> {
+        Focus::new(self)
+    }
+
+    /// Construct a [`FocusMut`][FocusMut] for a vector.
+    ///
+    /// Time: O(1)
+    ///
+    /// [FocusMut]: enum.FocusMut.html
+    #[inline]
+    #[must_use]
+    pub fn focus_mut(&mut self) -> FocusMut<'_, A> {
+        FocusMut::new(self)
+    }
+
+    /// Get a reference to the value at index `index` in a vector.
+    ///
+    /// Returns `None` if the index is out of bounds.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let vec = vector!["Joe", "Mike", "Robert"];
+    /// assert_eq!(Some(&"Robert"), vec.get(2));
+    /// assert_eq!(None, vec.get(5));
+    /// ```
+    #[must_use]
+    pub fn get(&self, index: usize) -> Option<&A> {
+        if index >= self.len() {
+            return None;
+        }
+
+        match &self.vector {
+            Inline(_, chunk) => chunk.get(index),
+            Single(_, chunk) => chunk.get(index),
+            Full(_, tree) => {
+                let mut local_index = index;
+
+                if local_index < tree.outer_f.len() {
+                    return Some(&tree.outer_f[local_index]);
+                }
+                local_index -= tree.outer_f.len();
+
+                if local_index < tree.inner_f.len() {
+                    return Some(&tree.inner_f[local_index]);
+                }
+                local_index -= tree.inner_f.len();
+
+                if local_index < tree.middle.len() {
+                    return Some(tree.middle.index(tree.middle_level, local_index));
+                }
+                local_index -= tree.middle.len();
+
+                if local_index < tree.inner_b.len() {
+                    return Some(&tree.inner_b[local_index]);
+                }
+                local_index -= tree.inner_b.len();
+
+                Some(&tree.outer_b[local_index])
+            }
+        }
+    }
+
+    /// Get a mutable reference to the value at index `index` in a
+    /// vector.
+    ///
+    /// Returns `None` if the index is out of bounds.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let mut vec = vector!["Joe", "Mike", "Robert"];
+    /// {
+    ///     let robert = vec.get_mut(2).unwrap();
+    ///     assert_eq!(&mut "Robert", robert);
+    ///     *robert = "Bjarne";
+    /// }
+    /// assert_eq!(vector!["Joe", "Mike", "Bjarne"], vec);
+    /// ```
+    #[must_use]
+    pub fn get_mut(&mut self, index: usize) -> Option<&mut A> {
+        if index >= self.len() {
+            return None;
+        }
+
+        match &mut self.vector {
+            Inline(_, chunk) => chunk.get_mut(index),
+            Single(pool, chunk) => PoolRef::make_mut(&pool.value_pool, chunk).get_mut(index),
+            Full(pool, tree) => {
+                let mut local_index = index;
+
+                if local_index < tree.outer_f.len() {
+                    let outer_f = PoolRef::make_mut(&pool.value_pool, &mut tree.outer_f);
+                    return Some(&mut outer_f[local_index]);
+                }
+                local_index -= tree.outer_f.len();
+
+                if local_index < tree.inner_f.len() {
+                    let inner_f = PoolRef::make_mut(&pool.value_pool, &mut tree.inner_f);
+                    return Some(&mut inner_f[local_index]);
+                }
+                local_index -= tree.inner_f.len();
+
+                if local_index < tree.middle.len() {
+                    let middle = Ref::make_mut(&mut tree.middle);
+                    return Some(middle.index_mut(pool, tree.middle_level, local_index));
+                }
+                local_index -= tree.middle.len();
+
+                if local_index < tree.inner_b.len() {
+                    let inner_b = PoolRef::make_mut(&pool.value_pool, &mut tree.inner_b);
+                    return Some(&mut inner_b[local_index]);
+                }
+                local_index -= tree.inner_b.len();
+
+                let outer_b = PoolRef::make_mut(&pool.value_pool, &mut tree.outer_b);
+                Some(&mut outer_b[local_index])
+            }
+        }
+    }
+
+    /// Get the first element of a vector.
+    ///
+    /// If the vector is empty, `None` is returned.
+    ///
+    /// Time: O(log n)
+    #[inline]
+    #[must_use]
+    pub fn front(&self) -> Option<&A> {
+        self.get(0)
+    }
+
+    /// Get a mutable reference to the first element of a vector.
+    ///
+    /// If the vector is empty, `None` is returned.
+    ///
+    /// Time: O(log n)
+    #[inline]
+    #[must_use]
+    pub fn front_mut(&mut self) -> Option<&mut A> {
+        self.get_mut(0)
+    }
+
+    /// Get the first element of a vector.
+    ///
+    /// If the vector is empty, `None` is returned.
+    ///
+    /// This is an alias for the [`front`][front] method.
+    ///
+    /// Time: O(log n)
+    ///
+    /// [front]: #method.front
+    #[inline]
+    #[must_use]
+    pub fn head(&self) -> Option<&A> {
+        self.get(0)
+    }
+
+    /// Get the last element of a vector.
+    ///
+    /// If the vector is empty, `None` is returned.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn back(&self) -> Option<&A> {
+        if self.is_empty() {
+            None
+        } else {
+            self.get(self.len() - 1)
+        }
+    }
+
+    /// Get a mutable reference to the last element of a vector.
+    ///
+    /// If the vector is empty, `None` is returned.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn back_mut(&mut self) -> Option<&mut A> {
+        if self.is_empty() {
+            None
+        } else {
+            let len = self.len();
+            self.get_mut(len - 1)
+        }
+    }
+
+    /// Get the last element of a vector.
+    ///
+    /// If the vector is empty, `None` is returned.
+    ///
+    /// This is an alias for the [`back`][back] method.
+    ///
+    /// Time: O(log n)
+    ///
+    /// [back]: #method.back
+    #[inline]
+    #[must_use]
+    pub fn last(&self) -> Option<&A> {
+        self.back()
+    }
+
+    /// Get the index of a given element in the vector.
+    ///
+    /// Searches the vector for the first occurrence of a given value,
+    /// and returns the index of the value if it's there. Otherwise,
+    /// it returns `None`.
+    ///
+    /// Time: O(n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let mut vec = vector![1, 2, 3, 4, 5];
+    /// assert_eq!(Some(2), vec.index_of(&3));
+    /// assert_eq!(None, vec.index_of(&31337));
+    /// ```
+    #[must_use]
+    pub fn index_of(&self, value: &A) -> Option<usize>
+    where
+        A: PartialEq,
+    {
+        for (index, item) in self.iter().enumerate() {
+            if value == item {
+                return Some(index);
+            }
+        }
+        None
+    }
+
+    /// Test if a given element is in the vector.
+    ///
+    /// Searches the vector for the first occurrence of a given value,
+    /// and returns `true` if it's there. If it's nowhere to be found
+    /// in the vector, it returns `false`.
+    ///
+    /// Time: O(n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let mut vec = vector![1, 2, 3, 4, 5];
+    /// assert_eq!(true, vec.contains(&3));
+    /// assert_eq!(false, vec.contains(&31337));
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn contains(&self, value: &A) -> bool
+    where
+        A: PartialEq,
+    {
+        self.index_of(value).is_some()
+    }
+
+    /// Discard all elements from the vector.
+    ///
+    /// This leaves you with an empty vector, and all elements that
+    /// were previously inside it are dropped.
+    ///
+    /// Time: O(n)
+    pub fn clear(&mut self) {
+        if !self.is_empty() {
+            self.vector = Inline(self.pool().clone(), InlineArray::new());
+        }
+    }
+
+    /// Binary search a sorted vector for a given element using a comparator
+    /// function.
+    ///
+    /// Assumes the vector has already been sorted using the same comparator
+    /// function, eg. by using [`sort_by`][sort_by].
+    ///
+    /// If the value is found, it returns `Ok(index)` where `index` is the index
+    /// of the element. If the value isn't found, it returns `Err(index)` where
+    /// `index` is the index at which the element would need to be inserted to
+    /// maintain sorted order.
+    ///
+    /// Time: O(log n)
+    ///
+    /// [sort_by]: #method.sort_by
+    pub fn binary_search_by<F>(&self, mut f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&A) -> Ordering,
+    {
+        let mut size = self.len();
+        if size == 0 {
+            return Err(0);
+        }
+        let mut base = 0;
+        while size > 1 {
+            let half = size / 2;
+            let mid = base + half;
+            base = match f(&self[mid]) {
+                Ordering::Greater => base,
+                _ => mid,
+            };
+            size -= half;
+        }
+        match f(&self[base]) {
+            Ordering::Equal => Ok(base),
+            Ordering::Greater => Err(base),
+            Ordering::Less => Err(base + 1),
+        }
+    }
+
+    /// Binary search a sorted vector for a given element.
+    ///
+    /// If the value is found, it returns `Ok(index)` where `index` is the index
+    /// of the element. If the value isn't found, it returns `Err(index)` where
+    /// `index` is the index at which the element would need to be inserted to
+    /// maintain sorted order.
+    ///
+    /// Time: O(log n)
+    pub fn binary_search(&self, value: &A) -> Result<usize, usize>
+    where
+        A: Ord,
+    {
+        self.binary_search_by(|e| e.cmp(value))
+    }
+
+    /// Binary search a sorted vector for a given element with a key extract
+    /// function.
+    ///
+    /// Assumes the vector has already been sorted using the same key extract
+    /// function, eg. by using [`sort_by_key`][sort_by_key].
+    ///
+    /// If the value is found, it returns `Ok(index)` where `index` is the index
+    /// of the element. If the value isn't found, it returns `Err(index)` where
+    /// `index` is the index at which the element would need to be inserted to
+    /// maintain sorted order.
+    ///
+    /// Time: O(log n)
+    ///
+    /// [sort_by_key]: #method.sort_by_key
+    pub fn binary_search_by_key<B, F>(&self, b: &B, mut f: F) -> Result<usize, usize>
+    where
+        F: FnMut(&A) -> B,
+        B: Ord,
+    {
+        self.binary_search_by(|k| f(k).cmp(b))
+    }
+}
+
+impl<A: Clone> Vector<A> {
+    /// Construct a vector with a single value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// let vec = Vector::unit(1337);
+    /// assert_eq!(1, vec.len());
+    /// assert_eq!(
+    ///   vec.get(0),
+    ///   Some(&1337)
+    /// );
+    /// ```
+    #[inline]
+    #[must_use]
+    pub fn unit(a: A) -> Self {
+        let pool = RRBPool::default();
+        if InlineArray::<A, Rrb<A>>::CAPACITY > 0 {
+            let mut array = InlineArray::new();
+            array.push(a);
+            Self {
+                vector: Inline(pool, array),
+            }
+        } else {
+            let chunk = PoolRef::new(&pool.value_pool, Chunk::unit(a));
+            Self {
+                vector: Single(pool, chunk),
+            }
+        }
+    }
+
+    /// Create a new vector with the value at index `index` updated.
+    ///
+    /// Panics if the index is out of bounds.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let mut vec = vector![1, 2, 3];
+    /// assert_eq!(vector![1, 5, 3], vec.update(1, 5));
+    /// ```
+    #[must_use]
+    pub fn update(&self, index: usize, value: A) -> Self {
+        let mut out = self.clone();
+        out[index] = value;
+        out
+    }
+
+    /// Update the value at index `index` in a vector.
+    ///
+    /// Returns the previous value at the index.
+    ///
+    /// Panics if the index is out of bounds.
+    ///
+    /// Time: O(log n)
+    #[inline]
+    pub fn set(&mut self, index: usize, value: A) -> A {
+        replace(&mut self[index], value)
+    }
+
+    /// Swap the elements at indices `i` and `j`.
+    ///
+    /// Time: O(log n)
+    pub fn swap(&mut self, i: usize, j: usize) {
+        swap_indices(self, i, j)
+    }
+
+    /// Push a value to the front of a vector.
+    ///
+    /// Time: O(1)*
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let mut vec = vector![5, 6, 7];
+    /// vec.push_front(4);
+    /// assert_eq!(vector![4, 5, 6, 7], vec);
+    /// ```
+    pub fn push_front(&mut self, value: A) {
+        if self.needs_promotion() {
+            self.promote_back();
+        }
+        match &mut self.vector {
+            Inline(_, chunk) => {
+                chunk.insert(0, value);
+            }
+            Single(pool, chunk) => PoolRef::make_mut(&pool.value_pool, chunk).push_front(value),
+            Full(pool, tree) => tree.push_front(pool, value),
+        }
+    }
+
+    /// Push a value to the back of a vector.
+    ///
+    /// Time: O(1)*
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let mut vec = vector![1, 2, 3];
+    /// vec.push_back(4);
+    /// assert_eq!(vector![1, 2, 3, 4], vec);
+    /// ```
+    pub fn push_back(&mut self, value: A) {
+        if self.needs_promotion() {
+            self.promote_front();
+        }
+        match &mut self.vector {
+            Inline(_, chunk) => {
+                chunk.push(value);
+            }
+            Single(pool, chunk) => PoolRef::make_mut(&pool.value_pool, chunk).push_back(value),
+            Full(pool, tree) => tree.push_back(pool, value),
+        }
+    }
+
+    /// Remove the first element from a vector and return it.
+    ///
+    /// Time: O(1)*
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let mut vec = vector![1, 2, 3];
+    /// assert_eq!(Some(1), vec.pop_front());
+    /// assert_eq!(vector![2, 3], vec);
+    /// ```
+    pub fn pop_front(&mut self) -> Option<A> {
+        if self.is_empty() {
+            None
+        } else {
+            match &mut self.vector {
+                Inline(_, chunk) => chunk.remove(0),
+                Single(pool, chunk) => Some(PoolRef::make_mut(&pool.value_pool, chunk).pop_front()),
+                Full(pool, tree) => tree.pop_front(pool),
+            }
+        }
+    }
+
+    /// Remove the last element from a vector and return it.
+    ///
+    /// Time: O(1)*
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::Vector;
+    /// let mut vec = vector![1, 2, 3];
+    /// assert_eq!(Some(3), vec.pop_back());
+    /// assert_eq!(vector![1, 2], vec);
+    /// ```
+    pub fn pop_back(&mut self) -> Option<A> {
+        if self.is_empty() {
+            None
+        } else {
+            match &mut self.vector {
+                Inline(_, chunk) => chunk.pop(),
+                Single(pool, chunk) => Some(PoolRef::make_mut(&pool.value_pool, chunk).pop_back()),
+                Full(pool, tree) => tree.pop_back(pool),
+            }
+        }
+    }
+
+    /// Append the vector `other` to the end of the current vector.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// let mut vec = vector![1, 2, 3];
+    /// vec.append(vector![7, 8, 9]);
+    /// assert_eq!(vector![1, 2, 3, 7, 8, 9], vec);
+    /// ```
+    pub fn append(&mut self, mut other: Self) {
+        if other.is_empty() {
+            return;
+        }
+
+        if self.is_empty() {
+            *self = other;
+            return;
+        }
+
+        self.promote_inline();
+        other.promote_inline();
+
+        let total_length = self
+            .len()
+            .checked_add(other.len())
+            .expect("Vector length overflow");
+
+        match &mut self.vector {
+            Inline(_, _) => unreachable!("inline vecs should have been promoted"),
+            Single(pool, left) => {
+                match &mut other.vector {
+                    Inline(_, _) => unreachable!("inline vecs should have been promoted"),
+                    // If both are single chunks and left has room for right: directly
+                    // memcpy right into left
+                    Single(_, ref mut right) if total_length <= CHUNK_SIZE => {
+                        PoolRef::make_mut(&pool.value_pool, left)
+                            .append(PoolRef::make_mut(&pool.value_pool, right));
+                        return;
+                    }
+                    // If only left is a single chunk and has room for right: push
+                    // right's elements into left
+                    _ if total_length <= CHUNK_SIZE => {
+                        while let Some(value) = other.pop_front() {
+                            PoolRef::make_mut(&pool.value_pool, left).push_back(value);
+                        }
+                        return;
+                    }
+                    _ => {}
+                }
+            }
+            Full(pool, left) => {
+                if let Full(_, mut right) = other.vector {
+                    // If left and right are trees with empty middles, left has no back
+                    // buffers, and right has no front buffers: copy right's back
+                    // buffers over to left
+                    if left.middle.is_empty()
+                        && right.middle.is_empty()
+                        && left.outer_b.is_empty()
+                        && left.inner_b.is_empty()
+                        && right.outer_f.is_empty()
+                        && right.inner_f.is_empty()
+                    {
+                        left.inner_b = right.inner_b;
+                        left.outer_b = right.outer_b;
+                        left.length = total_length;
+                        return;
+                    }
+                    // If left and right are trees with empty middles and left's buffers
+                    // can fit right's buffers: push right's elements onto left
+                    if left.middle.is_empty()
+                        && right.middle.is_empty()
+                        && total_length <= CHUNK_SIZE * 4
+                    {
+                        while let Some(value) = right.pop_front(pool) {
+                            left.push_back(pool, value);
+                        }
+                        return;
+                    }
+                    // Both are full and big: do the full RRB join
+                    let inner_b1 = left.inner_b.clone();
+                    left.push_middle(pool, Side::Right, inner_b1);
+                    let outer_b1 = left.outer_b.clone();
+                    left.push_middle(pool, Side::Right, outer_b1);
+                    let inner_f2 = right.inner_f.clone();
+                    right.push_middle(pool, Side::Left, inner_f2);
+                    let outer_f2 = right.outer_f.clone();
+                    right.push_middle(pool, Side::Left, outer_f2);
+
+                    let mut middle1 = clone_ref(replace(&mut left.middle, Ref::from(Node::new())));
+                    let mut middle2 = clone_ref(right.middle);
+                    let normalised_middle = match left.middle_level.cmp(&right.middle_level) {
+                        Ordering::Greater => {
+                            middle2 = middle2.elevate(pool, left.middle_level - right.middle_level);
+                            left.middle_level
+                        }
+                        Ordering::Less => {
+                            middle1 = middle1.elevate(pool, right.middle_level - left.middle_level);
+                            right.middle_level
+                        }
+                        Ordering::Equal => left.middle_level,
+                    };
+                    left.middle = Ref::new(Node::merge(pool, middle1, middle2, normalised_middle));
+                    left.middle_level = normalised_middle + 1;
+
+                    left.inner_b = right.inner_b;
+                    left.outer_b = right.outer_b;
+                    left.length = total_length;
+                    left.prune();
+                    return;
+                }
+            }
+        }
+        // No optimisations available, and either left, right or both are
+        // single: promote both to full and retry
+        self.promote_front();
+        other.promote_back();
+        self.append(other)
+    }
+
+    /// Retain only the elements specified by the predicate.
+    ///
+    /// Remove all elements for which the provided function `f`
+    /// returns false from the vector.
+    ///
+    /// Time: O(n)
+    pub fn retain<F>(&mut self, mut f: F)
+    where
+        F: FnMut(&A) -> bool,
+    {
+        let len = self.len();
+        let mut del = 0;
+        {
+            let mut focus = self.focus_mut();
+            for i in 0..len {
+                if !f(focus.index(i)) {
+                    del += 1;
+                } else if del > 0 {
+                    focus.swap(i - del, i);
+                }
+            }
+        }
+        if del > 0 {
+            self.split_off(len - del);
+        }
+    }
+
+    /// Split a vector at a given index.
+    ///
+    /// Split a vector at a given index, consuming the vector and
+    /// returning a pair of the left hand side and the right hand side
+    /// of the split.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// let mut vec = vector![1, 2, 3, 7, 8, 9];
+    /// let (left, right) = vec.split_at(3);
+    /// assert_eq!(vector![1, 2, 3], left);
+    /// assert_eq!(vector![7, 8, 9], right);
+    /// ```
+    pub fn split_at(mut self, index: usize) -> (Self, Self) {
+        let right = self.split_off(index);
+        (self, right)
+    }
+
+    /// Split a vector at a given index.
+    ///
+    /// Split a vector at a given index, leaving the left hand side in
+    /// the current vector and returning a new vector containing the
+    /// right hand side.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// let mut left = vector![1, 2, 3, 7, 8, 9];
+    /// let right = left.split_off(3);
+    /// assert_eq!(vector![1, 2, 3], left);
+    /// assert_eq!(vector![7, 8, 9], right);
+    /// ```
+    pub fn split_off(&mut self, index: usize) -> Self {
+        assert!(index <= self.len());
+
+        match &mut self.vector {
+            Inline(pool, chunk) => Self {
+                vector: Inline(pool.clone(), chunk.split_off(index)),
+            },
+            Single(pool, chunk) => Self {
+                vector: Single(
+                    pool.clone(),
+                    PoolRef::new(
+                        &pool.value_pool,
+                        PoolRef::make_mut(&pool.value_pool, chunk).split_off(index),
+                    ),
+                ),
+            },
+            Full(pool, tree) => {
+                let mut local_index = index;
+
+                if local_index < tree.outer_f.len() {
+                    let of2 = PoolRef::make_mut(&pool.value_pool, &mut tree.outer_f)
+                        .split_off(local_index);
+                    let right = Rrb {
+                        length: tree.length - index,
+                        middle_level: tree.middle_level,
+                        outer_f: PoolRef::new(&pool.value_pool, of2),
+                        inner_f: replace_pool_def(&pool.value_pool, &mut tree.inner_f),
+                        middle: std::mem::take(&mut tree.middle),
+                        inner_b: replace_pool_def(&pool.value_pool, &mut tree.inner_b),
+                        outer_b: replace_pool_def(&pool.value_pool, &mut tree.outer_b),
+                    };
+                    tree.length = index;
+                    tree.middle_level = 0;
+                    return Self {
+                        vector: Full(pool.clone(), right),
+                    };
+                }
+
+                local_index -= tree.outer_f.len();
+
+                if local_index < tree.inner_f.len() {
+                    let if2 = PoolRef::make_mut(&pool.value_pool, &mut tree.inner_f)
+                        .split_off(local_index);
+                    let right = Rrb {
+                        length: tree.length - index,
+                        middle_level: tree.middle_level,
+                        outer_f: PoolRef::new(&pool.value_pool, if2),
+                        inner_f: PoolRef::<Chunk<A>>::default(&pool.value_pool),
+                        middle: std::mem::take(&mut tree.middle),
+                        inner_b: replace_pool_def(&pool.value_pool, &mut tree.inner_b),
+                        outer_b: replace_pool_def(&pool.value_pool, &mut tree.outer_b),
+                    };
+                    tree.length = index;
+                    tree.middle_level = 0;
+                    swap(&mut tree.outer_b, &mut tree.inner_f);
+                    return Self {
+                        vector: Full(pool.clone(), right),
+                    };
+                }
+
+                local_index -= tree.inner_f.len();
+
+                if local_index < tree.middle.len() {
+                    let mut right_middle = tree.middle.clone();
+                    let (c1, c2) = {
+                        let m1 = Ref::make_mut(&mut tree.middle);
+                        let m2 = Ref::make_mut(&mut right_middle);
+                        match m1.split(pool, tree.middle_level, Side::Right, local_index) {
+                            SplitResult::Dropped(_) => (),
+                            SplitResult::OutOfBounds => unreachable!(),
+                        };
+                        match m2.split(pool, tree.middle_level, Side::Left, local_index) {
+                            SplitResult::Dropped(_) => (),
+                            SplitResult::OutOfBounds => unreachable!(),
+                        };
+                        let c1 = match m1.pop_chunk(pool, tree.middle_level, Side::Right) {
+                            PopResult::Empty => PoolRef::default(&pool.value_pool),
+                            PopResult::Done(chunk) => chunk,
+                            PopResult::Drained(chunk) => {
+                                m1.clear_node();
+                                chunk
+                            }
+                        };
+                        let c2 = match m2.pop_chunk(pool, tree.middle_level, Side::Left) {
+                            PopResult::Empty => PoolRef::default(&pool.value_pool),
+                            PopResult::Done(chunk) => chunk,
+                            PopResult::Drained(chunk) => {
+                                m2.clear_node();
+                                chunk
+                            }
+                        };
+                        (c1, c2)
+                    };
+                    let mut right = Rrb {
+                        length: tree.length - index,
+                        middle_level: tree.middle_level,
+                        outer_f: c2,
+                        inner_f: PoolRef::<Chunk<A>>::default(&pool.value_pool),
+                        middle: right_middle,
+                        inner_b: replace_pool_def(&pool.value_pool, &mut tree.inner_b),
+                        outer_b: replace(&mut tree.outer_b, c1),
+                    };
+                    tree.length = index;
+                    tree.prune();
+                    right.prune();
+                    return Self {
+                        vector: Full(pool.clone(), right),
+                    };
+                }
+
+                local_index -= tree.middle.len();
+
+                if local_index < tree.inner_b.len() {
+                    let ib2 = PoolRef::make_mut(&pool.value_pool, &mut tree.inner_b)
+                        .split_off(local_index);
+                    let right = Rrb {
+                        length: tree.length - index,
+                        outer_b: replace_pool_def(&pool.value_pool, &mut tree.outer_b),
+                        outer_f: PoolRef::new(&pool.value_pool, ib2),
+                        ..Rrb::new(pool)
+                    };
+                    tree.length = index;
+                    swap(&mut tree.outer_b, &mut tree.inner_b);
+                    return Self {
+                        vector: Full(pool.clone(), right),
+                    };
+                }
+
+                local_index -= tree.inner_b.len();
+
+                let ob2 =
+                    PoolRef::make_mut(&pool.value_pool, &mut tree.outer_b).split_off(local_index);
+                tree.length = index;
+                Self {
+                    vector: Single(pool.clone(), PoolRef::new(&pool.value_pool, ob2)),
+                }
+            }
+        }
+    }
+
+    /// Construct a vector with `count` elements removed from the
+    /// start of the current vector.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn skip(&self, count: usize) -> Self {
+        // FIXME can be made more efficient by dropping the unwanted side without constructing it
+        self.clone().split_off(count)
+    }
+
+    /// Construct a vector of the first `count` elements from the
+    /// current vector.
+    ///
+    /// Time: O(log n)
+    #[must_use]
+    pub fn take(&self, count: usize) -> Self {
+        // FIXME can be made more efficient by dropping the unwanted side without constructing it
+        let mut left = self.clone();
+        left.split_off(count);
+        left
+    }
+
+    /// Truncate a vector to the given size.
+    ///
+    /// Discards all elements in the vector beyond the given length.
+    ///
+    /// Panics if the new length is greater than the current length.
+    ///
+    /// Time: O(log n)
+    pub fn truncate(&mut self, len: usize) {
+        // FIXME can be made more efficient by dropping the unwanted side without constructing it
+        self.split_off(len);
+    }
+
+    /// Extract a slice from a vector.
+    ///
+    /// Remove the elements from `start_index` until `end_index` in
+    /// the current vector and return the removed slice as a new
+    /// vector.
+    ///
+    /// Time: O(log n)
+    pub fn slice<R>(&mut self, range: R) -> Self
+    where
+        R: RangeBounds<usize>,
+    {
+        let r = to_range(&range, self.len());
+        if r.start >= r.end || r.start >= self.len() {
+            return Vector::new();
+        }
+        let mut middle = self.split_off(r.start);
+        let right = middle.split_off(r.end - r.start);
+        self.append(right);
+        middle
+    }
+
+    /// Insert an element into a vector.
+    ///
+    /// Insert an element at position `index`, shifting all elements
+    /// after it to the right.
+    ///
+    /// ## Performance Note
+    ///
+    /// While `push_front` and `push_back` are heavily optimised
+    /// operations, `insert` in the middle of a vector requires a
+    /// split, a push, and an append. Thus, if you want to insert
+    /// many elements at the same location, instead of `insert`ing
+    /// them one by one, you should rather create a new vector
+    /// containing the elements to insert, split the vector at the
+    /// insertion point, and append the left hand, the new vector and
+    /// the right hand in order.
+    ///
+    /// Time: O(log n)
+    pub fn insert(&mut self, index: usize, value: A) {
+        if index == 0 {
+            return self.push_front(value);
+        }
+        if index == self.len() {
+            return self.push_back(value);
+        }
+        assert!(index < self.len());
+        if if let Inline(_, chunk) = &self.vector {
+            chunk.is_full()
+        } else {
+            false
+        } {
+            self.promote_inline();
+        }
+        match &mut self.vector {
+            Inline(_, chunk) => {
+                chunk.insert(index, value);
+            }
+            Single(pool, chunk) if chunk.len() < CHUNK_SIZE => {
+                PoolRef::make_mut(&pool.value_pool, chunk).insert(index, value)
+            }
+            // TODO a lot of optimisations still possible here
+            _ => {
+                let right = self.split_off(index);
+                self.push_back(value);
+                self.append(right);
+            }
+        }
+    }
+
+    /// Remove an element from a vector.
+    ///
+    /// Remove the element from position 'index', shifting all
+    /// elements after it to the left, and return the removed element.
+    ///
+    /// ## Performance Note
+    ///
+    /// While `pop_front` and `pop_back` are heavily optimised
+    /// operations, `remove` in the middle of a vector requires a
+    /// split, a pop, and an append. Thus, if you want to remove many
+    /// elements from the same location, instead of `remove`ing them
+    /// one by one, it is much better to use [`slice`][slice].
+    ///
+    /// Time: O(log n)
+    ///
+    /// [slice]: #method.slice
+    pub fn remove(&mut self, index: usize) -> A {
+        assert!(index < self.len());
+        match &mut self.vector {
+            Inline(_, chunk) => chunk.remove(index).unwrap(),
+            Single(pool, chunk) => PoolRef::make_mut(&pool.value_pool, chunk).remove(index),
+            _ => {
+                if index == 0 {
+                    return self.pop_front().unwrap();
+                }
+                if index == self.len() - 1 {
+                    return self.pop_back().unwrap();
+                }
+                // TODO a lot of optimisations still possible here
+                let mut right = self.split_off(index);
+                let value = right.pop_front().unwrap();
+                self.append(right);
+                value
+            }
+        }
+    }
+
+    /// Insert an element into a sorted vector.
+    ///
+    /// Insert an element into a vector in sorted order, assuming the vector is
+    /// already in sorted order.
+    ///
+    /// Time: O(log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// let mut vec = vector![1, 2, 3, 7, 8, 9];
+    /// vec.insert_ord(5);
+    /// assert_eq!(vector![1, 2, 3, 5, 7, 8, 9], vec);
+    /// ```
+    pub fn insert_ord(&mut self, item: A)
+    where
+        A: Ord,
+    {
+        match self.binary_search(&item) {
+            Ok(index) => self.insert(index, item),
+            Err(index) => self.insert(index, item),
+        }
+    }
+
+    /// Sort a vector.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// let mut vec = vector![3, 2, 5, 4, 1];
+    /// vec.sort();
+    /// assert_eq!(vector![1, 2, 3, 4, 5], vec);
+    /// ```
+    pub fn sort(&mut self)
+    where
+        A: Ord,
+    {
+        self.sort_by(Ord::cmp)
+    }
+
+    /// Sort a vector using a comparator function.
+    ///
+    /// Time: O(n log n)
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[macro_use] extern crate im_rc as im;
+    /// # use im::vector::Vector;
+    /// let mut vec = vector![3, 2, 5, 4, 1];
+    /// vec.sort_by(|left, right| left.cmp(right));
+    /// assert_eq!(vector![1, 2, 3, 4, 5], vec);
+    /// ```
+    pub fn sort_by<F>(&mut self, cmp: F)
+    where
+        F: Fn(&A, &A) -> Ordering,
+    {
+        let len = self.len();
+        if len > 1 {
+            sort::quicksort(self.focus_mut(), &cmp);
+        }
+    }
+
+    /// Verify the internal consistency of a vector.
+    ///
+    /// This method walks the RRB tree making up the current `Vector`
+    /// (if it has one) and verifies that all the invariants hold.
+    /// If something is wrong, it will panic.
+    ///
+    /// This method requires the `debug` feature flag.
+    #[cfg(any(test, feature = "debug"))]
+    pub fn assert_invariants(&self) {
+        if let Full(_, ref tree) = self.vector {
+            tree.assert_invariants();
+        }
+    }
+}
+
+// Implementation details
+
+impl<A: Clone> Rrb<A> {
+    fn new(pool: &RRBPool<A>) -> Self {
+        Rrb {
+            length: 0,
+            middle_level: 0,
+            outer_f: PoolRef::default(&pool.value_pool),
+            inner_f: PoolRef::default(&pool.value_pool),
+            middle: Ref::new(Node::new()),
+            inner_b: PoolRef::default(&pool.value_pool),
+            outer_b: PoolRef::default(&pool.value_pool),
+        }
+    }
+
+    #[cfg(any(test, feature = "debug"))]
+    fn assert_invariants(&self) {
+        let ml = self.middle.assert_invariants(self.middle_level);
+        assert_eq!(
+            self.length,
+            self.outer_f.len() + self.inner_f.len() + ml + self.inner_b.len() + self.outer_b.len()
+        );
+    }
+
+    fn prune(&mut self) {
+        if self.middle.is_empty() {
+            self.middle = Ref::new(Node::new());
+            self.middle_level = 0;
+        } else {
+            while self.middle_level > 0 && self.middle.is_single() {
+                // FIXME could be optimised, cloning the node is expensive
+                self.middle = Ref::new(self.middle.first_child().clone());
+                self.middle_level -= 1;
+            }
+        }
+    }
+
+    fn pop_front(&mut self, pool: &RRBPool<A>) -> Option<A> {
+        if self.length == 0 {
+            return None;
+        }
+        if self.outer_f.is_empty() {
+            if self.inner_f.is_empty() {
+                if self.middle.is_empty() {
+                    if self.inner_b.is_empty() {
+                        swap(&mut self.outer_f, &mut self.outer_b);
+                    } else {
+                        swap(&mut self.outer_f, &mut self.inner_b);
+                    }
+                } else {
+                    self.outer_f = self.pop_middle(pool, Side::Left).unwrap();
+                }
+            } else {
+                swap(&mut self.outer_f, &mut self.inner_f);
+            }
+        }
+        self.length -= 1;
+        let outer_f = PoolRef::make_mut(&pool.value_pool, &mut self.outer_f);
+        Some(outer_f.pop_front())
+    }
+
+    fn pop_back(&mut self, pool: &RRBPool<A>) -> Option<A> {
+        if self.length == 0 {
+            return None;
+        }
+        if self.outer_b.is_empty() {
+            if self.inner_b.is_empty() {
+                if self.middle.is_empty() {
+                    if self.inner_f.is_empty() {
+                        swap(&mut self.outer_b, &mut self.outer_f);
+                    } else {
+                        swap(&mut self.outer_b, &mut self.inner_f);
+                    }
+                } else {
+                    self.outer_b = self.pop_middle(pool, Side::Right).unwrap();
+                }
+            } else {
+                swap(&mut self.outer_b, &mut self.inner_b);
+            }
+        }
+        self.length -= 1;
+        let outer_b = PoolRef::make_mut(&pool.value_pool, &mut self.outer_b);
+        Some(outer_b.pop_back())
+    }
+
+    fn push_front(&mut self, pool: &RRBPool<A>, value: A) {
+        if self.outer_f.is_full() {
+            swap(&mut self.outer_f, &mut self.inner_f);
+            if !self.outer_f.is_empty() {
+                let mut chunk = PoolRef::new(&pool.value_pool, Chunk::new());
+                swap(&mut chunk, &mut self.outer_f);
+                self.push_middle(pool, Side::Left, chunk);
+            }
+        }
+        self.length = self.length.checked_add(1).expect("Vector length overflow");
+        let outer_f = PoolRef::make_mut(&pool.value_pool, &mut self.outer_f);
+        outer_f.push_front(value)
+    }
+
+    fn push_back(&mut self, pool: &RRBPool<A>, value: A) {
+        if self.outer_b.is_full() {
+            swap(&mut self.outer_b, &mut self.inner_b);
+            if !self.outer_b.is_empty() {
+                let mut chunk = PoolRef::new(&pool.value_pool, Chunk::new());
+                swap(&mut chunk, &mut self.outer_b);
+                self.push_middle(pool, Side::Right, chunk);
+            }
+        }
+        self.length = self.length.checked_add(1).expect("Vector length overflow");
+        let outer_b = PoolRef::make_mut(&pool.value_pool, &mut self.outer_b);
+        outer_b.push_back(value)
+    }
+
+    fn push_middle(&mut self, pool: &RRBPool<A>, side: Side, chunk: PoolRef<Chunk<A>>) {
+        if chunk.is_empty() {
+            return;
+        }
+        let new_middle = {
+            let middle = Ref::make_mut(&mut self.middle);
+            match middle.push_chunk(pool, self.middle_level, side, chunk) {
+                PushResult::Done => return,
+                PushResult::Full(chunk, _num_drained) => Ref::from({
+                    match side {
+                        Side::Left => Node::from_chunk(pool, self.middle_level, chunk)
+                            .join_branches(pool, middle.clone(), self.middle_level),
+                        Side::Right => middle.clone().join_branches(
+                            pool,
+                            Node::from_chunk(pool, self.middle_level, chunk),
+                            self.middle_level,
+                        ),
+                    }
+                }),
+            }
+        };
+        self.middle_level += 1;
+        self.middle = new_middle;
+    }
+
+    fn pop_middle(&mut self, pool: &RRBPool<A>, side: Side) -> Option<PoolRef<Chunk<A>>> {
+        let chunk = {
+            let middle = Ref::make_mut(&mut self.middle);
+            match middle.pop_chunk(pool, self.middle_level, side) {
+                PopResult::Empty => return None,
+                PopResult::Done(chunk) => chunk,
+                PopResult::Drained(chunk) => {
+                    middle.clear_node();
+                    self.middle_level = 0;
+                    chunk
+                }
+            }
+        };
+        Some(chunk)
+    }
+}
+
+#[inline]
+fn replace_pool_def<A: PoolDefault>(pool: &Pool<A>, dest: &mut PoolRef<A>) -> PoolRef<A> {
+    replace(dest, PoolRef::default(pool))
+}
+
+// Core traits
+
+impl<A: Clone> Default for Vector<A> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<A: Clone> Clone for Vector<A> {
+    /// Clone a vector.
+    ///
+    /// Time: O(1), or O(n) with a very small, bounded *n* for an inline vector.
+    fn clone(&self) -> Self {
+        Self {
+            vector: match &self.vector {
+                Inline(pool, chunk) => Inline(pool.clone(), chunk.clone()),
+                Single(pool, chunk) => Single(pool.clone(), chunk.clone()),
+                Full(pool, tree) => Full(pool.clone(), tree.clone()),
+            },
+        }
+    }
+}
+
+impl<A: Clone + Debug> Debug for Vector<A> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        f.debug_list().entries(self.iter()).finish()
+        // match self {
+        //     Full(rrb) => {
+        //         writeln!(f, "Head: {:?} {:?}", rrb.outer_f, rrb.inner_f)?;
+        //         rrb.middle.print(f, 0, rrb.middle_level)?;
+        //         writeln!(f, "Tail: {:?} {:?}", rrb.inner_b, rrb.outer_b)
+        //     }
+        //     Single(_) => write!(f, "nowt"),
+        // }
+    }
+}
+
+#[cfg(not(has_specialisation))]
+impl<A: Clone + PartialEq> PartialEq for Vector<A> {
+    fn eq(&self, other: &Self) -> bool {
+        self.len() == other.len() && self.iter().eq(other.iter())
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<A: Clone + PartialEq> PartialEq for Vector<A> {
+    default fn eq(&self, other: &Self) -> bool {
+        self.len() == other.len() && self.iter().eq(other.iter())
+    }
+}
+
+#[cfg(has_specialisation)]
+impl<A: Clone + Eq> PartialEq for Vector<A> {
+    fn eq(&self, other: &Self) -> bool {
+        fn cmp_chunk<A>(left: &PoolRef<Chunk<A>>, right: &PoolRef<Chunk<A>>) -> bool {
+            (left.is_empty() && right.is_empty()) || PoolRef::ptr_eq(left, right)
+        }
+
+        if std::ptr::eq(self, other) {
+            return true;
+        }
+
+        match (&self.vector, &other.vector) {
+            (Single(_, left), Single(_, right)) => {
+                if cmp_chunk(left, right) {
+                    return true;
+                }
+                self.iter().eq(other.iter())
+            }
+            (Full(_, left), Full(_, right)) => {
+                if left.length != right.length {
+                    return false;
+                }
+
+                if cmp_chunk(&left.outer_f, &right.outer_f)
+                    && cmp_chunk(&left.inner_f, &right.inner_f)
+                    && cmp_chunk(&left.inner_b, &right.inner_b)
+                    && cmp_chunk(&left.outer_b, &right.outer_b)
+                    && ((left.middle.is_empty() && right.middle.is_empty())
+                        || Ref::ptr_eq(&left.middle, &right.middle))
+                {
+                    return true;
+                }
+                self.iter().eq(other.iter())
+            }
+            _ => self.len() == other.len() && self.iter().eq(other.iter()),
+        }
+    }
+}
+
+impl<A: Clone + Eq> Eq for Vector<A> {}
+
+impl<A: Clone + PartialOrd> PartialOrd for Vector<A> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.iter().partial_cmp(other.iter())
+    }
+}
+
+impl<A: Clone + Ord> Ord for Vector<A> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.iter().cmp(other.iter())
+    }
+}
+
+impl<A: Clone + Hash> Hash for Vector<A> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        for i in self {
+            i.hash(state)
+        }
+    }
+}
+
+impl<A: Clone> Sum for Vector<A> {
+    fn sum<I>(it: I) -> Self
+    where
+        I: Iterator<Item = Self>,
+    {
+        it.fold(Self::new(), |a, b| a + b)
+    }
+}
+
+impl<A: Clone> Add for Vector<A> {
+    type Output = Vector<A>;
+
+    /// Concatenate two vectors.
+    ///
+    /// Time: O(log n)
+    fn add(mut self, other: Self) -> Self::Output {
+        self.append(other);
+        self
+    }
+}
+
+impl<'a, A: Clone> Add for &'a Vector<A> {
+    type Output = Vector<A>;
+
+    /// Concatenate two vectors.
+    ///
+    /// Time: O(log n)
+    fn add(self, other: Self) -> Self::Output {
+        let mut out = self.clone();
+        out.append(other.clone());
+        out
+    }
+}
+
+impl<A: Clone> Extend<A> for Vector<A> {
+    /// Add values to the end of a vector by consuming an iterator.
+    ///
+    /// Time: O(n)
+    fn extend<I>(&mut self, iter: I)
+    where
+        I: IntoIterator<Item = A>,
+    {
+        for item in iter {
+            self.push_back(item)
+        }
+    }
+}
+
+impl<A: Clone> Index<usize> for Vector<A> {
+    type Output = A;
+    /// Get a reference to the value at index `index` in the vector.
+    ///
+    /// Time: O(log n)
+    fn index(&self, index: usize) -> &Self::Output {
+        match self.get(index) {
+            Some(value) => value,
+            None => panic!(
+                "Vector::index: index out of bounds: {} < {}",
+                index,
+                self.len()
+            ),
+        }
+    }
+}
+
+impl<A: Clone> IndexMut<usize> for Vector<A> {
+    /// Get a mutable reference to the value at index `index` in the
+    /// vector.
+    ///
+    /// Time: O(log n)
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        match self.get_mut(index) {
+            Some(value) => value,
+            None => panic!("Vector::index_mut: index out of bounds"),
+        }
+    }
+}
+
+// Conversions
+
+impl<'a, A: Clone> IntoIterator for &'a Vector<A> {
+    type Item = &'a A;
+    type IntoIter = Iter<'a, A>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<A: Clone> IntoIterator for Vector<A> {
+    type Item = A;
+    type IntoIter = ConsumingIter<A>;
+    fn into_iter(self) -> Self::IntoIter {
+        ConsumingIter::new(self)
+    }
+}
+
+impl<A: Clone> FromIterator<A> for Vector<A> {
+    /// Create a vector from an iterator.
+    ///
+    /// Time: O(n)
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = A>,
+    {
+        let mut seq = Self::new();
+        for item in iter {
+            seq.push_back(item)
+        }
+        seq
+    }
+}
+
+impl<'s, 'a, A, OA> From<&'s Vector<&'a A>> for Vector<OA>
+where
+    A: ToOwned<Owned = OA>,
+    OA: Borrow<A> + Clone,
+{
+    fn from(vec: &Vector<&A>) -> Self {
+        vec.iter().map(|a| (*a).to_owned()).collect()
+    }
+}
+
+impl<'a, A: Clone> From<&'a [A]> for Vector<A> {
+    fn from(slice: &[A]) -> Self {
+        slice.iter().cloned().collect()
+    }
+}
+
+impl<A: Clone> From<Vec<A>> for Vector<A> {
+    /// Create a vector from a [`std::vec::Vec`][vec].
+    ///
+    /// Time: O(n)
+    ///
+    /// [vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html
+    fn from(vec: Vec<A>) -> Self {
+        vec.into_iter().collect()
+    }
+}
+
+impl<'a, A: Clone> From<&'a Vec<A>> for Vector<A> {
+    /// Create a vector from a [`std::vec::Vec`][vec].
+    ///
+    /// Time: O(n)
+    ///
+    /// [vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html
+    fn from(vec: &Vec<A>) -> Self {
+        vec.iter().cloned().collect()
+    }
+}
+
+// Iterators
+
+/// An iterator over vectors with values of type `A`.
+///
+/// To obtain one, use [`Vector::iter()`][iter].
+///
+/// [iter]: enum.Vector.html#method.iter
+pub struct Iter<'a, A> {
+    focus: Focus<'a, A>,
+    front_index: usize,
+    back_index: usize,
+}
+
+impl<'a, A: Clone> Iter<'a, A> {
+    fn new(seq: &'a Vector<A>) -> Self {
+        Iter {
+            focus: seq.focus(),
+            front_index: 0,
+            back_index: seq.len(),
+        }
+    }
+
+    fn from_focus(focus: Focus<'a, A>) -> Self {
+        Iter {
+            front_index: 0,
+            back_index: focus.len(),
+            focus,
+        }
+    }
+}
+
+impl<'a, A: Clone> Iterator for Iter<'a, A> {
+    type Item = &'a A;
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.front_index >= self.back_index {
+            return None;
+        }
+        #[allow(unsafe_code)]
+        let focus: &'a mut Focus<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) };
+        let value = focus.get(self.front_index);
+        self.front_index += 1;
+        value
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.back_index - self.front_index;
+        (remaining, Some(remaining))
+    }
+}
+
+impl<'a, A: Clone> DoubleEndedIterator for Iter<'a, A> {
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.front_index >= self.back_index {
+            return None;
+        }
+        self.back_index -= 1;
+        #[allow(unsafe_code)]
+        let focus: &'a mut Focus<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) };
+        focus.get(self.back_index)
+    }
+}
+
+impl<'a, A: Clone> ExactSizeIterator for Iter<'a, A> {}
+
+impl<'a, A: Clone> FusedIterator for Iter<'a, A> {}
+
+/// A mutable iterator over vectors with values of type `A`.
+///
+/// To obtain one, use [`Vector::iter_mut()`][iter_mut].
+///
+/// [iter_mut]: enum.Vector.html#method.iter_mut
+pub struct IterMut<'a, A> {
+    focus: FocusMut<'a, A>,
+    front_index: usize,
+    back_index: usize,
+}
+
+impl<'a, A> IterMut<'a, A>
+where
+    A: Clone,
+{
+    fn new(seq: &'a mut Vector<A>) -> Self {
+        let focus = seq.focus_mut();
+        let len = focus.len();
+        IterMut {
+            focus,
+            front_index: 0,
+            back_index: len,
+        }
+    }
+
+    fn from_focus(focus: FocusMut<'a, A>) -> Self {
+        IterMut {
+            front_index: 0,
+            back_index: focus.len(),
+            focus,
+        }
+    }
+}
+
+impl<'a, A> Iterator for IterMut<'a, A>
+where
+    A: 'a + Clone,
+{
+    type Item = &'a mut A;
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.front_index >= self.back_index {
+            return None;
+        }
+        #[allow(unsafe_code)]
+        let focus: &'a mut FocusMut<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) };
+        let value = focus.get_mut(self.front_index);
+        self.front_index += 1;
+        value
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let remaining = self.back_index - self.front_index;
+        (remaining, Some(remaining))
+    }
+}
+
+impl<'a, A> DoubleEndedIterator for IterMut<'a, A>
+where
+    A: 'a + Clone,
+{
+    /// Remove and return an element from the back of the iterator.
+    ///
+    /// Time: O(1)*
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.front_index >= self.back_index {
+            return None;
+        }
+        self.back_index -= 1;
+        #[allow(unsafe_code)]
+        let focus: &'a mut FocusMut<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) };
+        focus.get_mut(self.back_index)
+    }
+}
+
+impl<'a, A: Clone> ExactSizeIterator for IterMut<'a, A> {}
+
+impl<'a, A: Clone> FusedIterator for IterMut<'a, A> {}
+
+/// A consuming iterator over vectors with values of type `A`.
+pub struct ConsumingIter<A> {
+    vector: Vector<A>,
+}
+
+impl<A: Clone> ConsumingIter<A> {
+    fn new(vector: Vector<A>) -> Self {
+        Self { vector }
+    }
+}
+
+impl<A: Clone> Iterator for ConsumingIter<A> {
+    type Item = A;
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        self.vector.pop_front()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.vector.len();
+        (len, Some(len))
+    }
+}
+
+impl<A: Clone> DoubleEndedIterator for ConsumingIter<A> {
+    /// Remove and return an element from the back of the iterator.
+    ///
+    /// Time: O(1)*
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.vector.pop_back()
+    }
+}
+
+impl<A: Clone> ExactSizeIterator for ConsumingIter<A> {}
+
+impl<A: Clone> FusedIterator for ConsumingIter<A> {}
+
+/// An iterator over the leaf nodes of a vector.
+///
+/// To obtain one, use [`Vector::chunks()`][chunks].
+///
+/// [chunks]: enum.Vector.html#method.chunks
+pub struct Chunks<'a, A> {
+    focus: Focus<'a, A>,
+    front_index: usize,
+    back_index: usize,
+}
+
+impl<'a, A: Clone> Chunks<'a, A> {
+    fn new(seq: &'a Vector<A>) -> Self {
+        Chunks {
+            focus: seq.focus(),
+            front_index: 0,
+            back_index: seq.len(),
+        }
+    }
+}
+
+impl<'a, A: Clone> Iterator for Chunks<'a, A> {
+    type Item = &'a [A];
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.front_index >= self.back_index {
+            return None;
+        }
+        #[allow(unsafe_code)]
+        let focus: &'a mut Focus<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) };
+        let (range, value) = focus.chunk_at(self.front_index);
+        self.front_index = range.end;
+        Some(value)
+    }
+}
+
+impl<'a, A: Clone> DoubleEndedIterator for Chunks<'a, A> {
+    /// Remove and return an element from the back of the iterator.
+    ///
+    /// Time: O(1)*
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.front_index >= self.back_index {
+            return None;
+        }
+        self.back_index -= 1;
+        #[allow(unsafe_code)]
+        let focus: &'a mut Focus<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) };
+        let (range, value) = focus.chunk_at(self.back_index);
+        self.back_index = range.start;
+        Some(value)
+    }
+}
+
+impl<'a, A: Clone> FusedIterator for Chunks<'a, A> {}
+
+/// A mutable iterator over the leaf nodes of a vector.
+///
+/// To obtain one, use [`Vector::chunks_mut()`][chunks_mut].
+///
+/// [chunks_mut]: enum.Vector.html#method.chunks_mut
+pub struct ChunksMut<'a, A> {
+    focus: FocusMut<'a, A>,
+    front_index: usize,
+    back_index: usize,
+}
+
+impl<'a, A: Clone> ChunksMut<'a, A> {
+    fn new(seq: &'a mut Vector<A>) -> Self {
+        let len = seq.len();
+        ChunksMut {
+            focus: seq.focus_mut(),
+            front_index: 0,
+            back_index: len,
+        }
+    }
+}
+
+impl<'a, A: Clone> Iterator for ChunksMut<'a, A> {
+    type Item = &'a mut [A];
+
+    /// Advance the iterator and return the next value.
+    ///
+    /// Time: O(1)*
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.front_index >= self.back_index {
+            return None;
+        }
+        #[allow(unsafe_code)]
+        let focus: &'a mut FocusMut<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) };
+        let (range, value) = focus.chunk_at(self.front_index);
+        self.front_index = range.end;
+        Some(value)
+    }
+}
+
+impl<'a, A: Clone> DoubleEndedIterator for ChunksMut<'a, A> {
+    /// Remove and return an element from the back of the iterator.
+    ///
+    /// Time: O(1)*
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.front_index >= self.back_index {
+            return None;
+        }
+        self.back_index -= 1;
+        #[allow(unsafe_code)]
+        let focus: &'a mut FocusMut<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) };
+        let (range, value) = focus.chunk_at(self.back_index);
+        self.back_index = range.start;
+        Some(value)
+    }
+}
+
+impl<'a, A: Clone> FusedIterator for ChunksMut<'a, A> {}
+
+// Proptest
+#[cfg(any(test, feature = "proptest"))]
+#[doc(hidden)]
+pub mod proptest {
+    #[deprecated(
+        since = "14.3.0",
+        note = "proptest strategies have moved to im::proptest"
+    )]
+    pub use crate::proptest::vector;
+}
+
+// Tests
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::proptest::vector;
+    use ::proptest::collection::vec;
+    use ::proptest::num::{i32, usize};
+    use ::proptest::proptest;
+
+    #[test]
+    fn macro_allows_trailing_comma() {
+        let vec1 = vector![1, 2, 3];
+        let vec2 = vector![1, 2, 3,];
+        assert_eq!(vec1, vec2);
+    }
+
+    #[test]
+    fn indexing() {
+        let mut vec = vector![0, 1, 2, 3, 4, 5];
+        vec.push_front(0);
+        assert_eq!(0, *vec.get(0).unwrap());
+        assert_eq!(0, vec[0]);
+    }
+
+    #[test]
+    fn large_vector_focus() {
+        let input = (0..100_000).collect::<Vector<_>>();
+        let vec = input.clone();
+        let mut sum: i64 = 0;
+        let mut focus = vec.focus();
+        for i in 0..input.len() {
+            sum += *focus.index(i);
+        }
+        let expected: i64 = (0..100_000).sum();
+        assert_eq!(expected, sum);
+    }
+
+    #[test]
+    fn large_vector_focus_mut() {
+        let input = (0..100_000).collect::<Vector<_>>();
+        let mut vec = input.clone();
+        {
+            let mut focus = vec.focus_mut();
+            for i in 0..input.len() {
+                let p = focus.index_mut(i);
+                *p += 1;
+            }
+        }
+        let expected: Vector<i32> = input.into_iter().map(|i| i + 1).collect();
+        assert_eq!(expected, vec);
+    }
+
+    #[test]
+    fn issue_55_fwd() {
+        let mut l = Vector::new();
+        for i in 0..4098 {
+            l.append(Vector::unit(i));
+        }
+        l.append(Vector::unit(4098));
+        assert_eq!(Some(&4097), l.get(4097));
+        assert_eq!(Some(&4096), l.get(4096));
+    }
+
+    #[test]
+    fn issue_55_back() {
+        let mut l = Vector::unit(0);
+        for i in 0..4099 {
+            let mut tmp = Vector::unit(i + 1);
+            tmp.append(l);
+            l = tmp;
+        }
+        assert_eq!(Some(&4098), l.get(1));
+        assert_eq!(Some(&4097), l.get(2));
+        let len = l.len();
+        l.slice(2..len);
+    }
+
+    #[test]
+    fn issue_55_append() {
+        let mut vec1 = (0..92).collect::<Vector<_>>();
+        let vec2 = (0..165).collect::<Vector<_>>();
+        vec1.append(vec2);
+    }
+
+    #[test]
+    fn issue_70() {
+        let mut x = Vector::new();
+        for _ in 0..262 {
+            x.push_back(0);
+        }
+        for _ in 0..97 {
+            x.pop_front();
+        }
+        for &offset in &[160, 163, 160] {
+            x.remove(offset);
+        }
+        for _ in 0..64 {
+            x.push_back(0);
+        }
+        // At this point middle contains three chunks of size 64, 64 and 1
+        // respectively. Previously the next `push_back()` would append another
+        // zero-sized chunk to middle even though there is enough space left.
+        match x.vector {
+            VectorInner::Full(_, ref tree) => {
+                assert_eq!(129, tree.middle.len());
+                assert_eq!(3, tree.middle.number_of_children());
+            }
+            _ => unreachable!(),
+        }
+        x.push_back(0);
+        match x.vector {
+            VectorInner::Full(_, ref tree) => {
+                assert_eq!(131, tree.middle.len());
+                assert_eq!(3, tree.middle.number_of_children())
+            }
+            _ => unreachable!(),
+        }
+        for _ in 0..64 {
+            x.push_back(0);
+        }
+        for _ in x.iter() {}
+    }
+
+    #[test]
+    fn issue_67() {
+        let mut l = Vector::unit(4100);
+        for i in (0..4099).rev() {
+            let mut tmp = Vector::unit(i);
+            tmp.append(l);
+            l = tmp;
+        }
+        assert_eq!(4100, l.len());
+        let len = l.len();
+        let tail = l.slice(1..len);
+        assert_eq!(1, l.len());
+        assert_eq!(4099, tail.len());
+        assert_eq!(Some(&0), l.get(0));
+        assert_eq!(Some(&1), tail.get(0));
+    }
+
+    #[test]
+    fn issue_74_simple_size() {
+        use crate::nodes::rrb::NODE_SIZE;
+        let mut x = Vector::new();
+        for _ in 0..(CHUNK_SIZE
+            * (
+                1 // inner_f
+                + (2 * NODE_SIZE) // middle: two full Entry::Nodes (4096 elements each)
+                + 1 // inner_b
+                + 1
+                // outer_b
+            ))
+        {
+            x.push_back(0u32);
+        }
+        let middle_first_node_start = CHUNK_SIZE;
+        let middle_second_node_start = middle_first_node_start + NODE_SIZE * CHUNK_SIZE;
+        // This reduces the size of the second node to 4095.
+        x.remove(middle_second_node_start);
+        // As outer_b is full, this will cause inner_b (length 64) to be pushed
+        // to middle. The first element will be merged into the second node, the
+        // remaining 63 elements will end up in a new node.
+        x.push_back(0u32);
+        match x.vector {
+            VectorInner::Full(_, tree) => {
+                assert_eq!(3, tree.middle.number_of_children());
+                assert_eq!(
+                    2 * NODE_SIZE * CHUNK_SIZE + CHUNK_SIZE - 1,
+                    tree.middle.len()
+                );
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn issue_77() {
+        let mut x = Vector::new();
+        for _ in 0..44 {
+            x.push_back(0);
+        }
+        for _ in 0..20 {
+            x.insert(0, 0);
+        }
+        x.insert(1, 0);
+        for _ in 0..441 {
+            x.push_back(0);
+        }
+        for _ in 0..58 {
+            x.insert(0, 0);
+        }
+        x.insert(514, 0);
+        for _ in 0..73 {
+            x.push_back(0);
+        }
+        for _ in 0..10 {
+            x.insert(0, 0);
+        }
+        x.insert(514, 0);
+    }
+
+    #[test]
+    fn issue_105() {
+        let mut v = Vector::new();
+
+        for i in 0..270_000 {
+            v.push_front(i);
+        }
+
+        while !v.is_empty() {
+            v = v.take(v.len() - 1);
+        }
+    }
+
+    #[test]
+    fn issue_107_split_off_causes_overflow() {
+        let mut vec = (0..4289).collect::<Vector<_>>();
+        let mut control = (0..4289).collect::<Vec<_>>();
+        let chunk = 64;
+
+        while vec.len() >= chunk {
+            vec = vec.split_off(chunk);
+            control = control.split_off(chunk);
+            assert_eq!(vec.len(), control.len());
+            assert_eq!(control, vec.iter().cloned().collect::<Vec<_>>());
+        }
+    }
+
+    #[test]
+    fn collect_crash() {
+        let _vector: Vector<i32> = (0..5953).collect();
+        // let _vector: Vector<i32> = (0..16384).collect();
+    }
+
+    #[test]
+    fn issue_116() {
+        let vec = (0..300).collect::<Vector<_>>();
+        let rev_vec: Vector<u32> = vec.clone().into_iter().rev().collect();
+        assert_eq!(vec.len(), rev_vec.len());
+    }
+
+    #[test]
+    fn issue_131() {
+        let smol = std::iter::repeat(42).take(64).collect::<Vector<_>>();
+        let mut smol2 = smol.clone();
+        assert!(smol.ptr_eq(&smol2));
+        smol2.set(63, 420);
+        assert!(!smol.ptr_eq(&smol2));
+
+        let huge = std::iter::repeat(42).take(65).collect::<Vector<_>>();
+        let mut huge2 = huge.clone();
+        assert!(huge.ptr_eq(&huge2));
+        huge2.set(63, 420);
+        assert!(!huge.ptr_eq(&huge2));
+    }
+
+    #[test]
+    fn ptr_eq() {
+        for len in 32..256 {
+            let input = std::iter::repeat(42).take(len).collect::<Vector<_>>();
+            let mut inp2 = input.clone();
+            assert!(input.ptr_eq(&inp2));
+            inp2.set(len - 1, 98);
+            assert_ne!(inp2.get(len - 1), input.get(len - 1));
+            assert!(!input.ptr_eq(&inp2));
+        }
+    }
+
+    proptest! {
+        #[test]
+        fn iter(ref vec in vec(i32::ANY, 0..1000)) {
+            let seq: Vector<i32> = vec.iter().cloned().collect::<Vector<_>>();
+            for (index, item) in seq.iter().enumerate() {
+                assert_eq!(&vec[index], item);
+            }
+            assert_eq!(vec.len(), seq.len());
+        }
+
+        #[test]
+        fn push_front_mut(ref input in vec(i32::ANY, 0..1000)) {
+            let mut vector = Vector::new();
+            for (count, value) in input.iter().cloned().enumerate() {
+                assert_eq!(count, vector.len());
+                vector.push_front(value);
+                assert_eq!(count + 1, vector.len());
+            }
+            let input2 = input.iter().rev().cloned().collect::<Vec<_>>();
+            assert_eq!(input2, vector.iter().cloned().collect::<Vec<_>>());
+        }
+
+        #[test]
+        fn push_back_mut(ref input in vec(i32::ANY, 0..1000)) {
+            let mut vector = Vector::new();
+            for (count, value) in input.iter().cloned().enumerate() {
+                assert_eq!(count, vector.len());
+                vector.push_back(value);
+                assert_eq!(count + 1, vector.len());
+            }
+            assert_eq!(input, &vector.iter().cloned().collect::<Vec<_>>());
+        }
+
+        #[test]
+        fn pop_back_mut(ref input in vec(i32::ANY, 0..1000)) {
+            let mut vector = input.iter().cloned().collect::<Vector<_>>();
+            assert_eq!(input.len(), vector.len());
+            for (index, value) in input.iter().cloned().enumerate().rev() {
+                match vector.pop_back() {
+                    None => panic!("vector emptied unexpectedly"),
+                    Some(item) => {
+                        assert_eq!(index, vector.len());
+                        assert_eq!(value, item);
+                    }
+                }
+            }
+            assert_eq!(0, vector.len());
+        }
+
+        #[test]
+        fn pop_front_mut(ref input in vec(i32::ANY, 0..1000)) {
+            let mut vector = input.iter().cloned().collect::<Vector<_>>();
+            assert_eq!(input.len(), vector.len());
+            for (index, value) in input.iter().cloned().rev().enumerate().rev() {
+                match vector.pop_front() {
+                    None => panic!("vector emptied unexpectedly"),
+                    Some(item) => {
+                        assert_eq!(index, vector.len());
+                        assert_eq!(value, item);
+                    }
+                }
+            }
+            assert_eq!(0, vector.len());
+        }
+
+        // #[test]
+        // fn push_and_pop(ref input in vec(i32::ANY, 0..1000)) {
+        //     let mut vector = Vector::new();
+        //     for (count, value) in input.iter().cloned().enumerate() {
+        //         assert_eq!(count, vector.len());
+        //         vector.push_back(value);
+        //         assert_eq!(count + 1, vector.len());
+        //     }
+        //     for (index, value) in input.iter().cloned().rev().enumerate().rev() {
+        //         match vector.pop_front() {
+        //             None => panic!("vector emptied unexpectedly"),
+        //             Some(item) => {
+        //                 assert_eq!(index, vector.len());
+        //                 assert_eq!(value, item);
+        //             }
+        //         }
+        //     }
+        //     assert_eq!(true, vector.is_empty());
+        // }
+
+        #[test]
+        fn split(ref vec in vec(i32::ANY, 1..2000), split_pos in usize::ANY) {
+            let split_index = split_pos % (vec.len() + 1);
+            let mut left = vec.iter().cloned().collect::<Vector<_>>();
+            let right = left.split_off(split_index);
+            assert_eq!(left.len(), split_index);
+            assert_eq!(right.len(), vec.len() - split_index);
+            for (index, item) in left.iter().enumerate() {
+                assert_eq!(& vec[index], item);
+            }
+            for (index, item) in right.iter().enumerate() {
+                assert_eq!(&vec[split_index + index], item);
+            }
+        }
+
+        #[test]
+        fn append(ref vec1 in vec(i32::ANY, 0..1000), ref vec2 in vec(i32::ANY, 0..1000)) {
+            let mut seq1 = vec1.iter().cloned().collect::<Vector<_>>();
+            let seq2 = vec2.iter().cloned().collect::<Vector<_>>();
+            assert_eq!(seq1.len(), vec1.len());
+            assert_eq!(seq2.len(), vec2.len());
+            seq1.append(seq2);
+            let mut vec = vec1.clone();
+            vec.extend(vec2);
+            assert_eq!(seq1.len(), vec.len());
+            for (index, item) in seq1.into_iter().enumerate() {
+                assert_eq!(vec[index], item);
+            }
+        }
+
+        #[test]
+        fn iter_mut(ref input in vector(i32::ANY, 0..10000)) {
+            let mut vec = input.clone();
+            {
+                for p in vec.iter_mut() {
+                    *p = p.overflowing_add(1).0;
+                }
+            }
+            let expected: Vector<i32> = input.clone().into_iter().map(|i| i.overflowing_add(1).0).collect();
+            assert_eq!(expected, vec);
+        }
+
+        #[test]
+        fn focus(ref input in vector(i32::ANY, 0..10000)) {
+            let mut vec = input.clone();
+            {
+                let mut focus = vec.focus_mut();
+                for i in 0..input.len() {
+                    let p = focus.index_mut(i);
+                    *p = p.overflowing_add(1).0;
+                }
+            }
+            let expected: Vector<i32> = input.clone().into_iter().map(|i| i.overflowing_add(1).0).collect();
+            assert_eq!(expected, vec);
+        }
+
+        #[test]
+        fn focus_mut_split(ref input in vector(i32::ANY, 0..10000)) {
+            let mut vec = input.clone();
+
+            fn split_down(focus: FocusMut<'_, i32>) {
+                let len = focus.len();
+                if len < 8 {
+                    for p in focus {
+                        *p = p.overflowing_add(1).0;
+                    }
+                } else {
+                    let (left, right) = focus.split_at(len / 2);
+                    split_down(left);
+                    split_down(right);
+                }
+            }
+
+            split_down(vec.focus_mut());
+
+            let expected: Vector<i32> = input.clone().into_iter().map(|i| i.overflowing_add(1).0).collect();
+            assert_eq!(expected, vec);
+        }
+
+        #[test]
+        fn chunks(ref input in vector(i32::ANY, 0..10000)) {
+            let output: Vector<_> = input.leaves().flatten().cloned().collect();
+            assert_eq!(input, &output);
+            let rev_in: Vector<_> = input.iter().rev().cloned().collect();
+            let rev_out: Vector<_> = input.leaves().rev().map(|c| c.iter().rev()).flatten().cloned().collect();
+            assert_eq!(rev_in, rev_out);
+        }
+
+        #[test]
+        fn chunks_mut(ref mut input_src in vector(i32::ANY, 0..10000)) {
+            let mut input = input_src.clone();
+            #[allow(clippy::map_clone)]
+            let output: Vector<_> = input.leaves_mut().flatten().map(|v| *v).collect();
+            assert_eq!(input, output);
+            let rev_in: Vector<_> = input.iter().rev().cloned().collect();
+            let rev_out: Vector<_> = input.leaves_mut().rev().map(|c| c.iter().rev()).flatten().cloned().collect();
+            assert_eq!(rev_in, rev_out);
+        }
+
+        // The following two tests are very slow and there are unit tests above
+        // which test for regression of issue #55.  It would still be good to
+        // run them occasionally.
+
+        // #[test]
+        // fn issue55_back(count in 0..10000, slice_at in usize::ANY) {
+        //     let count = count as usize;
+        //     let slice_at = slice_at % count;
+        //     let mut l = Vector::unit(0);
+        //     for _ in 0..count {
+        //         let mut tmp = Vector::unit(0);
+        //         tmp.append(l);
+        //         l = tmp;
+        //     }
+        //     let len = l.len();
+        //     l.slice(slice_at..len);
+        // }
+
+        // #[test]
+        // fn issue55_fwd(count in 0..10000, slice_at in usize::ANY) {
+        //     let count = count as usize;
+        //     let slice_at = slice_at % count;
+        //     let mut l = Vector::new();
+        //     for i in 0..count {
+        //         l.append(Vector::unit(i));
+        //     }
+        //     assert_eq!(Some(&slice_at), l.get(slice_at));
+        // }
+    }
+}
diff --git a/vendor/im-rc/src/vector/pool.rs b/vendor/im-rc/src/vector/pool.rs
new file mode 100644
index 000000000..4d4edae6b
--- /dev/null
+++ b/vendor/im-rc/src/vector/pool.rs
@@ -0,0 +1,74 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+use crate::config::POOL_SIZE;
+use crate::nodes::chunk::Chunk;
+use crate::nodes::rrb::Node;
+use crate::util::Pool;
+
+/// A memory pool for `Vector`.
+pub struct RRBPool<A> {
+    pub(crate) node_pool: Pool<Chunk<Node<A>>>,
+    pub(crate) value_pool: Pool<Chunk<A>>,
+    pub(crate) size_pool: Pool<Chunk<usize>>,
+}
+
+impl<A> RRBPool<A> {
+    /// Create a new memory pool with the given size.
+    pub fn new(size: usize) -> Self {
+        Self::with_sizes(size, size, size)
+    }
+
+    /// Create a new memory pool with the given sizes for each subpool.
+    pub fn with_sizes(
+        node_pool_size: usize,
+        leaf_pool_size: usize,
+        size_table_pool_size: usize,
+    ) -> Self {
+        Self {
+            node_pool: Pool::new(node_pool_size),
+            value_pool: Pool::new(leaf_pool_size),
+            size_pool: Pool::new(size_table_pool_size),
+        }
+    }
+
+    /// Fill the memory pool with preallocated chunks.
+    pub fn fill(&self) {
+        self.node_pool.fill();
+        self.value_pool.fill();
+        self.size_pool.fill();
+    }
+
+    /// Get the size of the node subpool.
+    pub fn node_pool_size(&self) -> usize {
+        self.node_pool.get_pool_size()
+    }
+
+    /// Get the size of the leaf node subpool.
+    pub fn leaf_pool_size(&self) -> usize {
+        self.value_pool.get_pool_size()
+    }
+
+    /// Get the size of the size table subpool.
+    pub fn size_table_pool_size(&self) -> usize {
+        self.size_pool.get_pool_size()
+    }
+}
+
+impl<A> Default for RRBPool<A> {
+    /// Construct a pool with a reasonable default pool size.
+    fn default() -> Self {
+        Self::new(POOL_SIZE)
+    }
+}
+
+impl<A> Clone for RRBPool<A> {
+    fn clone(&self) -> Self {
+        Self {
+            node_pool: self.node_pool.clone(),
+            value_pool: self.value_pool.clone(),
+            size_pool: self.size_pool.clone(),
+        }
+    }
+}
diff --git a/vendor/im-rc/src/vector/rayon.rs b/vendor/im-rc/src/vector/rayon.rs
new file mode 100644
index 000000000..054620dc0
--- /dev/null
+++ b/vendor/im-rc/src/vector/rayon.rs
@@ -0,0 +1,209 @@
+//! Parallel iterators.
+//!
+//! These are only available when using the `rayon` feature flag.
+
+use super::*;
+use ::rayon::iter::plumbing::{bridge, Consumer, Producer, ProducerCallback, UnindexedConsumer};
+use ::rayon::iter::{
+    IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator,
+};
+
+impl<'a, A> IntoParallelRefIterator<'a> for Vector<A>
+where
+    A: Clone + Send + Sync + 'a,
+{
+    type Item = &'a A;
+    type Iter = ParIter<'a, A>;
+
+    fn par_iter(&'a self) -> Self::Iter {
+        ParIter {
+            focus: self.focus(),
+        }
+    }
+}
+
+impl<'a, A> IntoParallelRefMutIterator<'a> for Vector<A>
+where
+    A: Clone + Send + Sync + 'a,
+{
+    type Item = &'a mut A;
+    type Iter = ParIterMut<'a, A>;
+
+    fn par_iter_mut(&'a mut self) -> Self::Iter {
+        ParIterMut {
+            focus: self.focus_mut(),
+        }
+    }
+}
+
+/// A parallel iterator for [`Vector`][Vector].
+///
+/// [Vector]: ../struct.Vector.html
+pub struct ParIter<'a, A>
+where
+    A: Clone + Send + Sync,
+{
+    focus: Focus<'a, A>,
+}
+
+impl<'a, A> ParallelIterator for ParIter<'a, A>
+where
+    A: Clone + Send + Sync + 'a,
+{
+    type Item = &'a A;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+}
+
+impl<'a, A> IndexedParallelIterator for ParIter<'a, A>
+where
+    A: Clone + Send + Sync + 'a,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.focus.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(VectorProducer { focus: self.focus })
+    }
+}
+
+/// A mutable parallel iterator for [`Vector`][Vector].
+///
+/// [Vector]: ../struct.Vector.html
+pub struct ParIterMut<'a, A>
+where
+    A: Clone + Send + Sync,
+{
+    focus: FocusMut<'a, A>,
+}
+
+impl<'a, A> ParallelIterator for ParIterMut<'a, A>
+where
+    A: Clone + Send + Sync + 'a,
+{
+    type Item = &'a mut A;
+
+    fn drive_unindexed<C>(self, consumer: C) -> C::Result
+    where
+        C: UnindexedConsumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+}
+
+impl<'a, A> IndexedParallelIterator for ParIterMut<'a, A>
+where
+    A: Clone + Send + Sync + 'a,
+{
+    fn drive<C>(self, consumer: C) -> C::Result
+    where
+        C: Consumer<Self::Item>,
+    {
+        bridge(self, consumer)
+    }
+
+    fn len(&self) -> usize {
+        self.focus.len()
+    }
+
+    fn with_producer<CB>(self, callback: CB) -> CB::Output
+    where
+        CB: ProducerCallback<Self::Item>,
+    {
+        callback.callback(VectorMutProducer { focus: self.focus })
+    }
+}
+
+struct VectorProducer<'a, A>
+where
+    A: Clone + Send + Sync,
+{
+    focus: Focus<'a, A>,
+}
+
+impl<'a, A> Producer for VectorProducer<'a, A>
+where
+    A: Clone + Send + Sync + 'a,
+{
+    type Item = &'a A;
+    type IntoIter = Iter<'a, A>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.focus.into_iter()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.focus.split_at(index);
+        (
+            VectorProducer { focus: left },
+            VectorProducer { focus: right },
+        )
+    }
+}
+
+struct VectorMutProducer<'a, A>
+where
+    A: Clone + Send + Sync,
+{
+    focus: FocusMut<'a, A>,
+}
+
+impl<'a, A> Producer for VectorMutProducer<'a, A>
+where
+    A: Clone + Send + Sync + 'a,
+{
+    type Item = &'a mut A;
+    type IntoIter = IterMut<'a, A>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.focus.into_iter()
+    }
+
+    fn split_at(self, index: usize) -> (Self, Self) {
+        let (left, right) = self.focus.split_at(index);
+        (
+            VectorMutProducer { focus: left },
+            VectorMutProducer { focus: right },
+        )
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::super::*;
+    use super::proptest::vector;
+    use ::proptest::num::i32;
+    use ::proptest::proptest;
+    use ::rayon::iter::{IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator};
+
+    proptest! {
+        #[test]
+        fn par_iter(ref mut input in vector(i32::ANY, 0..10000)) {
+            assert_eq!(input.iter().max(), input.par_iter().max())
+        }
+
+        #[test]
+        fn par_mut_iter(ref mut input in vector(i32::ANY, 0..10000)) {
+            let mut vec = input.clone();
+            vec.par_iter_mut().for_each(|i| *i = i.overflowing_add(1).0);
+            let expected: Vector<i32> = input.clone().into_iter().map(|i| i.overflowing_add(1).0).collect();
+            assert_eq!(expected, vec);
+        }
+    }
+}
author	Daniel Baumann <daniel.baumann@progress-linux.org>	2024-05-04 12:41:35 +0000
committer	Daniel Baumann <daniel.baumann@progress-linux.org>	2024-05-04 12:41:35 +0000
commit	7e5d7eea9c580ef4b41a765bde624af431942b96 (patch)
tree	2c0d9ca12878fc4525650aa4e54d77a81a07cc09 /vendor/im-rc
parent	Adding debian version 1.70.0+dfsg1-9. (diff)
download	rustc-7e5d7eea9c580ef4b41a765bde624af431942b96.tar.xz rustc-7e5d7eea9c580ef4b41a765bde624af431942b96.zip